Files
metin2-server/tests/features/test_battlepass.py
T
shenleiandClaude Opus 5.5 cd395c73b7 Battle pass: add 2027 seasons (202701-202712)
Same 8 missions and final reward as 202612, monthly Berlin starts through 2028-01-01.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 09:39:52 +09:00

273 lines
21 KiB
Python

#!/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)