Compare commits
5
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
38b62cfdbd | ||
|
|
cd395c73b7 | ||
|
|
7f4e8b3f76 | ||
|
|
1bdaae8807 | ||
|
|
69e335ba9c |
@@ -0,0 +1,38 @@
|
||||
# AVA2 drop tables
|
||||
|
||||
203 drops what AVA2 drops. Tables: `tools/ava2-drops/make_drops.py`. Code: `ITEM_MANAGER::ReadCommonDropNewItemFile` (item_manager_read_tables.cpp), the common-drop block and `GetDropPct` in item_manager.cpp, the load in input_db.cpp. The items AVA2 drops that 40250 lacks come from metin2-client `tools/server/ava2-items` and must be installed in the same deploy (the readers fail on an unknown item vnum and the core stops).
|
||||
|
||||
## Tables
|
||||
|
||||
Built by `make_drops.py <AVA2 locale dir> <203 locale dir> <out dir> <item_proto.txt>...`, the protos being every row the db will load (live item_proto.txt + ava2-items' items-server.tsv).
|
||||
|
||||
| File | Content |
|
||||
|---|---|
|
||||
| mob_drop_item.txt | AVA2's 247 `drop` groups. Entries with an unknown item are removed and the rest renumbered: the reader stops at the first missing index. |
|
||||
| common_drop_new.txt | AVA2's 26 level-range common groups (new file, see below). |
|
||||
| special_item_group.txt | 203's groups; AVA2's groups replace those of the same box vnum (50011, 50082, 50186, 50255) and AVA2-only boxes are added. 50035 keeps 203's group: it is the children's day box on 203 but a GM box on AVA2. |
|
||||
| common_drop_item.txt, etc_drop_item.txt | empty, as on AVA2. |
|
||||
|
||||
`report.json` lists group counts, removed items and replaced boxes.
|
||||
|
||||
## common_drop_new.txt
|
||||
|
||||
```
|
||||
Group <name>
|
||||
{
|
||||
map_index 0 # 0 = every map, otherwise the maps listed
|
||||
level_range <min> <max> # killer level
|
||||
<n> <item vnum> <count> <pct> # pct as a float, chance = pct / 100
|
||||
}
|
||||
```
|
||||
|
||||
A group drops when the monster level is within 20 of the killer, the killer level is in `level_range` and the map matches. Each entry is rolled against `GetDropPct`'s range (base 4,000,000) with probability `pct × 40000`. A missing file is logged and skipped; a parse error or unknown item fails the boot like the other drop files.
|
||||
|
||||
## Changes to the drop code (from AVA2)
|
||||
|
||||
- `GetDropPct`: premium item or glove doubles the drop rate, otherwise +50%; the permanent glove adds 100 (50 with premium) to the denominator bonus. `iRandRange = 4000000 * 100 / (100 + priv + bonus)`; 203 had an operator-precedence bug that fixed the divisor at 100.
|
||||
- PC-bang bonus removed. The event-manager bonus is not ported (203 has no ENABLE_EVENT_MANAGER).
|
||||
- A mob with two `drop` groups no longer reads an uninitialised group pointer.
|
||||
- special_item_group.txt groups may have up to 1023 entries (AVA2's cofreskindop boxes have 267).
|
||||
|
||||
The wiki (`/mt_features ... mob`) lists common_drop_new rows as rule 0 (FEATURE-QUERY-PROTOCOL.md). Not ported: AVA2's `/reload y`; quest-script and hardcoded drops are not compared.
|
||||
@@ -0,0 +1,111 @@
|
||||
# PORT battle pass
|
||||
|
||||
A monthly mission pass, ported from AVA2's `ENABLE_BATTLE_PASS` (the window behind `uibattlepassex.py`). A season is a time window with up to ten missions. Each mission has its own reward, and a final reward unlocks once every mission is done. The pass is free for every player; AVA2 sold a ticket item (25150–25161), and this port has none.
|
||||
|
||||
Source:
|
||||
- `src/server/game/src/port_battlepass.h`: config, per-player state and bag fit; standard C++ only.
|
||||
- `port_battlepass_runtime.h`: game side, included only by cmd_general.cpp.
|
||||
- `port_battlepass_hooks.h`: hook declarations for the other files.
|
||||
|
||||
Tables: `tools/battlepass/schema.sql`. Season file: `tools/battlepass/port_battlepass.tsv`. Test: `tests/features/test_battlepass.py`.
|
||||
|
||||
## Season file
|
||||
|
||||
The file is `<locale base>/port_battlepass.tsv`, for example `share/locale/newcibn/port_battlepass.tsv`. Every core checks it at most once every 5 s and reloads it when its mtime, size or inode changes, the same rule the event calendar uses. Replace it atomically with a temporary file and `mv`.
|
||||
|
||||
```
|
||||
MTBATTLEPASS 1
|
||||
season ID START END unix seconds, [START, END)
|
||||
mission SLOT TYPE SUB TARGET [VNUM COUNT]x0..3
|
||||
final VNUM COUNT [VNUM COUNT]x0..5
|
||||
```
|
||||
|
||||
- Any error disables the whole file; the game logs `PORT_BP: port_battlepass.tsv disabled: line N: why`. Errors include:
|
||||
- a bad number or a duplicate slot;
|
||||
- overlapping seasons;
|
||||
- a season without missions;
|
||||
- a sub on a type that takes none.
|
||||
- Slot numbers are 1..10. A season ID must never be reused: progress and claims are stored per season ID.
|
||||
- A reward must be a bag item:
|
||||
- not a dragon soul stone;
|
||||
- size 1..3;
|
||||
- at most 24 stacks per claim.
|
||||
|
||||
A bad reward is caught when someone claims it: the answer is `config`, `sys_err` logs it, and the slot stays claimable after the file is fixed.
|
||||
|
||||
| Type | Counts | SUB |
|
||||
|---|---|---|
|
||||
| 1 | monster kills (not boss, not stone) | mob vnum or 0 |
|
||||
| 2 | boss kills (rank ≥ boss) | mob vnum or 0 |
|
||||
| 3 | metin stone kills | stone vnum or 0 |
|
||||
| 4 | seconds online | 0 |
|
||||
| 5 | fish caught | item vnum or 0 |
|
||||
| 6 | successful refines | resulting item vnum or 0 |
|
||||
| 7 | levels gained | 0 |
|
||||
| 8 | gold paid to NPC shops | 0 |
|
||||
| 9 | items sold to NPC shops | item vnum (required) |
|
||||
|
||||
A kill counts for the player that `CHARACTER::Reward` gives the quest kill event to, which is the `DistributeExp` attacker. As in AVA2, it counts only when the monster is within 20 levels of the player. A party member who is not that attacker gets nothing. Type 9 needs a vnum because selling any item could be farmed with cheap shop items.
|
||||
|
||||
The shipped file has seasons 202610–202712 (through 2028-01-01), starting at local midnight on the first of each month (Europe/Berlin, the server's zone). Each has:
|
||||
- eight missions, rewards taken from 40250 items;
|
||||
- a final reward of the three pearls and 70024.
|
||||
|
||||
The targets follow the scale of AVA2's month 10 (`player.battle_pass`).
|
||||
|
||||
## Storage
|
||||
|
||||
```
|
||||
player.mt_battlepass_progress (pid, season, slot, value, target) PRIMARY KEY (pid, season, slot)
|
||||
player.mt_battlepass_claim (pid, season, slot, claimed_at) PRIMARY KEY (pid, season, slot); slot 0 = final
|
||||
```
|
||||
|
||||
**Counting.** Events are counted in memory, as the delta per slot. `CHARACTER::SaveReal`, which covers the periodic save, logout and warp, adds play time, then queues one upsert on the game's ordered SQL connection:
|
||||
|
||||
`value = LEAST(value + delta, target)`
|
||||
|
||||
Because the write adds, a core does not need to have read the row first. Two cores that both see the player during a warp add their own deltas, with no overwrite.
|
||||
|
||||
**Loading.** At the first event or `/mt_bp`, a `FuncQuery` reads the stored values and claims. Flushes queued after that read are added on top. A generation number drops the answers of a session that has already ended.
|
||||
|
||||
**Season change.** The counts of the old season are written while that season is still in the file. The new season then loads its own rows.
|
||||
|
||||
**Claims.** A claim checks four things before writing anything:
|
||||
1. the state is loaded;
|
||||
2. the mission is complete;
|
||||
3. the slot is not claimed yet;
|
||||
4. all the stacks fit in the bag. The fit is first-fit in `GetEmptyInventory` order, and a size-2 or size-3 item stays inside one 45-cell page.
|
||||
|
||||
Only then does it run `INSERT IGNORE` into the claim table synchronously. Only the request whose insert affected a row creates the items, into the cells checked before. A double click, a retry or another core finds the row already there and gets `claimed`. Each item gets an `MT_BP_CLAIM` item log with the hint `SEASON SLOT`, and the character is saved right away.
|
||||
|
||||
Known limits:
|
||||
- If the core crashes between the claim row and the item save, that reward is lost. The claim row and the item log are there for a GM to compensate.
|
||||
- While a warp is in flight, the window can show slightly less progress than is stored. Nothing is lost or counted twice.
|
||||
|
||||
## Protocol
|
||||
|
||||
```
|
||||
/mt_bp 1 info | 1 claim SLOT | 1 close
|
||||
MTBP1 season ID START END NOW COUNT
|
||||
MTBP1 mission SLOT TYPE SUB TARGET VALUE CLAIMED [VNUM COUNT]...
|
||||
MTBP1 final CLAIMED ALLDONE [VNUM COUNT]...
|
||||
MTBP1 end
|
||||
MTBP1 none no season running (or no valid file)
|
||||
MTBP1 progress SLOT VALUE pushed while the window is open
|
||||
MTBP1 done SLOT a mission was finished (always sent)
|
||||
MTBP1 claimed SLOT the reward is in the bag; a full info follows
|
||||
MTBP1 error loading|slot|claimed|incomplete|space|config|db|rate|invalid
|
||||
```
|
||||
|
||||
- `info` before the load is answered as soon as the load arrives.
|
||||
- A `done` for a mission that an event finished before the load is sent when the load arrives.
|
||||
- `info` and `claim` share a 300 ms gap per player (`rate`).
|
||||
- A wrong version, more than three tokens, or a token longer than 10 characters gets no answer.
|
||||
|
||||
## Setup
|
||||
|
||||
1. Apply `tools/battlepass/schema.sql` once.
|
||||
2. Copy `port_battlepass.tsv` to the locale base directory.
|
||||
3. Restart the cores with the new binary.
|
||||
|
||||
Without the file, every `/mt_bp` answers `none` and nothing is counted or written.
|
||||
@@ -39,7 +39,7 @@ Rules:
|
||||
|
||||
| RULE | Meaning of MIN/MAX and weights |
|
||||
|---|---|
|
||||
| 0 | rank common drop; MIN/MAX = eligible player levels |
|
||||
| 0 | rank common drop (common_drop_item.txt) or level-range common drop (common_drop_new.txt, MIN/MAX clipped to monster level ±20); MIN/MAX = eligible player levels |
|
||||
| 1 | independent monster drop group; weight is original configured threshold, not final probability |
|
||||
| 2 | weighted kill group; MIN = original kill-per-drop parameter; weight/group total describe the conditional selection |
|
||||
| 3 | level group; MIN = player minimum level; original denominator 1,000,000 |
|
||||
|
||||
@@ -0,0 +1,101 @@
|
||||
# PORT VIP card
|
||||
|
||||
A card extends all seven original premium services of the account. 40250 has the services but no in-game way to grant them. Source: `src/server/game/src/port_premium.h`, the hook in `CHARACTER::UseItem` (char_item.cpp), the enter-game refresh in input_login.cpp, `CHARACTER::PortSetPremiumTime` (char.h) and `/mt_vip` (cmd_general.cpp, cmd.cpp). Item data (size, flags, names, shop): metin2-client `tools/server/vip-card`.
|
||||
|
||||
## Services
|
||||
|
||||
`account.account` holds one end time per service. The game keeps them in `m_aiPremiumTimes` and shows affect `AFFECT_PREMIUM_START + i` (500..506) as the icon.
|
||||
|
||||
| i | Premium | Column | Effect on newcibn |
|
||||
|---|---|---|---|
|
||||
| 0 | `PREMIUM_EXP` | `silver_expire` | monster exp ×1.2 × `mob_exp_buyer`/100 (char_battle.cpp) |
|
||||
| 1 | `PREMIUM_ITEM` | `gold_expire` | item drop rate |
|
||||
| 2 | `PREMIUM_SAFEBOX` | `safebox_expire` | safebox size 3 (input_db.cpp) |
|
||||
| 3 | `PREMIUM_AUTOLOOT` | `autoloot_expire` | gold goes straight to the bag (char_battle.cpp) |
|
||||
| 4 | `PREMIUM_FISH_MIND` | `fish_mind_expire` | fishing |
|
||||
| 5 | `PREMIUM_MARRIAGE_FAST` | `marriage_fast_expire` | marriage love points |
|
||||
| 6 | `PREMIUM_GOLD` | `money_drop_rate_expire` | gold drop rate |
|
||||
|
||||
## Cards
|
||||
|
||||
| Vnum | Days |
|
||||
|---|---|
|
||||
| 38001 | 7 |
|
||||
| 38002 | 30 |
|
||||
|
||||
Both are unused `ITEM_NONE` rows in 40250. `PortVipUseCard` runs in `UseItem` after the sex check, before any type handling, so the item type does not matter.
|
||||
|
||||
When a card is used:
|
||||
|
||||
1. The card is refused, and not consumed, in two cases:
|
||||
- the player used a card or `/mt_vip` less than 1 s ago (`rate`);
|
||||
- for any service, the remaining time plus the card would exceed 400 days (`full`). The `int` end times stay far below 2038.
|
||||
2. Otherwise one card is consumed, with an `MT_VIP_CARD` item log whose hint is the number of days.
|
||||
3. One `UPDATE` moves every column to `GREATEST(UNIX_TIMESTAMP(col), UNIX_TIMESTAMP()) + days × 86400`. A service that has expired restarts from now; a running one is extended.
|
||||
|
||||
## Freshness
|
||||
|
||||
Auth reads the columns only at login and passes them to the db core's `CLoginData`. Every later player load, such as a warp or a core change, fills `TPlayerTable.aiPremiumTimes` from that login-time copy. So after a card, and on every enter-game, the game reads the row itself.
|
||||
|
||||
`PortVipRefresh` handles this:
|
||||
- It queues `SELECT UNIX_TIMESTAMP(col)... FROM account.account WHERE id=` through `DBManager::FuncQuery`. That is the same ordered queue and connection as the card's `UPDATE`, so the read sees the update.
|
||||
- The answer finds the player again by PID and checks the account ID; if the player has left, nothing happens.
|
||||
- For each service whose end changed, it sets `m_aiPremiumTimes[i]`, then either adds the affect with the remaining duration or removes it if the service has expired.
|
||||
- It logs `PORT_VIP: <name> type <i> end <unix>`.
|
||||
|
||||
The db core is not changed.
|
||||
|
||||
## Protocol
|
||||
|
||||
```
|
||||
/mt_vip 1 status ask for the remaining time
|
||||
MTVIP1 times R0 R1 R2 R3 R4 R5 R6 remaining seconds per service (0 = none), PREMIUM_EXP .. PREMIUM_GOLD
|
||||
MTVIP1 added VNUM DAYS a card was consumed; a times line follows once the row is read back
|
||||
MTVIP1 error CODE rate full invalid
|
||||
```
|
||||
|
||||
- `status` and card use share the 1 s throttle per player.
|
||||
- A wrong version, or more than three tokens, gets no answer; an old client never sends one.
|
||||
- The client (metin2-client `src/platform/ScriptLib/VipScript.inc`, module `mt_vip`) treats a `status` with no answer within 3 s as a server without the feature.
|
||||
|
||||
## Exp bonus
|
||||
|
||||
On newcibn the premium exp branch multiplies by 1.2 and then by `GetMobExpRate`, which returns event flag `mob_exp_buyer` (default 100). `/e mob_exp_buyer 167` gives 1.2 × 1.67 ≈ 2.0, that is +100 %. Event flags live in `player.quest` (pid 0) and every core shares them, so the flag is set once, by a GM, at deploy.
|
||||
|
||||
## Verification
|
||||
|
||||
- `tests/features/test_vip.py` checks the wiring:
|
||||
- the command entry is at the end of `cmd_info`;
|
||||
- the include is outside the `__AUCTION__` block;
|
||||
- the hook sits between the sex check and the summon-item block;
|
||||
- the refresh runs after the login affect loop.
|
||||
- It also compiles the production header against a stub account table, the ordered SQL queue and the affects. It covers:
|
||||
- a 7-day card, the read-back and the icons;
|
||||
- the gap refusal, then a 30-day card stacked onto the current end;
|
||||
- the 400-day cap: no card consumed, no query;
|
||||
- other items left untouched;
|
||||
- the enter-game refresh over stale values;
|
||||
- a service expired by hand, and the `status` command;
|
||||
- a player who leaves before the answer, and a missing account row.
|
||||
- Live test, channel5 (2026-10-15), Admin account with all expire values reset to 0:
|
||||
- 38002 (30 days) set all seven columns to now + 30 days, added affects 500..506 and returned `times 2592000…`.
|
||||
- Two 38001 used through the inventory right-click, 2 s apart, extended to 44 days.
|
||||
- A same-map `/warp` reloaded the player with the login-time 30 days. The refresh logged the seven `PORT_VIP` corrections to 44 days, and the panel showed "剩余 43 天 23 小时" for every service.
|
||||
- Earlier, with premium, autoloot gold went straight to the bag; without it, the gold stayed on the ground.
|
||||
|
||||
## Production deployment
|
||||
|
||||
- Deployed 2026-10-16 (server clock 2026-10-15 20:44) with the user's approval, 0 players online. Server main 69e335b, which includes the `/m` command-prefix fix 3590a06. Game sha256 `8d0bf9f0…` (the channel-5 tested binary); db unchanged.
|
||||
- Package: `/root/deploy-features/20261016-vip` (metin2-client `tools/server` at main 32372c2a).
|
||||
- Binary backup: `/root/backup-bin/20261015-204352`.
|
||||
- Rollback: `sh /root/deploy-features/20261016-vip/deploy.sh rollback`. The data backups are in `/root/backup-vip-card/20261015-204353` and `/root/backup-npcshop/item_mall-20261015-204353`.
|
||||
- `/usr/metin2/src` was synced with the six changed files.
|
||||
- `deploy.sh go` stops every core, then installs the game. It runs `vip-card/install.sh` and the item-mall shop install while the db core is down, since db reads `item_proto.txt` at boot. Then it starts db alone, waits for port 15000, and starts auth, CH1–CH4, game99 and channel5: 14 game, 1 db, 1 auth.
|
||||
- At boot the db core rewrites `player.item_proto` from the txt, with `locale_name` `Noname` for every item; names come from `item_names.txt`. Both cards: size 1, flag 8196, antiflag 256.
|
||||
- `/e mob_exp_buyer 167` was set from CH1. Every core logged `QUEST eventflag mob_exp_buyer 167`, and the row is in `player.quest` (pid 0).
|
||||
- CH1 (13000) acceptance:
|
||||
- `/m 101` spawned and `/purge` removed it.
|
||||
- 9010 (map a1) lists 38001/38002. A buyer from another empire pays the original triple price (shop.cpp), 15 000 000 for a 7-day card.
|
||||
- Two 38001 bought: each takes one cell (a shop buy never merges), and dragging one onto the other gives a stack of 2.
|
||||
- Using one: `added 38001 7`, then `times 4400055…`. The panel shows 50 days 22 hours for all seven services.
|
||||
- syserr only has the pre-existing `new_quest_lv52` LUA_ERROR.
|
||||
@@ -57,6 +57,7 @@
|
||||
// #include "HackShield.h"
|
||||
#include "skill_power.h"
|
||||
#include "buff_on_attributes.h"
|
||||
#include "port_battlepass_hooks.h"
|
||||
|
||||
#ifdef __PET_SYSTEM__
|
||||
#include "PetSystem.h"
|
||||
@@ -1304,6 +1305,8 @@ void CHARACTER::SaveReal()
|
||||
marriage::TMarriage* pMarriage = marriage::CManager::instance().Get(GetPlayerID());
|
||||
if (pMarriage)
|
||||
pMarriage->Save();
|
||||
|
||||
PortBpSave(this); // PORT: battle pass progress
|
||||
}
|
||||
|
||||
void CHARACTER::FlushDelayedSaveItem()
|
||||
@@ -1393,6 +1396,7 @@ void CHARACTER::Disconnect(const char * c_pszReason)
|
||||
|
||||
SaveAffect();
|
||||
m_bIsLoadedAffect = false;
|
||||
PortBpLogout(this); // PORT: battle pass, after the last save
|
||||
|
||||
m_bSkipSave = true; // 이 이후에는 더이상 저장하면 안된다.
|
||||
|
||||
@@ -3063,6 +3067,8 @@ void CHARACTER::PointChange(BYTE type, int amount, bool bAmount, bool bBroadcast
|
||||
|
||||
if (amount)
|
||||
{
|
||||
if (amount > 0)
|
||||
PortBpCount(this, PORT_BP_LEVEL_UP, 0, amount); // PORT: battle pass
|
||||
quest::CQuestManager::instance().LevelUp(GetPlayerID());
|
||||
|
||||
LogManager::instance().LevelLog(this, val, GetRealPoint(POINT_PLAYTIME) + (get_dword_time() - m_dwPlayStartTime) / 60000);
|
||||
|
||||
@@ -1746,6 +1746,8 @@ class CHARACTER : public CEntity, public CFSM, public CHorseRider
|
||||
|
||||
public:
|
||||
int GetPremiumRemainSeconds(BYTE bType) const;
|
||||
// PORT: the VIP card re-reads the account end times (port_premium.h).
|
||||
void PortSetPremiumTime(BYTE bType, int iTime) { if (bType < PREMIUM_MAX_NUM) m_aiPremiumTimes[bType] = iTime; }
|
||||
|
||||
private:
|
||||
int m_aiPremiumTimes[PREMIUM_MAX_NUM];
|
||||
|
||||
@@ -40,6 +40,7 @@
|
||||
#include "BlueDragon.h"
|
||||
#include "DragonLair.h"
|
||||
#include <random>
|
||||
#include "port_battlepass_hooks.h"
|
||||
#include <algorithm>
|
||||
DWORD AdjustExpByLevel(const LPCHARACTER ch, const DWORD exp)
|
||||
{
|
||||
@@ -785,6 +786,8 @@ void CHARACTER::Reward(bool bItemDrop)
|
||||
pkAttacker->UpdateAlignment(2);
|
||||
|
||||
pkAttacker->SetQuestNPCID(GetVID());
|
||||
// PORT: battle pass kill, credited like the quest kill below (port_battlepass_runtime.h).
|
||||
PortBpKill(pkAttacker, this);
|
||||
quest::CQuestManager::instance().Kill(pkAttacker->GetPlayerID(), GetRaceNum());
|
||||
CHARACTER_MANAGER::instance().KillLog(GetRaceNum());
|
||||
|
||||
|
||||
@@ -50,6 +50,8 @@
|
||||
#ifdef __AUCTION__
|
||||
#include "auction_manager.h"
|
||||
#endif
|
||||
#include "port_premium.h"
|
||||
#include "port_battlepass_hooks.h"
|
||||
const int ITEM_BROKEN_METIN_VNUM = 28960;
|
||||
|
||||
// CHANGE_ITEM_ATTRIBUTES
|
||||
@@ -923,6 +925,7 @@ bool CHARACTER::DoRefine(LPITEM item, bool bMoneyOnly)
|
||||
{
|
||||
ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
|
||||
LogManager::instance().ItemLog(this, pkNewItem, "REFINE SUCCESS", pkNewItem->GetName());
|
||||
PortBpCount(this, PORT_BP_REFINE, pkNewItem->GetVnum(), 1); // PORT: battle pass
|
||||
|
||||
WORD bCell = item->GetCell();
|
||||
|
||||
@@ -1196,6 +1199,7 @@ bool CHARACTER::DoRefineWithScroll(LPITEM item)
|
||||
{
|
||||
ITEM_MANAGER::CopyAllAttrTo(item, pkNewItem);
|
||||
LogManager::instance().ItemLog(this, pkNewItem, "REFINE SUCCESS", pkNewItem->GetName());
|
||||
PortBpCount(this, PORT_BP_REFINE, pkNewItem->GetVnum(), 1); // PORT: battle pass
|
||||
|
||||
WORD bCell = item->GetCell();
|
||||
|
||||
@@ -5207,6 +5211,10 @@ bool CHARACTER::UseItem(TItemPos Cell, TItemPos DestCell)
|
||||
return false;
|
||||
}
|
||||
|
||||
// PORT: VIP card (port_premium.h)
|
||||
if (PortVipUseCard(this, item))
|
||||
return true;
|
||||
|
||||
//PREVENT_TRADE_WINDOW
|
||||
if (IS_SUMMON_ITEM(item->GetVnum()))
|
||||
{
|
||||
|
||||
@@ -13,6 +13,8 @@ ACMD(do_port_features);
|
||||
ACMD(do_port_switchbot);
|
||||
ACMD(do_port_pickup);
|
||||
ACMD(do_port_chest);
|
||||
ACMD(do_port_vip);
|
||||
ACMD(do_port_bp);
|
||||
ACMD(do_user_horse_ride);
|
||||
ACMD(do_user_horse_back);
|
||||
ACMD(do_user_horse_feed);
|
||||
@@ -605,6 +607,8 @@ struct command_info cmd_info[] =
|
||||
{ "mt_switchbot", do_port_switchbot, 0, POS_DEAD, GM_PLAYER },
|
||||
{ "mt_pickup", do_port_pickup, 0, POS_DEAD, GM_PLAYER },
|
||||
{ "mt_chest", do_port_chest, 0, POS_DEAD, GM_PLAYER },
|
||||
{ "mt_vip", do_port_vip, 0, POS_DEAD, GM_PLAYER },
|
||||
{ "mt_bp", do_port_bp, 0, POS_DEAD, GM_PLAYER },
|
||||
{ "\n", NULL, 0, POS_DEAD, GM_IMPLEMENTOR } /* 반드시 이 것이 마지막이어야 한다. */
|
||||
};
|
||||
|
||||
|
||||
@@ -46,6 +46,23 @@
|
||||
#include "port_switchbot.h"
|
||||
#include "port_pickup.h"
|
||||
#include "port_chest.h"
|
||||
#include "port_premium.h"
|
||||
#include "port_battlepass_runtime.h"
|
||||
|
||||
ACMD(do_port_vip)
|
||||
{
|
||||
if (!ch || !ch->IsPC() || !ch->GetDesc())
|
||||
return;
|
||||
PortVipCommand(ch, argument);
|
||||
}
|
||||
|
||||
// PORT: battle pass (port_battlepass_runtime.h)
|
||||
ACMD(do_port_bp)
|
||||
{
|
||||
if (!ch || !ch->IsPC() || !ch->GetDesc())
|
||||
return;
|
||||
PortBpCommand(ch, argument);
|
||||
}
|
||||
|
||||
extern int g_server_id;
|
||||
|
||||
|
||||
@@ -23,6 +23,7 @@
|
||||
|
||||
#include "affect.h"
|
||||
#include "unique_item.h"
|
||||
#include "port_battlepass_hooks.h"
|
||||
#endif
|
||||
|
||||
namespace fishing
|
||||
@@ -634,6 +635,7 @@ void Take(fishing_event_info* info, LPCHARACTER ch)
|
||||
if (item_vnum)
|
||||
{
|
||||
FishingSuccess(ch);
|
||||
PortBpCount(ch, PORT_BP_CATCH_FISH, item_vnum, 1); // PORT: battle pass
|
||||
|
||||
TPacketGCFishing p;
|
||||
p.header = HEADER_GC_FISHING;
|
||||
|
||||
@@ -963,6 +963,22 @@ void CInputDB::Boot(const char* data)
|
||||
return;
|
||||
}
|
||||
|
||||
// AVA2 NEW_COMMON_DROP; optional so the binary still runs on a locale without the file
|
||||
char szCommonDropNewFileName[FILE_NAME_LEN];
|
||||
snprintf(szCommonDropNewFileName, sizeof(szCommonDropNewFileName), "%s/common_drop_new.txt", LocaleService_GetBasePath().c_str());
|
||||
if (access(szCommonDropNewFileName, R_OK) != 0)
|
||||
sys_log(0, "LoadLocaleFile: CommonDropNew: %s absent", szCommonDropNewFileName);
|
||||
else
|
||||
{
|
||||
sys_log(0, "LoadLocaleFile: CommonDropNew: %s", szCommonDropNewFileName);
|
||||
if (!ITEM_MANAGER::instance().ReadCommonDropNewItemFile(szCommonDropNewFileName))
|
||||
{
|
||||
sys_err("cannot load CommonDropNew: %s", szCommonDropNewFileName);
|
||||
thecore_shutdown();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
sys_log(0, "LoadLocaleFile: ETCDropItem: %s", szETCDropItemFileName);
|
||||
if (!ITEM_MANAGER::instance().ReadEtcDropItemFile(szETCDropItemFileName))
|
||||
{
|
||||
|
||||
@@ -28,6 +28,9 @@
|
||||
#include "block_country.h"
|
||||
#include "dev_log.h"
|
||||
#include "log.h"
|
||||
#include "db.h"
|
||||
#include "item.h"
|
||||
#include "port_premium.h"
|
||||
#include "horsename_manager.h"
|
||||
#include "MarkManager.h"
|
||||
// #include "HackShield.h"
|
||||
@@ -642,6 +645,8 @@ void CInputLogin::Entergame(LPDESC d, const char * data)
|
||||
ch->AddAffect(AFFECT_PREMIUM_START + i, POINT_NONE, 0, 0, remain, 0, true);
|
||||
sys_log(0, "PREMIUM: %s type %d %dmin", ch->GetName(), i, remain);
|
||||
}
|
||||
// PORT: the db core keeps the login-time premium ends; a VIP card used since then is in the account table.
|
||||
PortVipRefresh(ch, false);
|
||||
|
||||
if (LC_IsEurope())
|
||||
{
|
||||
|
||||
@@ -817,25 +817,26 @@ bool ITEM_MANAGER::GetDropPct(LPCHARACTER pkChr, LPCHARACTER pkKiller, OUT int&
|
||||
|
||||
//if (pkKiller->GetPoint(POINT_MALL_ITEMBONUS) > 0)
|
||||
//iDeltaPercent += iDeltaPercent * pkKiller->GetPoint(POINT_MALL_ITEMBONUS) / 100;
|
||||
// ADD_PREMIUM
|
||||
// ADD_PREMIUM (AVA2 rates: premium or a thief glove doubles, everyone else gets +50%)
|
||||
if (pkKiller->GetPremiumRemainSeconds(PREMIUM_ITEM) > 0 ||
|
||||
pkKiller->IsEquipUniqueGroup(UNIQUE_GROUP_DOUBLE_ITEM))
|
||||
iDeltaPercent += iDeltaPercent;
|
||||
else
|
||||
iDeltaPercent += iDeltaPercent / 2;
|
||||
// END_OF_ADD_PREMIUM
|
||||
|
||||
// PC_BANG_ITEM_ADD
|
||||
if (pkKiller->GetPoint(POINT_PC_BANG_DROP_BONUS) > 0)
|
||||
{
|
||||
if (pkKiller->IsPCBang() == true)
|
||||
iDeltaPercent += iDeltaPercent * pkKiller->GetPoint(POINT_PC_BANG_DROP_BONUS)/100;
|
||||
}
|
||||
// END_PC_BANG_ITEM_ADD
|
||||
// AVA2: the permanent glove adds 100 with premium and 50 alone (or a removable glove with premium). This also
|
||||
// fixes the original ternary without parentheses, which always made the divisor 100 and ignored PRIV_ITEM_DROP.
|
||||
int bonus = 0;
|
||||
if (pkKiller->IsEquipUniqueItem(UNIQUE_ITEM_DOUBLE_ITEM) && pkKiller->GetPremiumRemainSeconds(PREMIUM_ITEM) > 0)
|
||||
bonus = 100;
|
||||
else if (pkKiller->IsEquipUniqueItem(UNIQUE_ITEM_DOUBLE_ITEM) ||
|
||||
(pkKiller->IsEquipUniqueGroup(UNIQUE_GROUP_DOUBLE_ITEM) && pkKiller->GetPremiumRemainSeconds(PREMIUM_ITEM) > 0))
|
||||
bonus = 50;
|
||||
|
||||
iRandRange = 4000000;
|
||||
iRandRange = iRandRange * 100 /
|
||||
(100 +
|
||||
CPrivManager::instance().GetPriv(pkKiller, PRIV_ITEM_DROP) +
|
||||
pkKiller->IsEquipUniqueItem(UNIQUE_ITEM_DOUBLE_ITEM)?100:0);
|
||||
iRandRange = iRandRange * 100 /
|
||||
(100 + CPrivManager::instance().GetPriv(pkKiller, PRIV_ITEM_DROP) + bonus);
|
||||
|
||||
if (distribution_test_server) iRandRange /= 3;
|
||||
|
||||
@@ -926,6 +927,26 @@ bool ITEM_MANAGER::CreateDropItem(LPCHARACTER pkChr, LPCHARACTER pkKiller, std::
|
||||
}
|
||||
}
|
||||
|
||||
// AVA2 NEW_COMMON_DROP: killer level within a group's range and within 20 levels of the victim
|
||||
if (abs(pkChr->GetLevel() - iLevel) <= 20)
|
||||
{
|
||||
for (size_t g = 0; g < m_vec_pkCommonNewItemGroup.size(); ++g)
|
||||
{
|
||||
const CCommonDropNew* commonNew = m_vec_pkCommonNewItemGroup[g];
|
||||
if (iLevel < commonNew->minLevel || iLevel > commonNew->maxLevel || !commonNew->CanDropThisMap(pkKiller->GetMapIndex()))
|
||||
continue;
|
||||
for (size_t i = 0; i < commonNew->m_vecProbs.size(); ++i)
|
||||
{
|
||||
int iPercent = (commonNew->m_vecProbs[i] * iDeltaPercent) / 100;
|
||||
if (iPercent >= number(1, iRandRange))
|
||||
{
|
||||
item = CreateItem(commonNew->m_vecItems[i].first, commonNew->m_vecItems[i].second, 0, true);
|
||||
if (item) vec_item.push_back(item);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MobDropItem Group
|
||||
{
|
||||
itertype(m_map_pkMobItemGroup) it;
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
#ifndef __INC_ITEM_MANAGER__
|
||||
#define __INC_ITEM_MANAGER__
|
||||
#include "port_feature_types.h"
|
||||
#include <climits>
|
||||
|
||||
#ifdef M2_USE_POOL
|
||||
#include "pool.h"
|
||||
@@ -273,6 +274,31 @@ class CDropItemGroup
|
||||
std::vector<SDropItemGroupInfo> m_vec_items;
|
||||
};
|
||||
|
||||
// AVA2 NEW_COMMON_DROP (common_drop_new.txt): level-ranged, optionally map-restricted groups replacing the
|
||||
// rank-based common_drop_item.txt. Probabilities are stored on the 40000-per-percent scale of the other drop tables.
|
||||
class CCommonDropNew
|
||||
{
|
||||
public:
|
||||
CCommonDropNew() : minLevel(0), maxLevel(INT_MAX) {}
|
||||
|
||||
bool CanDropThisMap(DWORD mapIndex) const
|
||||
{
|
||||
return m_vecMapIndex.empty() || std::find(m_vecMapIndex.begin(), m_vecMapIndex.end(), mapIndex) != m_vecMapIndex.end();
|
||||
}
|
||||
|
||||
void AddItem(DWORD dwItemVnum, DWORD iCount, DWORD iPartPct)
|
||||
{
|
||||
m_vecProbs.push_back(iPartPct);
|
||||
m_vecItems.push_back(std::make_pair(dwItemVnum, iCount));
|
||||
}
|
||||
|
||||
int minLevel;
|
||||
int maxLevel;
|
||||
std::vector<DWORD> m_vecMapIndex;
|
||||
std::vector<DWORD> m_vecProbs;
|
||||
std::vector<std::pair<DWORD, DWORD> > m_vecItems;
|
||||
};
|
||||
|
||||
class CLevelItemGroup
|
||||
{
|
||||
struct SLevelItemGroupInfo
|
||||
@@ -393,6 +419,7 @@ class ITEM_MANAGER : public singleton<ITEM_MANAGER>
|
||||
bool CreateDropItem(LPCHARACTER pkChr, LPCHARACTER pkKiller, std::vector<LPITEM> & vec_item);
|
||||
|
||||
bool ReadCommonDropItemFile(const char * c_pszFileName);
|
||||
bool ReadCommonDropNewItemFile(const char * c_pszFileName);
|
||||
bool ReadEtcDropItemFile(const char * c_pszFileName);
|
||||
bool ReadDropItemGroup(const char * c_pszFileName);
|
||||
bool ReadMonsterDropItemGroup(const char * c_pszFileName);
|
||||
@@ -444,6 +471,7 @@ class ITEM_MANAGER : public singleton<ITEM_MANAGER>
|
||||
std::map<DWORD, CMobItemGroup*> m_map_pkMobItemGroup;
|
||||
std::map<DWORD, CLevelItemGroup*> m_map_pkLevelItemGroup;
|
||||
std::map<DWORD, CBuyerThiefGlovesItemGroup*> m_map_pkGloveItemGroup;
|
||||
std::vector<CCommonDropNew*> m_vec_pkCommonNewItemGroup;
|
||||
|
||||
// CHECK_UNIQUE_GROUP
|
||||
std::map<DWORD, int> m_ItemToSpecialGroup;
|
||||
|
||||
@@ -169,9 +169,9 @@ bool ITEM_MANAGER::ReadSpecialDropItemFile(const char * c_pszFileName)
|
||||
if ("attr" == stType)
|
||||
{
|
||||
CSpecialAttrGroup * pkGroup = M2_NEW CSpecialAttrGroup(iVnum);
|
||||
for (int k = 1; k < 256; ++k)
|
||||
for (int k = 1; k < 1024; ++k) // AVA2 @fixme148: groups up to 1023 entries
|
||||
{
|
||||
char buf[4];
|
||||
char buf[8];
|
||||
snprintf(buf, sizeof(buf), "%d", k);
|
||||
|
||||
if (loader.GetTokenVector(buf, &pTok))
|
||||
@@ -212,9 +212,9 @@ bool ITEM_MANAGER::ReadSpecialDropItemFile(const char * c_pszFileName)
|
||||
else
|
||||
{
|
||||
CSpecialItemGroup * pkGroup = M2_NEW CSpecialItemGroup(iVnum, type);
|
||||
for (int k = 1; k < 256; ++k)
|
||||
for (int k = 1; k < 1024; ++k) // AVA2 @fixme148: groups up to 1023 entries
|
||||
{
|
||||
char buf[4];
|
||||
char buf[8];
|
||||
snprintf(buf, sizeof(buf), "%d", k);
|
||||
|
||||
if (loader.GetTokenVector(buf, &pTok))
|
||||
@@ -427,6 +427,96 @@ bool ITEM_MANAGER::ConvSpecialDropItemFile()
|
||||
return true;
|
||||
}
|
||||
|
||||
// AVA2 NEW_COMMON_DROP. Each group: optional "map_index" list (0 = every map), optional "level_range MIN MAX" of the
|
||||
// killer, entries "N vnum count percent". A malformed group fails the whole file like the other drop tables.
|
||||
bool ITEM_MANAGER::ReadCommonDropNewItemFile(const char * c_pszFileName)
|
||||
{
|
||||
CTextFileLoader loader;
|
||||
if (!loader.Load(c_pszFileName))
|
||||
return false;
|
||||
|
||||
std::vector<CCommonDropNew*> groups;
|
||||
std::string stName;
|
||||
bool ok = true;
|
||||
|
||||
for (DWORD i = 0; i < loader.GetChildNodeCount() && ok; ++i)
|
||||
{
|
||||
CCommonDropNew* dropPtr = M2_NEW CCommonDropNew;
|
||||
TTokenVector* pTok = NULL;
|
||||
loader.SetChildNode(i);
|
||||
loader.GetCurrentNodeName(&stName);
|
||||
|
||||
if (loader.GetTokenVector("map_index", &pTok))
|
||||
{
|
||||
if (pTok->empty())
|
||||
ok = false;
|
||||
for (DWORD j = 0; ok && j < pTok->size(); ++j)
|
||||
{
|
||||
DWORD mapIndex = 0;
|
||||
str_to_number(mapIndex, pTok->at(j).c_str());
|
||||
if (mapIndex)
|
||||
dropPtr->m_vecMapIndex.push_back(mapIndex);
|
||||
}
|
||||
}
|
||||
if (ok && loader.GetTokenVector("level_range", &pTok))
|
||||
{
|
||||
if (pTok->size() != 2)
|
||||
ok = false;
|
||||
else
|
||||
{
|
||||
str_to_number(dropPtr->minLevel, pTok->at(0).c_str());
|
||||
str_to_number(dropPtr->maxLevel, pTok->at(1).c_str());
|
||||
}
|
||||
}
|
||||
for (int k = 1; ok && k < 256; ++k)
|
||||
{
|
||||
char buf[4];
|
||||
snprintf(buf, sizeof(buf), "%d", k);
|
||||
if (!loader.GetTokenVector(buf, &pTok))
|
||||
continue;
|
||||
DWORD itemVnum = 0, itemCount = 0;
|
||||
float itemPct = 0.0f;
|
||||
if (pTok->size() != 3)
|
||||
{
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
str_to_number(itemVnum, pTok->at(0).c_str());
|
||||
str_to_number(itemCount, pTok->at(1).c_str());
|
||||
str_to_number(itemPct, pTok->at(2).c_str());
|
||||
if (!GetTable(itemVnum) || !itemCount)
|
||||
{
|
||||
sys_err("ReadCommonDropNewItemFile : no item %u (count %u) : node %s", itemVnum, itemCount, stName.c_str());
|
||||
ok = false;
|
||||
break;
|
||||
}
|
||||
dropPtr->AddItem(itemVnum, itemCount, (DWORD)(40000.0f * itemPct));
|
||||
}
|
||||
loader.SetParentNode();
|
||||
|
||||
if (!ok)
|
||||
sys_err("ReadCommonDropNewItemFile : Syntax error %s : node %s", c_pszFileName, stName.c_str());
|
||||
if (!ok || dropPtr->m_vecItems.empty())
|
||||
{
|
||||
M2_DELETE(dropPtr);
|
||||
continue;
|
||||
}
|
||||
groups.push_back(dropPtr);
|
||||
}
|
||||
|
||||
if (!ok)
|
||||
{
|
||||
for (size_t i = 0; i < groups.size(); ++i)
|
||||
M2_DELETE(groups[i]);
|
||||
return false;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < m_vec_pkCommonNewItemGroup.size(); ++i)
|
||||
M2_DELETE(m_vec_pkCommonNewItemGroup[i]);
|
||||
m_vec_pkCommonNewItemGroup.swap(groups);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool ITEM_MANAGER::ReadEtcDropItemFile(const char * c_pszFileName)
|
||||
{
|
||||
FILE * fp = fopen(c_pszFileName, "r");
|
||||
@@ -634,7 +724,7 @@ bool ITEM_MANAGER::ReadMonsterDropItemGroup(const char * c_pszFileName)
|
||||
else
|
||||
{
|
||||
bNew = false;
|
||||
CDropItemGroup* pkGroup = it->second;
|
||||
pkGroup = it->second;
|
||||
}
|
||||
|
||||
for (int k = 1; k < 256; ++k)
|
||||
|
||||
@@ -0,0 +1,226 @@
|
||||
#ifndef PORT_BATTLEPASS_H
|
||||
#define PORT_BATTLEPASS_H
|
||||
// PORT: battle pass, from AVA2's ENABLE_BATTLE_PASS (the monthly mission pass behind uibattlepassex.py). A season
|
||||
// is a time window from port_battlepass.tsv with up to ten missions, each with its own reward, and a final reward
|
||||
// once every mission is done. Only real server events count: kills, fishing, refines, level ups, NPC shop trades
|
||||
// and play time; the client only asks and claims. Progress and claims live in player.mt_battlepass_progress and
|
||||
// player.mt_battlepass_claim (unique per player, season and slot). Design: docs/FEATURE-BATTLEPASS.md.
|
||||
// This header holds the game-independent part: the config, the per-player state and the bag fit.
|
||||
#include <algorithm>
|
||||
#include <fstream>
|
||||
#include <istream>
|
||||
#include <limits>
|
||||
#include <set>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <sys/stat.h>
|
||||
#include <vector>
|
||||
|
||||
enum PortBpType {
|
||||
PORT_BP_NONE,
|
||||
PORT_BP_KILL_MONSTER, // sub: mob vnum, 0 = any normal monster (not a boss or a stone)
|
||||
PORT_BP_KILL_BOSS, // sub: mob vnum, 0 = any boss
|
||||
PORT_BP_KILL_STONE, // sub: stone vnum, 0 = any metin stone
|
||||
PORT_BP_PLAYTIME, // seconds online
|
||||
PORT_BP_CATCH_FISH, // sub: caught item vnum, 0 = any
|
||||
PORT_BP_REFINE, // successful refines; sub: resulting item vnum, 0 = any
|
||||
PORT_BP_LEVEL_UP, // levels gained
|
||||
PORT_BP_NPC_SPEND, // gold paid to NPC shops
|
||||
PORT_BP_NPC_SELL, // items sold to NPC shops; sub (required): item vnum
|
||||
PORT_BP_TYPE_MAX
|
||||
};
|
||||
static const unsigned kPortBpSlots=10; // mission slots 1..10; slot 0 is the final reward
|
||||
static const unsigned kPortBpMissionRewards=3; // AVA2 BATTLE_SUB_REWARD
|
||||
static const unsigned kPortBpFinalRewards=6; // AVA2 BATTLE_REWARD_MAX
|
||||
static const unsigned long long kPortBpMaxTarget=1000000000000ULL;
|
||||
static const unsigned kPortBpMaxRewardCount=10000;
|
||||
|
||||
struct PortBpReward {unsigned vnum,count;};
|
||||
struct PortBpMission {
|
||||
unsigned slot,type,sub;unsigned long long target;std::vector<PortBpReward> rewards;
|
||||
bool Matches(unsigned kind,unsigned what)const{return type==kind && (!sub || sub==what);}
|
||||
};
|
||||
struct PortBpSeason {
|
||||
unsigned id,start,end;std::vector<PortBpMission> missions;std::vector<PortBpReward> final;
|
||||
const PortBpMission* Slot(unsigned slot)const {
|
||||
for(const auto& m:missions)if(m.slot==slot)return &m;
|
||||
return nullptr;
|
||||
}
|
||||
bool Has(unsigned kind)const {
|
||||
for(const auto& m:missions)if(m.type==kind)return true;
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
// Whole-file config: any error disables the battle pass rather than running half a season.
|
||||
class PortBpConfig {
|
||||
public:
|
||||
std::vector<PortBpSeason> seasons;
|
||||
bool valid=false;
|
||||
std::string error;
|
||||
bool Parse(std::istream& input) {
|
||||
std::vector<PortBpSeason> next;std::string line;unsigned bytes=0,number=0;bool header=false;
|
||||
error.clear();
|
||||
auto fail=[&](const char* why){error="line "+std::to_string(number)+": "+why;return false;};
|
||||
auto run=[&]()->bool {
|
||||
while(std::getline(input,line)) {
|
||||
++number;bytes+=unsigned(line.size()+1);
|
||||
if(bytes>65536)return fail("file too large");
|
||||
if(!line.empty() && line.back()=='\r')line.pop_back();
|
||||
if(line.empty() || line[0]=='#')continue;
|
||||
if(!header){if(line!="MTBATTLEPASS 1")return fail("header");header=true;continue;}
|
||||
std::istringstream row(line);std::string word,token;std::vector<unsigned long long> v;
|
||||
row>>word;
|
||||
while(row>>token) {
|
||||
unsigned long long value=0;
|
||||
if(token.size()>13)return fail("number too long");
|
||||
for(char c:token){if(c<'0'||c>'9')return fail("not a number");value=value*10+unsigned(c-'0');}
|
||||
v.push_back(value);
|
||||
}
|
||||
if(word=="season") {
|
||||
if(v.size()!=3 || !v[0] || v[0]>0xffffffffULL || v[1]>=v[2] || v[2]>0xffffffffULL)return fail("season ID START END");
|
||||
if(next.size()>=64)return fail("too many seasons");
|
||||
for(const auto& s:next)if(s.id==v[0])return fail("duplicate season id");
|
||||
next.push_back(PortBpSeason{unsigned(v[0]),unsigned(v[1]),unsigned(v[2]),{},{}});
|
||||
continue;
|
||||
}
|
||||
if(next.empty())return fail("mission or final before season");
|
||||
PortBpSeason& season=next.back();
|
||||
std::vector<PortBpReward> rewards;
|
||||
auto pairs=[&](size_t from,unsigned most)->bool {
|
||||
if((v.size()-from)%2 || (v.size()-from)/2>most)return false;
|
||||
for(size_t i=from;i<v.size();i+=2) {
|
||||
if(!v[i] || v[i]>0xffffffffULL || !v[i+1] || v[i+1]>kPortBpMaxRewardCount)return false;
|
||||
rewards.push_back(PortBpReward{unsigned(v[i]),unsigned(v[i+1])});
|
||||
}
|
||||
return true;
|
||||
};
|
||||
if(word=="mission") {
|
||||
if(v.size()<4 || !pairs(4,kPortBpMissionRewards))return fail("mission SLOT TYPE SUB TARGET [VNUM COUNT]x0..3");
|
||||
if(!v[0] || v[0]>kPortBpSlots || season.Slot(unsigned(v[0])))return fail("slot 1..10, once per season");
|
||||
if(!v[1] || v[1]>=PORT_BP_TYPE_MAX)return fail("type");
|
||||
if(v[2]>0xffffffffULL)return fail("sub");
|
||||
const unsigned type=unsigned(v[1]);
|
||||
const bool subAllowed=type!=PORT_BP_PLAYTIME && type!=PORT_BP_LEVEL_UP && type!=PORT_BP_NPC_SPEND;
|
||||
if(v[2] && !subAllowed)return fail("this type takes sub 0");
|
||||
if(!v[2] && type==PORT_BP_NPC_SELL)return fail("NPC sell needs an item vnum");
|
||||
if(!v[3] || v[3]>kPortBpMaxTarget)return fail("target");
|
||||
season.missions.push_back(PortBpMission{unsigned(v[0]),type,unsigned(v[2]),v[3],rewards});
|
||||
continue;
|
||||
}
|
||||
if(word=="final") {
|
||||
if(!season.final.empty() || !pairs(0,kPortBpFinalRewards) || rewards.empty())return fail("final VNUM COUNT x1..6, once per season");
|
||||
season.final=rewards;
|
||||
continue;
|
||||
}
|
||||
return fail("unknown line");
|
||||
}
|
||||
if(input.bad())return fail("read error");
|
||||
if(!header)return fail("header");
|
||||
if(next.empty())return fail("no season");
|
||||
std::sort(next.begin(),next.end(),[](const PortBpSeason& a,const PortBpSeason& b){return a.start<b.start;});
|
||||
for(size_t i=0;i<next.size();++i) {
|
||||
if(next[i].missions.empty()){number=0;return fail("season without missions");}
|
||||
if(i && next[i].start<next[i-1].end){number=0;return fail("seasons overlap");}
|
||||
std::sort(next[i].missions.begin(),next[i].missions.end(),[](const PortBpMission& a,const PortBpMission& b){return a.slot<b.slot;});
|
||||
}
|
||||
return true;
|
||||
};
|
||||
valid=run();
|
||||
if(valid)seasons.swap(next);
|
||||
else seasons.clear();
|
||||
return valid;
|
||||
}
|
||||
const PortBpSeason* Active(long long now)const {
|
||||
if(!valid)return nullptr;
|
||||
for(const auto& s:seasons)if(now>=s.start && now<s.end)return &s;
|
||||
return nullptr;
|
||||
}
|
||||
// Same contract as the event calendar: an atomic file replacement is picked up by every core within 5 s.
|
||||
bool Refresh(const std::string& path,unsigned tick) {
|
||||
if(checked && unsigned(tick-lastCheck)<5000)return false;
|
||||
checked=true;lastCheck=tick;
|
||||
struct stat info;
|
||||
if(stat(path.c_str(),&info)!=0){const bool had=loaded;valid=false;seasons.clear();loaded=false;error="missing";return had;}
|
||||
if(loaded && info.st_mtime==modified && info.st_size==size && info.st_ino==inode)return false;
|
||||
loaded=true;modified=info.st_mtime;size=info.st_size;inode=info.st_ino;
|
||||
if(size>65536 || size<0){valid=false;seasons.clear();error="file too large";return true;}
|
||||
std::ifstream file(path);Parse(file);
|
||||
return true;
|
||||
}
|
||||
private:
|
||||
bool checked=false,loaded=false;unsigned lastCheck=0;time_t modified=0;off_t size=0;ino_t inode=0;
|
||||
};
|
||||
|
||||
// One player's view of the active season. base is what the database held when the load was queued, plus every
|
||||
// flush queued after it; delta is counted here and not flushed yet. Flushes add, so a missed load never loses
|
||||
// progress and the stored value is capped at the target by the database itself.
|
||||
struct PortBpState {
|
||||
unsigned season=0,generation=0;
|
||||
bool loaded=false,watching=false,wantInfo=false;
|
||||
unsigned long long base[kPortBpSlots+1]={},delta[kPortBpSlots+1]={},inflight[kPortBpSlots+1]={};
|
||||
std::set<unsigned> claimed; // slots; 0 = final
|
||||
unsigned playtimeMark=0; // get_dword_time() up to which play time has been counted
|
||||
unsigned lastCommand=0;
|
||||
unsigned long long Value(const PortBpMission& m)const {return std::min(m.target,base[m.slot]+delta[m.slot]);}
|
||||
bool Done(const PortBpMission& m)const {return base[m.slot]+delta[m.slot]>=m.target;}
|
||||
bool AllDone(const PortBpSeason& s)const {
|
||||
for(const auto& m:s.missions)if(!Done(m))return false;
|
||||
return true;
|
||||
}
|
||||
void Reset(unsigned id) {
|
||||
season=id;loaded=false;wantInfo=false;claimed.clear();
|
||||
std::fill(base,base+kPortBpSlots+1,0ULL);std::fill(delta,delta+kPortBpSlots+1,0ULL);std::fill(inflight,inflight+kPortBpSlots+1,0ULL);
|
||||
}
|
||||
};
|
||||
|
||||
// Adds amount to every unfinished mission of this kind; returns the slots that changed and those it finished.
|
||||
inline void PortBpAdd(const PortBpSeason& season,PortBpState& state,unsigned kind,unsigned what,unsigned long long amount,
|
||||
std::vector<unsigned>& changed,std::vector<unsigned>& finished) {
|
||||
if(!amount)return;
|
||||
for(const auto& m:season.missions) {
|
||||
if(!m.Matches(kind,what) || state.Done(m))continue;
|
||||
const unsigned long long left=m.target-(state.base[m.slot]+state.delta[m.slot]);
|
||||
state.delta[m.slot]+=std::min(left,amount);
|
||||
changed.push_back(m.slot);
|
||||
if(state.Done(m))finished.push_back(m.slot);
|
||||
}
|
||||
}
|
||||
|
||||
// Why a claim of slot (0 = final) cannot go ahead, or nullptr.
|
||||
inline const char* PortBpClaimError(const PortBpSeason& season,const PortBpState& state,unsigned slot) {
|
||||
if(!state.loaded)return "loading";
|
||||
if(slot>kPortBpSlots)return "slot";
|
||||
if(slot) {
|
||||
const PortBpMission* m=season.Slot(slot);
|
||||
if(!m)return "slot";
|
||||
if(state.claimed.count(slot))return "claimed";
|
||||
if(!state.Done(*m))return "incomplete";
|
||||
if(m->rewards.empty())return "slot";
|
||||
} else {
|
||||
if(season.final.empty())return "slot";
|
||||
if(state.claimed.count(0))return "claimed";
|
||||
if(!state.AllDone(season))return "incomplete";
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// First-fit placement of item sizes into a bag of pages, the order CHARACTER::GetEmptyInventory searches: an item
|
||||
// of size s at cell c takes c, c+width, ... c+width*(s-1), all in c's page. free is updated with the cells taken.
|
||||
inline bool PortBpFit(std::vector<bool>& free,unsigned page,unsigned width,const std::vector<unsigned>& sizes,std::vector<unsigned>& cells) {
|
||||
cells.clear();
|
||||
for(unsigned size:sizes) {
|
||||
bool placed=false;
|
||||
for(unsigned c=0;c<free.size() && !placed;++c) {
|
||||
if(!size || c%page+width*(size-1)>=page)continue;
|
||||
bool ok=true;
|
||||
for(unsigned k=0;k<size && ok;++k)ok=c+width*k<free.size() && free[c+width*k];
|
||||
if(!ok)continue;
|
||||
for(unsigned k=0;k<size;++k)free[c+width*k]=false;
|
||||
cells.push_back(c);placed=true;
|
||||
}
|
||||
if(!placed)return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,10 @@
|
||||
#ifndef PORT_BATTLEPASS_HOOKS_H
|
||||
#define PORT_BATTLEPASS_HOOKS_H
|
||||
// PORT: battle pass event hooks; defined in port_battlepass_runtime.h (cmd_general.cpp). docs/FEATURE-BATTLEPASS.md.
|
||||
#include "port_battlepass.h"
|
||||
class CHARACTER;
|
||||
void PortBpCount(CHARACTER* ch,unsigned kind,unsigned what,unsigned long long amount); // a real event, never rate-scaled
|
||||
void PortBpKill(CHARACTER* attacker,CHARACTER* victim); // CHARACTER::Reward, the quest kill attacker
|
||||
void PortBpSave(CHARACTER* ch); // CHARACTER::SaveReal
|
||||
void PortBpLogout(CHARACTER* ch); // CHARACTER::Disconnect, after the last save
|
||||
#endif
|
||||
@@ -0,0 +1,245 @@
|
||||
#ifndef PORT_BATTLEPASS_RUNTIME_H
|
||||
#define PORT_BATTLEPASS_RUNTIME_H
|
||||
// PORT: battle pass, game side (port_battlepass.h has the config and state). Protocol: docs/FEATURE-BATTLEPASS.md.
|
||||
// Included once, by cmd_general.cpp; the hooks in other files go through port_battlepass_hooks.h.
|
||||
#include <map>
|
||||
#include <memory>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include "port_battlepass_hooks.h"
|
||||
|
||||
static const unsigned kPortBpGapMs=300; // per-player gap between /mt_bp commands
|
||||
static const unsigned kPortBpMaxStacks=24; // reward items one claim may put in the bag
|
||||
static const int kPortBpKillLevelDelta=20; // AVA2: kills count only within 20 levels of the monster
|
||||
|
||||
inline PortBpConfig& PortBpConfigFile() {static PortBpConfig config;return config;}
|
||||
inline const PortBpSeason* PortBpSeasonNow() {
|
||||
PortBpConfig& config=PortBpConfigFile();
|
||||
if(config.Refresh(LocaleService_GetBasePath()+"/port_battlepass.tsv",get_dword_time()) && !config.valid && config.error!="missing")
|
||||
sys_err("PORT_BP: port_battlepass.tsv disabled: %s",config.error.c_str());
|
||||
return config.Active(get_global_time());
|
||||
}
|
||||
inline std::map<DWORD,PortBpState>& PortBpStates() {static std::map<DWORD,PortBpState> states;return states;}
|
||||
|
||||
inline void PortBpSendRewards(std::string& line,const std::vector<PortBpReward>& rewards) {
|
||||
for(const auto& r:rewards)line+=" "+std::to_string(r.vnum)+" "+std::to_string(r.count);
|
||||
}
|
||||
|
||||
inline void PortBpSendInfo(LPCHARACTER ch,const PortBpSeason& season,PortBpState& state) {
|
||||
state.watching=true;state.wantInfo=false;
|
||||
ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 season %u %u %u %lld %u",season.id,season.start,season.end,(long long)get_global_time(),unsigned(season.missions.size()));
|
||||
for(const auto& m:season.missions) {
|
||||
std::string line="MTBP1 mission "+std::to_string(m.slot)+" "+std::to_string(m.type)+" "+std::to_string(m.sub)+" "+
|
||||
std::to_string(m.target)+" "+std::to_string(state.Value(m))+" "+std::to_string(state.claimed.count(m.slot));
|
||||
PortBpSendRewards(line,m.rewards);
|
||||
ch->ChatPacket(CHAT_TYPE_COMMAND,"%s",line.c_str());
|
||||
}
|
||||
std::string line="MTBP1 final "+std::to_string(state.claimed.count(0))+" "+std::to_string(int(state.AllDone(season)));
|
||||
PortBpSendRewards(line,season.final);
|
||||
ch->ChatPacket(CHAT_TYPE_COMMAND,"%s",line.c_str());
|
||||
ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 end");
|
||||
}
|
||||
|
||||
// Queues the deltas as one additive, capped upsert on the game's ordered SQL connection.
|
||||
inline void PortBpFlush(DWORD pid,PortBpState& state,const PortBpSeason* season) {
|
||||
if(!state.season || !season || season->id!=state.season)return;
|
||||
std::string values;
|
||||
for(const auto& m:season->missions) {
|
||||
const unsigned long long d=state.delta[m.slot];
|
||||
if(!d)continue;
|
||||
values+=std::string(values.empty()?"":",")+"("+std::to_string(pid)+","+std::to_string(state.season)+","+std::to_string(m.slot)+","+
|
||||
std::to_string(std::min(d,m.target))+","+std::to_string(m.target)+")";
|
||||
state.base[m.slot]+=d;state.delta[m.slot]=0;
|
||||
if(!state.loaded)state.inflight[m.slot]+=d;
|
||||
}
|
||||
if(values.empty())return;
|
||||
DBManager::instance().Query("INSERT INTO player.mt_battlepass_progress (pid,season,slot,value,target) VALUES %s "
|
||||
"ON DUPLICATE KEY UPDATE value=LEAST(value+VALUES(value),VALUES(target)),target=VALUES(target)",values.c_str());
|
||||
}
|
||||
|
||||
inline void PortBpLoad(DWORD pid,PortBpState& state) {
|
||||
static unsigned generations=0;
|
||||
state.generation=++generations;
|
||||
std::fill(state.inflight,state.inflight+kPortBpSlots+1,0ULL);
|
||||
const unsigned season=state.season,generation=state.generation;
|
||||
DBManager::instance().FuncQuery([pid,season,generation](SQLMsg* msg) {
|
||||
auto it=PortBpStates().find(pid);
|
||||
if(it==PortBpStates().end() || it->second.generation!=generation || it->second.season!=season)return;
|
||||
PortBpState& state=it->second;
|
||||
if(!msg->Get()){sys_err("PORT_BP: load failed pid %u season %u",pid,season);return;}
|
||||
unsigned long long stored[kPortBpSlots+1]={};
|
||||
for(unsigned i=0;i<msg->Get()->uiNumRows;++i) {
|
||||
MYSQL_ROW row=mysql_fetch_row(msg->Get()->pSQLResult);
|
||||
if(!row || !row[0] || !row[1] || !row[2])continue;
|
||||
const unsigned slot=unsigned(strtoul(row[1],nullptr,10));
|
||||
if(slot>kPortBpSlots)continue;
|
||||
if(row[0][0]=='p')state.base[slot]=(stored[slot]=strtoull(row[2],nullptr,10))+state.inflight[slot];
|
||||
else state.claimed.insert(slot);
|
||||
}
|
||||
state.loaded=true;
|
||||
LPCHARACTER ch=CHARACTER_MANAGER::instance().FindByPID(pid);
|
||||
const PortBpSeason* now=PortBpConfigFile().Active(get_global_time());
|
||||
if(!ch || !now || now->id!=season)return;
|
||||
// PortBpNotify held back the done notices of events counted before the load; send those now.
|
||||
for(const auto& m:now->missions)
|
||||
if(stored[m.slot]<m.target && state.Done(m))ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 done %u",m.slot);
|
||||
if(state.wantInfo)PortBpSendInfo(ch,*now,state);
|
||||
},"SELECT 'p',slot,value FROM player.mt_battlepass_progress WHERE pid=%u AND season=%u "
|
||||
"UNION ALL SELECT 'c',slot,0 FROM player.mt_battlepass_claim WHERE pid=%u AND season=%u",pid,season,pid,season);
|
||||
}
|
||||
|
||||
inline const PortBpSeason* PortBpFindSeason(unsigned id) {
|
||||
for(const auto& s:PortBpConfigFile().seasons)if(s.id==id)return &s;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// The player's state for the active season, or nullptr when no season runs. A season change first writes what
|
||||
// was counted for the old season, while its definition is still in the file, then starts a fresh load.
|
||||
inline PortBpState* PortBpSync(LPCHARACTER ch,const PortBpSeason*& season) {
|
||||
if(!ch || !ch->IsPC() || !ch->GetDesc())return nullptr;
|
||||
season=PortBpSeasonNow();
|
||||
const DWORD pid=ch->GetPlayerID();
|
||||
auto& states=PortBpStates();
|
||||
auto it=states.find(pid);
|
||||
if(!season && it==states.end())return nullptr;
|
||||
if(it==states.end()) {
|
||||
it=states.emplace(pid,PortBpState()).first;
|
||||
it->second.playtimeMark=get_dword_time();
|
||||
}
|
||||
PortBpState& state=it->second;
|
||||
const unsigned id=season?season->id:0;
|
||||
if(state.season!=id) {
|
||||
if(state.season)PortBpFlush(pid,state,PortBpFindSeason(state.season));
|
||||
const bool watching=state.watching;
|
||||
state.Reset(id);state.watching=watching;
|
||||
state.playtimeMark=get_dword_time();
|
||||
if(id)PortBpLoad(pid,state);
|
||||
}
|
||||
return season?&state:nullptr;
|
||||
}
|
||||
|
||||
inline void PortBpNotify(LPCHARACTER ch,const PortBpSeason& season,PortBpState& state,const std::vector<unsigned>& changed,const std::vector<unsigned>& finished) {
|
||||
if(state.watching)
|
||||
for(unsigned slot:changed)ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 progress %u %llu",slot,state.Value(*season.Slot(slot)));
|
||||
if(!state.loaded)return; // values are not known yet; the window shows them once it is loaded
|
||||
for(unsigned slot:finished)ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 done %u",slot);
|
||||
}
|
||||
|
||||
inline void PortBpAccruePlaytime(LPCHARACTER ch,const PortBpSeason& season,PortBpState& state) {
|
||||
const unsigned now=get_dword_time(),seconds=(now-state.playtimeMark)/1000;
|
||||
if(!seconds)return;
|
||||
state.playtimeMark+=seconds*1000;
|
||||
if(!season.Has(PORT_BP_PLAYTIME))return;
|
||||
std::vector<unsigned> changed,finished;
|
||||
PortBpAdd(season,state,PORT_BP_PLAYTIME,0,seconds,changed,finished);
|
||||
PortBpNotify(ch,season,state,changed,finished);
|
||||
}
|
||||
|
||||
// Every hook calls this with a real event; amount is a count, gold or levels, never scaled by an event rate.
|
||||
void PortBpCount(LPCHARACTER ch,unsigned kind,unsigned what,unsigned long long amount) {
|
||||
const PortBpSeason* season=nullptr;
|
||||
PortBpState* state=PortBpSync(ch,season);
|
||||
if(!state || !amount || !season->Has(kind))return;
|
||||
std::vector<unsigned> changed,finished;
|
||||
PortBpAdd(*season,*state,kind,what,amount,changed,finished);
|
||||
PortBpNotify(ch,*season,*state,changed,finished);
|
||||
}
|
||||
|
||||
// CHARACTER::Reward: the attacker DistributeExp picked, the one the quest kill event goes to.
|
||||
void PortBpKill(LPCHARACTER attacker,LPCHARACTER victim) {
|
||||
if(!attacker || !victim || !attacker->IsPC() || victim->IsPC())return;
|
||||
const int gap=int(victim->GetLevel())-int(attacker->GetLevel());
|
||||
if(gap>kPortBpKillLevelDelta || gap<-kPortBpKillLevelDelta)return;
|
||||
const unsigned kind=victim->IsStone()?PORT_BP_KILL_STONE:victim->GetMobRank()>=MOB_RANK_BOSS?PORT_BP_KILL_BOSS:PORT_BP_KILL_MONSTER;
|
||||
PortBpCount(attacker,kind,victim->GetRaceNum(),1);
|
||||
}
|
||||
|
||||
// CHARACTER::SaveReal: the periodic and logout save also writes the battle pass.
|
||||
void PortBpSave(LPCHARACTER ch) {
|
||||
const PortBpSeason* season=nullptr;
|
||||
PortBpState* state=PortBpSync(ch,season);
|
||||
if(!state)return;
|
||||
PortBpAccruePlaytime(ch,*season,*state);
|
||||
PortBpFlush(ch->GetPlayerID(),*state,season);
|
||||
}
|
||||
|
||||
// CHARACTER::Disconnect, after the last save.
|
||||
void PortBpLogout(LPCHARACTER ch) {
|
||||
if(ch && ch->IsPC())PortBpStates().erase(ch->GetPlayerID());
|
||||
}
|
||||
|
||||
struct PortBpStack {unsigned vnum,count,size;};
|
||||
inline const char* PortBpStacks(const std::vector<PortBpReward>& rewards,std::vector<PortBpStack>& stacks) {
|
||||
stacks.clear();
|
||||
for(const auto& r:rewards) {
|
||||
const TItemTable* table=ITEM_MANAGER::instance().GetTable(r.vnum);
|
||||
if(!table || table->bType==ITEM_DS || !table->bSize || table->bSize>3)return "config";
|
||||
const bool stackable=IS_SET(table->dwFlags,ITEM_FLAG_STACKABLE) && !IS_SET(table->dwAntiFlags,ITEM_ANTIFLAG_STACK);
|
||||
for(unsigned left=r.count;left;) {
|
||||
const unsigned count=stackable?std::min<unsigned>(left,ITEM_MAX_COUNT):1;
|
||||
stacks.push_back(PortBpStack{r.vnum,count,table->bSize});left-=count;
|
||||
if(stacks.size()>kPortBpMaxStacks)return "config";
|
||||
}
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// /mt_bp 1 claim SLOT. The claim row is written first and synchronously; only the request that inserted it hands
|
||||
// out the items, into cells checked free beforehand, so retries, double clicks and other cores cannot pay twice.
|
||||
inline void PortBpClaim(LPCHARACTER ch,const PortBpSeason& season,PortBpState& state,unsigned slot) {
|
||||
if(const char* error=PortBpClaimError(season,state,slot)){ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 error %s",error);return;}
|
||||
const std::vector<PortBpReward>& rewards=slot?season.Slot(slot)->rewards:season.final;
|
||||
std::vector<PortBpStack> stacks;
|
||||
if(const char* error=PortBpStacks(rewards,stacks)){
|
||||
sys_err("PORT_BP: season %u slot %u has a reward that cannot go to the bag",season.id,slot);
|
||||
ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 error %s",error);return;
|
||||
}
|
||||
std::vector<bool> free(INVENTORY_MAX_NUM);
|
||||
for(unsigned c=0;c<INVENTORY_MAX_NUM;++c)free[c]=ch->IsEmptyItemGrid(TItemPos(INVENTORY,c),1);
|
||||
std::vector<unsigned> sizes,cells;
|
||||
for(const auto& s:stacks)sizes.push_back(s.size);
|
||||
if(!PortBpFit(free,INVENTORY_PAGE_SIZE,5,sizes,cells)){ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 error space");return;}
|
||||
const DWORD pid=ch->GetPlayerID();
|
||||
std::unique_ptr<SQLMsg> msg(DBManager::instance().DirectQuery(
|
||||
"INSERT IGNORE INTO player.mt_battlepass_claim (pid,season,slot,claimed_at) VALUES (%u,%u,%u,%lld)",pid,season.id,slot,(long long)get_global_time()));
|
||||
if(!msg || !msg->Get()){sys_err("PORT_BP: claim insert failed pid %u season %u slot %u",pid,season.id,slot);ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 error db");return;}
|
||||
state.claimed.insert(slot);
|
||||
if(msg->Get()->uiAffectedRows!=1){ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 error claimed");return;}
|
||||
const std::string hint=std::to_string(season.id)+" "+std::to_string(slot);
|
||||
for(size_t i=0;i<stacks.size();++i) {
|
||||
LPITEM item=ITEM_MANAGER::instance().CreateItem(stacks[i].vnum,stacks[i].count);
|
||||
if(!item){sys_err("PORT_BP: cannot create %u x%u for pid %u season %u slot %u",stacks[i].vnum,stacks[i].count,pid,season.id,slot);continue;}
|
||||
item->AddToCharacter(ch,TItemPos(INVENTORY,cells[i]));
|
||||
ITEM_MANAGER::instance().FlushDelayedSave(item);
|
||||
LogManager::instance().ItemLog(ch,item,"MT_BP_CLAIM",hint.c_str());
|
||||
}
|
||||
sys_log(0,"PORT_BP: %s claimed season %u slot %u (%u stacks)",ch->GetName(),season.id,slot,unsigned(stacks.size()));
|
||||
ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 claimed %u",slot);
|
||||
ch->Save();
|
||||
}
|
||||
|
||||
// /mt_bp 1 info | /mt_bp 1 claim SLOT | /mt_bp 1 close
|
||||
inline void PortBpCommand(LPCHARACTER ch,const char* argument) {
|
||||
std::istringstream input(argument);std::vector<std::string> args;std::string token;
|
||||
while(input>>token){if(token.size()>10 || args.size()>=3)return;args.push_back(token);}
|
||||
if(args.empty() || args[0]!="1")return;
|
||||
const PortBpSeason* season=nullptr;
|
||||
PortBpState* state=PortBpSync(ch,season);
|
||||
const bool info=args.size()==2 && args[1]=="info",close=args.size()==2 && args[1]=="close";
|
||||
const bool claim=args.size()==3 && args[1]=="claim" && args[2].size()<=2 && args[2].find_first_not_of("0123456789")==std::string::npos;
|
||||
if(!info && !close && !claim){ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 error invalid");return;}
|
||||
if(!state){if(!close)ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 none");return;}
|
||||
if(close){state->watching=false;return;}
|
||||
if(state->lastCommand && get_dword_time()-state->lastCommand<kPortBpGapMs){ch->ChatPacket(CHAT_TYPE_COMMAND,"MTBP1 error rate");return;}
|
||||
state->lastCommand=get_dword_time();
|
||||
PortBpAccruePlaytime(ch,*season,*state);
|
||||
if(info) {
|
||||
if(state->loaded)PortBpSendInfo(ch,*season,*state);
|
||||
else {state->wantInfo=true;state->watching=true;}
|
||||
return;
|
||||
}
|
||||
PortBpClaim(ch,*season,*state,unsigned(atoi(args[2].c_str())));
|
||||
if(state->loaded)PortBpSendInfo(ch,*season,*state);
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,103 @@
|
||||
#ifndef METIN2_PORT_PREMIUM_H
|
||||
#define METIN2_PORT_PREMIUM_H
|
||||
// PORT: VIP card. Using card 38001 (7 days) or 38002 (30 days) extends all seven premium services of the account
|
||||
// (account.account *_expire) from the later of now and their current end. The original server reads these columns
|
||||
// only when auth logs the account in, and the db core hands those login-time values to every later player load
|
||||
// (CLoginData), so after a card and on every enter-game the game re-reads them and updates m_aiPremiumTimes and the
|
||||
// AFFECT_PREMIUM_START+i icons. Protocol: docs/FEATURE-VIP.md.
|
||||
#include <cstdlib>
|
||||
#include <map>
|
||||
#include <sstream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
static const int kPortVipTypes=7; // PREMIUM_EXP .. PREMIUM_GOLD, in account column order
|
||||
static const char* const kPortVipColumns[kPortVipTypes]={"silver_expire","gold_expire","safebox_expire",
|
||||
"autoloot_expire","fish_mind_expire","marriage_fast_expire","money_drop_rate_expire"};
|
||||
static const DWORD kPortVipCards[][2]={{38001,7},{38002,30}};
|
||||
static const int kPortVipMaxDays=400; // remaining time a card may reach, far from the 2038 limit of the int times
|
||||
static const DWORD kPortVipGapMs=1000;
|
||||
|
||||
inline int PortVipCardDays(DWORD vnum) {
|
||||
for(const auto& card:kPortVipCards)if(card[0]==vnum)return int(card[1]);
|
||||
return 0;
|
||||
}
|
||||
|
||||
// One throttle per player id for card use and status requests: both queue a query whose answer updates memory.
|
||||
inline bool PortVipThrottled(LPCHARACTER ch) {
|
||||
static std::map<DWORD,DWORD> last;
|
||||
DWORD& at=last[ch->GetPlayerID()];
|
||||
if(at && get_dword_time()-at<kPortVipGapMs)return true;
|
||||
at=get_dword_time();
|
||||
return false;
|
||||
}
|
||||
|
||||
// The account's end times (unix seconds) are the truth: premium state, icons, and on request the client.
|
||||
inline void PortVipApply(LPCHARACTER ch,const int* times,bool report) {
|
||||
const int now=get_global_time();
|
||||
std::string line="MTVIP1 times";
|
||||
for(int i=0;i<kPortVipTypes;++i) {
|
||||
const int remain=times[i]-now;
|
||||
if(times[i]!=ch->GetPremiumRemainSeconds(i)+now) {
|
||||
ch->PortSetPremiumTime(i,times[i]);
|
||||
if(remain>0)ch->AddAffect(AFFECT_PREMIUM_START+i,POINT_NONE,0,0,remain,0,true);
|
||||
else ch->RemoveAffect(AFFECT_PREMIUM_START+i);
|
||||
sys_log(0,"PORT_VIP: %s type %d end %d",ch->GetName(),i,times[i]);
|
||||
}
|
||||
line+=" "+std::to_string(remain>0?remain:0);
|
||||
}
|
||||
if(report)ch->ChatPacket(CHAT_TYPE_COMMAND,"%s",line.c_str());
|
||||
}
|
||||
|
||||
inline void PortVipRefresh(LPCHARACTER ch,bool report) {
|
||||
if(!ch->GetDesc())return;
|
||||
const DWORD pid=ch->GetPlayerID(),account=ch->GetDesc()->GetAccountTable().id;
|
||||
std::string columns;
|
||||
for(int i=0;i<kPortVipTypes;++i)columns+=std::string(i?",":"")+"UNIX_TIMESTAMP("+kPortVipColumns[i]+")";
|
||||
DBManager::instance().FuncQuery([pid,account,report](SQLMsg* msg) {
|
||||
LPCHARACTER ch=CHARACTER_MANAGER::instance().FindByPID(pid);
|
||||
if(!ch || !ch->GetDesc() || ch->GetDesc()->GetAccountTable().id!=account)return;
|
||||
if(!msg->Get() || msg->Get()->uiNumRows!=1){sys_err("PORT_VIP: account %u not found",account);return;}
|
||||
MYSQL_ROW row=mysql_fetch_row(msg->Get()->pSQLResult);
|
||||
int times[kPortVipTypes];
|
||||
for(int i=0;i<kPortVipTypes;++i)times[i]=row[i]?atoi(row[i]):0;
|
||||
PortVipApply(ch,times,report);
|
||||
},"SELECT %s FROM account.account WHERE id=%u",columns.c_str(),account);
|
||||
}
|
||||
|
||||
// Called by CHARACTER::UseItem before the original item handling: true when the item is a VIP card, used or not.
|
||||
inline bool PortVipUseCard(LPCHARACTER ch,LPITEM item) {
|
||||
const int days=PortVipCardDays(item->GetVnum());
|
||||
if(!days)return false;
|
||||
if(!ch->IsPC() || !ch->GetDesc())return true;
|
||||
if(PortVipThrottled(ch)){ch->ChatPacket(CHAT_TYPE_COMMAND,"MTVIP1 error rate");return true;}
|
||||
for(int i=0;i<kPortVipTypes;++i) {
|
||||
const int remain=ch->GetPremiumRemainSeconds(i);
|
||||
if((remain>0?remain:0)+days*86400>kPortVipMaxDays*86400){ch->ChatPacket(CHAT_TYPE_COMMAND,"MTVIP1 error full");return true;}
|
||||
}
|
||||
const DWORD vnum=item->GetVnum(),account=ch->GetDesc()->GetAccountTable().id;
|
||||
std::string sets;
|
||||
for(int i=0;i<kPortVipTypes;++i) {
|
||||
const std::string column=kPortVipColumns[i];
|
||||
sets+=(i?",":"")+column+"=FROM_UNIXTIME(GREATEST(UNIX_TIMESTAMP("+column+"),UNIX_TIMESTAMP())+"+
|
||||
std::to_string(days*86400)+")";
|
||||
}
|
||||
LogManager::instance().ItemLog(ch,item,"MT_VIP_CARD",std::to_string(days).c_str());
|
||||
item->SetCount(item->GetCount()-1);
|
||||
// Same connection as the refresh, which therefore reads the updated row.
|
||||
DBManager::instance().Query("UPDATE account.account SET %s WHERE id=%u",sets.c_str(),account);
|
||||
ch->ChatPacket(CHAT_TYPE_COMMAND,"MTVIP1 added %u %d",unsigned(vnum),days);
|
||||
PortVipRefresh(ch,true);
|
||||
return true;
|
||||
}
|
||||
|
||||
// /mt_vip 1 status -> MTVIP1 times (seven remaining seconds, PREMIUM_EXP .. PREMIUM_GOLD)
|
||||
inline void PortVipCommand(LPCHARACTER ch,const char* argument) {
|
||||
std::istringstream input(argument);std::vector<std::string> args;std::string token;
|
||||
while(input>>token){if(token.size()>10 || args.size()>=3)return;args.push_back(token);}
|
||||
if(args.empty() || args[0]!="1")return;
|
||||
if(args.size()!=2 || args[1]!="status"){ch->ChatPacket(CHAT_TYPE_COMMAND,"MTVIP1 error invalid");return;}
|
||||
if(PortVipThrottled(ch)){ch->ChatPacket(CHAT_TYPE_COMMAND,"MTVIP1 error rate");return;}
|
||||
PortVipRefresh(ch,true);
|
||||
}
|
||||
#endif
|
||||
@@ -13,6 +13,13 @@ std::vector<PortWikiRow> ITEM_MANAGER::PortWikiDrops(DWORD race) {
|
||||
if (mob->m_table.bRank<MOB_RANK_MAX_NUM)
|
||||
for (const auto& row:g_vec_pkCommonDropItem[mob->m_table.bRank])
|
||||
add(row.m_dwVnum,1,WIKI_COMMON,row.m_iLevelStart,row.m_iLevelEnd,row.m_iPercent,0);
|
||||
// common_drop_new.txt: the player range narrowed to the killers within 20 levels of this mob; map lists are not shown
|
||||
for (const CCommonDropNew* group:m_vec_pkCommonNewItemGroup) {
|
||||
int low=std::max(group->minLevel,int(mob->m_table.bLevel)-20),high=std::min(group->maxLevel,int(mob->m_table.bLevel)+20);
|
||||
if (low>high) continue;
|
||||
for (size_t i=0;i<group->m_vecItems.size() && i<group->m_vecProbs.size();++i)
|
||||
add(group->m_vecItems[i].first,group->m_vecItems[i].second,WIKI_COMMON,unsigned(std::max(low,0)),unsigned(high),group->m_vecProbs[i],0);
|
||||
}
|
||||
auto drop=m_map_pkDropItemGroup.find(race);
|
||||
if (drop!=m_map_pkDropItemGroup.end() && drop->second)
|
||||
for (const auto& row:drop->second->GetVector()) add(row.dwVnum,row.iCount,WIKI_DROP,0,0,row.dwPct,0);
|
||||
|
||||
@@ -19,6 +19,7 @@
|
||||
#include "mob_manager.h"
|
||||
#include "locale_service.h"
|
||||
#include "unique_item.h"
|
||||
#include "port_battlepass_hooks.h"
|
||||
|
||||
// MT: the sockets ITEM_MANAGER::CreateItem gives a new item of this vnum (its remaining time), sent
|
||||
// with an NPC shop's items so the client tooltip shows how long a bought one lasts instead of 0.
|
||||
@@ -341,6 +342,8 @@ int CShop::Buy(LPCHARACTER ch, BYTE pos)
|
||||
}
|
||||
|
||||
ch->PointChange(POINT_GOLD, -dwPrice, false);
|
||||
if (!m_pkPC)
|
||||
PortBpCount(ch, PORT_BP_NPC_SPEND, 0, dwPrice); // PORT: battle pass, NPC shops only
|
||||
|
||||
//¼¼±Ý °è»ê
|
||||
DWORD dwTax = 0;
|
||||
|
||||
@@ -25,6 +25,7 @@
|
||||
#include <boost/algorithm/string/predicate.hpp>
|
||||
#include "shop_manager.h"
|
||||
#include <cctype>
|
||||
#include "port_battlepass_hooks.h"
|
||||
|
||||
CShopManager::CShopManager()
|
||||
{
|
||||
@@ -347,6 +348,7 @@ void CShopManager::Sell(LPCHARACTER ch, BYTE bCell, BYTE bCount)
|
||||
ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("판매금액의 %d %% 가 세금으로 나가게됩니다"), iVal);
|
||||
|
||||
DBManager::instance().SendMoneyLog(MONEY_LOG_SHOP, item->GetVnum(), dwPrice);
|
||||
PortBpCount(ch, PORT_BP_NPC_SELL, item->GetVnum(), bCount); // PORT: battle pass
|
||||
|
||||
if (bCount == item->GetCount())
|
||||
{
|
||||
|
||||
@@ -0,0 +1,272 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Battle pass: the wiring of the hooks, then the production headers compiled against stubs of the characters,
|
||||
the bag, the item table and an in-memory player database (ordered async queue plus synchronous direct queries)."""
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
ROOT=Path(__file__).resolve().parents[2]
|
||||
SRC=ROOT/'src/server/game/src'
|
||||
TSV=ROOT/'tools/battlepass/port_battlepass.tsv'
|
||||
def source(name):return (SRC/name).read_bytes().decode('latin1')
|
||||
cmd=source('cmd.cpp')
|
||||
assert 'ACMD(do_port_bp);' in cmd
|
||||
entry=cmd.index('{ "mt_bp", do_port_bp, 0, POS_DEAD, GM_PLAYER },')
|
||||
assert entry<cmd.index('{ "\\n",',entry) and cmd.count('"mt_bp"')==1
|
||||
general=source('cmd_general.cpp')
|
||||
assert '#include "port_battlepass_runtime.h"' in general and 'PortBpCommand(ch, argument);' in general
|
||||
for name in ('char.cpp','char_battle.cpp','char_item.cpp','fishing.cpp','shop.cpp','shop_manager.cpp'):
|
||||
assert '#include "port_battlepass_hooks.h"' in source(name),name
|
||||
assert '#include "port_battlepass_runtime.h"' not in source(name),name
|
||||
battle=source('char_battle.cpp')
|
||||
reward=battle.index('void CHARACTER::Reward(bool bItemDrop)')
|
||||
assert reward<battle.index('PortBpKill(pkAttacker, this);')<battle.index('quest::CQuestManager::instance().Kill(pkAttacker->GetPlayerID(), GetRaceNum());',reward)
|
||||
assert battle.count('PortBpKill(')==1
|
||||
item=source('char_item.cpp')
|
||||
assert item.count('PortBpCount(this, PORT_BP_REFINE, pkNewItem->GetVnum(), 1);')==2==item.count('"REFINE SUCCESS"')
|
||||
assert '#endif\n#include "port_premium.h"\n#include "port_battlepass_hooks.h"\n' in item # outside __AUCTION__
|
||||
fishing=source('fishing.cpp')
|
||||
assert fishing.index('FishingSuccess(ch);\n\t\t\t\t\tPortBpCount(ch, PORT_BP_CATCH_FISH, item_vnum, 1);')>fishing.index('void Take(')
|
||||
shop=source('shop.cpp')
|
||||
assert 'ch->PointChange(POINT_GOLD, -dwPrice, false);\n\tif (!m_pkPC)\n\t\tPortBpCount(ch, PORT_BP_NPC_SPEND, 0, dwPrice);' in shop
|
||||
sell=source('shop_manager.cpp')
|
||||
assert sell.index('void CShopManager::Sell(')<sell.index('PortBpCount(ch, PORT_BP_NPC_SELL, item->GetVnum(), bCount);')
|
||||
char=source('char.cpp')
|
||||
save=char.index('void CHARACTER::SaveReal()')
|
||||
assert save<char.index('PortBpSave(this);')<char.index('void CHARACTER::FlushDelayedSaveItem()')
|
||||
disc=char.index('void CHARACTER::Disconnect(')
|
||||
assert char.index('SaveAffect();',disc)<char.index('PortBpLogout(this);',disc)<char.index('m_bSkipSave = true;',disc)
|
||||
level=char.index('case POINT_LEVEL:')
|
||||
assert level<char.index('PortBpCount(this, PORT_BP_LEVEL_UP, 0, amount);',level)<char.index('quest::CQuestManager::instance().LevelUp(GetPlayerID());',level)
|
||||
|
||||
code=r'''
|
||||
#include <cassert>
|
||||
#include <cstdarg>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <deque>
|
||||
#include <functional>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <string>
|
||||
#include <tuple>
|
||||
#include <vector>
|
||||
using DWORD=unsigned;using BYTE=unsigned char;using WORD=unsigned short;
|
||||
enum {CHAT_TYPE_INFO=1,CHAT_TYPE_COMMAND=5,MOB_RANK_BOSS=4,ITEM_DS=29,ITEM_FLAG_STACKABLE=1<<2,ITEM_ANTIFLAG_STACK=1<<15,
|
||||
ITEM_MAX_COUNT=200,INVENTORY=1,INVENTORY_PAGE_SIZE=45,INVENTORY_MAX_NUM=225};
|
||||
#define IS_SET(flag,bit) ((flag)&(bit))
|
||||
static long long now=1790900000;static DWORD clockms=1000;
|
||||
long long get_global_time(){return now;}DWORD get_dword_time(){return clockms;}
|
||||
static std::string basePath;std::string LocaleService_GetBasePath(){return basePath;}
|
||||
static std::vector<std::string> logs;
|
||||
void sys_log(int,const char* f,...){char o[1024];va_list a;va_start(a,f);vsnprintf(o,sizeof(o),f,a);va_end(a);logs.push_back(o);}
|
||||
void sys_err(const char* f,...){char o[1024];va_list a;va_start(a,f);vsnprintf(o,sizeof(o),f,a);va_end(a);logs.push_back(std::string("ERR ")+o);}
|
||||
static std::string format(const char* f,va_list a){char o[8192];vsnprintf(o,sizeof(o),f,a);return o;}
|
||||
struct TItemPos{BYTE window_type;WORD cell;TItemPos(BYTE w,WORD c):window_type(w),cell(c){}};
|
||||
struct TItemTable{BYTE bType,bSize;DWORD dwFlags,dwAntiFlags;};
|
||||
// --- player database
|
||||
static std::map<std::tuple<DWORD,DWORD,DWORD>,std::pair<unsigned long long,unsigned long long>> progress; // value,target
|
||||
static std::set<std::tuple<DWORD,DWORD,DWORD>> claims;
|
||||
static bool dbDown=false;
|
||||
using MYSQL_ROW=char**;
|
||||
struct Result{std::vector<std::vector<std::string>> rows;size_t next=0;std::vector<char*> cells;};
|
||||
struct SQLResult{unsigned uiNumRows=0,uiAffectedRows=0;Result* pSQLResult=nullptr;};
|
||||
struct SQLMsg{SQLResult result;Result data;bool ok=true;SQLResult* Get(){return ok?&result:nullptr;}};
|
||||
MYSQL_ROW mysql_fetch_row(Result* r){
|
||||
if(r->next>=r->rows.size())return nullptr;auto& row=r->rows[r->next++];r->cells.clear();
|
||||
for(auto& c:row)r->cells.push_back(&c[0]);return r->cells.data();}
|
||||
static int selects=0;
|
||||
struct DBManager{
|
||||
std::deque<std::function<void()>> queue;std::vector<std::string> queries;
|
||||
static DBManager& instance(){static DBManager m;return m;}
|
||||
void Query(const char* f,...){va_list a;va_start(a,f);std::string q=format(f,a);va_end(a);queries.push_back(q);
|
||||
queue.push_back([q]{
|
||||
assert(q.rfind("INSERT INTO player.mt_battlepass_progress (pid,season,slot,value,target) VALUES (",0)==0);
|
||||
assert(q.find("ON DUPLICATE KEY UPDATE value=LEAST(value+VALUES(value),VALUES(target)),target=VALUES(target)")!=std::string::npos);
|
||||
const char* p=q.c_str()+q.find("VALUES (")+7;unsigned pid,season,slot;unsigned long long v,t;int n;
|
||||
while(sscanf(p,"(%u,%u,%u,%llu,%llu)%n",&pid,&season,&slot,&v,&t,&n)==5){
|
||||
auto& row=progress[std::make_tuple(pid,season,slot)];row.first=std::min(row.first+v,t);row.second=t;p+=n;if(*p==',')++p;else break;}
|
||||
});}
|
||||
template<class F> void FuncQuery(F f,const char* fmt,...){va_list a;va_start(a,fmt);std::string q=format(fmt,a);va_end(a);queries.push_back(q);++selects;
|
||||
queue.push_back([f,q]{unsigned pid,season,pid2,season2;
|
||||
assert(sscanf(q.c_str(),"SELECT 'p',slot,value FROM player.mt_battlepass_progress WHERE pid=%u AND season=%u "
|
||||
"UNION ALL SELECT 'c',slot,0 FROM player.mt_battlepass_claim WHERE pid=%u AND season=%u",&pid,&season,&pid2,&season2)==4);
|
||||
assert(pid==pid2 && season==season2);
|
||||
SQLMsg m;m.ok=!dbDown;m.result.pSQLResult=&m.data;
|
||||
for(auto& e:progress)if(std::get<0>(e.first)==pid && std::get<1>(e.first)==season)
|
||||
m.data.rows.push_back({"p",std::to_string(std::get<2>(e.first)),std::to_string(e.second.first)});
|
||||
for(auto& e:claims)if(std::get<0>(e)==pid && std::get<1>(e)==season)m.data.rows.push_back({"c",std::to_string(std::get<2>(e)),"0"});
|
||||
m.result.uiNumRows=unsigned(m.data.rows.size());f(&m);});}
|
||||
SQLMsg* DirectQuery(const char* f,...){va_list a;va_start(a,f);std::string q=format(f,a);va_end(a);queries.push_back(q);
|
||||
SQLMsg* m=new SQLMsg;m->ok=!dbDown;unsigned pid,season,slot;long long at;
|
||||
assert(sscanf(q.c_str(),"INSERT IGNORE INTO player.mt_battlepass_claim (pid,season,slot,claimed_at) VALUES (%u,%u,%u,%lld)",&pid,&season,&slot,&at)==4 && at==now);
|
||||
if(m->ok)m->result.uiAffectedRows=claims.insert(std::make_tuple(pid,season,slot)).second?1:0;
|
||||
return m;}
|
||||
void Run(){while(!queue.empty()){auto job=queue.front();queue.pop_front();job();}}
|
||||
};
|
||||
// --- characters, bag and items
|
||||
class CHARACTER;
|
||||
struct CItem{DWORD vnum,count;CHARACTER* owner=nullptr;unsigned cell=0;bool AddToCharacter(CHARACTER* ch,TItemPos pos);DWORD GetVnum(){return vnum;}};
|
||||
using LPITEM=CItem*;
|
||||
struct DESC{};
|
||||
class CHARACTER{public:
|
||||
DESC desc;bool online=true,pc=true,stone=false;DWORD pid=7,race=101;int level=50;BYTE rank=0;int saves=0;
|
||||
std::vector<std::string> messages;std::vector<bool> used=std::vector<bool>(INVENTORY_MAX_NUM,false);std::vector<CItem*> bag;
|
||||
const char* GetName(){return "Admin";}bool IsPC(){return pc;}DESC* GetDesc(){return online?&desc:nullptr;}DWORD GetPlayerID(){return pid;}
|
||||
int GetLevel(){return level;}bool IsStone(){return stone;}BYTE GetMobRank(){return rank;}DWORD GetRaceNum(){return race;}
|
||||
bool IsEmptyItemGrid(TItemPos p,BYTE size){assert(p.window_type==INVENTORY && size==1);return !used[p.cell];}
|
||||
void Save(){++saves;}
|
||||
void ChatPacket(BYTE type,const char* f,...){va_list a;va_start(a,f);std::string s=format(f,a);va_end(a);assert(type==CHAT_TYPE_COMMAND);messages.push_back(s);}
|
||||
};
|
||||
using LPCHARACTER=CHARACTER*;
|
||||
static std::map<DWORD,TItemTable> tables={{70043,{1,1,0,0}},{71153,{3,1,ITEM_FLAG_STACKABLE,0}},{25041,{3,1,ITEM_FLAG_STACKABLE,0}},
|
||||
{71032,{3,1,ITEM_FLAG_STACKABLE,0}},{50513,{3,1,ITEM_FLAG_STACKABLE,0}},{27992,{3,1,ITEM_FLAG_STACKABLE,0}},{27993,{3,1,ITEM_FLAG_STACKABLE,0}},
|
||||
{27994,{3,1,ITEM_FLAG_STACKABLE,0}},{70024,{3,1,ITEM_FLAG_STACKABLE,0}},{19,{1,2,0,0}},{11299,{2,3,0,0}},{110000,{ITEM_DS,1,0,0}},
|
||||
{71084,{3,1,ITEM_FLAG_STACKABLE,ITEM_ANTIFLAG_STACK}},{71094,{3,1,ITEM_FLAG_STACKABLE,0}},{27987,{3,1,ITEM_FLAG_STACKABLE,0}},
|
||||
{25040,{3,1,ITEM_FLAG_STACKABLE,0}}};
|
||||
bool CItem::AddToCharacter(CHARACTER* ch,TItemPos pos){
|
||||
const unsigned size=tables[vnum].bSize;
|
||||
for(unsigned k=0;k<size;++k){assert(pos.cell+5*k<INVENTORY_MAX_NUM && !ch->used[pos.cell+5*k]);ch->used[pos.cell+5*k]=true;}
|
||||
assert(pos.cell/45==(pos.cell+5*(size-1))/45);owner=ch;cell=pos.cell;ch->bag.push_back(this);return true;}
|
||||
static int flushedItems=0;
|
||||
struct ITEM_MANAGER{static ITEM_MANAGER& instance(){static ITEM_MANAGER m;return m;}
|
||||
TItemTable* GetTable(DWORD v){auto it=tables.find(v);return it==tables.end()?nullptr:&it->second;}
|
||||
LPITEM CreateItem(DWORD v,DWORD c){return new CItem{v,c};}
|
||||
void FlushDelayedSave(LPITEM){++flushedItems;}};
|
||||
static std::vector<std::string> itemlog;
|
||||
struct LogManager{static LogManager& instance(){static LogManager m;return m;}
|
||||
void ItemLog(LPCHARACTER,LPITEM item,const char* what,const char* hint){itemlog.push_back(std::string(what)+" "+std::to_string(item->vnum)+"x"+std::to_string(item->count)+" "+hint);}};
|
||||
static std::map<DWORD,CHARACTER*> online;
|
||||
struct CHARACTER_MANAGER{static CHARACTER_MANAGER& instance(){static CHARACTER_MANAGER m;return m;}
|
||||
LPCHARACTER FindByPID(DWORD pid){auto it=online.find(pid);return it==online.end()?nullptr:it->second;}};
|
||||
#include "port_battlepass_runtime.h"
|
||||
#include <fstream>
|
||||
#include <sstream>
|
||||
|
||||
static DBManager& db=DBManager::instance();
|
||||
static void tick(unsigned ms=1000){clockms+=ms;}
|
||||
static std::string Last(CHARACTER* c){return c->messages.empty()?"":c->messages.back();}
|
||||
static bool Said(CHARACTER* c,const std::string& line,size_t from=0){for(size_t i=from;i<c->messages.size();++i)if(c->messages[i]==line)return true;return false;}
|
||||
static void WriteConfig(const std::string& text){std::ofstream(basePath+"/port_battlepass.tsv.tmp")<<text;
|
||||
std::rename((basePath+"/port_battlepass.tsv.tmp").c_str(),(basePath+"/port_battlepass.tsv").c_str());tick(5001);}
|
||||
static void Kill(CHARACTER* a,DWORD race,BYTE rank=0,bool stone=false,int level=50){CHARACTER m;m.pc=false;m.race=race;m.rank=rank;m.stone=stone;m.level=level;PortBpKill(a,&m);}
|
||||
static bool Parses(const std::string& text){PortBpConfig c;std::istringstream in(text);return c.Parse(in);}
|
||||
|
||||
int main(int argc,char** argv){
|
||||
basePath=argv[1];
|
||||
// --- the shipped config
|
||||
{PortBpConfig c;std::ifstream in(argv[2]);assert(c.Parse(in));assert(c.seasons.size()==15 && c.seasons[0].id==202610 && c.seasons.back().id==202712);
|
||||
for(auto& s:c.seasons){assert(s.missions.size()==8 && s.final.size()==4);for(auto& m:s.missions)for(auto& r:m.rewards)assert(tables.count(r.vnum));
|
||||
for(auto& r:s.final)assert(tables.count(r.vnum));}
|
||||
assert(c.seasons[0].end==c.seasons[1].start && c.Active(1790805600)==&c.seasons[0] && !c.Active(1790805599));}
|
||||
// --- config validation: any bad line disables the whole file
|
||||
const std::string H="MTBATTLEPASS 1\nseason 1 100 200\n";
|
||||
assert(Parses(H+"mission 1 1 0 10\n") && Parses(H+"mission 1 9 27992 10 1 1\nfinal 1 1\n"));
|
||||
for(auto bad:{"mission 1 9 0 10\n","mission 1 4 5 10\n","mission 11 1 0 10\n","mission 1 1 0 10\nmission 1 2 0 10\n","mission 1 1 0 10 1 1 2 2 3 3 4 4\n",
|
||||
"mission 1 1 0 10\nfinal 1 1\nfinal 1 1\n","mission 1 1 0 0\n","mission 1 10 0 10\n","mission 1 1 0 10\nbogus\n","mission 1 1 0 10 5\n",
|
||||
"mission 1 1 0 10 5 0\n","mission 1 1 0 x\n","mission 1 1 0 10\nfinal\n"})assert(!Parses(H+bad));
|
||||
assert(!Parses("MTBATTLEPASS 2\n") && !Parses(H) && !Parses("MTBATTLEPASS 1\nmission 1 1 0 10\n"));
|
||||
assert(!Parses(H+"mission 1 1 0 10\nseason 2 150 300\nmission 1 1 0 10\n") && Parses(H+"mission 1 1 0 10\nseason 2 200 300\nmission 1 1 0 10\n"));
|
||||
// --- bag fit: first fit in GetEmptyInventory order, a tall item stays inside its page
|
||||
{std::vector<bool> free(90,true);std::vector<unsigned> cells;
|
||||
for(unsigned c=0;c<45;++c)if(c<40)free[c]=false; // first page: only its last row (40..44) is free
|
||||
assert(PortBpFit(free,45,5,{1,3,1},cells) && cells==std::vector<unsigned>({40,45,41}));
|
||||
std::vector<bool> none(45,false);none[44]=true;assert(!PortBpFit(none,45,5,{2},cells));}
|
||||
|
||||
// --- no file: no season
|
||||
CHARACTER* a=new CHARACTER;online[7]=a;
|
||||
PortBpCommand(a,"1 info");assert(Last(a)=="MTBP1 none");Kill(a,101);db.Run();assert(progress.empty() && PortBpStates().empty());
|
||||
// --- a season running now with small targets
|
||||
const std::string cfg="MTBATTLEPASS 1\nseason 77 "+std::to_string(now-100)+" "+std::to_string(now+100000)+"\n"
|
||||
"mission 1 1 0 5 70043 1 71153 450\nmission 2 2 0 2 25041 2\nmission 3 3 0 1 11299 1\nmission 4 4 0 3600 71032 1\n"
|
||||
"mission 5 1 2493 2 19 3\nmission 6 7 0 2 110000 1\nfinal 27992 2 27993 1 27994 1 70024 1\n"
|
||||
"season 78 "+std::to_string(now+100000)+" "+std::to_string(now+200000)+"\nmission 1 1 0 5 70043 1\n";
|
||||
WriteConfig(cfg);
|
||||
// info before the load answers once it arrives; counting before the load is kept
|
||||
PortBpCommand(a,"1 info");assert(a->messages.size()==1 && PortBpStates()[7].wantInfo);
|
||||
Kill(a,101);Kill(a,101);
|
||||
db.Run();assert(Said(a,"MTBP1 season 77 "+std::to_string(now-100)+" "+std::to_string(now+100000)+" "+std::to_string(now)+" 6"));
|
||||
assert(Said(a,"MTBP1 mission 1 1 0 5 2 0 70043 1 71153 450") && Said(a,"MTBP1 final 0 0 27992 2 27993 1 27994 1 70024 1") && Last(a)=="MTBP1 end");
|
||||
// kill kinds: normal / boss / stone / level gap / specific vnum / a player victim
|
||||
size_t mark=a->messages.size();
|
||||
Kill(a,101);assert(Last(a)=="MTBP1 progress 1 3");
|
||||
Kill(a,691,MOB_RANK_BOSS);assert(Last(a)=="MTBP1 progress 2 1");
|
||||
Kill(a,8001,0,true);assert(Said(a,"MTBP1 progress 3 1",mark) && Last(a)=="MTBP1 done 3");
|
||||
Kill(a,101,0,false,71);Kill(a,101,0,false,29);assert(PortBpStates()[7].Value(*PortBpConfigFile().seasons[0].Slot(1))==3);
|
||||
Kill(a,101,0,false,70);assert(Last(a)=="MTBP1 progress 1 4");
|
||||
Kill(a,2493,MOB_RANK_BOSS);assert(Said(a,"MTBP1 progress 2 2",mark) && Last(a)=="MTBP1 done 2" && !Said(a,"MTBP1 progress 5 1",mark));
|
||||
{CHARACTER pc;pc.pid=8;PortBpKill(a,&pc);CHARACTER mob;mob.pc=false;PortBpKill(&mob,a);}
|
||||
// a boss of the specific vnum counts for slot 5 only through its own kind: slot 5 is "kill monster 2493"
|
||||
assert(PortBpStates()[7].Value(*PortBpConfigFile().seasons[0].Slot(5))==0);
|
||||
// close stops the progress pushes; a finished mission is still announced
|
||||
PortBpCommand(a,"1 close");mark=a->messages.size();Kill(a,101);assert(Last(a)=="MTBP1 done 1" && a->messages.size()==mark+1);
|
||||
// 2493 counts for its own slot (any-monster slot 1 is full already)
|
||||
mark=a->messages.size();Kill(a,2493);Kill(a,2493);Kill(a,2493);
|
||||
assert(PortBpStates()[7].Value(*PortBpConfigFile().seasons[0].Slot(5))==2 && a->messages.size()==mark+1 && Last(a)=="MTBP1 done 5");
|
||||
// --- save writes deltas additively, capped in the database
|
||||
a->saves=0;PortBpSave(a);db.Run();
|
||||
assert(progress[std::make_tuple(7u,77u,1u)].first==5 && progress[std::make_tuple(7u,77u,2u)].first==2 && progress[std::make_tuple(7u,77u,3u)].first==1);
|
||||
const size_t queries=db.queries.size();PortBpSave(a);db.Run();assert(db.queries.size()==queries); // nothing new, no query
|
||||
// play time: an hour online
|
||||
tick(3600*1000);PortBpSave(a);db.Run();assert(progress[std::make_tuple(7u,77u,4u)].first==3600);
|
||||
// --- claims
|
||||
tick();PortBpCommand(a,"1 claim 6");assert(Said(a,"MTBP1 error incomplete"));
|
||||
tick();PortBpCommand(a,"1 claim 1");
|
||||
assert(Said(a,"MTBP1 claimed 1") && claims.count(std::make_tuple(7u,77u,1u)) && a->bag.size()==1+3); // 70043 + 200,200,50
|
||||
assert(a->bag[1]->vnum==71153 && a->bag[1]->count==200 && a->bag[3]->count==50 && itemlog.back()=="MT_BP_CLAIM 71153x50 77 1" && flushedItems==4);
|
||||
assert(Said(a,"MTBP1 mission 1 1 0 5 5 1 70043 1 71153 450"));
|
||||
PortBpCommand(a,"1 claim 1");assert(Last(a)=="MTBP1 error rate");
|
||||
tick();PortBpCommand(a,"1 claim 1");assert(Said(a,"MTBP1 error claimed") && a->bag.size()==4);
|
||||
// another core already paid slot 2: the insert finds the row and nothing is given
|
||||
claims.insert(std::make_tuple(7u,77u,2u));tick();PortBpCommand(a,"1 claim 2");assert(Said(a,"MTBP1 error claimed") && a->bag.size()==4);
|
||||
// the database is down: no items
|
||||
dbDown=true;tick();PortBpCommand(a,"1 claim 3");assert(Said(a,"MTBP1 error db") && a->bag.size()==4);dbDown=false;
|
||||
claims.erase(std::make_tuple(7u,77u,3u));PortBpStates()[7].claimed.erase(3);
|
||||
// full bag: the size-3 armor does not fit, no claim row
|
||||
for(unsigned c=0;c<INVENTORY_MAX_NUM;++c)if(c%45<35)a->used[c]=true;
|
||||
tick();PortBpCommand(a,"1 claim 3");assert(Said(a,"MTBP1 error space") && !claims.count(std::make_tuple(7u,77u,3u)));
|
||||
for(unsigned c=0;c<INVENTORY_MAX_NUM;++c)if(c%45<35 && c>=45)a->used[c]=false;
|
||||
tick();PortBpCommand(a,"1 claim 3");assert(Said(a,"MTBP1 claimed 3") && a->bag.back()->vnum==11299 && a->bag.back()->cell==45);
|
||||
// a dragon soul stone in the config is refused at claim time (and logged), the slot stays claimable
|
||||
{PortBpState& s=PortBpStates()[7];s.delta[6]=2;}
|
||||
tick();PortBpCommand(a,"1 claim 6");assert(Said(a,"MTBP1 error config") && !claims.count(std::make_tuple(7u,77u,6u)));
|
||||
assert(logs.back()=="ERR PORT_BP: season 77 slot 6 has a reward that cannot go to the bag");
|
||||
// the final reward needs every mission
|
||||
tick();PortBpCommand(a,"1 claim 0");assert(Said(a,"MTBP1 error incomplete"));
|
||||
tick();PortBpCommand(a,"1 claim 11");assert(Said(a,"MTBP1 error slot"));
|
||||
for(auto bad:{"1 claim","1 claim x","1 claim 123","1 open"}){tick();mark=a->messages.size();PortBpCommand(a,bad);assert(a->messages.size()==mark+1 && Last(a)=="MTBP1 error invalid");}
|
||||
mark=a->messages.size();PortBpCommand(a,"2 info");PortBpCommand(a,"1 a b c");PortBpCommand(a,"1 claim 1 2");PortBpCommand(a,"1 claim 12345678901");assert(a->messages.size()==mark);
|
||||
{PortBpState& s=PortBpStates()[7];for(unsigned i=1;i<=6;++i)s.delta[i]+=100000;} // everything done
|
||||
tick();PortBpCommand(a,"1 claim 0");assert(Said(a,"MTBP1 claimed 0") && Said(a,"MTBP1 final 1 1 27992 2 27993 1 27994 1 70024 1"));
|
||||
// --- logout writes and forgets; a new session loads the claims
|
||||
PortBpSave(a);PortBpLogout(a);db.Run();assert(!PortBpStates().count(7) && progress[std::make_tuple(7u,77u,6u)].first==2);
|
||||
assert(progress[std::make_tuple(7u,77u,4u)].first==3600);
|
||||
tick();mark=a->messages.size();PortBpCommand(a,"1 info");db.Run();
|
||||
assert(Said(a,"MTBP1 mission 1 1 0 5 5 1 70043 1 71153 450",mark) && Said(a,"MTBP1 mission 3 3 0 1 1 1 11299 1",mark) && Said(a,"MTBP1 final 1 1 27992 2 27993 1 27994 1 70024 1",mark));
|
||||
// --- a flush queued before the load answers is not counted twice
|
||||
CHARACTER* b=new CHARACTER;b->pid=9;online[9]=b;
|
||||
progress[std::make_tuple(9u,77u,1u)]={2,5};
|
||||
Kill(b,101);PortBpSave(b);Kill(b,101);db.Run();
|
||||
assert(progress[std::make_tuple(9u,77u,1u)].first==3 && PortBpStates()[9].Value(*PortBpConfigFile().seasons[0].Slot(1))==4);
|
||||
// a stale load (logout and back before the answer) is ignored
|
||||
PortBpLogout(b);Kill(b,101);PortBpLogout(b);Kill(b,101);db.Run();
|
||||
assert(PortBpStates()[9].loaded && PortBpStates()[9].Value(*PortBpConfigFile().seasons[0].Slot(1))==4); // 3 stored + 1, the lost delta of the dropped session aside
|
||||
// a mission finished before the load answers is announced once the load arrives; one already stored done is not
|
||||
{CHARACTER* c=new CHARACTER;c->pid=10;online[10]=c;progress[std::make_tuple(10u,77u,2u)]={2,2};
|
||||
Kill(c,8001,0,true);Kill(c,691,MOB_RANK_BOSS);assert(!Said(c,"MTBP1 done 3") && !Said(c,"MTBP1 done 2"));
|
||||
db.Run();assert(Said(c,"MTBP1 done 3") && !Said(c,"MTBP1 done 2"));}
|
||||
// --- season change: the old season's deltas are written, the new one starts from its own rows
|
||||
Kill(b,101);now+=100000;tick(5001);Kill(b,101);db.Run();
|
||||
assert(progress[std::make_tuple(9u,77u,1u)].first==5 && progress.count(std::make_tuple(9u,78u,1u))==0 && PortBpStates()[9].season==78);
|
||||
PortBpSave(b);db.Run();assert(progress[std::make_tuple(9u,78u,1u)].first==1);
|
||||
// --- the file is removed: no season, nothing counted
|
||||
std::remove((basePath+"/port_battlepass.tsv").c_str());tick(5001);mark=b->messages.size();
|
||||
PortBpCommand(b,"1 info");assert(Last(b)=="MTBP1 none");
|
||||
WriteConfig("MTBATTLEPASS 1\nseason 1 1 2\n");tick();PortBpCommand(b,"1 info");assert(Last(b)=="MTBP1 none" && logs.back().find("ERR PORT_BP: port_battlepass.tsv disabled: ")==0);
|
||||
puts("PASS: config, fit, kills, pushes, save, play time, claims (idempotent, space, db, config), final, reload, load race, season change");
|
||||
}
|
||||
'''
|
||||
with tempfile.TemporaryDirectory(prefix='mt-bp-') as folder:
|
||||
path=Path(folder);(path/'test.cpp').write_text(code);(path/'locale').mkdir()
|
||||
subprocess.run(['c++','-std=c++17','-Wall','-I'+str(SRC),str(path/'test.cpp'),'-o',str(path/'test')],check=True)
|
||||
subprocess.run([str(path/'test'),str(path/'locale'),str(TSV)],check=True)
|
||||
@@ -0,0 +1,52 @@
|
||||
#!/usr/bin/env python3
|
||||
"""AVA2 drop tables: the table builder on fixtures, then the wiring of the ported drop code."""
|
||||
from pathlib import Path
|
||||
import importlib.util
|
||||
import json
|
||||
import tempfile
|
||||
ROOT=Path(__file__).resolve().parents[2]
|
||||
SRC=ROOT/'src/server/game/src'
|
||||
spec=importlib.util.spec_from_file_location('make_drops',ROOT/'tools/ava2-drops/make_drops.py')
|
||||
make_drops=importlib.util.module_from_spec(spec);spec.loader.exec_module(make_drops)
|
||||
|
||||
with tempfile.TemporaryDirectory(prefix='mt-drops-') as folder:
|
||||
base=Path(folder);ava=base/'ava';live=base/'live';out=base/'out';ava.mkdir();live.mkdir()
|
||||
(ava/'mob_drop_item.txt').write_bytes(b'Group\tA\n{\n\tMob\t101\n\tType\tdrop\n\t1\t19\t1\t100\n\t2\t99999\t1\t100\n\t3\t110005\t1\t50\n}\n'
|
||||
b'Group\tB\n{\n\tMob\t102\n\tType\tdrop\n\t1\t99999\t1\t100\n}\n')
|
||||
(ava/'common_drop_new.txt').write_bytes(b'Group\tW\n{\n\tmap_index\t0\n\tlevel_range\t1\t12\n\t1\t19\t1\t0.03\n}\n')
|
||||
(ava/'special_item_group.txt').write_bytes(b'Group\tX\r\n{\r\n\tVnum\t50011\r\n\t1\t19\t5\t2\r\n}\r\n'
|
||||
b'Group\tGM\n{\n\tVnum\t50035\n\tType\tPct\n\t1\t19\t2000\t100\n}\n'
|
||||
b'Group\tNew\n{\n\tVnum\t77900\n\t1\t99999\t1\t30\n\t2\t19\t1\t30\n}\n')
|
||||
(live/'special_item_group.txt').write_bytes(b'Group\t\xc0\xcc\n{\n\tVnum\t50011\n\t1\t\xb0\xe6 \xc7\xe8\t1\t1\n}\n'
|
||||
b'Group\tKid\n{\n\tVnum\t50035\n\t1\t19\t1\t1\n}\n'
|
||||
b'Group\tOld\n{\n\tVnum\t10000\n\t1\t19\t1\t1\n}\n')
|
||||
(base/'proto.txt').write_bytes(b'VNUM\tNAME\n19\tsword\n110000~110099\tds\n')
|
||||
report=make_drops.build(ava,live,out,[base/'proto.txt'])
|
||||
mob=(out/'mob_drop_item.txt').read_bytes()
|
||||
# unknown items removed, entries renumbered (the reader stops at the first gap), empty groups skipped, ranges known
|
||||
assert mob==b'Group\tA\n{\n\tMob\t101\n\tType\tdrop\n\t1\t19\t1\t100\n\t2\t110005\t1\t50\n}\n',mob
|
||||
assert report['mob_dropped']=={'99999':2}
|
||||
assert b'level_range\t1\t12' in (out/'common_drop_new.txt').read_bytes()
|
||||
special=(out/'special_item_group.txt').read_bytes()
|
||||
assert b'Vnum\t50011\n\t1\t19\t5\t2' in special and b'\xb0\xe6' not in special # AVA2 replaces the same vnum
|
||||
assert b'Kid' in special and b'2000' not in special # 50035 is a different box on 203
|
||||
assert b'Old' in special and b'Vnum\t77900\n\t1\t19\t1\t30' in special
|
||||
assert (out/'common_drop_item.txt').read_bytes()==b''==(out/'etc_drop_item.txt').read_bytes()
|
||||
assert json.loads((out/'report.json').read_text())['special_replaced']==[50011]
|
||||
|
||||
def source(name):return (SRC/name).read_bytes().decode('latin1')
|
||||
manager=source('item_manager.cpp')
|
||||
pct=manager[manager.index('bool ITEM_MANAGER::GetDropPct('):manager.index('bool ITEM_MANAGER::CreateDropItem(')]
|
||||
assert '?100:0' not in pct.replace(' ','') # the precedence bug that pinned the denominator to 100
|
||||
assert 'else\n\t\tiDeltaPercent += iDeltaPercent / 2;' in pct
|
||||
assert '(100 + CPrivManager::instance().GetPriv(pkKiller, PRIV_ITEM_DROP) + bonus)' in pct
|
||||
drop=manager[manager.index('bool ITEM_MANAGER::CreateDropItem('):]
|
||||
assert drop.index('// Drop Item Group')<drop.index('m_vec_pkCommonNewItemGroup')<drop.index('// MobDropItem Group')
|
||||
assert 'abs(pkChr->GetLevel() - iLevel) <= 20' in drop
|
||||
tables=source('item_manager_read_tables.cpp')
|
||||
assert 'CDropItemGroup* pkGroup = it->second;' not in tables # second group of a mob used an uninitialised pointer
|
||||
special=tables[tables.index('bool ITEM_MANAGER::ReadSpecialDropItemFile('):tables.index('bool ITEM_MANAGER::ReadCommonDropNewItemFile(')]
|
||||
assert special.count('k < 1024')==2 and 'char buf[4]' not in special.split('ConvSpecialDropItemFile')[0]
|
||||
db=source('input_db.cpp')
|
||||
assert db.index('ReadCommonDropItemFile(')<db.index('ReadCommonDropNewItemFile(')<db.index('ReadEtcDropItemFile(')
|
||||
print('PASS: drop table builder (filter, renumber, ranges, merge, kept 203 box) and AVA2 drop code wiring')
|
||||
@@ -12,6 +12,7 @@ points=sorted(set(re.findall(r'\bPOINT_[A-Z_]+', (SRC/'port_features.h').read_te
|
||||
code=r'''
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
#include <climits>
|
||||
#include <cstdarg>
|
||||
#include <cstdio>
|
||||
#include <map>
|
||||
@@ -28,7 +29,7 @@ GROUPS
|
||||
#include "item_manager_private_types.h"
|
||||
std::vector<CItemDropInfo> g_vec_pkCommonDropItem[MOB_RANK_MAX_NUM];
|
||||
struct TItemTable{unsigned dwVnum;unsigned bType=0;};
|
||||
struct MobTable{unsigned bType=0,bRank=0,dwPolymorphItemVnum=0,dwDropItemVnum=0;};
|
||||
struct MobTable{unsigned bType=0,bRank=0,dwPolymorphItemVnum=0,dwDropItemVnum=0;unsigned char bLevel=0;};
|
||||
struct CMob{MobTable m_table;};
|
||||
class CMobManager {
|
||||
public:std::map<DWORD,CMob*> mobs;
|
||||
@@ -44,6 +45,7 @@ class ITEM_MANAGER {
|
||||
std::map<DWORD,CLevelItemGroup*> m_map_pkLevelItemGroup;
|
||||
std::map<DWORD,CBuyerThiefGlovesItemGroup*> m_map_pkGloveItemGroup;
|
||||
std::map<DWORD,DWORD> m_map_dwEtcItemDropProb;
|
||||
std::vector<CCommonDropNew*> m_vec_pkCommonNewItemGroup;
|
||||
std::map<DWORD,CSpecialItemGroup*> special;
|
||||
static ITEM_MANAGER& instance(){static ITEM_MANAGER m;return m;}
|
||||
TItemTable* GetTable(unsigned id){for(auto& t:tables)if(t.dwVnum==id)return &t;return nullptr;}
|
||||
@@ -100,6 +102,13 @@ int main(){
|
||||
assert(items.PortWikiDrops(9001).empty() && items.PortWikiDrops(99999).empty());
|
||||
drop.AddItem(30220,25,1);assert(items.PortWikiDrops(101).size()==8);
|
||||
drop.AddItem(70104,1,1);assert(items.PortWikiDrops(101).size()==9); // Non-common groups retain configured polymorph candidates. // Sees active changes, not exported text.
|
||||
// common_drop_new: player range clipped to the mob level +-20; groups out of reach are left out
|
||||
mob.m_table.bLevel=10;CCommonDropNew low,high;low.minLevel=1;low.maxLevel=40;low.AddItem(30006,3,1200);high.minLevel=31;high.maxLevel=60;high.AddItem(19,1,1200);
|
||||
items.m_vec_pkCommonNewItemGroup={&low,&high};rows=items.PortWikiDrops(101);assert(rows.size()==10);
|
||||
assert(rows[1].item==30006 && rows[1].count==3 && rows[1].rule==WIKI_COMMON && rows[1].minimum==1 && rows[1].maximum==30 && rows[1].weight==1200);
|
||||
high.minLevel=30;assert(items.PortWikiDrops(101).size()==11 && items.PortWikiDrops(101)[2].minimum==30);
|
||||
assert(low.CanDropThisMap(41));low.m_vecMapIndex={1};assert(low.CanDropThisMap(1) && !low.CanDropThisMap(41));
|
||||
items.m_vec_pkCommonNewItemGroup.clear();mob.m_table.bLevel=0;
|
||||
CSpecialItemGroup chest(50011);chest.AddItem(19,1,80,0);chest.AddItem(1,500,20,0);items.special[50011]=&chest;
|
||||
CSpecialItemGroup multi(50012,CSpecialItemGroup::PCT);multi.AddItem(19,2,20,0);multi.AddItem(3,101,150,0);items.special[50012]=&multi;
|
||||
CSpecialItemGroup attr(50013,CSpecialItemGroup::SPECIAL);attr.AddItem(19,1,100,0);items.special[50013]=&attr;
|
||||
|
||||
@@ -0,0 +1,137 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Compile the production VIP card header against stubs of the account table, the ordered async SQL queue and
|
||||
the premium affects."""
|
||||
from pathlib import Path
|
||||
import subprocess
|
||||
import tempfile
|
||||
ROOT=Path(__file__).resolve().parents[2]
|
||||
SRC=ROOT/'src/server/game/src'
|
||||
def source(name):return (SRC/name).read_bytes().decode('latin1')
|
||||
cmd=source('cmd.cpp')
|
||||
assert 'ACMD(do_port_vip);' in cmd and '"mt_vip", do_port_vip, 0, POS_DEAD, GM_PLAYER' in cmd
|
||||
general=source('cmd_general.cpp')
|
||||
assert '#include "port_premium.h"' in general and 'PortVipCommand(ch, argument);' in general
|
||||
item=source('char_item.cpp')
|
||||
use=item.index('bool CHARACTER::UseItem(TItemPos Cell, TItemPos DestCell)')
|
||||
hook=item.index('if (PortVipUseCard(this, item))',use)
|
||||
assert '#endif\n#include "port_premium.h"\n' in item # not inside the __AUCTION__ block
|
||||
assert item.index('FN_check_item_sex(this, item)',use)<hook<item.index('IS_SUMMON_ITEM(item->GetVnum())',use)
|
||||
login=source('input_login.cpp')
|
||||
assert login.index('AFFECT_PREMIUM_START + i')<login.index('PortVipRefresh(ch, false);')
|
||||
assert 'void\t\t\t\tPortSetPremiumTime(BYTE bType, int iTime)' in source('char.h')
|
||||
code=r'''
|
||||
#include <cassert>
|
||||
#include <cstdarg>
|
||||
#include <cstdio>
|
||||
#include <cstring>
|
||||
#include <deque>
|
||||
#include <functional>
|
||||
#include <map>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
using DWORD=unsigned;using BYTE=unsigned char;
|
||||
enum {CHAT_TYPE_INFO=1,CHAT_TYPE_COMMAND=5,POINT_NONE=0,AFFECT_PREMIUM_START=500,PREMIUM_MAX_NUM=9};
|
||||
static int now=1700000000;static DWORD clockms=1000;
|
||||
int get_global_time(){return now;}DWORD get_dword_time(){return clockms;}
|
||||
static std::vector<std::string> logs;
|
||||
void sys_log(int,const char* format,...){char out[512];va_list a;va_start(a,format);vsnprintf(out,sizeof(out),format,a);va_end(a);logs.push_back(out);}
|
||||
void sys_err(const char* format,...){char out[512];va_list a;va_start(a,format);vsnprintf(out,sizeof(out),format,a);va_end(a);logs.push_back(std::string("ERR ")+out);}
|
||||
static std::string format(const char* f,va_list a){char out[4096];vsnprintf(out,sizeof(out),f,a);return out;}
|
||||
// Account table: id -> seven end times (0 = never), as UNIX_TIMESTAMP reads them.
|
||||
static std::map<DWORD,std::vector<int>> accounts;
|
||||
using MYSQL_ROW=char**;
|
||||
struct Rows{char* cells[7];char text[7][16];};
|
||||
struct SQLResult{unsigned uiNumRows;Rows* pSQLResult;Rows rows;};
|
||||
struct SQLMsg{SQLResult result;bool ok=true;SQLResult* Get(){return ok?&result:nullptr;}};
|
||||
MYSQL_ROW mysql_fetch_row(Rows* r){return r->cells;}
|
||||
struct DBManager{
|
||||
std::deque<std::function<void()>> queue;std::vector<std::string> queries;
|
||||
static DBManager& instance(){static DBManager m;return m;}
|
||||
void Query(const char* f,...){va_list a;va_start(a,f);std::string q=format(f,a);va_end(a);queries.push_back(q);
|
||||
queue.push_back([q]{DWORD id;int secs;
|
||||
const char* where=strstr(q.c_str()," WHERE id=");assert(where && sscanf(where," WHERE id=%u",&id)==1);
|
||||
const char* add=strstr(q.c_str(),"UNIX_TIMESTAMP())+");assert(add && sscanf(add,"UNIX_TIMESTAMP())+%d)",&secs)==1);
|
||||
for(int& t:accounts[id])t=(t>now?t:now)+secs;});}
|
||||
template<class F> void FuncQuery(F f,const char* fmt,...){va_list a;va_start(a,fmt);std::string q=format(fmt,a);va_end(a);queries.push_back(q);
|
||||
queue.push_back([f,q]{DWORD id;assert(sscanf(strstr(q.c_str()," WHERE id="), " WHERE id=%u",&id)==1);
|
||||
SQLMsg m{};auto it=accounts.find(id);m.result.uiNumRows=it==accounts.end()?0:1;m.result.pSQLResult=&m.result.rows;
|
||||
for(int i=0;i<7;++i){m.result.rows.cells[i]=m.result.rows.text[i];snprintf(m.result.rows.text[i],16,"%d",it==accounts.end()?0:it->second[i]);}
|
||||
f(&m);});}
|
||||
void Run(){while(!queue.empty()){auto job=queue.front();queue.pop_front();job();}}
|
||||
};
|
||||
struct CItem{DWORD vnum;int count;DWORD GetVnum(){return vnum;}int GetCount(){return count;}void SetCount(int c){count=c;}};
|
||||
using LPITEM=CItem*;
|
||||
struct TAccountTable{DWORD id;};
|
||||
struct DESC{TAccountTable table;TAccountTable& GetAccountTable(){return table;}};
|
||||
struct CHARACTER{
|
||||
DESC desc;bool online=true;int premium[PREMIUM_MAX_NUM]={};std::map<DWORD,long> affects;std::vector<std::string> messages;
|
||||
const char* GetName(){return "Admin";}bool IsPC(){return true;}DESC* GetDesc(){return online?&desc:nullptr;}DWORD GetPlayerID(){return 7;}
|
||||
int GetPremiumRemainSeconds(BYTE t)const{return t<PREMIUM_MAX_NUM?premium[t]-now:0;}
|
||||
void PortSetPremiumTime(BYTE t,int v){if(t<PREMIUM_MAX_NUM)premium[t]=v;}
|
||||
bool AddAffect(DWORD type,BYTE,long,DWORD,long duration,long,bool override){assert(override);affects[type]=duration;return true;}
|
||||
bool RemoveAffect(DWORD type){return affects.erase(type)>0;}
|
||||
void ChatPacket(BYTE type,const char* f,...){va_list a;va_start(a,f);std::string s=format(f,a);va_end(a);assert(type==CHAT_TYPE_COMMAND);messages.push_back(s);}
|
||||
};
|
||||
using LPCHARACTER=CHARACTER*;
|
||||
static CHARACTER* player=nullptr;
|
||||
struct CHARACTER_MANAGER{static CHARACTER_MANAGER& instance(){static CHARACTER_MANAGER m;return m;}
|
||||
LPCHARACTER FindByPID(DWORD pid){return player && pid==7?player:nullptr;}};
|
||||
static std::vector<std::string> itemlog;
|
||||
struct LogManager{static LogManager& instance(){static LogManager m;return m;}
|
||||
void ItemLog(LPCHARACTER,LPITEM item,const char* how,const char* hint){assert(item->count>0);itemlog.push_back(std::string(how)+" "+std::to_string(item->vnum)+" "+hint);}};
|
||||
#include "port_premium.h"
|
||||
static DBManager& db=DBManager::instance();
|
||||
static const std::string& last(){return player->messages.back();}
|
||||
static void tick(){clockms+=1100;}
|
||||
int main(){
|
||||
const int DAY=86400;
|
||||
accounts[1]=std::vector<int>(7,0);
|
||||
player=new CHARACTER;player->desc.table.id=1;
|
||||
// Fresh account: 7 days from now on all seven columns, one card consumed, icons 500..506 for 7 days.
|
||||
CItem card{38001,2};
|
||||
assert(PortVipUseCard(player,&card) && card.count==1 && itemlog.back()=="MT_VIP_CARD 38001 7");
|
||||
assert(db.queries[0].rfind("UPDATE account.account SET silver_expire=FROM_UNIXTIME(GREATEST(UNIX_TIMESTAMP(silver_expire),UNIX_TIMESTAMP())+604800),gold_expire=",0)==0);
|
||||
assert(db.queries[0].find("money_drop_rate_expire=FROM_UNIXTIME(GREATEST(UNIX_TIMESTAMP(money_drop_rate_expire),UNIX_TIMESTAMP())+604800) WHERE id=1")!=std::string::npos);
|
||||
assert(db.queries[1]=="SELECT UNIX_TIMESTAMP(silver_expire),UNIX_TIMESTAMP(gold_expire),UNIX_TIMESTAMP(safebox_expire),UNIX_TIMESTAMP(autoloot_expire),UNIX_TIMESTAMP(fish_mind_expire),UNIX_TIMESTAMP(marriage_fast_expire),UNIX_TIMESTAMP(money_drop_rate_expire) FROM account.account WHERE id=1");
|
||||
assert(last()=="MTVIP1 added 38001 7" && player->premium[0]==0); // memory waits for the read-back
|
||||
db.Run();
|
||||
assert(last()=="MTVIP1 times 604800 604800 604800 604800 604800 604800 604800");
|
||||
for(int i=0;i<7;++i)assert(player->premium[i]==now+7*DAY && player->affects[500+i]==7*DAY && accounts[1][i]==now+7*DAY);
|
||||
assert(!player->affects.count(507) && player->premium[7]==0);
|
||||
// A second card inside the gap is refused and kept; after it, 30 days add to the current end.
|
||||
CItem month{38002,1};
|
||||
assert(PortVipUseCard(player,&month) && last()=="MTVIP1 error rate" && month.count==1);
|
||||
tick();now+=DAY;assert(PortVipUseCard(player,&month) && month.count==0);db.Run();
|
||||
assert(last()=="MTVIP1 times 3110400 3110400 3110400 3110400 3110400 3110400 3110400" && player->premium[3]==now-DAY+37*DAY);
|
||||
// Past the 400-day cap: refused before anything is consumed or queried.
|
||||
const size_t queries=db.queries.size();CItem many{38002,20};
|
||||
for(int k=0;k<13;++k){tick();assert(PortVipUseCard(player,&many));db.Run();} // 36 days left: 12 cards reach 396
|
||||
assert(last()=="MTVIP1 error full" && many.count==8 && db.queries.size()==queries+24);
|
||||
// Not a card: untouched, nothing queried.
|
||||
CItem other{27001,5};assert(!PortVipUseCard(player,&other) && other.count==5 && db.queries.size()==queries+24);
|
||||
// Enter-game on another core: the db core still has the login-time ends (here, none); the refresh restores them.
|
||||
tick();const auto stale=player->messages.size();
|
||||
for(int i=0;i<PREMIUM_MAX_NUM;++i)player->premium[i]=0;player->affects.clear();
|
||||
PortVipRefresh(player,false);db.Run();
|
||||
assert(player->messages.size()==stale && player->premium[6]==accounts[1][6] && player->affects[506]==accounts[1][6]-now);
|
||||
// Expired in the account (edited by hand): state and icon go away; unchanged types keep their icon untouched.
|
||||
accounts[1][2]=now-5;player->affects[502]=1;player->affects[503]=12345;
|
||||
PortVipRefresh(player,false);db.Run();
|
||||
assert(player->GetPremiumRemainSeconds(2)<0 && !player->affects.count(502) && player->affects[503]==12345);
|
||||
// Status command: version, validation, throttle, report of remaining seconds (0 when expired).
|
||||
tick();PortVipCommand(player,"1 status");db.Run();assert(last().rfind("MTVIP1 times ",0)==0 && last().find(" 0 ")!=std::string::npos);
|
||||
PortVipCommand(player,"1 status");assert(last()=="MTVIP1 error rate");
|
||||
for(auto bad:{"1 stats","1","1 status x"}){tick();PortVipCommand(player,bad);assert(last()=="MTVIP1 error invalid");}
|
||||
const auto quiet=player->messages.size();tick();PortVipCommand(player,"2 status");PortVipCommand(player,"1 status x y z");
|
||||
assert(player->messages.size()==quiet);
|
||||
// The player left before the read-back: nothing is touched.
|
||||
tick();PortVipCommand(player,"1 status");CHARACTER* gone=player;player=nullptr;db.Run();assert(gone->messages.size()==quiet);
|
||||
// Missing account row: logged, no state change.
|
||||
player=gone;player->desc.table.id=99;tick();PortVipRefresh(player,true);db.Run();assert(logs.back()=="ERR PORT_VIP: account 99 not found");
|
||||
puts("PASS: card use and read-back, stacking, gap, cap, other items, enter-game refresh, expiry, status command");
|
||||
}
|
||||
'''
|
||||
with tempfile.TemporaryDirectory(prefix='mt-vip-') as folder:
|
||||
path=Path(folder);(path/'test.cpp').write_text(code)
|
||||
subprocess.run(['c++','-std=c++17','-Wall','-I'+str(SRC),str(path/'test.cpp'),'-o',str(path/'test')],check=True)
|
||||
subprocess.run([str(path/'test')],check=True)
|
||||
@@ -0,0 +1,106 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Build the 203 drop tables from AVA2's (docs/FEATURE-AVA2-DROPS.md).
|
||||
|
||||
mob_drop_item.txt AVA2's, entries whose item 203 lacks are dropped and the rest renumbered
|
||||
(the reader stops at the first missing index and fails on an unknown item)
|
||||
common_drop_new.txt AVA2's NEW_COMMON_DROP groups, filtered the same way
|
||||
special_item_group.txt 203's groups with AVA2's groups replacing those of the same vnum; AVA2-only groups added
|
||||
common_drop_item.txt empty, like AVA2 (common drops come from common_drop_new.txt)
|
||||
etc_drop_item.txt empty, like AVA2
|
||||
|
||||
Usage: make_drops.py <AVA2 locale dir> <203 locale dir> <output dir> <item_proto.txt>...
|
||||
The item_proto files are every row the servers will load (the live one plus ava2-items' items-server.tsv).
|
||||
"""
|
||||
import json,re,sys
|
||||
from pathlib import Path
|
||||
|
||||
# AVA2 reused these vnums for a different box: 50035 is 203's children's day gift box but AVA2's GM-only
|
||||
# 'Pct' box handing out thousands of items, so 203's group stays.
|
||||
KEEP_203={50035}
|
||||
|
||||
def vnums(paths):
|
||||
result=set()
|
||||
for p in paths:
|
||||
for line in Path(p).read_bytes().splitlines():
|
||||
head=line.split(b'\t',1)[0].strip()
|
||||
if head.isdigit():result.add(int(head))
|
||||
elif re.fullmatch(rb'\d+~\d+',head): # dragon soul rows cover a vnum range
|
||||
lo,hi=map(int,head.split(b'~'));result.update(range(lo,hi+1))
|
||||
return result
|
||||
|
||||
def groups(data):
|
||||
"""[(name bytes, [body line bytes])] of a CTextFileLoader file ('Group <name>' then a braced body)."""
|
||||
lines=data.replace(b'\r\n',b'\n').split(b'\n');result=[];i=0
|
||||
while i<len(lines):
|
||||
m=re.match(rb'\s*group\s+(.*?)\s*$',lines[i],re.I)
|
||||
if not m:
|
||||
if lines[i].strip() and not lines[i].strip().startswith((b'#',b'//')):raise SystemExit('unexpected line %r'%lines[i])
|
||||
i+=1;continue
|
||||
assert lines[i+1].strip()==b'{',lines[i:i+2]
|
||||
j=i+2;body=[]
|
||||
while lines[j].strip()!=b'}':body.append(lines[j]);j+=1
|
||||
result.append((m.group(1),body));i=j+1
|
||||
return result
|
||||
|
||||
def key(body,name):
|
||||
for line in body:
|
||||
t=line.split()
|
||||
if t and t[0].lower()==name.encode():return t[1:]
|
||||
return None
|
||||
|
||||
def entries(body):
|
||||
return [line.split() for line in body if line.split() and line.split()[0].isdigit()]
|
||||
|
||||
def render(name,head,items):
|
||||
out=[b'Group\t'+name,b'{']+[b'\t'+b'\t'.join(t) for t in head]
|
||||
out+=[b'\t'+b'\t'.join([str(k).encode()]+t[1:]) for k,t in enumerate(items,1)]
|
||||
return out+[b'}']
|
||||
|
||||
def filtered(gs,known,item_column,dropped):
|
||||
"""Groups with unknown items removed and indexes renumbered; groups left empty are skipped."""
|
||||
out=[]
|
||||
for name,body in gs:
|
||||
head=[line.split() for line in body if line.split() and not line.split()[0].isdigit()]
|
||||
items=[]
|
||||
for t in entries(body):
|
||||
token=t[item_column]
|
||||
if token.isdigit() and int(token) not in known:dropped.setdefault(int(token),0);dropped[int(token)]+=1;continue
|
||||
items.append(t)
|
||||
if items:out+=render(name,head,items)
|
||||
return out
|
||||
|
||||
def build(ava,live,output,protos):
|
||||
known=vnums(protos);report={}
|
||||
output.mkdir(parents=True,exist_ok=True)
|
||||
mob=groups((ava/'mob_drop_item.txt').read_bytes())
|
||||
assert all(key(b,'type')[0].lower()==b'drop' for _,b in mob) # every AVA2 group is a 'drop' group
|
||||
assert max(len(entries(b)) for _,b in mob)<256
|
||||
dropped={};text=filtered(mob,known,1,dropped)
|
||||
(output/'mob_drop_item.txt').write_bytes(b'\n'.join(text)+b'\n')
|
||||
report['mob_groups']=sum(1 for l in text if l==b'{');report['mob_dropped']=dropped
|
||||
common=groups((ava/'common_drop_new.txt').read_bytes())
|
||||
dropped={};text=filtered(common,known,1,dropped)
|
||||
(output/'common_drop_new.txt').write_bytes(b'\n'.join(text)+b'\n')
|
||||
report['common_new_groups']=sum(1 for l in text if l==b'{');report['common_new_dropped']=dropped
|
||||
theirs=groups((ava/'special_item_group.txt').read_bytes());ours=groups((live/'special_item_group.txt').read_bytes())
|
||||
assert all((key(b,'type') or [b'x'])[0].lower()!=b'attr' for _,b in theirs)
|
||||
theirs=[(n,b) for n,b in theirs if int(key(b,'vnum')[0]) not in KEEP_203]
|
||||
replaced={int(key(b,'vnum')[0]) for _,b in theirs}
|
||||
dropped={};text=[]
|
||||
for name,body in ours:
|
||||
if int(key(body,'vnum')[0]) in replaced:continue
|
||||
text+=[b'Group\t'+name,b'{']+body+[b'}']
|
||||
text+=filtered(theirs,known,1,dropped)
|
||||
(output/'special_item_group.txt').write_bytes(b'\n'.join(text)+b'\n')
|
||||
kept=[int(key(b,'vnum')[0]) for _,b in ours if int(key(b,'vnum')[0]) not in replaced]
|
||||
report.update(special_kept_203=len(kept),special_from_ava2=len(replaced),
|
||||
special_replaced=sorted(replaced&{int(key(b,'vnum')[0]) for _,b in ours}),special_dropped=dropped)
|
||||
for name in ('common_drop_item.txt','etc_drop_item.txt'):(output/name).write_bytes(b'')
|
||||
for k in [k for k in report if k.endswith('_dropped')]:report[k]={str(v):n for v,n in sorted(report[k].items())}
|
||||
(output/'report.json').write_text(json.dumps(report,indent=1)+'\n')
|
||||
return report
|
||||
|
||||
if __name__=='__main__':
|
||||
if len(sys.argv)<5:sys.exit(__doc__)
|
||||
r=build(Path(sys.argv[1]),Path(sys.argv[2]),Path(sys.argv[3]),sys.argv[4:])
|
||||
print(json.dumps({k:(len(v) if isinstance(v,(list,dict)) else v) for k,v in r.items()}))
|
||||
@@ -0,0 +1,194 @@
|
||||
# PORT battle pass seasons (docs/FEATURE-BATTLEPASS.md). Installed as share/locale/newcibn/port_battlepass.tsv;
|
||||
# every core rereads it within 5 s of an atomic replace. Any error disables the battle pass (see syserr PORT_BP).
|
||||
#
|
||||
# season ID START END unix seconds, START inclusive, END exclusive; seasons must not overlap
|
||||
# mission SLOT TYPE SUB TARGET [VNUM COUNT]x0..3
|
||||
# SLOT 1..10. Progress and claims are stored per season and slot: do not reuse a slot for another mission
|
||||
# within a running season.
|
||||
# TYPE 1 kill monster (SUB mob vnum or 0 = any normal monster) 2 kill boss (SUB vnum or 0)
|
||||
# 3 kill metin stone (SUB vnum or 0) 4 seconds online 5 catch fish (SUB item vnum or 0)
|
||||
# 6 successful refine (SUB result vnum or 0) 7 levels gained 8 gold paid to NPC shops
|
||||
# 9 items sold to NPC shops (SUB item vnum, required)
|
||||
# Kills count for the player the quest kill goes to, within 20 levels of the monster.
|
||||
# final VNUM COUNT x1..6 once every mission of the season is done
|
||||
MTBATTLEPASS 1
|
||||
|
||||
# 2026-10 (Europe/Berlin)
|
||||
season 202610 1790805600 1793487600
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2026-11 (Europe/Berlin)
|
||||
season 202611 1793487600 1796079600
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2026-12 (Europe/Berlin)
|
||||
season 202612 1796079600 1798758000
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2027-01 (Europe/Berlin)
|
||||
season 202701 1798758000 1801436400
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2027-02 (Europe/Berlin)
|
||||
season 202702 1801436400 1803855600
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2027-03 (Europe/Berlin)
|
||||
season 202703 1803855600 1806530400
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2027-04 (Europe/Berlin)
|
||||
season 202704 1806530400 1809122400
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2027-05 (Europe/Berlin)
|
||||
season 202705 1809122400 1811800800
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2027-06 (Europe/Berlin)
|
||||
season 202706 1811800800 1814392800
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2027-07 (Europe/Berlin)
|
||||
season 202707 1814392800 1817071200
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2027-08 (Europe/Berlin)
|
||||
season 202708 1817071200 1819749600
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2027-09 (Europe/Berlin)
|
||||
season 202709 1819749600 1822341600
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2027-10 (Europe/Berlin)
|
||||
season 202710 1822341600 1825023600
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2027-11 (Europe/Berlin)
|
||||
season 202711 1825023600 1827615600
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
||||
# 2027-12 (Europe/Berlin)
|
||||
season 202712 1827615600 1830294000
|
||||
mission 1 1 0 20000 70043 1 71153 5
|
||||
mission 2 2 0 30 25041 2 71032 1
|
||||
mission 3 3 0 300 50513 3
|
||||
mission 4 4 0 172800 71094 2
|
||||
mission 5 5 0 100 27987 5
|
||||
mission 6 6 0 50 25040 2
|
||||
mission 7 7 0 5 71153 5
|
||||
mission 8 8 0 50000000 71084 20
|
||||
final 27992 2 27993 1 27994 1 70024 1
|
||||
|
@@ -0,0 +1,20 @@
|
||||
-- PORT: battle pass tables (docs/FEATURE-BATTLEPASS.md). Idempotent; run once on the player database.
|
||||
-- Progress: one row per player, season and mission slot; the game adds deltas and MySQL caps them at target.
|
||||
CREATE TABLE IF NOT EXISTS player.mt_battlepass_progress (
|
||||
pid INT UNSIGNED NOT NULL,
|
||||
season INT UNSIGNED NOT NULL,
|
||||
slot TINYINT UNSIGNED NOT NULL,
|
||||
value BIGINT UNSIGNED NOT NULL DEFAULT 0,
|
||||
target BIGINT UNSIGNED NOT NULL DEFAULT 0,
|
||||
updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
|
||||
PRIMARY KEY (pid, season, slot)
|
||||
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
|
||||
-- Claims: the primary key is the idempotency guard; only the request whose INSERT IGNORE adds the row pays out.
|
||||
-- slot 0 is the final reward.
|
||||
CREATE TABLE IF NOT EXISTS player.mt_battlepass_claim (
|
||||
pid INT UNSIGNED NOT NULL,
|
||||
season INT UNSIGNED NOT NULL,
|
||||
slot TINYINT UNSIGNED NOT NULL,
|
||||
claimed_at INT UNSIGNED NOT NULL,
|
||||
PRIMARY KEY (pid, season, slot)
|
||||
) ENGINE=InnoDB DEFAULT CHARSET=latin1;
|
||||
Reference in New Issue
Block a user