You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
645 lines
23 KiB
645 lines
23 KiB
/**
|
|
* Copyright (C) 2015-2017 Jessica James.
|
|
*
|
|
* Permission to use, copy, modify, and/or distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
|
|
* SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
|
|
* OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
|
|
* CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*
|
|
* Written by Jessica James <jessica.aj@outlook.com>
|
|
*/
|
|
|
|
#include "RenX_LadderDatabase.h"
|
|
#include "RenX_Server.h"
|
|
#include "RenX_PlayerInfo.h"
|
|
#include "RenX_BanDatabase.h"
|
|
|
|
RenX::LadderDatabase *RenX::default_ladder_database = nullptr;
|
|
Jupiter::ArrayList<RenX::LadderDatabase> _ladder_databases;
|
|
Jupiter::ArrayList<RenX::LadderDatabase> &RenX::ladder_databases = _ladder_databases;
|
|
|
|
RenX::LadderDatabase::LadderDatabase()
|
|
{
|
|
_ladder_databases.add(this);
|
|
|
|
if (RenX::default_ladder_database == nullptr)
|
|
RenX::default_ladder_database = this;
|
|
}
|
|
|
|
RenX::LadderDatabase::LadderDatabase(const Jupiter::ReadableString &in_name) : LadderDatabase()
|
|
{
|
|
RenX::LadderDatabase::setName(in_name);
|
|
}
|
|
|
|
RenX::LadderDatabase::~LadderDatabase()
|
|
{
|
|
while (RenX::LadderDatabase::head != nullptr)
|
|
{
|
|
RenX::LadderDatabase::end = RenX::LadderDatabase::head;
|
|
RenX::LadderDatabase::head = RenX::LadderDatabase::head->next;
|
|
delete RenX::LadderDatabase::end;
|
|
}
|
|
|
|
for (size_t index = 0; index != _ladder_databases.size(); ++index)
|
|
if (_ladder_databases.get(index) == this)
|
|
{
|
|
_ladder_databases.remove(index);
|
|
break;
|
|
}
|
|
|
|
if (RenX::default_ladder_database == this)
|
|
{
|
|
if (_ladder_databases.size() == 0)
|
|
RenX::default_ladder_database = nullptr;
|
|
else
|
|
RenX::default_ladder_database = _ladder_databases.get(0);
|
|
}
|
|
}
|
|
|
|
void RenX::LadderDatabase::process_data(Jupiter::DataBuffer &buffer, FILE *file, fpos_t pos)
|
|
{
|
|
RenX::LadderDatabase::Entry *entry = new RenX::LadderDatabase::Entry();
|
|
|
|
// read data from buffer to entry
|
|
entry->steam_id = buffer.pop<uint64_t>();
|
|
entry->total_score = buffer.pop<uint64_t>();
|
|
|
|
entry->total_kills = buffer.pop<uint32_t>();
|
|
entry->total_deaths = buffer.pop<uint32_t>();
|
|
entry->total_headshot_kills = buffer.pop<uint32_t>();
|
|
entry->total_vehicle_kills = buffer.pop<uint32_t>();
|
|
entry->total_building_kills = buffer.pop<uint32_t>();
|
|
entry->total_defence_kills = buffer.pop<uint32_t>();
|
|
entry->total_captures = buffer.pop<uint32_t>();
|
|
entry->total_game_time = buffer.pop<uint32_t>();
|
|
entry->total_games = buffer.pop<uint32_t>();
|
|
if (this->read_version == 0)
|
|
{
|
|
entry->total_gdi_games = buffer.pop<uint32_t>();
|
|
entry->total_nod_games = buffer.pop<uint32_t>();
|
|
}
|
|
entry->total_wins = buffer.pop<uint32_t>();
|
|
if (this->read_version == 0)
|
|
{
|
|
entry->total_gdi_wins = buffer.pop<uint32_t>();
|
|
entry->total_nod_wins = buffer.pop<uint32_t>();
|
|
}
|
|
entry->total_beacon_placements = buffer.pop<uint32_t>();
|
|
entry->total_beacon_disarms = buffer.pop<uint32_t>();
|
|
entry->total_proxy_placements = buffer.pop<uint32_t>();
|
|
entry->total_proxy_disarms = buffer.pop<uint32_t>();
|
|
|
|
if (this->read_version > 0)
|
|
{
|
|
entry->total_gdi_games = buffer.pop<uint32_t>();
|
|
entry->total_gdi_wins = buffer.pop<uint32_t>();
|
|
entry->total_gdi_ties = buffer.pop<uint32_t>();
|
|
entry->total_gdi_game_time = buffer.pop<uint32_t>();
|
|
entry->total_gdi_score = buffer.pop<uint64_t>();
|
|
entry->total_gdi_beacon_placements = buffer.pop<uint32_t>();
|
|
entry->total_gdi_beacon_disarms = buffer.pop<uint32_t>();
|
|
entry->total_gdi_proxy_placements = buffer.pop<uint32_t>();
|
|
entry->total_gdi_proxy_disarms = buffer.pop<uint32_t>();
|
|
entry->total_gdi_kills = buffer.pop<uint32_t>();
|
|
entry->total_gdi_deaths = buffer.pop<uint32_t>();
|
|
entry->total_gdi_vehicle_kills = buffer.pop<uint32_t>();
|
|
entry->total_gdi_defence_kills = buffer.pop<uint32_t>();
|
|
entry->total_gdi_building_kills = buffer.pop<uint32_t>();
|
|
entry->total_gdi_headshots = buffer.pop<uint32_t>();
|
|
|
|
entry->total_nod_games = buffer.pop<uint32_t>();
|
|
entry->total_nod_wins = buffer.pop<uint32_t>();
|
|
entry->total_nod_game_time = buffer.pop<uint32_t>();
|
|
entry->total_nod_score = buffer.pop<uint64_t>();
|
|
entry->total_nod_beacon_placements = buffer.pop<uint32_t>();
|
|
entry->total_nod_beacon_disarms = buffer.pop<uint32_t>();
|
|
entry->total_nod_proxy_placements = buffer.pop<uint32_t>();
|
|
entry->total_nod_proxy_disarms = buffer.pop<uint32_t>();
|
|
entry->total_nod_kills = buffer.pop<uint32_t>();
|
|
entry->total_nod_deaths = buffer.pop<uint32_t>();
|
|
entry->total_nod_vehicle_kills = buffer.pop<uint32_t>();
|
|
entry->total_nod_defence_kills = buffer.pop<uint32_t>();
|
|
entry->total_nod_building_kills = buffer.pop<uint32_t>();
|
|
entry->total_nod_headshots = buffer.pop<uint32_t>();
|
|
}
|
|
|
|
entry->top_score = buffer.pop<uint32_t>();
|
|
entry->top_kills = buffer.pop<uint32_t>();
|
|
entry->most_deaths = buffer.pop<uint32_t>();
|
|
entry->top_headshot_kills = buffer.pop<uint32_t>();
|
|
entry->top_vehicle_kills = buffer.pop<uint32_t>();
|
|
entry->top_building_kills = buffer.pop<uint32_t>();
|
|
entry->top_defence_kills = buffer.pop<uint32_t>();
|
|
entry->top_captures = buffer.pop<uint32_t>();
|
|
entry->top_game_time = buffer.pop<uint32_t>();
|
|
entry->top_beacon_placements = buffer.pop<uint32_t>();
|
|
entry->top_beacon_disarms = buffer.pop<uint32_t>();
|
|
entry->top_proxy_placements = buffer.pop<uint32_t>();
|
|
entry->top_proxy_disarms = buffer.pop<uint32_t>();
|
|
|
|
entry->most_recent_ip = buffer.pop<uint32_t>();
|
|
entry->last_game = buffer.pop<time_t>();
|
|
entry->most_recent_name = buffer.pop<Jupiter::String_Strict, char>();
|
|
|
|
// push data to list
|
|
if (RenX::LadderDatabase::head == nullptr)
|
|
{
|
|
RenX::LadderDatabase::head = entry;
|
|
RenX::LadderDatabase::end = RenX::LadderDatabase::head;
|
|
}
|
|
else
|
|
{
|
|
RenX::LadderDatabase::end->next = entry;
|
|
entry->prev = end;
|
|
end = entry;
|
|
}
|
|
|
|
entry->rank = ++RenX::LadderDatabase::entries;
|
|
}
|
|
|
|
void RenX::LadderDatabase::process_header(FILE *file)
|
|
{
|
|
int chr = fgetc(file);
|
|
if (chr != EOF)
|
|
RenX::LadderDatabase::read_version = chr;
|
|
}
|
|
|
|
void RenX::LadderDatabase::create_header(FILE *file)
|
|
{
|
|
fputc(RenX::LadderDatabase::write_version, file);
|
|
}
|
|
|
|
void RenX::LadderDatabase::process_file_finish(FILE *file)
|
|
{
|
|
if (RenX::LadderDatabase::read_version != RenX::LadderDatabase::write_version)
|
|
{
|
|
puts("Notice: Ladder database is out of date; upgrading...");
|
|
std::chrono::steady_clock::duration write_duration;
|
|
std::chrono::steady_clock::time_point start_time = std::chrono::steady_clock::now();
|
|
|
|
RenX::LadderDatabase::write(this->getFilename());
|
|
|
|
write_duration = std::chrono::steady_clock::now() - start_time;
|
|
printf("Ladder database upgrade completed in %f seconds", static_cast<double>(write_duration.count()) * (static_cast<double>(std::chrono::steady_clock::duration::period::num) / static_cast<double>(std::chrono::steady_clock::duration::period::den) * static_cast<double>(std::chrono::seconds::duration::period::den / std::chrono::seconds::duration::period::num)));
|
|
RenX::LadderDatabase::read_version = RenX::LadderDatabase::write_version;
|
|
}
|
|
}
|
|
|
|
RenX::LadderDatabase::Entry *RenX::LadderDatabase::getHead() const
|
|
{
|
|
return RenX::LadderDatabase::head;
|
|
}
|
|
|
|
RenX::LadderDatabase::Entry *RenX::LadderDatabase::getPlayerEntry(uint64_t steamid) const
|
|
{
|
|
for (RenX::LadderDatabase::Entry *itr = RenX::LadderDatabase::head; itr != nullptr; itr = itr->next)
|
|
if (itr->steam_id == steamid)
|
|
return itr;
|
|
return nullptr;
|
|
}
|
|
|
|
std::pair<RenX::LadderDatabase::Entry *, size_t> RenX::LadderDatabase::getPlayerEntryAndIndex(uint64_t steamid) const
|
|
{
|
|
size_t index = 0;
|
|
for (RenX::LadderDatabase::Entry *itr = RenX::LadderDatabase::head; itr != nullptr; itr = itr->next, ++index)
|
|
if (itr->steam_id == steamid)
|
|
return std::pair<RenX::LadderDatabase::Entry *, size_t>(itr, index);
|
|
return std::pair<RenX::LadderDatabase::Entry *, size_t>(nullptr, Jupiter::INVALID_INDEX);
|
|
}
|
|
|
|
RenX::LadderDatabase::Entry *RenX::LadderDatabase::getPlayerEntryByName(const Jupiter::ReadableString &name) const
|
|
{
|
|
for (RenX::LadderDatabase::Entry *itr = RenX::LadderDatabase::head; itr != nullptr; itr = itr->next)
|
|
if (itr->most_recent_name.equalsi(name))
|
|
return itr;
|
|
return nullptr;
|
|
}
|
|
|
|
std::pair<RenX::LadderDatabase::Entry *, size_t> RenX::LadderDatabase::getPlayerEntryAndIndexByName(const Jupiter::ReadableString &name) const
|
|
{
|
|
size_t index = 0;
|
|
for (RenX::LadderDatabase::Entry *itr = RenX::LadderDatabase::head; itr != nullptr; itr = itr->next, ++index)
|
|
if (itr->most_recent_name.equalsi(name))
|
|
return std::pair<RenX::LadderDatabase::Entry *, size_t>(itr, index);
|
|
return std::pair<RenX::LadderDatabase::Entry *, size_t>(nullptr, Jupiter::INVALID_INDEX);
|
|
}
|
|
|
|
RenX::LadderDatabase::Entry *RenX::LadderDatabase::getPlayerEntryByPartName(const Jupiter::ReadableString &name) const
|
|
{
|
|
for (RenX::LadderDatabase::Entry *itr = RenX::LadderDatabase::head; itr != nullptr; itr = itr->next)
|
|
if (itr->most_recent_name.findi(name) != Jupiter::INVALID_INDEX)
|
|
return itr;
|
|
return nullptr;
|
|
}
|
|
|
|
std::pair<RenX::LadderDatabase::Entry *, size_t> RenX::LadderDatabase::getPlayerEntryAndIndexByPartName(const Jupiter::ReadableString &name) const
|
|
{
|
|
size_t index = 0;
|
|
for (RenX::LadderDatabase::Entry *itr = RenX::LadderDatabase::head; itr != nullptr; itr = itr->next, ++index)
|
|
if (itr->most_recent_name.findi(name) != Jupiter::INVALID_INDEX)
|
|
return std::pair<RenX::LadderDatabase::Entry *, size_t>(itr, index);
|
|
return std::pair<RenX::LadderDatabase::Entry *, size_t>(nullptr, Jupiter::INVALID_INDEX);
|
|
}
|
|
|
|
std::forward_list<RenX::LadderDatabase::Entry> RenX::LadderDatabase::getPlayerEntriesByPartName(const Jupiter::ReadableString &name, size_t max) const
|
|
{
|
|
std::forward_list<RenX::LadderDatabase::Entry> list;
|
|
if (max == 0)
|
|
{
|
|
for (RenX::LadderDatabase::Entry *itr = RenX::LadderDatabase::head; itr != nullptr; itr = itr->next)
|
|
if (itr->most_recent_name.findi(name) != Jupiter::INVALID_INDEX)
|
|
list.emplace_front(*itr);
|
|
}
|
|
else
|
|
for (RenX::LadderDatabase::Entry *itr = RenX::LadderDatabase::head; itr != nullptr; itr = itr->next)
|
|
if (itr->most_recent_name.findi(name) != Jupiter::INVALID_INDEX)
|
|
{
|
|
list.emplace_front(*itr);
|
|
if (--max == 0)
|
|
return list;
|
|
}
|
|
return list;
|
|
}
|
|
|
|
std::forward_list<std::pair<RenX::LadderDatabase::Entry, size_t>> RenX::LadderDatabase::getPlayerEntriesAndIndexByPartName(const Jupiter::ReadableString &name, size_t max) const
|
|
{
|
|
std::forward_list<std::pair<RenX::LadderDatabase::Entry, size_t>> list;
|
|
size_t index = 0;
|
|
if (max == 0)
|
|
{
|
|
for (RenX::LadderDatabase::Entry *itr = RenX::LadderDatabase::head; itr != nullptr; itr = itr->next, ++index)
|
|
if (itr->most_recent_name.findi(name) != Jupiter::INVALID_INDEX)
|
|
list.emplace_front(*itr, index);
|
|
}
|
|
else
|
|
for (RenX::LadderDatabase::Entry *itr = RenX::LadderDatabase::head; itr != nullptr; itr = itr->next, ++index)
|
|
if (itr->most_recent_name.findi(name) != Jupiter::INVALID_INDEX)
|
|
{
|
|
list.emplace_front(*itr, index);
|
|
if (--max)
|
|
return list;
|
|
}
|
|
return list;
|
|
}
|
|
|
|
RenX::LadderDatabase::Entry *RenX::LadderDatabase::getPlayerEntryByIndex(size_t index) const
|
|
{
|
|
for (RenX::LadderDatabase::Entry *itr = RenX::LadderDatabase::head; itr != nullptr; itr = itr->next, --index)
|
|
if (index == 0)
|
|
return itr;
|
|
return nullptr;
|
|
}
|
|
|
|
size_t RenX::LadderDatabase::getEntries() const
|
|
{
|
|
return RenX::LadderDatabase::entries;
|
|
}
|
|
|
|
std::chrono::steady_clock::time_point RenX::LadderDatabase::getLastSortTime() const
|
|
{
|
|
return RenX::LadderDatabase::last_sort;
|
|
}
|
|
|
|
void RenX::LadderDatabase::append(RenX::LadderDatabase::Entry *entry)
|
|
{
|
|
++RenX::LadderDatabase::entries;
|
|
if (RenX::LadderDatabase::head == nullptr)
|
|
{
|
|
RenX::LadderDatabase::head = entry;
|
|
RenX::LadderDatabase::end = RenX::LadderDatabase::head;
|
|
return;
|
|
}
|
|
RenX::LadderDatabase::end->next = entry;
|
|
entry->prev = RenX::LadderDatabase::end;
|
|
RenX::LadderDatabase::end = entry;
|
|
}
|
|
|
|
void RenX::LadderDatabase::write(const Jupiter::CStringType &filename)
|
|
{
|
|
return RenX::LadderDatabase::write(filename.c_str());
|
|
}
|
|
|
|
void RenX::LadderDatabase::write(const char *filename)
|
|
{
|
|
if (RenX::LadderDatabase::entries != 0)
|
|
{
|
|
FILE *file = fopen(filename, "wb");
|
|
if (file != nullptr)
|
|
{
|
|
size_t rank = 0;
|
|
Jupiter::DataBuffer buffer;
|
|
RenX::LadderDatabase::create_header(file);
|
|
RenX::LadderDatabase::Entry *entry = RenX::LadderDatabase::head;
|
|
while (entry != nullptr)
|
|
{
|
|
// update rank
|
|
entry->rank = ++rank;
|
|
|
|
// push data from entry to buffer
|
|
buffer.push(entry->steam_id);
|
|
buffer.push(entry->total_score);
|
|
|
|
buffer.push(entry->total_kills);
|
|
buffer.push(entry->total_deaths);
|
|
buffer.push(entry->total_headshot_kills);
|
|
buffer.push(entry->total_vehicle_kills);
|
|
buffer.push(entry->total_building_kills);
|
|
buffer.push(entry->total_defence_kills);
|
|
buffer.push(entry->total_captures);
|
|
buffer.push(entry->total_game_time);
|
|
buffer.push(entry->total_games);
|
|
buffer.push(entry->total_wins);
|
|
buffer.push(entry->total_beacon_placements);
|
|
buffer.push(entry->total_beacon_disarms);
|
|
buffer.push(entry->total_proxy_placements);
|
|
buffer.push(entry->total_proxy_disarms);
|
|
|
|
buffer.push(entry->total_gdi_games);
|
|
buffer.push(entry->total_gdi_wins);
|
|
buffer.push(entry->total_gdi_ties);
|
|
buffer.push(entry->total_gdi_game_time);
|
|
buffer.push(entry->total_gdi_score);
|
|
buffer.push(entry->total_gdi_beacon_placements);
|
|
buffer.push(entry->total_gdi_beacon_disarms);
|
|
buffer.push(entry->total_gdi_proxy_placements);
|
|
buffer.push(entry->total_gdi_proxy_disarms);
|
|
buffer.push(entry->total_gdi_kills);
|
|
buffer.push(entry->total_gdi_deaths);
|
|
buffer.push(entry->total_gdi_vehicle_kills);
|
|
buffer.push(entry->total_gdi_defence_kills);
|
|
buffer.push(entry->total_gdi_building_kills);
|
|
buffer.push(entry->total_gdi_headshots);
|
|
|
|
buffer.push(entry->total_nod_games);
|
|
buffer.push(entry->total_nod_wins);
|
|
buffer.push(entry->total_nod_game_time);
|
|
buffer.push(entry->total_nod_score);
|
|
buffer.push(entry->total_nod_beacon_placements);
|
|
buffer.push(entry->total_nod_beacon_disarms);
|
|
buffer.push(entry->total_nod_proxy_placements);
|
|
buffer.push(entry->total_nod_proxy_disarms);
|
|
buffer.push(entry->total_nod_kills);
|
|
buffer.push(entry->total_nod_deaths);
|
|
buffer.push(entry->total_nod_vehicle_kills);
|
|
buffer.push(entry->total_nod_defence_kills);
|
|
buffer.push(entry->total_nod_building_kills);
|
|
buffer.push(entry->total_nod_headshots);
|
|
|
|
buffer.push(entry->top_score);
|
|
buffer.push(entry->top_kills);
|
|
buffer.push(entry->most_deaths);
|
|
buffer.push(entry->top_headshot_kills);
|
|
buffer.push(entry->top_vehicle_kills);
|
|
buffer.push(entry->top_building_kills);
|
|
buffer.push(entry->top_defence_kills);
|
|
buffer.push(entry->top_captures);
|
|
buffer.push(entry->top_game_time);
|
|
buffer.push(entry->top_beacon_placements);
|
|
buffer.push(entry->top_beacon_disarms);
|
|
buffer.push(entry->top_proxy_placements);
|
|
buffer.push(entry->top_proxy_disarms);
|
|
|
|
buffer.push(entry->most_recent_ip);
|
|
buffer.push(entry->last_game);
|
|
buffer.push(entry->most_recent_name);
|
|
|
|
// push buffer to file
|
|
buffer.push_to(file);
|
|
|
|
// iterate
|
|
entry = entry->next;
|
|
}
|
|
fclose(file);
|
|
}
|
|
}
|
|
}
|
|
|
|
void RenX::LadderDatabase::sort_entries()
|
|
{
|
|
if (RenX::LadderDatabase::entries <= 1)
|
|
return;
|
|
|
|
RenX::LadderDatabase::Entry *itr = RenX::LadderDatabase::head;
|
|
RenX::LadderDatabase::Entry *itr2, *ptr;
|
|
|
|
// iterate forward (search for out-of-order content)
|
|
while (itr->next != nullptr)
|
|
{
|
|
// out-of-order content found
|
|
if (itr->next->total_score > itr->total_score)
|
|
{
|
|
// pull content out
|
|
ptr = itr->next;
|
|
itr->next = ptr->next;
|
|
if (itr->next != nullptr)
|
|
itr->next->prev = itr;
|
|
|
|
// iterate backwards from our iterator, and insert
|
|
itr2 = itr;
|
|
while (true)
|
|
{
|
|
if (itr2->prev == nullptr)
|
|
{
|
|
// push ptr to head
|
|
ptr->next = itr2;
|
|
ptr->prev = nullptr;
|
|
itr2->prev = ptr;
|
|
RenX::LadderDatabase::head = ptr;
|
|
break;
|
|
}
|
|
itr2 = itr2->prev;
|
|
if (itr2->total_score > ptr->total_score)
|
|
{
|
|
// insert ptr after itr2
|
|
ptr->next = itr2->next;
|
|
ptr->next->prev = ptr;
|
|
ptr->prev = itr2;
|
|
itr2->next = ptr;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else // continue iterating
|
|
itr = itr->next;
|
|
}
|
|
|
|
RenX::LadderDatabase::end = itr;
|
|
RenX::LadderDatabase::last_sort = std::chrono::steady_clock::now();
|
|
}
|
|
|
|
void RenX::LadderDatabase::updateLadder(RenX::Server &server, const RenX::TeamType &team)
|
|
{
|
|
if (server.players.size() != server.getBotCount())
|
|
{
|
|
// call the PreUpdateLadder event
|
|
if (this->OnPreUpdateLadder != nullptr)
|
|
this->OnPreUpdateLadder(*this, server, team);
|
|
|
|
// update player stats in memory
|
|
RenX::LadderDatabase::Entry *entry;
|
|
for (auto player = server.players.begin(); player != server.players.end(); ++player)
|
|
{
|
|
if (player->steamid != 0 && (player->ban_flags & RenX::BanDatabase::Entry::FLAG_TYPE_LADDER) == 0)
|
|
{
|
|
entry = RenX::LadderDatabase::getPlayerEntry(player->steamid);
|
|
if (entry == nullptr)
|
|
{
|
|
entry = new RenX::LadderDatabase::Entry();
|
|
RenX::LadderDatabase::append(entry);
|
|
entry->steam_id = player->steamid;
|
|
}
|
|
|
|
entry->total_score += static_cast<uint64_t>(player->score);
|
|
|
|
entry->total_kills += player->kills;
|
|
entry->total_deaths += player->deaths;
|
|
entry->total_headshot_kills += player->headshots;
|
|
entry->total_vehicle_kills += player->vehicleKills;
|
|
entry->total_building_kills += player->buildingKills;
|
|
entry->total_defence_kills += player->defenceKills;
|
|
entry->total_captures += player->captures;
|
|
entry->total_game_time += static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::seconds>(server.getGameTime(*player)).count());
|
|
entry->total_beacon_placements += player->beaconPlacements;
|
|
entry->total_beacon_disarms += player->beaconDisarms;
|
|
entry->total_proxy_placements += player->proxy_placements;
|
|
entry->total_proxy_disarms += player->proxy_disarms;
|
|
|
|
++entry->total_games;
|
|
switch (player->team)
|
|
{
|
|
case RenX::TeamType::GDI:
|
|
++entry->total_gdi_games;
|
|
if (player->team == team)
|
|
++entry->total_wins, ++entry->total_gdi_wins;
|
|
else if (team == RenX::TeamType::None)
|
|
++entry->total_gdi_ties;
|
|
|
|
entry->total_gdi_game_time += static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::seconds>(server.getGameTime(*player)).count());
|
|
entry->total_gdi_score += static_cast<uint64_t>(player->score);
|
|
entry->total_gdi_beacon_placements += player->beaconPlacements;
|
|
entry->total_gdi_beacon_disarms += player->beaconDisarms;
|
|
entry->total_gdi_proxy_placements += player->proxy_placements;
|
|
entry->total_gdi_proxy_disarms += player->proxy_disarms;
|
|
entry->total_gdi_kills += player->kills;
|
|
entry->total_gdi_deaths += player->deaths;
|
|
entry->total_gdi_vehicle_kills += player->vehicleKills;
|
|
entry->total_gdi_defence_kills += player->defenceKills;
|
|
entry->total_gdi_building_kills += player->buildingKills;
|
|
entry->total_gdi_headshots += player->headshots;
|
|
break;
|
|
case RenX::TeamType::Nod:
|
|
++entry->total_nod_games;
|
|
if (player->team == team)
|
|
++entry->total_wins, ++entry->total_nod_wins;
|
|
else if (team == RenX::TeamType::None)
|
|
++entry->total_nod_ties;
|
|
|
|
entry->total_nod_game_time += static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::seconds>(server.getGameTime(*player)).count());
|
|
entry->total_nod_score += static_cast<uint64_t>(player->score);
|
|
entry->total_nod_beacon_placements += player->beaconPlacements;
|
|
entry->total_nod_beacon_disarms += player->beaconDisarms;
|
|
entry->total_nod_proxy_placements += player->proxy_placements;
|
|
entry->total_nod_proxy_disarms += player->proxy_disarms;
|
|
entry->total_nod_kills += player->kills;
|
|
entry->total_nod_deaths += player->deaths;
|
|
entry->total_nod_vehicle_kills += player->vehicleKills;
|
|
entry->total_nod_defence_kills += player->defenceKills;
|
|
entry->total_nod_building_kills += player->buildingKills;
|
|
entry->total_nod_headshots += player->headshots;
|
|
break;
|
|
default:
|
|
if (player->team == team)
|
|
++entry->total_wins;
|
|
break;
|
|
}
|
|
|
|
auto set_if_greater = [](uint32_t &src, const uint32_t &cmp)
|
|
{
|
|
if (cmp > src)
|
|
src = cmp;
|
|
};
|
|
|
|
set_if_greater(entry->top_score, static_cast<uint32_t>(player->score));
|
|
set_if_greater(entry->top_kills, player->kills);
|
|
set_if_greater(entry->most_deaths, player->deaths);
|
|
set_if_greater(entry->top_headshot_kills, player->headshots);
|
|
set_if_greater(entry->top_vehicle_kills, player->vehicleKills);
|
|
set_if_greater(entry->top_building_kills, player->buildingKills);
|
|
set_if_greater(entry->top_defence_kills, player->defenceKills);
|
|
set_if_greater(entry->top_captures, player->captures);
|
|
set_if_greater(entry->top_game_time, static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::seconds>(server.getGameTime(*player)).count()));
|
|
set_if_greater(entry->top_beacon_placements, player->beaconPlacements);
|
|
set_if_greater(entry->top_beacon_disarms, player->beaconDisarms);
|
|
set_if_greater(entry->top_proxy_placements, player->proxy_placements);
|
|
set_if_greater(entry->top_proxy_disarms, player->proxy_disarms);
|
|
|
|
entry->most_recent_ip = player->ip32;
|
|
entry->last_game = time(nullptr);
|
|
entry->most_recent_name = player->name;
|
|
}
|
|
}
|
|
|
|
// sort new stats
|
|
std::chrono::steady_clock::time_point start_time = std::chrono::steady_clock::now();
|
|
RenX::LadderDatabase::sort_entries();
|
|
std::chrono::steady_clock::duration sort_duration = std::chrono::steady_clock::now() - start_time;
|
|
|
|
// write new stats
|
|
start_time = std::chrono::steady_clock::now();
|
|
RenX::LadderDatabase::write(this->getFilename());
|
|
std::chrono::steady_clock::duration write_duration = std::chrono::steady_clock::now() - start_time;
|
|
|
|
if (RenX::LadderDatabase::output_times)
|
|
{
|
|
Jupiter::StringS str = Jupiter::StringS::Format("Ladder: %zu entries sorted in %f seconds; Database written in %f seconds." ENDL,
|
|
RenX::LadderDatabase::getEntries(),
|
|
static_cast<double>(sort_duration.count()) * (static_cast<double>(std::chrono::steady_clock::duration::period::num) / static_cast<double>(std::chrono::steady_clock::duration::period::den) * static_cast<double>(std::chrono::seconds::duration::period::den / std::chrono::seconds::duration::period::num)),
|
|
static_cast<double>(write_duration.count()) * (static_cast<double>(std::chrono::steady_clock::duration::period::num) / static_cast<double>(std::chrono::steady_clock::duration::period::den) * static_cast<double>(std::chrono::seconds::duration::period::den / std::chrono::seconds::duration::period::num)));
|
|
str.println(stdout);
|
|
server.sendLogChan(str);
|
|
}
|
|
}
|
|
}
|
|
|
|
void RenX::LadderDatabase::erase()
|
|
{
|
|
if (RenX::LadderDatabase::head != nullptr)
|
|
{
|
|
RenX::LadderDatabase::entries = 0;
|
|
while (RenX::LadderDatabase::head->next != nullptr)
|
|
{
|
|
RenX::LadderDatabase::head = head->next;
|
|
delete head->prev;
|
|
}
|
|
delete RenX::LadderDatabase::head;
|
|
RenX::LadderDatabase::head = nullptr;
|
|
RenX::LadderDatabase::end = nullptr;
|
|
}
|
|
}
|
|
|
|
const Jupiter::ReadableString &RenX::LadderDatabase::getName() const
|
|
{
|
|
return RenX::LadderDatabase::name;
|
|
}
|
|
|
|
void RenX::LadderDatabase::setName(const Jupiter::ReadableString &in_name)
|
|
{
|
|
RenX::LadderDatabase::name = in_name;
|
|
}
|
|
|
|
bool RenX::LadderDatabase::getOutputTimes() const
|
|
{
|
|
return RenX::LadderDatabase::output_times;
|
|
}
|
|
|
|
void RenX::LadderDatabase::setOutputTimes(bool in_output_times)
|
|
{
|
|
RenX::LadderDatabase::output_times = in_output_times;
|
|
}
|
|
|