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>
273 lines
21 KiB
Python
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)
|