Made new stats visible same time with old for comparision (need testing)
This commit is contained in:
Pauli Nieminen
parent
7b9fd1bcbc
commit
90930ec599
6 changed files with 204 additions and 148 deletions
|
|
@ -57,7 +57,6 @@ opts.AddOptions(
|
|||
BoolOption('prereqs','abort if prerequisites cannot be detected',True),
|
||||
('program_suffix', 'suffix to append to names of installed programs',""),
|
||||
BoolOption('python', 'Enable in-game python extensions.', True),
|
||||
BoolOption('maboul_stats', 'Enable alternative excpeted damage calculations', False),
|
||||
BoolOption('raw_sockets', 'Set to use raw receiving sockets in the multiplayer network layer rather than the SDL_net facilities', False),
|
||||
('server_gid', 'group id of the user who runs wesnothd', ""),
|
||||
('server_uid', 'user id of the user who runs wesnothd', ""),
|
||||
|
|
@ -236,9 +235,6 @@ if env['internal_data']:
|
|||
if env['python']:
|
||||
env.Append(CPPDEFINES = "HAVE_PYTHON")
|
||||
|
||||
if env['maboul_stats']:
|
||||
env.Append(CPPDEFINES = "MABOUL_STATS")
|
||||
|
||||
if sys.platform != "win32":
|
||||
if env['prefsdir']:
|
||||
env.Append(CPPDEFINES = "PREFERENCES_DIR='\"%s\"'" % env['prefsdir'] )
|
||||
|
|
|
|||
|
|
@ -284,11 +284,6 @@ AC_ARG_ENABLE([raw-sockets],
|
|||
[raw_sockets=$enableval],
|
||||
[raw_sockets=no])
|
||||
|
||||
AC_ARG_ENABLE([mabul_stats],
|
||||
AS_HELP_STRING([--enable-maboul-stats], [replace excepted battle result calcualtions per fight version]),
|
||||
[maboul_stats=$enableval],
|
||||
[maboul_stats=no])
|
||||
|
||||
if test "x$raw_sockets" = "xyes"
|
||||
then
|
||||
CPPFLAGS="$CPPFLAGS -DNETWORK_USE_RAW_SOCKETS"
|
||||
|
|
@ -306,7 +301,6 @@ AM_CONDITIONAL([GCC], [test x$GXX = xyes])
|
|||
AM_CONDITIONAL([INCLUDEDINTL], [test x$nls_cv_use_gnu_gettext = xyes])
|
||||
AM_CONDITIONAL([INSTALLDATA], [test x$game = xyes || x$editor = xyes])
|
||||
AM_CONDITIONAL([DUMMYLOCALES], [test x$dummylocales = xyes])
|
||||
AM_CONDITIONAL([MABOUL_STATS], [test x$maboul_stats = xyes])
|
||||
|
||||
if test x$dummylocales = xyes; then
|
||||
AC_DEFINE([USE_DUMMYLOCALES],,[Define if the game should not use system locales])
|
||||
|
|
|
|||
|
|
@ -377,10 +377,6 @@ else
|
|||
CXXFLAGS += -DWESNOTH_BOOST_TEST_MAIN
|
||||
endif
|
||||
|
||||
if MABOUL_STATS
|
||||
CXXFLAGS += -DMABOUL_STATS
|
||||
endif
|
||||
|
||||
CXXLD = $(LDPREFIX) $(CXX)
|
||||
CXXFLAGS += $(BOOST_CPPFLAGS)
|
||||
|
||||
|
|
|
|||
|
|
@ -100,6 +100,7 @@ public:
|
|||
protected:
|
||||
void action(gui::dialog_process_info &dp_info);
|
||||
private:
|
||||
void make_damage_line(std::vector<std::string>&,const std::string&,const long long&,const long long&,const long long&,const long long&);
|
||||
gui::dialog_button *detail_btn_;
|
||||
std::string player_name_;
|
||||
statistics::stats stats_;
|
||||
|
|
@ -215,54 +216,29 @@ team_num_(team), unit_count_(5,0)
|
|||
<< COLUMN_SEPARATOR << _("This Turn");
|
||||
items.push_back(str.str());
|
||||
}
|
||||
{
|
||||
const int dsa = 100 * stats_.damage_inflicted
|
||||
- stats_.expected_damage_inflicted;
|
||||
const int dst = 100 * stats_.turn_damage_inflicted
|
||||
- stats_.turn_expected_damage_inflicted;
|
||||
std::stringstream str;
|
||||
str << _("Inflicted") << COLUMN_SEPARATOR
|
||||
<< stats_.damage_inflicted << " / "
|
||||
<< (stats_.expected_damage_inflicted / 100.0)
|
||||
<< COLUMN_SEPARATOR
|
||||
<< ((dsa > 0) ? "+" : "")
|
||||
<< ((stats_.expected_damage_inflicted == 0) ? 0
|
||||
: 100 * dsa / stats_.expected_damage_inflicted)
|
||||
<< "%" << COLUMN_SEPARATOR
|
||||
<< COLUMN_SEPARATOR
|
||||
<< stats_.turn_damage_inflicted << " / "
|
||||
<< (stats_.turn_expected_damage_inflicted / 100.0)
|
||||
<< COLUMN_SEPARATOR
|
||||
<< ((dst > 0) ? "+" : "")
|
||||
<< ((stats_.turn_expected_damage_inflicted == 0) ? 0
|
||||
: 100 * dst / stats_.turn_expected_damage_inflicted)
|
||||
<< "%";
|
||||
items.push_back(str.str());
|
||||
}
|
||||
{
|
||||
const int dsa = 100 * stats_.damage_taken
|
||||
- stats_.expected_damage_taken;
|
||||
const int dst = 100 * stats_.turn_damage_taken
|
||||
- stats_.turn_expected_damage_taken;
|
||||
std::stringstream str;
|
||||
str << _("Taken") << COLUMN_SEPARATOR
|
||||
<< stats_.damage_taken << " / "
|
||||
<< (stats_.expected_damage_taken / 100.0)
|
||||
<< COLUMN_SEPARATOR
|
||||
<< ((dsa > 0) ? "+" : "")
|
||||
<< ((stats_.expected_damage_taken == 0) ? 0
|
||||
: 100 * dsa / stats_.expected_damage_taken)
|
||||
<< "%" << COLUMN_SEPARATOR
|
||||
<< COLUMN_SEPARATOR
|
||||
<< stats_.turn_damage_taken << " / "
|
||||
<< (stats_.turn_expected_damage_taken / 100.0)
|
||||
<< COLUMN_SEPARATOR
|
||||
<< ((dst > 0) ? "+" : "")
|
||||
<< ((stats_.turn_expected_damage_taken == 0) ? 0
|
||||
: 100 * dst / stats_.turn_expected_damage_taken)
|
||||
<< "%";
|
||||
items.push_back(str.str());
|
||||
}
|
||||
|
||||
statistics_dialog::make_damage_line(items, _("Inflicted"),
|
||||
stats_.damage_inflicted,
|
||||
stats_.expected_damage_inflicted,
|
||||
stats_.turn_damage_inflicted,
|
||||
stats_.turn_expected_damage_inflicted);
|
||||
statistics_dialog::make_damage_line(items, _("Taken"),
|
||||
stats_.damage_taken,
|
||||
stats_.expected_damage_taken,
|
||||
stats_.turn_damage_taken,
|
||||
stats_.turn_expected_damage_taken);
|
||||
items.push_back("New stats:");
|
||||
|
||||
statistics_dialog::make_damage_line(items, _("Inflicted"),
|
||||
stats_.damage_inflicted,
|
||||
stats_.new_expected_damage_inflicted,
|
||||
stats_.turn_damage_inflicted,
|
||||
stats_.new_turn_expected_damage_inflicted);
|
||||
statistics_dialog::make_damage_line(items, _("Taken"),
|
||||
stats_.damage_taken,
|
||||
stats_.new_expected_damage_taken,
|
||||
stats_.turn_damage_taken,
|
||||
stats_.new_turn_expected_damage_taken);
|
||||
set_menu(items);
|
||||
}
|
||||
|
||||
|
|
@ -270,6 +246,39 @@ statistics_dialog::~statistics_dialog()
|
|||
{
|
||||
}
|
||||
|
||||
void statistics_dialog::make_damage_line(std::vector<std::string>& items,
|
||||
const std::string& header,
|
||||
const long long& damage,
|
||||
const long long& expected,
|
||||
const long long& turn_damage,
|
||||
const long long& turn_expected)
|
||||
{
|
||||
const int dsa = statistics::stats::desimal_shift * damage
|
||||
- expected;
|
||||
const int dst = statistics::stats::desimal_shift * turn_damage
|
||||
- turn_expected;
|
||||
|
||||
std::stringstream str;
|
||||
str << header << COLUMN_SEPARATOR
|
||||
<< damage << " / "
|
||||
<< (expected / (double)statistics::stats::desimal_shift)
|
||||
<< COLUMN_SEPARATOR
|
||||
<< ((dsa > 0) ? "+" : "")
|
||||
<< ((expected == 0) ? 0
|
||||
: statistics::stats::desimal_shift * dsa / expected)
|
||||
<< "%" << COLUMN_SEPARATOR
|
||||
<< COLUMN_SEPARATOR
|
||||
<< turn_damage << " / "
|
||||
<< (turn_expected / (double)statistics::stats::desimal_shift)
|
||||
<< COLUMN_SEPARATOR
|
||||
<< ((dst > 0) ? "+" : "")
|
||||
<< ((turn_expected == 0) ? 0
|
||||
: statistics::stats::desimal_shift * dst / turn_expected)
|
||||
<< "%";
|
||||
items.push_back(str.str());
|
||||
|
||||
}
|
||||
|
||||
} // end anonymous namespace
|
||||
|
||||
namespace events{
|
||||
|
|
|
|||
|
|
@ -235,29 +235,51 @@ config stats::write() const
|
|||
res.add_child("attacks",write_battle_result_map(attacks));
|
||||
res.add_child("defends",write_battle_result_map(defends));
|
||||
|
||||
char buf[50];
|
||||
snprintf(buf,sizeof(buf),"%d",recruit_cost);
|
||||
res["recruit_cost"] = buf;
|
||||
snprintf(buf,sizeof(buf),"%d",recall_cost);
|
||||
res["recall_cost"] = buf;
|
||||
std::stringstream ss;
|
||||
ss << recruit_cost;
|
||||
res["recruit_cost"] = ss.str();
|
||||
ss.str(std::string());
|
||||
ss << recall_cost;
|
||||
res["recall_cost"] = ss.str();
|
||||
|
||||
snprintf(buf,sizeof(buf),"%d",damage_inflicted);
|
||||
res["damage_inflicted"] = buf;
|
||||
snprintf(buf,sizeof(buf),"%d",damage_taken);
|
||||
res["damage_taken"] = buf;
|
||||
snprintf(buf,sizeof(buf),"%d",expected_damage_inflicted);
|
||||
res["expected_damage_inflicted"] = buf;
|
||||
snprintf(buf,sizeof(buf),"%d",expected_damage_taken);
|
||||
res["expected_damage_taken"] = buf;
|
||||
ss.str(std::string());
|
||||
ss << damage_inflicted;
|
||||
res["damage_inflicted"] = ss.str();
|
||||
ss.str(std::string());
|
||||
ss << damage_taken;
|
||||
res["damage_taken"] = ss.str();
|
||||
ss.str(std::string());
|
||||
ss << expected_damage_inflicted;
|
||||
res["expected_damage_inflicted"] = ss.str();
|
||||
ss.str(std::string());
|
||||
ss << expected_damage_taken;
|
||||
res["expected_damage_taken"] = ss.str();
|
||||
ss.str(std::string());
|
||||
ss << turn_damage_inflicted;
|
||||
|
||||
snprintf(buf,sizeof(buf),"%d",turn_damage_inflicted);
|
||||
res["turn_damage_inflicted"] = buf;
|
||||
snprintf(buf,sizeof(buf),"%d",turn_damage_taken);
|
||||
res["turn_damage_taken"] = buf;
|
||||
snprintf(buf,sizeof(buf),"%d",turn_expected_damage_inflicted);
|
||||
res["turn_expected_damage_inflicted"] = buf;
|
||||
snprintf(buf,sizeof(buf),"%d",turn_expected_damage_taken);
|
||||
res["turn_expected_damage_taken"] = buf;
|
||||
res["turn_damage_inflicted"] = ss.str();
|
||||
ss.str(std::string());
|
||||
ss << turn_damage_taken;
|
||||
res["turn_damage_taken"] = ss.str();
|
||||
ss.str(std::string());
|
||||
ss << turn_expected_damage_inflicted;
|
||||
res["turn_expected_damage_inflicted"] = ss.str();
|
||||
ss.str(std::string());
|
||||
ss << turn_expected_damage_taken;
|
||||
res["turn_expected_damage_taken"] = ss.str();
|
||||
|
||||
ss.str(std::string());
|
||||
ss << new_expected_damage_inflicted;
|
||||
res["new_expected_damage_inflicted"] = ss.str();
|
||||
ss.str(std::string());
|
||||
ss << new_expected_damage_taken;
|
||||
res["new_expected_damage_taken"] = ss.str();
|
||||
ss.str(std::string());
|
||||
ss << new_turn_expected_damage_inflicted;
|
||||
res["new_turn_expected_damage_inflicted"] = ss.str();
|
||||
ss.str(std::string());
|
||||
ss << new_turn_expected_damage_taken;
|
||||
res["new_turn_expected_damage_taken"] = ss.str();
|
||||
|
||||
return res;
|
||||
}
|
||||
|
|
@ -286,29 +308,52 @@ void stats::write(config_writer &out) const
|
|||
write_battle_result_map(out, defends);
|
||||
out.close_child("defends");
|
||||
|
||||
char buf[50];
|
||||
snprintf(buf,sizeof(buf),"%d",recruit_cost);
|
||||
out.write_key_val("recruit_cost", buf);
|
||||
snprintf(buf,sizeof(buf),"%d",recall_cost);
|
||||
out.write_key_val("recall_cost", buf);
|
||||
std::stringstream ss;
|
||||
ss << recruit_cost;
|
||||
out.write_key_val("recruit_cost", ss.str());
|
||||
ss.str(std::string());
|
||||
ss << recall_cost;
|
||||
out.write_key_val("recall_cost", ss.str());
|
||||
|
||||
snprintf(buf,sizeof(buf),"%d",damage_inflicted);
|
||||
out.write_key_val("damage_inflicted", buf);
|
||||
snprintf(buf,sizeof(buf),"%d",damage_taken);
|
||||
out.write_key_val("damage_taken", buf);
|
||||
snprintf(buf,sizeof(buf),"%d",expected_damage_inflicted);
|
||||
out.write_key_val("expected_damage_inflicted", buf);
|
||||
snprintf(buf,sizeof(buf),"%d",expected_damage_taken);
|
||||
out.write_key_val("expected_damage_taken", buf);
|
||||
ss.str(std::string());
|
||||
ss << damage_inflicted;
|
||||
out.write_key_val("damage_inflicted", ss.str());
|
||||
ss.str(std::string());
|
||||
ss << damage_taken;
|
||||
out.write_key_val("damage_taken", ss.str());
|
||||
ss.str(std::string());
|
||||
ss << expected_damage_inflicted;
|
||||
out.write_key_val("expected_damage_inflicted", ss.str());
|
||||
ss.str(std::string());
|
||||
ss << expected_damage_taken;
|
||||
out.write_key_val("expected_damage_taken", ss.str());
|
||||
ss.str(std::string());
|
||||
ss << turn_damage_inflicted;
|
||||
|
||||
out.write_key_val("turn_damage_inflicted", ss.str());
|
||||
ss.str(std::string());
|
||||
ss << turn_damage_taken;
|
||||
out.write_key_val("turn_damage_taken", ss.str());
|
||||
ss.str(std::string());
|
||||
ss << turn_expected_damage_inflicted;
|
||||
out.write_key_val("turn_expected_damage_inflicted", ss.str());
|
||||
ss.str(std::string());
|
||||
ss << turn_expected_damage_taken;
|
||||
out.write_key_val("turn_expected_damage_taken", ss.str());
|
||||
|
||||
ss.str(std::string());
|
||||
ss << new_expected_damage_inflicted;
|
||||
out.write_key_val("new_expected_damage_inflicted", ss.str());
|
||||
ss.str(std::string());
|
||||
ss << new_expected_damage_taken;
|
||||
out.write_key_val("new_expected_damage_taken", ss.str());
|
||||
ss.str(std::string());
|
||||
ss << new_turn_expected_damage_inflicted;
|
||||
out.write_key_val("new_turn_expected_damage_inflicted", ss.str());
|
||||
ss.str(std::string());
|
||||
ss << new_turn_expected_damage_taken;
|
||||
out.write_key_val("new_turn_expected_damage_taken", ss.str());
|
||||
|
||||
snprintf(buf,sizeof(buf),"%d",turn_damage_inflicted);
|
||||
out.write_key_val("turn_damage_inflicted", buf);
|
||||
snprintf(buf,sizeof(buf),"%d",turn_damage_taken);
|
||||
out.write_key_val("turn_damage_taken", buf);
|
||||
snprintf(buf,sizeof(buf),"%d",turn_expected_damage_inflicted);
|
||||
out.write_key_val("turn_expected_damage_inflicted", buf);
|
||||
snprintf(buf,sizeof(buf),"%d",turn_expected_damage_taken);
|
||||
out.write_key_val("turn_expected_damage_taken", buf);
|
||||
}
|
||||
|
||||
void stats::read(const config& cfg)
|
||||
|
|
@ -338,18 +383,23 @@ void stats::read(const config& cfg)
|
|||
defends = read_battle_result_map(*cfg.child("defends"));
|
||||
}
|
||||
|
||||
recruit_cost = atoi(cfg["recruit_cost"].c_str());
|
||||
recall_cost = atoi(cfg["recall_cost"].c_str());
|
||||
recruit_cost = lexical_cast<long long>(cfg["recruit_cost"]);
|
||||
recall_cost = lexical_cast<long long>(cfg["recall_cost"]);
|
||||
|
||||
damage_inflicted = atoi(cfg["damage_inflicted"].c_str());
|
||||
damage_taken = atoi(cfg["damage_taken"].c_str());
|
||||
expected_damage_inflicted = atoi(cfg["expected_damage_inflicted"].c_str());
|
||||
expected_damage_taken = atoi(cfg["expected_damage_taken"].c_str());
|
||||
damage_inflicted = lexical_cast<long long>(cfg["damage_inflicted"]);
|
||||
damage_taken = lexical_cast<long long>(cfg["damage_taken"]);
|
||||
expected_damage_inflicted = lexical_cast<long long>(cfg["expected_damage_inflicted"]);
|
||||
expected_damage_taken = lexical_cast<long long>(cfg["expected_damage_taken"]);
|
||||
|
||||
turn_damage_inflicted = atoi(cfg["turn_damage_inflicted"].c_str());
|
||||
turn_damage_taken = atoi(cfg["turn_damage_taken"].c_str());
|
||||
turn_expected_damage_inflicted = atoi(cfg["turn_expected_damage_inflicted"].c_str());
|
||||
turn_expected_damage_taken = atoi(cfg["turn_expected_damage_taken"].c_str());
|
||||
turn_damage_inflicted = lexical_cast<long long>(cfg["turn_damage_inflicted"]);
|
||||
turn_damage_taken = lexical_cast<long long>(cfg["turn_damage_taken"]);
|
||||
turn_expected_damage_inflicted = lexical_cast<long long>(cfg["turn_expected_damage_inflicted"]);
|
||||
turn_expected_damage_taken = lexical_cast<long long>(cfg["turn_expected_damage_taken"]);
|
||||
|
||||
new_expected_damage_inflicted = lexical_cast_default<long long>(cfg["new_expected_damage_inflicted"],expected_damage_inflicted);
|
||||
new_expected_damage_taken = lexical_cast_default<long long>(cfg["new_expected_damage_taken"],expected_damage_taken);
|
||||
new_turn_expected_damage_inflicted = lexical_cast_default<long long>(cfg["new_turn_expected_damage_inflicted"],turn_expected_damage_inflicted);
|
||||
new_turn_expected_damage_taken = lexical_cast_default<long long>(cfg["new_turn_expected_damage_taken"],turn_expected_damage_taken);
|
||||
}
|
||||
|
||||
disabler::disabler() { stats_disabled++; }
|
||||
|
|
@ -398,24 +448,22 @@ stats& attack_context::defender_stats()
|
|||
return get_stats(defender_side);
|
||||
}
|
||||
|
||||
#ifdef MABOUL_STATS
|
||||
void attack_context::attack_excepted_damage(double attacker_inflict, double defender_inflict)
|
||||
void attack_context::attack_excepted_damage(double attacker_inflict_, double defender_inflict_)
|
||||
{
|
||||
attacker_inflict *= 100.0;
|
||||
defender_inflict *= 100.0;
|
||||
attacker_stats().expected_damage_inflicted += attacker_inflict;
|
||||
attacker_stats().expected_damage_taken += defender_inflict;
|
||||
defender_stats().expected_damage_inflicted += defender_inflict;
|
||||
defender_stats().expected_damage_taken += attacker_inflict;
|
||||
attacker_stats().turn_expected_damage_inflicted += attacker_inflict;
|
||||
attacker_stats().turn_expected_damage_taken += defender_inflict;
|
||||
defender_stats().turn_expected_damage_inflicted += defender_inflict;
|
||||
defender_stats().turn_expected_damage_taken += attacker_inflict;
|
||||
const long long attacker_inflict = static_cast<long long>(attacker_inflict_ * stats::desimal_shift);
|
||||
const long long defender_inflict = static_cast<long long>(defender_inflict_ * stats::desimal_shift);
|
||||
attacker_stats().new_expected_damage_inflicted += attacker_inflict;
|
||||
attacker_stats().new_expected_damage_taken += defender_inflict;
|
||||
defender_stats().new_expected_damage_inflicted += defender_inflict;
|
||||
defender_stats().new_expected_damage_taken += attacker_inflict;
|
||||
attacker_stats().new_turn_expected_damage_inflicted += attacker_inflict;
|
||||
attacker_stats().new_turn_expected_damage_taken += defender_inflict;
|
||||
defender_stats().new_turn_expected_damage_inflicted += defender_inflict;
|
||||
defender_stats().new_turn_expected_damage_taken += attacker_inflict;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
void attack_context::attack_result(attack_context::ATTACK_RESULT res, int damage, int drain)
|
||||
void attack_context::attack_result(attack_context::ATTACK_RESULT res, long long damage, long long drain)
|
||||
{
|
||||
if(stats_disabled > 0)
|
||||
return;
|
||||
|
|
@ -423,24 +471,30 @@ void attack_context::attack_result(attack_context::ATTACK_RESULT res, int damage
|
|||
push_back(attacker_res,(res == MISSES ? '0' : '1'));
|
||||
|
||||
if(res != MISSES) {
|
||||
#ifdef MABOUL_STATS
|
||||
// handle drain
|
||||
attacker_stats().damage_taken -= drain;
|
||||
defender_stats().damage_inflicted -= drain;
|
||||
attacker_stats().turn_damage_taken -= drain;
|
||||
defender_stats().turn_damage_inflicted -= drain;
|
||||
#endif
|
||||
|
||||
attacker_stats().damage_inflicted += damage;
|
||||
defender_stats().damage_taken += damage;
|
||||
attacker_stats().turn_damage_inflicted += damage;
|
||||
defender_stats().turn_damage_taken += damage;
|
||||
}
|
||||
#ifndef MABOUL_STATS
|
||||
const int exp_damage = damage * chance_to_hit_defender;
|
||||
const int exp_damage = damage * chance_to_hit_defender * 10;
|
||||
const int exp_drain = drain * chance_to_hit_defender * 10;
|
||||
|
||||
attacker_stats().expected_damage_taken -= exp_drain;
|
||||
defender_stats().expected_damage_inflicted -= exp_drain;
|
||||
attacker_stats().turn_expected_damage_taken -= exp_drain;
|
||||
defender_stats().turn_expected_damage_inflicted -= exp_drain;
|
||||
|
||||
// handle drain
|
||||
attacker_stats().expected_damage_inflicted += exp_damage;
|
||||
defender_stats().expected_damage_taken += exp_damage;
|
||||
attacker_stats().turn_expected_damage_inflicted += exp_damage;
|
||||
defender_stats().turn_expected_damage_taken += exp_damage;
|
||||
#endif
|
||||
|
||||
if(res == KILLS) {
|
||||
attacker_stats().killed[defender_type]++;
|
||||
|
|
@ -448,7 +502,7 @@ void attack_context::attack_result(attack_context::ATTACK_RESULT res, int damage
|
|||
}
|
||||
}
|
||||
|
||||
void attack_context::defend_result(attack_context::ATTACK_RESULT res, int damage, int drain)
|
||||
void attack_context::defend_result(attack_context::ATTACK_RESULT res, long long damage, long long drain)
|
||||
{
|
||||
if(stats_disabled > 0)
|
||||
return;
|
||||
|
|
@ -457,24 +511,29 @@ void attack_context::defend_result(attack_context::ATTACK_RESULT res, int damage
|
|||
|
||||
|
||||
if(res != MISSES) {
|
||||
#ifdef MABOUL_STATS
|
||||
//handle drain
|
||||
defender_stats().damage_taken -= drain;
|
||||
attacker_stats().damage_inflicted -= drain;
|
||||
defender_stats().turn_damage_taken -= drain;
|
||||
attacker_stats().turn_damage_inflicted -= drain;
|
||||
#endif
|
||||
|
||||
attacker_stats().damage_taken += damage;
|
||||
defender_stats().damage_inflicted += damage;
|
||||
attacker_stats().turn_damage_taken += damage;
|
||||
defender_stats().turn_damage_inflicted += damage;
|
||||
}
|
||||
#ifndef MABOUL_STATS
|
||||
const int exp_damage = damage * chance_to_hit_attacker;
|
||||
const long long exp_damage = damage * chance_to_hit_attacker * 10;
|
||||
const long long exp_drain = drain * chance_to_hit_attacker * 10;
|
||||
//handle drain
|
||||
defender_stats().expected_damage_taken -= exp_drain;
|
||||
attacker_stats().expected_damage_inflicted -= exp_drain;
|
||||
defender_stats().turn_expected_damage_taken -= exp_drain;
|
||||
attacker_stats().turn_expected_damage_inflicted -= exp_drain;
|
||||
|
||||
attacker_stats().expected_damage_taken += exp_damage;
|
||||
defender_stats().expected_damage_inflicted += exp_damage;
|
||||
attacker_stats().turn_expected_damage_taken += exp_damage;
|
||||
defender_stats().turn_expected_damage_inflicted += exp_damage;
|
||||
#endif
|
||||
|
||||
if(res == KILLS) {
|
||||
attacker_stats().deaths[attacker_type]++;
|
||||
|
|
|
|||
|
|
@ -50,17 +50,21 @@ namespace statistics
|
|||
|
||||
battle_result_map attacks, defends;
|
||||
|
||||
int damage_inflicted, damage_taken;
|
||||
int turn_damage_inflicted, turn_damage_taken;
|
||||
long long damage_inflicted, damage_taken;
|
||||
long long turn_damage_inflicted, turn_damage_taken;
|
||||
|
||||
// Expected value for damage inflicted/taken * 100, based on
|
||||
static const long long desimal_shift = 1000;
|
||||
|
||||
// Expected value for damage inflicted/taken * 1000, based on
|
||||
// probability to hit,
|
||||
// Use this long term to see how lucky a side is.
|
||||
//! @todo FIXME: Since integers are used, rounding errors accumulate.
|
||||
// Also, slow isn't accounted for properly.
|
||||
// Rusty's simulator could be used obtain valid values.
|
||||
int expected_damage_inflicted, expected_damage_taken;
|
||||
int turn_expected_damage_inflicted, turn_expected_damage_taken;
|
||||
long long expected_damage_inflicted, expected_damage_taken;
|
||||
long long turn_expected_damage_inflicted, turn_expected_damage_taken;
|
||||
long long new_expected_damage_inflicted, new_expected_damage_taken;
|
||||
long long new_turn_expected_damage_inflicted, new_turn_expected_damage_taken;
|
||||
};
|
||||
|
||||
int sum_str_int_map(const stats::str_int_map& m);
|
||||
|
|
@ -85,11 +89,9 @@ namespace statistics
|
|||
|
||||
enum ATTACK_RESULT { MISSES, HITS, KILLS };
|
||||
|
||||
#ifdef MABOUL_STATS
|
||||
void attack_excepted_damage(double attacker_inflict, double defender_inflict);
|
||||
#endif
|
||||
void attack_result(ATTACK_RESULT res, int damage, int drain);
|
||||
void defend_result(ATTACK_RESULT res, int damage, int drain);
|
||||
void attack_result(ATTACK_RESULT res, long long damage, long long drain);
|
||||
void defend_result(ATTACK_RESULT res, long long damage, long long drain);
|
||||
|
||||
private:
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue