Files
Dreierpack-Manager/src/modern/ui/demo_transfer.cpp
T

308 lines
25 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "modern/ui/demo_transfer.hpp"
#include "modern/ui/demo_finance.hpp"
#include <algorithm>
#include <array>
#include <chrono>
#include <cmath>
#include <limits>
#include <set>
namespace bmh::modern_ui {
namespace {
constexpr int64_t cap = 99999999, salary_cap = 200000;
constexpr std::array<const char *,4> positions{"gk","def","mid","fwd"};
constexpr std::array<const char *,7> skills{"corner","free_kick","tackling","passing","shooting","speed","teamplay"};
bool keys(const Json &v, std::initializer_list<const char *> expected) {
return v.is_object() && v.size() == expected.size() && std::all_of(expected.begin(),expected.end(),[&](auto *k){return v.contains(k);});
}
bool integer(const Json &v, int64_t lo, int64_t hi) {
if (v.is_number_unsigned()) return hi >= 0 && v.get<uint64_t>() <= uint64_t(hi) && (lo <= 0 || v.get<uint64_t>() >= uint64_t(lo));
return v.is_number_integer() && v.get<int64_t>() >= lo && v.get<int64_t>() <= hi;
}
Json error(const char *code) { return {{"ok",false},{"error",code}}; }
std::string own(const Catalog &world, const std::string &club) {
if (!club.empty()) {
if (!world.manageable(club)) throw editor::Error("invalid_transfer_club");
return club;
}
for (auto *c : world.clubs()) if (world.manageable(c->value("id",""))) return c->value("id","");
return "";
}
std::string position(const Json &p) {
const auto found = p.find("positions");
if (found == p.end() || !found->is_array()) return "";
for (auto *role : positions) if (std::find(found->begin(),found->end(),role) != found->end()) return role;
return "";
}
int role_index(const std::string &p) {
const auto it = std::find(positions.begin(),positions.end(),p);
return int(it - positions.begin());
}
bool iso(const Json &v) {
if (!v.is_string()) return false;
const auto s = v.get<std::string>();
if (s.size()!=10 || s[4]!='-' || s[7]!='-') return false;
for (size_t i=0;i<10;++i) if(i!=4 && i!=7 && (s[i]<'0'||s[i]>'9')) return false;
return std::stoi(s.substr(0,4))>0 && std::chrono::year_month_day{std::chrono::year{std::stoi(s.substr(0,4))},std::chrono::month{unsigned(std::stoi(s.substr(5,2)))},std::chrono::day{unsigned(std::stoi(s.substr(8,2)))}}.ok();
}
Json age(const Json &p, const Json &state, const Catalog &world) {
const auto when = state.value("date",world.manifest().value("start_date",Json()));
if (p.contains("born") && iso(p.at("born")) && iso(when)) {
const auto born=p.at("born").get<std::string>(), day=when.get<std::string>();
const int years=std::stoi(day.substr(0,4))-std::stoi(born.substr(0,4))-(day.substr(5)<born.substr(5)?1:0);
return years>=0 && years<=100 ? Json(years):Json();
}
const auto initial=p.value("age_at_start",Json());
if(integer(initial,0,100)) return initial;
if(initial.is_object() && initial.contains("years") && integer(initial.at("years"),0,100) && initial.value("on",Json())==when) return initial.at("years");
return nullptr;
}
Json attribute(const Json &p, const char *key) {
const auto a=p.find("attributes");
if(a==p.end()||!a->is_object()) return nullptr;
const auto v=a->find(key);
return v!=a->end() && v->is_number() && std::isfinite(v->get<double>()) && *v>=0 && *v<=100 ? *v:Json();
}
Json criteria(int64_t factor) {
return {{"age_min",16},{"age_max",40},{"strength_min",0},{"strength_max",100},{"traits",7},{"foot",0},{"type",0},{"price_max",cap*factor}};
}
bool valid_criteria(const Json &c, int64_t factor) {
return keys(c,{"age_min","age_max","strength_min","strength_max","traits","foot","type","price_max"}) &&
integer(c.at("age_min"),16,40) && integer(c.at("age_max"),16,40) && c.at("age_min")<=c.at("age_max") &&
integer(c.at("strength_min"),0,100) && integer(c.at("strength_max"),0,100) && c.at("strength_min")<=c.at("strength_max") &&
integer(c.at("traits"),1,7) && integer(c.at("foot"),0,3) && integer(c.at("type"),0,3) && integer(c.at("price_max"),0,cap*factor);
}
bool query_text(const Json &v) {
if(!v.is_string()) return false;
const auto &s=v.get_ref<const std::string&>(); size_t chars=0;
for(size_t i=0;i<s.size();) {
const auto c=static_cast<unsigned char>(s[i]); size_t n= c<128?1:c>=194&&c<=223?2:c>=224&&c<=239?3:c>=240&&c<=244?4:0;
if(!n || i+n>s.size() || c<32) return false;
for(size_t k=1;k<n;++k) if((static_cast<unsigned char>(s[i+k])&192)!=128) return false;
if((c==224 && static_cast<unsigned char>(s[i+1])<160)||(c==237 && static_cast<unsigned char>(s[i+1])>=160)||(c==240 && static_cast<unsigned char>(s[i+1])<144)||(c==244 && static_cast<unsigned char>(s[i+1])>=144)) return false;
i+=n; if(++chars>40) return false;
}
return true;
}
std::string fold(std::string s) {
for(const auto &[a,b]:std::initializer_list<std::pair<std::string,std::string>>{
{"Ä","a"},{"ä","a"},{"Ö","o"},{"ö","o"},{"Ü","u"},{"ü","u"},{"ẞ","ss"},{"ß","ss"},
{"É","e"},{"é","e"},{"È","e"},{"è","e"},{"Ê","e"},{"ê","e"},{"Ë","e"},{"ë","e"},
{"Á","a"},{"á","a"},{"À","a"},{"à","a"},{"Â","a"},{"â","a"},{"Ã","a"},{"ã","a"},{"Å","a"},{"å","a"},
{"Í","i"},{"í","i"},{"Ì","i"},{"ì","i"},{"Î","i"},{"î","i"},{"İ","i"},
{"Ñ","n"},{"ñ","n"},{"Ç","c"},{"ç","c"},{"Ł","l"},{"ł","l"},
{"Ó","o"},{"ó","o"},{"Ò","o"},{"ò","o"},{"Ô","o"},{"ô","o"},{"Õ","o"},{"õ","o"},{"Ø","o"},{"ø","o"},
{"Ú","u"},{"ú","u"},{"Ù","u"},{"ù","u"},{"Û","u"},{"û","u"},{"Æ","ae"},{"æ","ae"},{"Œ","oe"},{"œ","oe"},
{"Ś","s"},{"ś","s"},{"Ć","c"},{"ć","c"},{"Ź","z"},{"ź","z"},{"Ż","z"},{"ż","z"}}) {
size_t at=0;while((at=s.find(a,at))!=std::string::npos){s.replace(at,a.size(),b);at+=b.size();}
}
for(auto &c:s) if(c>='A'&&c<='Z') c=char(c-'A'+'a');
return s;
}
std::vector<const Json*> market_players(const Catalog &world, const std::string &club) {
if(club.empty()) return {};
std::vector<const Json*> clubs;
for(auto *c:world.clubs()) {
auto *l=world.find("competitions",c->value("competition",""));
if(c->at("id")!=club && l && l->value("type","")=="league") clubs.push_back(c);
}
std::vector<const Json*> out;std::set<std::string> used;
for(int slot=0;slot<12 && !clubs.empty();++slot) {
const Json *chosen=nullptr;
for(size_t offset=0;offset<clubs.size()&&!chosen;++offset) {
const auto squad=world.squad(clubs[(size_t(slot)+offset)%clubs.size()]->at("id"));
for(auto *p:squad) if(!used.contains(p->at("id")) && position(*p)==positions[size_t(slot)%4]) {chosen=p;break;}
if(!chosen) for(auto *p:squad) if(!used.contains(p->at("id"))) {chosen=p;break;}
}
if(!chosen) break;
used.insert(chosen->at("id").get<std::string>());out.push_back(chosen);
}
return out;
}
bool available(const Catalog &world, const Json *p) {
if(!p) return false;
auto *c=world.find("clubs",p->value("team",""));
auto *l=c?world.find("competitions",c->value("competition","")):nullptr;
return c && c->value("type","club")=="club" && l && l->value("type","")=="league";
}
Json row(const Json &state, const Catalog &world, const std::string &club, const Json &p, const std::vector<const Json*> *cached_market = nullptr) {
const auto factor=finance_currency_factor(world);
const auto id=p.at("id").get<std::string>(), team=p.value("team","");
const bool is_own=team==club;
auto squad=world.squad(team);auto at=std::find(squad.begin(),squad.end(),&p);
size_t ordinal=at==squad.end()?0:size_t(at-squad.begin());
const auto market=cached_market?*cached_market:market_players(world,club);auto candidate=std::find(market.begin(),market.end(),&p);
if(candidate!=market.end()) ordinal=size_t(candidate-market.begin());
const int64_t fee=std::min<int64_t>(cap,(is_own?600000:450000)+int64_t(std::min<size_t>(ordinal,500))* (is_own?95000:170000))*factor;
Json strength=attribute(p,"strength");
const auto cond=attribute(p,"condition"),tech=attribute(p,"technique"),form=attribute(p,"form");
if(strength.is_null()&&!cond.is_null()&&!tech.is_null()&&!form.is_null()) strength=int(std::floor((cond.get<double>()+tech.get<double>()+form.get<double>())/3));
Json salary=nullptr;
if(is_own&&state.contains("contracts")&&state.at("contracts").is_object()) {
const auto players=state.at("contracts").find("players");
if(players!=state.at("contracts").end()&&players->is_object()&&players->contains(id)) {
const auto &c=players->at(id);if(c.is_object()&&c.contains("salary")&&integer(c.at("salary"),0,salary_cap*factor)) salary=c.at("salary");
}
}
const auto *c=world.find("clubs",team);
Json nation=nullptr; const auto ns=p.find("nationalities");
if(ns!=p.end()&&ns->is_array()&&!ns->empty()&&(*ns)[0].is_string()&&world.find("nations",(*ns)[0])) nation=(*ns)[0];
Json skill=Json::array();for(auto *key:skills)skill.push_back(attribute(p,key));
Json foot=attribute(p,"foot"),type=attribute(p,"type");
if(!integer(foot,1,3))foot=nullptr;
if(!integer(type,1,3))type=nullptr;
return {{"id",id},{"name",world.name(p)},{"club",team},{"club_name",c?world.name(*c):""},{"crest",c?c->value("crest",Json()):Json()},
{"photo",p.value("photo",Json())},{"position",position(p).empty()?Json():Json(position(p))},{"age",age(p,state,world)},
{"condition",cond},{"technique",tech},{"form",form},{"strength",strength},{"foot",foot},{"type",type},
{"nation",nation},{"nation_name",nation.is_string()?world.nation_name(nation.get<std::string>()):""},{"skills",skill},
{"games",attribute(p,"games")},{"goals",attribute(p,"goals")},{"assists",attribute(p,"assists")},
{"league_games",attribute(p,"league_games")},{"cup_games",attribute(p,"cup_games")},{"europe_games",attribute(p,"europe_games")},
{"fee",fee},{"salary",salary},{"own",is_own}};
}
bool valid_order(const Json &o, const Catalog &world, const std::string &club, int64_t factor) {
if(!keys(o,{"kind","player","source_club","fee","salary","months","bonuses","poached"}) ||!o.at("kind").is_string()||!o.at("player").is_string()||!o.at("source_club").is_string()||!o.at("poached").is_boolean())return false;
const auto kind=o.at("kind").get<std::string>();const bool is_own=kind=="sell"||kind=="lend",loan=kind=="loan"||kind=="lend";
const auto *p=world.find("players",o.at("player"));
if(!(is_own||kind=="buy"||kind=="loan")||!available(world,p)||p->value("team","")!=o.at("source_club").get<std::string>()||is_own!=(p->value("team","")==club))return false;
if(is_own&&o.at("poached")!=false)return false;
if(!is_own&&o.at("poached")==false) {
const auto market=market_players(world,club);if(std::find(market.begin(),market.end(),p)==market.end())return false;
}
if(!integer(o.at("fee"),0,cap*factor)||!integer(o.at("salary"),0,salary_cap*factor)||!integer(o.at("months"),12,48)||
!(o.at("months")==12||o.at("months")==24||(!loan&&(o.at("months")==36||o.at("months")==48)))||!o.at("bonuses").is_array()||o.at("bonuses").size()!=7)return false;
return std::all_of(o.at("bonuses").begin(),o.at("bonuses").end(),[&](const auto &v){return integer(v,0,100*factor);});
}
bool same_order_target(const Json &a,const Json &b) {
const bool own=a.at("kind")=="sell"||a.at("kind")=="lend";
return a.at("player")==b.at("player")&&a.at("source_club")==b.at("source_club")&&
(own?(b.at("kind")=="sell"||b.at("kind")=="lend"):a.at("kind")==b.at("kind"));
}
} // namespace
Json demo_transfer(const Catalog &world,const std::string &requested) {
const auto club=own(world,requested);return {{"club",club},{"query",""},{"positions",15},{"criteria",criteria(finance_currency_factor(world))},{"listed",Json::array()},{"orders",Json::array()}};
}
bool valid_demo_transfer(const Json &state,const Catalog &world,const std::string &requested) {
try {
const auto club=own(world,requested);
const auto factor=finance_currency_factor(world);const auto &t=state.at("transfer");
if(!keys(t,{"club","query","positions","criteria","listed","orders"})||t.at("club")!=club||!query_text(t.at("query"))||!integer(t.at("positions"),1,15)||!valid_criteria(t.at("criteria"),factor)||!t.at("listed").is_array()||t.at("listed").size()>3||!t.at("orders").is_array()||t.at("orders").size()>50)return false;
std::set<std::string> listed,required;
for(const auto &p:t.at("listed")){if(!p.is_string()||!listed.insert(p.get<std::string>()).second)return false;const auto *r=world.find("players",p);if(!r||r->value("team","")!=club)return false;}
std::vector<Json> accepted;
for(const auto &o:t.at("orders")) {
if(!valid_order(o,world,club,factor)||std::any_of(accepted.begin(),accepted.end(),[&](const auto&a){return same_order_target(a,o);}))return false;
if(o.at("kind")=="sell"||o.at("kind")=="lend")required.insert(o.at("player").get<std::string>());
accepted.push_back(o);
}
return listed==required;
}catch(const std::exception&){return false;}
}
bool migrate_demo_transfer(Json &state,const Catalog &world,const std::string &club) {
try{if(!state.is_object())return false;if(state.contains("transfer"))return valid_demo_transfer(state,world,club);auto next=state;next["transfer"]=demo_transfer(world,club);if(!valid_demo_transfer(next,world,club))return false;state=std::move(next);return true;}catch(const std::exception&){return false;}
}
std::string edit_demo_transfer(Json &state,const Json &action,const Catalog &world,const std::string &requested) {
if(!valid_demo_transfer(state,world,requested))return "invalid_transfer_state";
try {
if(!action.is_object()||!action.contains("kind")||!action.at("kind").is_string())return "invalid_transfer_action";
auto next=state;auto &t=next["transfer"];const auto club=own(world,requested);const auto factor=finance_currency_factor(world);const auto kind=action.at("kind").get<std::string>();
if(kind=="search") {if(!keys(action,{"kind","query"})||!query_text(action.at("query")))return "invalid_transfer_query";
t["query"]=action.at("query");}
else if(kind=="criteria") {
if(!keys(action,{"kind","value","positions"})||!integer(action.at("positions"),1,15))return "invalid_transfer_criteria";
auto c=action.at("value");if(!c.is_object()||!c.contains("price_max")||!integer(c.at("price_max"),0,cap))return "invalid_transfer_criteria";
c["price_max"]=c.at("price_max").get<int64_t>()*factor;if(!valid_criteria(c,factor))return "invalid_transfer_criteria";
t["criteria"]=c;t["positions"]=action.at("positions");t["query"]="";
} else if(kind=="positions") {if(!keys(action,{"kind","value"})||!integer(action.at("value"),1,15))return "invalid_transfer_criteria";
t["positions"]=action.at("value");}
else if(kind=="unlist") {
if(!keys(action,{"kind","player"})||!action.at("player").is_string())return "invalid_transfer_player";
const auto id=action.at("player").get<std::string>();auto &ls=t["listed"];auto it=std::find(ls.begin(),ls.end(),id);if(it==ls.end())return "transfer_not_listed";
ls.erase(it);auto &os=t["orders"];os.erase(std::remove_if(os.begin(),os.end(),[&](const auto&o){return o.at("player")==id&&(o.at("kind")=="sell"||o.at("kind")=="lend");}),os.end());
} else if(kind=="remove") {
if(!keys(action,{"kind","index"})||!integer(action.at("index"),0,int64_t(t["orders"].size())-1))return "invalid_transfer_order";
const auto index=action.at("index").get<size_t>();const auto removed=t["orders"][index];t["orders"].erase(t["orders"].begin()+ptrdiff_t(index));if(removed.at("kind")=="sell"||removed.at("kind")=="lend"){auto &ls=t["listed"];auto it=std::find(ls.begin(),ls.end(),removed.at("player"));if(it!=ls.end())ls.erase(it);}
} else if(kind=="submit") {
if(!keys(action,{"kind","order"}))return "invalid_transfer_order";
auto o=action.at("order");
if(!keys(o,{"kind","player","source_club","fee","salary","months","bonuses","poached"})||!integer(o.at("fee"),0,cap)||!integer(o.at("salary"),0,salary_cap)||!o.at("bonuses").is_array()||o.at("bonuses").size()!=7)return "invalid_transfer_order";
for(auto &b:o["bonuses"]){if(!integer(b,0,100))return "invalid_transfer_order";
b=b.get<int64_t>()*factor;}
o["fee"]=o.at("fee").get<int64_t>()*factor;o["salary"]=o.at("salary").get<int64_t>()*factor;if(!valid_order(o,world,club,factor))return "invalid_transfer_order";
const bool is_own=o.at("kind")=="sell"||o.at("kind")=="lend";auto &os=t["orders"];auto it=std::find_if(os.begin(),os.end(),[&](const auto&a){return same_order_target(a,o);});
if(it==os.end()){if(os.size()>=50)return "transfer_orders_full";
os.push_back(o);}else *it=o;
if(is_own&&std::find(t["listed"].begin(),t["listed"].end(),o.at("player"))==t["listed"].end()){if(t["listed"].size()>=3)return "transfer_list_full";
t["listed"].push_back(o.at("player"));}
}else return "unknown_transfer_action";
if(!valid_demo_transfer(next,world,requested))return "invalid_transfer_state";
state=std::move(next);return {};
}catch(const std::exception&){return "invalid_transfer_action";}
}
Json demo_transfer_player(const Json &state,const Catalog &world,const std::string &requested,const std::string &id) {
if(!valid_demo_transfer(state,world,requested))return error("invalid_transfer_state");
const auto *p=world.find("players",id);if(!available(world,p))return error("invalid_transfer_player");
return {{"ok",true},{"row",row(state,world,own(world,requested),*p)}};
}
Json demo_transfer_view(const Json &state,const Catalog &world,const std::string &requested) {
if(!valid_demo_transfer(state,world,requested))return error("invalid_transfer_state");
const auto club=own(world,requested);const auto &t=state.at("transfer"),&c=t.at("criteria");Json ours=Json::array(),market=Json::array(),orders=Json::array();
const auto candidates=market_players(world,club);
if(!club.empty())for(auto *p:world.squad(club))ours.push_back(row(state,world,club,*p,&candidates));
std::vector<Json> pool;for(auto *p:candidates)pool.push_back(row(state,world,club,*p,&candidates));for(const auto &id:t.at("listed"))pool.push_back(row(state,world,club,*world.find("players",id),&candidates));
const auto inrange=[](const Json&v,int low,int high,int defaultlow,int defaulthigh){return v.is_null()?(low==defaultlow&&high==defaulthigh):v>=low&&v<=high;};
std::erase_if(pool,[&](const auto&p){
const int index=role_index(p.at("position").is_string()?p.at("position").template get<std::string>():"");const int mask=t.at("positions");if(index==4?mask!=15:!(mask&(1<<index)))return true;
if(fold(p.at("name").template get<std::string>()).find(fold(t.at("query").template get<std::string>()))==std::string::npos)return true;
if(!inrange(p.at("age"),c.at("age_min"),c.at("age_max"),16,40))return true;
Json strength=nullptr;double sum=0;int count=0;bool known=true;int bit=0;
for(auto *field:{"condition","technique","form"}){if(c.at("traits").template get<int>()&(1<<bit)){if(p.at(field).is_null())known=false;else{sum+=p.at(field).template get<double>();++count;}}++bit;}
if(known&&count)strength=int(std::floor(sum/count));
if(!inrange(strength,c.at("strength_min"),c.at("strength_max"),0,100))return true;
return (c.at("foot")!=0&&c.at("foot")!=p.at("foot"))||(c.at("type")!=0&&c.at("type")!=p.at("type"))||p.at("fee")>c.at("price_max");
});
std::stable_sort(pool.begin(),pool.end(),[](const auto&a,const auto&b){const int pa=role_index(a.at("position").is_string()?a.at("position").template get<std::string>():""),pb=role_index(b.at("position").is_string()?b.at("position").template get<std::string>():"");if(pa!=pb)return pa<pb;if(a.at("strength").is_null()!=b.at("strength").is_null())return !a.at("strength").is_null();if(a.at("strength")!=b.at("strength"))return a.at("strength")>b.at("strength");return a.at("own")==false&&b.at("own")==true;});
for(const auto &p:pool)market.push_back(p);
for(const auto &o:t.at("orders")){auto display=o;auto *p=world.find("players",o.at("player"));display["name"]=world.name(*p);orders.push_back(display);}
return {{"ok",true},{"club",club},{"own",ours},{"market",market},{"orders",orders},{"criteria",c},{"positions",t.at("positions")},{"query",t.at("query")}};
}
Json demo_transfer_roster(const Json &state,const Catalog &world,const std::string &requested,const std::string &team) {
if(!valid_demo_transfer(state,world,requested))return error("invalid_transfer_state");
const auto *c=world.find("clubs",team);
if(!c||c->value("type","club")!="club")return error("invalid_transfer_club");
const auto club=own(world,requested);const auto candidates=market_players(world,club);Json rows=Json::array();
for(auto *p:world.squad(team))if(available(world,p))rows.push_back(row(state,world,club,*p,&candidates));
return {{"ok",true},{"club",team},{"rows",rows}};
}
Json demo_transfer_quote(const Json &state,const Json &request,const Catalog &world,const std::string &requested) {
if(!valid_demo_transfer(state,world,requested))return error("invalid_transfer_state");
try {
if(!keys(request,{"kind","player","poached"})||!request.at("kind").is_string()||!request.at("player").is_string()||!request.at("poached").is_boolean())return error("invalid_transfer_quote");
const auto club=own(world,requested),kind=request.at("kind").get<std::string>();const auto factor=finance_currency_factor(world);const bool is_own=kind=="sell"||kind=="lend",loan=kind=="loan"||kind=="lend";auto *p=world.find("players",request.at("player"));if(!available(world,p))return error("invalid_transfer_player");
auto r=row(state,world,club,*p);
Json order={{"kind",kind},{"player",request.at("player")},{"source_club",p->at("team")},{"fee",0},{"salary",0},{"months",12},{"bonuses",{0,0,0,0,0,0,0}},{"poached",request.at("poached")}};
if(!valid_order(order,world,club,factor))return error("invalid_transfer_player");
if(is_own&&std::find(state.at("transfer").at("listed").begin(),state.at("transfer").at("listed").end(),request.at("player"))==state.at("transfer").at("listed").end()&&state.at("transfer").at("listed").size()>=3)return error("transfer_list_full");
const auto value=r.at("fee").get<int64_t>();const int64_t price=request.at("poached")==true?std::min(cap*factor,((value/factor*3+1)/2)*factor):value;
const Json salary=is_own?r.at("salary"):Json(25000*factor);order["fee"]=loan?50000*factor:price;order["salary"]=salary.is_null()?Json(0):salary;order["months"]=loan?12:24;
for(const auto&o:state.at("transfer").at("orders"))if(o.at("kind")==kind&&o.at("player")==request.at("player")&&o.at("source_club")==p->at("team")){order=o;break;}
const auto &orders=state.at("transfer").at("orders");
const bool can_submit=orders.size()<50||std::any_of(orders.begin(),orders.end(),[&](const auto &saved){return same_order_target(saved,order);});
return {{"ok",true},{"can_submit",can_submit},{"row",r},{"kind",kind},{"source_club",p->at("team")},{"poached",request.at("poached")},
{"demand_fee",loan?Json(50000*factor):Json(price)},{"demand_salary",salary},{"fee",order.at("fee")},{"salary",order.at("salary")},{"months",order.at("months")},{"bonuses",order.at("bonuses")}};
}catch(const std::exception&){return error("invalid_transfer_quote");}
}
Json demo_transfer_strengths(const Json &state,const Catalog &world,const std::string &requested,const Json &active) {
if(!valid_demo_transfer(state,world,requested))return error("invalid_transfer_state");
const auto club=own(world,requested);std::set<std::string> selected;if(active.is_array())for(const auto&id:active)if(id.is_string())selected.insert(id.get<std::string>());
std::array<double,5> sa{},st{};std::array<int,5> ca{},ct{};const auto candidates=market_players(world,club);
if(!club.empty())for(auto *p:world.squad(club)){const auto r=row(state,world,club,*p,&candidates);if(r.at("strength").is_null())continue;const auto strength=r.at("strength").get<double>();const auto pos=role_index(position(*p));st[4]+=strength;++ct[4];if(pos<4){st[size_t(pos)]+=strength;++ct[size_t(pos)];}if(selected.contains(p->at("id"))){sa[4]+=strength;++ca[4];if(pos<4){sa[size_t(pos)]+=strength;++ca[size_t(pos)];}}}
Json a=Json::array(),t=Json::array();for(size_t i=0;i<4;++i){a.push_back(ca[i]?Json(int(std::floor(sa[i]/ca[i]))):Json());t.push_back(ct[i]?Json(int(std::floor(st[i]/ct[i]))):Json());}
return {{"ok",true},{"active",a},{"team",t},{"active_average",ca[4]?Json(int(std::floor(sa[4]/ca[4]))):Json()},{"team_average",ct[4]?Json(int(std::floor(st[4]/ct[4]))):Json()}};
}
Json demo_transfer_suggestion(const Json &state,const Catalog &world,const std::string &club,const Json &active) {
const auto values=demo_transfer_strengths(state,world,club,active);if(!values.value("ok",false))return values;int weakest=0;int score=101;for(int i=0;i<4;++i)if(values.at("active")[size_t(i)].is_number_integer()&&values.at("active")[size_t(i)].get<int>()<score){score=values.at("active")[size_t(i)];weakest=i;}
const auto factor=finance_currency_factor(world);auto c=criteria(factor);c["age_min"]=18;c["age_max"]=28;c["strength_min"]=values.at("active_average").is_number_integer()?values.at("active_average"):Json(0);const auto cash=state.value("cash",Json());c["price_max"]=integer(cash,0,cap*factor)?Json(std::min<int64_t>(cash.get<int64_t>(),3000000*factor)):Json(0);return {{"ok",true},{"criteria",c},{"positions",1<<weakest}};
}
} // namespace bmh::modern_ui