762 lines
23 KiB
C++
762 lines
23 KiB
C++
#include <iostream>
|
|
#include <fstream>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <vector>
|
|
#include <map>
|
|
#include <unordered_map>
|
|
#include <chrono>
|
|
#include <thread>
|
|
#include <cstring>
|
|
#include <cstdlib>
|
|
#include <algorithm>
|
|
#include <mutex>
|
|
#include <atomic>
|
|
#include <iomanip>
|
|
#include <ctime>
|
|
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <arpa/inet.h>
|
|
#include <sys/time.h>
|
|
|
|
struct Item {
|
|
int id;
|
|
std::string name;
|
|
std::string type;
|
|
int power;
|
|
int price;
|
|
};
|
|
|
|
struct Note {
|
|
int id;
|
|
char title[64];
|
|
char content[256];
|
|
std::chrono::system_clock::time_point created_at;
|
|
};
|
|
|
|
struct Fighter {
|
|
int id;
|
|
char name[32];
|
|
std::string fighter_class;
|
|
int hp;
|
|
int max_hp;
|
|
int strength;
|
|
int agility;
|
|
int gold;
|
|
std::vector<int> inventory;
|
|
std::unordered_map<int, int> equipment;
|
|
std::vector<Note> notes;
|
|
std::string auth_token;
|
|
std::chrono::system_clock::time_point last_activity;
|
|
bool active;
|
|
};
|
|
|
|
struct Battle {
|
|
int id;
|
|
int fighter1_id;
|
|
int fighter2_id;
|
|
int current_turn;
|
|
bool active;
|
|
std::vector<std::string> logs;
|
|
std::chrono::system_clock::time_point created_at;
|
|
};
|
|
|
|
std::map<int, Fighter> fighters;
|
|
std::map<int, Battle> battles;
|
|
std::map<int, Item> items;
|
|
std::mutex state_mutex;
|
|
|
|
std::atomic<int> next_fighter_id{1};
|
|
std::atomic<int> next_battle_id{1};
|
|
|
|
std::unordered_map<int, int> client_fighter;
|
|
std::unordered_map<int, int> fighter_battle;
|
|
|
|
std::ofstream log_file;
|
|
std::mutex log_mutex;
|
|
|
|
std::string get_timestamp() {
|
|
auto now = std::chrono::system_clock::now();
|
|
auto time = std::chrono::system_clock::to_time_t(now);
|
|
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()) % 1000;
|
|
std::stringstream ss;
|
|
ss << std::put_time(std::localtime(&time), "%Y-%m-%d %H:%M:%S");
|
|
ss << '.' << std::setfill('0') << std::setw(3) << ms.count();
|
|
return ss.str();
|
|
}
|
|
|
|
void log_event(const std::string& message) {
|
|
std::lock_guard<std::mutex> lock(log_mutex);
|
|
if (log_file.is_open()) {
|
|
log_file << "[" << get_timestamp() << "] " << message << std::endl;
|
|
log_file.flush();
|
|
}
|
|
}
|
|
|
|
#define LOG(msg) log_event(msg)
|
|
|
|
void init_items() {
|
|
items[1] = {1, "Rusty Sword", "weapon", 5, 10};
|
|
items[2] = {2, "Steel Sword", "weapon", 10, 25};
|
|
items[3] = {3, "Fire Blade", "weapon", 20, 50};
|
|
items[4] = {4, "Leather Armor", "armor", 3, 15};
|
|
items[5] = {5, "Chain Mail", "armor", 8, 35};
|
|
items[6] = {6, "Plate Armor", "armor", 15, 75};
|
|
items[7] = {7, "Health Potion", "potion", 25, 5};
|
|
items[8] = {8, "Super Potion", "potion", 50, 12};
|
|
}
|
|
|
|
std::string trim(const std::string& str) {
|
|
size_t first = str.find_first_not_of(" \t\r\n");
|
|
if (first == std::string::npos) return "";
|
|
size_t last = str.find_last_not_of(" \t\r\n");
|
|
return str.substr(first, last - first + 1);
|
|
}
|
|
|
|
std::vector<std::string> split(const std::string& str, char delim) {
|
|
std::vector<std::string> tokens;
|
|
std::stringstream ss(str);
|
|
std::string token;
|
|
while (std::getline(ss, token, delim)) {
|
|
tokens.push_back(token);
|
|
}
|
|
return tokens;
|
|
}
|
|
|
|
std::chrono::system_clock::time_point now() {
|
|
return std::chrono::system_clock::now();
|
|
}
|
|
|
|
int64_t seconds_since(std::chrono::system_clock::time_point t) {
|
|
auto diff = now() - t;
|
|
return std::chrono::duration_cast<std::chrono::seconds>(diff).count();
|
|
}
|
|
|
|
int create_fighter(const std::string& name, const std::string& fighter_class) {
|
|
Fighter f;
|
|
f.id = next_fighter_id++;
|
|
|
|
strncpy(f.name, name.c_str(), sizeof(f.name));
|
|
f.name[sizeof(f.name) - 1] = '\0';
|
|
|
|
f.fighter_class = fighter_class;
|
|
f.hp = 100;
|
|
f.max_hp = 100;
|
|
f.strength = 10;
|
|
f.agility = 10;
|
|
f.gold = 100;
|
|
f.last_activity = now();
|
|
f.active = true;
|
|
|
|
f.auth_token = "token_" + std::to_string(f.id) + "_" + std::to_string(rand());
|
|
|
|
if (fighter_class == "warrior") {
|
|
f.strength = 15;
|
|
f.max_hp = 120;
|
|
f.hp = 120;
|
|
} else if (fighter_class == "archer") {
|
|
f.agility = 20;
|
|
} else if (fighter_class == "mage") {
|
|
f.strength = 20;
|
|
f.max_hp = 80;
|
|
f.hp = 80;
|
|
}
|
|
|
|
fighters[f.id] = f;
|
|
return f.id;
|
|
}
|
|
|
|
std::string cmd_register(int client_fd, const std::vector<std::string>& args) {
|
|
if (args.size() < 2) return "ERROR: Usage: REGISTER <name> <class>";
|
|
|
|
std::string name = args[0];
|
|
std::string fighter_class = args[1];
|
|
|
|
if (fighter_class != "warrior" && fighter_class != "archer" && fighter_class != "mage") {
|
|
return "ERROR: Invalid class. Choose: warrior, archer, mage";
|
|
}
|
|
|
|
if (client_fighter.count(client_fd)) {
|
|
return "ERROR: Already registered";
|
|
}
|
|
|
|
int fid = create_fighter(name, fighter_class);
|
|
client_fighter[client_fd] = fid;
|
|
|
|
std::stringstream ss;
|
|
ss << "OK: Registered fighter " << fid << " (" << name << ", " << fighter_class << ")";
|
|
ss << " HP:" << fighters[fid].hp << " STR:" << fighters[fid].strength
|
|
<< " AGI:" << fighters[fid].agility << " Gold:" << fighters[fid].gold;
|
|
ss << " TOKEN:" << fighters[fid].auth_token;
|
|
return ss.str();
|
|
}
|
|
|
|
std::string cmd_fighter(int client_fd, const std::vector<std::string>&) {
|
|
if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
|
|
|
|
int fid = client_fighter[client_fd];
|
|
if (!fighters.count(fid)) return "ERROR: Fighter not found";
|
|
|
|
Fighter& f = fighters[fid];
|
|
f.last_activity = now();
|
|
|
|
std::stringstream ss;
|
|
ss << "FIGHTER " << f.id << ": " << f.name << " (" << f.fighter_class << ")";
|
|
ss << " HP:" << f.hp << "/" << f.max_hp;
|
|
ss << " STR:" << f.strength << " AGI:" << f.agility;
|
|
ss << " Gold:" << f.gold;
|
|
return ss.str();
|
|
}
|
|
|
|
std::string cmd_buy(int client_fd, const std::vector<std::string>& args) {
|
|
if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
|
|
if (args.size() < 2) return "ERROR: Usage: BUY <item_id> <quantity>";
|
|
|
|
int fid = client_fighter[client_fd];
|
|
if (!fighters.count(fid)) return "ERROR: Fighter not found";
|
|
|
|
int item_id = std::atoi(args[0].c_str());
|
|
int quantity = std::atoi(args[1].c_str());
|
|
|
|
if (!items.count(item_id)) return "ERROR: Item not found";
|
|
if (quantity <= 0) return "ERROR: Invalid quantity";
|
|
|
|
Fighter& f = fighters[fid];
|
|
Item& item = items[item_id];
|
|
|
|
int total_price = item.price * quantity;
|
|
|
|
if (total_price < 0) {
|
|
f.gold += abs(total_price);
|
|
f.last_activity = now();
|
|
return "OK: Overflow exploited! Gold:" + std::to_string(f.gold);
|
|
}
|
|
|
|
if (f.gold < total_price) {
|
|
return "ERROR: Not enough gold. Need:" + std::to_string(total_price) +
|
|
" Have:" + std::to_string(f.gold);
|
|
}
|
|
|
|
f.gold -= total_price;
|
|
for (int i = 0; i < quantity; i++) {
|
|
f.inventory.push_back(item_id);
|
|
}
|
|
f.last_activity = now();
|
|
|
|
return "OK: Bought " + std::to_string(quantity) + "x " + item.name +
|
|
" for " + std::to_string(total_price) + " gold. Remaining:" + std::to_string(f.gold);
|
|
}
|
|
|
|
std::string cmd_inventory(int client_fd) {
|
|
if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
|
|
|
|
int fid = client_fighter[client_fd];
|
|
if (!fighters.count(fid)) return "ERROR: Fighter not found";
|
|
|
|
Fighter& f = fighters[fid];
|
|
f.last_activity = now();
|
|
|
|
std::stringstream ss;
|
|
ss << "INVENTORY (Gold:" << f.gold << "): ";
|
|
|
|
if (f.inventory.empty()) {
|
|
ss << "empty";
|
|
} else {
|
|
std::map<int, int> counts;
|
|
for (int item_id : f.inventory) {
|
|
counts[item_id]++;
|
|
}
|
|
bool first = true;
|
|
for (auto& p : counts) {
|
|
if (!first) ss << ", ";
|
|
if (items.count(p.first)) {
|
|
ss << items[p.first].name << "x" << p.second;
|
|
} else {
|
|
ss << "Unknown(" << p.first << ")x" << p.second;
|
|
}
|
|
first = false;
|
|
}
|
|
}
|
|
|
|
ss << " | EQUIPPED: ";
|
|
if (f.equipment.empty()) {
|
|
ss << "none";
|
|
} else {
|
|
bool first = true;
|
|
for (auto& p : f.equipment) {
|
|
if (!first) ss << ", ";
|
|
if (items.count(p.second)) {
|
|
ss << "slot" << p.first << ":" << items[p.second].name;
|
|
}
|
|
first = false;
|
|
}
|
|
}
|
|
|
|
return ss.str();
|
|
}
|
|
|
|
std::string cmd_equip(int client_fd, const std::vector<std::string>& args) {
|
|
if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
|
|
if (args.size() < 2) return "ERROR: Usage: EQUIP <slot> <item_id>";
|
|
|
|
int fid = client_fighter[client_fd];
|
|
if (!fighters.count(fid)) return "ERROR: Fighter not found";
|
|
|
|
int slot = std::atoi(args[0].c_str());
|
|
int item_id = std::atoi(args[1].c_str());
|
|
|
|
Fighter& f = fighters[fid];
|
|
|
|
auto it = std::find(f.inventory.begin(), f.inventory.end(), item_id);
|
|
if (it == f.inventory.end()) {
|
|
return "ERROR: Item not in inventory";
|
|
}
|
|
|
|
f.inventory.erase(it);
|
|
|
|
f.equipment[slot] = item_id;
|
|
f.last_activity = now();
|
|
|
|
if (items.count(item_id)) {
|
|
Item& item = items[item_id];
|
|
if (item.type == "weapon") {
|
|
f.strength += item.power;
|
|
} else if (item.type == "armor") {
|
|
f.max_hp += item.power * 2;
|
|
f.hp += item.power * 2;
|
|
}
|
|
}
|
|
|
|
return "OK: Equipped item " + std::to_string(item_id) + " to slot " + std::to_string(slot);
|
|
}
|
|
|
|
std::string cmd_fight(int client_fd, const std::vector<std::string>& args) {
|
|
if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
|
|
if (args.size() < 1) return "ERROR: Usage: FIGHT <opponent_id>";
|
|
|
|
int fid = client_fighter[client_fd];
|
|
if (!fighters.count(fid)) return "ERROR: Fighter not found";
|
|
|
|
int opponent_id = std::atoi(args[0].c_str());
|
|
if (!fighters.count(opponent_id)) return "ERROR: Opponent not found";
|
|
if (opponent_id == fid) return "ERROR: Cannot fight yourself";
|
|
|
|
Fighter& f = fighters[fid];
|
|
Fighter& opponent = fighters[opponent_id];
|
|
|
|
if (fighter_battle.count(fid) || fighter_battle.count(opponent_id)) {
|
|
return "ERROR: Already in battle";
|
|
}
|
|
|
|
// Create battle
|
|
Battle b;
|
|
b.id = next_battle_id++;
|
|
b.fighter1_id = fid;
|
|
b.fighter2_id = opponent_id;
|
|
b.current_turn = 1;
|
|
b.active = true;
|
|
b.created_at = now();
|
|
b.logs.push_back("Battle started: " + std::string(f.name) + " vs " + std::string(opponent.name));
|
|
|
|
battles[b.id] = b;
|
|
fighter_battle[fid] = b.id;
|
|
fighter_battle[opponent_id] = b.id;
|
|
|
|
f.last_activity = now();
|
|
opponent.last_activity = now();
|
|
|
|
return "OK: Battle " + std::to_string(b.id) + " started against " + opponent.name;
|
|
}
|
|
|
|
std::string cmd_attack(int client_fd, const std::vector<std::string>&) {
|
|
if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
|
|
|
|
int fid = client_fighter[client_fd];
|
|
if (!fighters.count(fid)) return "ERROR: Fighter not found";
|
|
|
|
if (!fighter_battle.count(fid)) {
|
|
return "ERROR: Not in battle";
|
|
}
|
|
|
|
int bid = fighter_battle[fid];
|
|
if (!battles.count(bid)) return "ERROR: Battle not found";
|
|
|
|
Battle& b = battles[bid];
|
|
if (!b.active) return "ERROR: Battle already ended";
|
|
|
|
Fighter& attacker = fighters[fid];
|
|
int defender_id = (b.fighter1_id == fid) ? b.fighter2_id : b.fighter1_id;
|
|
Fighter& defender = fighters[defender_id];
|
|
|
|
// Calculate damage
|
|
int damage = attacker.strength + (attacker.agility / 2);
|
|
|
|
// Apply equipment bonuses
|
|
for (auto& eq : attacker.equipment) {
|
|
if (items.count(eq.second) && items[eq.second].type == "weapon") {
|
|
damage += items[eq.second].power;
|
|
}
|
|
}
|
|
|
|
// Reduce by armor
|
|
int armor = 0;
|
|
for (auto& eq : defender.equipment) {
|
|
if (items.count(eq.second) && items[eq.second].type == "armor") {
|
|
armor += items[eq.second].power;
|
|
}
|
|
}
|
|
damage = std::max(1, damage - armor);
|
|
|
|
defender.hp -= damage;
|
|
b.logs.push_back(std::string(attacker.name) + " attacks " + std::string(defender.name) + " for " +
|
|
std::to_string(damage) + " damage (HP:" + std::to_string(defender.hp) + ")");
|
|
|
|
attacker.last_activity = now();
|
|
defender.last_activity = now();
|
|
|
|
// Check for death
|
|
if (defender.hp <= 0) {
|
|
b.active = false;
|
|
defender.hp = 0;
|
|
defender.active = false;
|
|
|
|
// Winner gets gold
|
|
int reward = defender.gold / 2;
|
|
attacker.gold += reward;
|
|
defender.gold = 0;
|
|
|
|
b.logs.push_back(std::string(attacker.name) + " wins! Gets " + std::to_string(reward) + " gold");
|
|
|
|
fighter_battle.erase(fid);
|
|
fighter_battle.erase(defender_id);
|
|
|
|
return "OK: " + std::string(defender.name) + " defeated! You get " + std::to_string(reward) + " gold";
|
|
}
|
|
|
|
b.current_turn++;
|
|
return "OK: Dealt " + std::to_string(damage) + " damage. Enemy HP:" + std::to_string(defender.hp);
|
|
}
|
|
|
|
std::string cmd_heal(int client_fd) {
|
|
if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
|
|
|
|
int fid = client_fighter[client_fd];
|
|
if (!fighters.count(fid)) return "ERROR: Fighter not found";
|
|
|
|
Fighter& f = fighters[fid];
|
|
|
|
// Find health potion in inventory
|
|
auto it = std::find(f.inventory.begin(), f.inventory.end(), 7); // Health Potion id=7
|
|
if (it == f.inventory.end()) {
|
|
// Try super potion
|
|
it = std::find(f.inventory.begin(), f.inventory.end(), 8);
|
|
if (it != f.inventory.end()) {
|
|
f.inventory.erase(it);
|
|
int heal = 50;
|
|
f.hp = std::min(f.max_hp, f.hp + heal);
|
|
f.last_activity = now();
|
|
return "OK: Used Super Potion. HP:" + std::to_string(f.hp);
|
|
}
|
|
return "ERROR: No potions in inventory";
|
|
}
|
|
|
|
f.inventory.erase(it);
|
|
int heal = 25;
|
|
f.hp = std::min(f.max_hp, f.hp + heal);
|
|
f.last_activity = now();
|
|
|
|
return "OK: Used Health Potion. HP:" + std::to_string(f.hp);
|
|
}
|
|
|
|
std::string cmd_status(int client_fd) {
|
|
if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
|
|
|
|
int fid = client_fighter[client_fd];
|
|
if (!fighters.count(fid)) return "ERROR: Fighter not found";
|
|
|
|
if (!fighter_battle.count(fid)) {
|
|
return "STATUS: Not in battle";
|
|
}
|
|
|
|
int bid = fighter_battle[fid];
|
|
if (!battles.count(bid)) return "ERROR: Battle not found";
|
|
|
|
Battle& b = battles[bid];
|
|
Fighter& f = fighters[fid];
|
|
int opponent_id = (b.fighter1_id == fid) ? b.fighter2_id : b.fighter1_id;
|
|
Fighter& opponent = fighters[opponent_id];
|
|
|
|
std::stringstream ss;
|
|
ss << "BATTLE " << b.id << " (Turn " << b.current_turn << "): ";
|
|
ss << f.name << " HP:" << f.hp << " vs " << opponent.name << " HP:" << opponent.hp;
|
|
return ss.str();
|
|
}
|
|
|
|
std::string cmd_logout(int client_fd) {
|
|
if (client_fighter.count(client_fd)) {
|
|
client_fighter.erase(client_fd);
|
|
}
|
|
return "OK: Logged out";
|
|
}
|
|
|
|
std::string cmd_note_create(int client_fd, const std::vector<std::string>& args) {
|
|
if (!client_fighter.count(client_fd)) return "ERROR: Not registered";
|
|
if (args.size() < 2) return "ERROR: Usage: NOTE_CREATE <title> <content>";
|
|
|
|
int fid = client_fighter[client_fd];
|
|
if (!fighters.count(fid)) return "ERROR: Fighter not found";
|
|
|
|
Fighter& f = fighters[fid];
|
|
|
|
Note note;
|
|
note.id = f.notes.size() + 1;
|
|
strncpy(note.title, args[0].c_str(), sizeof(note.title) - 1);
|
|
note.title[sizeof(note.title) - 1] = '\0';
|
|
strncpy(note.content, args[1].c_str(), sizeof(note.content) - 1);
|
|
note.content[sizeof(note.content) - 1] = '\0';
|
|
note.created_at = now();
|
|
|
|
f.notes.push_back(note);
|
|
f.last_activity = now();
|
|
|
|
return "OK: Note created with id " + std::to_string(note.id);
|
|
}
|
|
|
|
std::string cmd_note_get(const std::vector<std::string>& args) {
|
|
if (args.size() < 1) return "ERROR: Usage: NOTE_GET <auth_token> [note_id]";
|
|
|
|
std::string auth_token = args[0];
|
|
int note_id = (args.size() > 1) ? std::atoi(args[1].c_str()) : -1;
|
|
|
|
Fighter* target_fighter = nullptr;
|
|
for (auto& fp : fighters) {
|
|
if (fp.second.auth_token == auth_token) {
|
|
target_fighter = &fp.second;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!target_fighter) {
|
|
return "ERROR: Invalid auth token";
|
|
}
|
|
|
|
if (note_id < 0) {
|
|
std::stringstream ss;
|
|
ss << "NOTES: ";
|
|
for (const auto& note : target_fighter->notes) {
|
|
ss << note.id << ":" << note.title << " ";
|
|
}
|
|
return ss.str();
|
|
}
|
|
|
|
for (const auto& note : target_fighter->notes) {
|
|
if (note.id == note_id) {
|
|
return "NOTE " + std::to_string(note.id) + ": " + note.title + " | " + note.content;
|
|
}
|
|
}
|
|
|
|
return "ERROR: Note not found";
|
|
}
|
|
|
|
void handle_client(int client_fd) {
|
|
char buffer[1024];
|
|
|
|
struct sockaddr_in client_addr;
|
|
socklen_t client_len = sizeof(client_addr);
|
|
getpeername(client_fd, (struct sockaddr*)&client_addr, &client_len);
|
|
std::string client_str = std::string(inet_ntoa(client_addr.sin_addr)) + ":" +
|
|
std::to_string(ntohs(client_addr.sin_port));
|
|
|
|
while (true) {
|
|
memset(buffer, 0, sizeof(buffer));
|
|
int bytes_read = read(client_fd, buffer, sizeof(buffer) - 1);
|
|
|
|
if (bytes_read <= 0) {
|
|
break;
|
|
}
|
|
|
|
std::string line(buffer);
|
|
line = trim(line);
|
|
|
|
if (line.empty()) continue;
|
|
|
|
std::vector<std::string> parts = split(line, ' ');
|
|
if (parts.empty()) continue;
|
|
|
|
std::string cmd = parts[0];
|
|
std::vector<std::string> args(parts.begin() + 1, parts.end());
|
|
|
|
LOG(client_str + " " + line);
|
|
|
|
std::string response;
|
|
|
|
if (cmd == "REGISTER") {
|
|
response = cmd_register(client_fd, args);
|
|
} else if (cmd == "FIGHTER") {
|
|
response = cmd_fighter(client_fd, args);
|
|
} else if (cmd == "BUY") {
|
|
response = cmd_buy(client_fd, args);
|
|
} else if (cmd == "INVENTORY") {
|
|
response = cmd_inventory(client_fd);
|
|
} else if (cmd == "EQUIP") {
|
|
response = cmd_equip(client_fd, args);
|
|
} else if (cmd == "FIGHT") {
|
|
response = cmd_fight(client_fd, args);
|
|
} else if (cmd == "ATTACK") {
|
|
response = cmd_attack(client_fd, args);
|
|
} else if (cmd == "HEAL") {
|
|
response = cmd_heal(client_fd);
|
|
} else if (cmd == "STATUS") {
|
|
response = cmd_status(client_fd);
|
|
} else if (cmd == "NOTE_CREATE") {
|
|
response = cmd_note_create(client_fd, args);
|
|
} else if (cmd == "NOTE_GET") {
|
|
response = cmd_note_get(args);
|
|
} else if (cmd == "LOGOUT") {
|
|
response = cmd_logout(client_fd);
|
|
} else if (cmd == "QUIT" || cmd == "EXIT") {
|
|
response = "BYE";
|
|
write(client_fd, response.c_str(), response.length());
|
|
break;
|
|
} else {
|
|
response = "ERROR: Unknown command: " + cmd;
|
|
}
|
|
|
|
response += "\n";
|
|
write(client_fd, response.c_str(), response.length());
|
|
}
|
|
|
|
// Cleanup
|
|
if (client_fighter.count(client_fd)) {
|
|
int fid = client_fighter[client_fd];
|
|
if (fighter_battle.count(fid)) {
|
|
int bid = fighter_battle[fid];
|
|
if (battles.count(bid)) {
|
|
battles[bid].active = false;
|
|
}
|
|
fighter_battle.erase(fid);
|
|
}
|
|
client_fighter.erase(client_fd);
|
|
}
|
|
|
|
close(client_fd);
|
|
}
|
|
|
|
void cleanup_thread() {
|
|
while (true) {
|
|
std::this_thread::sleep_for(std::chrono::minutes(5));
|
|
|
|
std::lock_guard<std::mutex> lock(state_mutex);
|
|
|
|
auto it = fighters.begin();
|
|
while (it != fighters.end()) {
|
|
int64_t inactive_seconds = seconds_since(it->second.last_activity);
|
|
if (inactive_seconds > 3600) {
|
|
int fid = it->first;
|
|
|
|
if (fighter_battle.count(fid)) {
|
|
int bid = fighter_battle[fid];
|
|
if (battles.count(bid)) {
|
|
battles[bid].active = false;
|
|
}
|
|
fighter_battle.erase(fid);
|
|
}
|
|
|
|
for (auto cf = client_fighter.begin(); cf != client_fighter.end(); ) {
|
|
if (cf->second == fid) {
|
|
close(cf->first);
|
|
cf = client_fighter.erase(cf);
|
|
} else {
|
|
++cf;
|
|
}
|
|
}
|
|
|
|
it = fighters.erase(it);
|
|
LOG("Cleanup: removed fighter " + std::to_string(fid));
|
|
} else {
|
|
++it;
|
|
}
|
|
}
|
|
|
|
for (auto& bp : battles) {
|
|
if (!bp.second.active) {
|
|
int64_t age = seconds_since(bp.second.created_at);
|
|
if (age > 3600) {
|
|
fighter_battle.erase(bp.second.fighter1_id);
|
|
fighter_battle.erase(bp.second.fighter2_id);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int main(int argc, char* argv[]) {
|
|
int port = 31337;
|
|
if (argc > 1) {
|
|
port = std::atoi(argv[1]);
|
|
}
|
|
|
|
init_items();
|
|
|
|
signal(SIGPIPE, SIG_IGN);
|
|
|
|
log_file.open("logs/server.log", std::ios::app);
|
|
if (!log_file.is_open()) {
|
|
log_file.open("/var/log/arena-battle/server.log", std::ios::app);
|
|
}
|
|
if (!log_file.is_open()) {
|
|
log_file.open("server.log", std::ios::app);
|
|
}
|
|
LOG("Server started on port " + std::to_string(port));
|
|
|
|
std::thread cleanup(cleanup_thread);
|
|
cleanup.detach();
|
|
|
|
int server_fd = socket(AF_INET, SOCK_STREAM, 0);
|
|
if (server_fd < 0) {
|
|
return 1;
|
|
}
|
|
|
|
int opt = 1;
|
|
setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
|
|
|
|
struct sockaddr_in addr;
|
|
memset(&addr, 0, sizeof(addr));
|
|
addr.sin_family = AF_INET;
|
|
addr.sin_addr.s_addr = INADDR_ANY;
|
|
addr.sin_port = htons(port);
|
|
|
|
if (bind(server_fd, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
|
|
return 1;
|
|
}
|
|
|
|
if (listen(server_fd, 10) < 0) {
|
|
return 1;
|
|
}
|
|
|
|
LOG("Listening on port " + std::to_string(port));
|
|
|
|
while (true) {
|
|
struct sockaddr_in client_addr;
|
|
socklen_t client_len = sizeof(client_addr);
|
|
|
|
int client_fd = accept(server_fd, (struct sockaddr*)&client_addr, &client_len);
|
|
if (client_fd < 0) {
|
|
continue;
|
|
}
|
|
|
|
std::string client_str = std::string(inet_ntoa(client_addr.sin_addr)) + ":" +
|
|
std::to_string(ntohs(client_addr.sin_port));
|
|
LOG("Connect " + client_str);
|
|
|
|
std::thread client_thread(handle_client, client_fd);
|
|
client_thread.detach();
|
|
}
|
|
|
|
close(server_fd);
|
|
return 0;
|
|
}
|