generated_by_ai.cpp

#include <vector>
#include <string>
#include <unordered_map>
#include <set>
#include <cstdlib> // for rand()
#include <ctime>   // for time()
#include <iostream>

// Типы-заглушки
struct t_client_name { std::string name; };
struct t_client_move { /* details omitted */ };
struct t_client_world { /* details omitted */ };
using t_client_id = int;

struct t_env {
  struct t_move {
    struct t_rec {
      t_client_name id;
      t_client_move m;
    };
    std::vector<t_rec> arr;
  };

  // Поверхностное API t_world с заглушками
  struct t_world {
    // Применяет ход к миру (заглушка)
    void use(const t_move& /*m*/) { /* stub */ }
    // Один шаг симуляции (заглушка)
    void sim_step() { /* stub */ }

    // Добавляем поддержку волн мобов (заглушка)
    struct wave_t {
      int wave_number = 0;
      double mob_strength_factor = 1.0;
    };
    std::vector<wave_t> waves;
    void generate_wave(int wave_id) {
      (void)wave_id; // stub
    }
  };

  t_world w;

  // Проверка валидности последовательности ходов (stub)
  static bool ok(const t_world& /*w*/, const std::vector<t_move>& /*way*/) {
    return true;
  }

  // Квадратичная разница между состояниями миров (stub)
  static double sqrdiff(const t_world& /*a*/, const t_world& /*b*/) {
    return 0.0;
  }
};

// t_step - один геймплейный шаг: входные данные + действие
struct t_step {
  t_client_world inp;
  t_client_move out;
};

// Игрок с ограниченной памятью
struct LimitedMemoryPlayer {
  size_t memory_capacity = 10; // сколько последних шагов хранит игрок
  std::vector<t_step> memory_steps;

  // Добавляет шаг в память, с ограничением размера
  void remember(const t_step& step) {
    if (memory_steps.size() >= memory_capacity) {
      memory_steps.erase(memory_steps.begin());
    }
    memory_steps.push_back(step);
  }

  // Внешний код может «повредить» память - удалить случайные шаги
  void damage_memory(double damage_chance = 0.1) {
    for (auto it = memory_steps.begin(); it != memory_steps.end();) {
      if ((rand() / (double)RAND_MAX) < damage_chance) {
        it = memory_steps.erase(it);
      } else {
        ++it;
      }
    }
  }

  // Принять входное состояние мира и выбрать следующий ход
  t_client_move brain(const t_client_world& inp) {
    // stub: решает опираясь на память и текущее состояние, пока случайно
    (void)inp;
    if (memory_steps.empty()) return t_client_move{};
    return memory_steps.back().out; // просто повтор действия
  }
};

// Администратор / наблюдатель
struct Admin {
  std::string name;
  void observe(const t_env::t_world& /*world*/) {
    // заглушка
  }
  void moderate() {
    // заглушка
  }
};

// Мобильный «моб» в игре, действует по своим правилам
struct Mob {
  t_client_id id;
  void act(t_env::t_world& /*world*/) {
    // stub: действие моба в мире
  }
};

// Игроки, админы, мобы в игре
class GameServer {
  struct PlayerData {
    t_client_id id;
    LimitedMemoryPlayer brain;
    bool active = true;
  };

  std::unordered_map<t_client_id, PlayerData> players;
  std::unordered_map<t_client_id, Admin> admins;
  std::unordered_map<t_client_id, Mob> mobs;

  t_env::t_world world;

  size_t step_counter = 0;

public:
  GameServer() { srand(static_cast<unsigned>(time(nullptr))); }

  // Добавить игрока
  void add_player(t_client_id id) {
    players.emplace(id, PlayerData{id, LimitedMemoryPlayer{}, true});
  }
  // Удалить игрока
  void remove_player(t_client_id id) {
    players.erase(id);
  }
  // Добавить админа
  void add_admin(t_client_id id, const std::string& name) {
    admins.emplace(id, Admin{name});
  }
  // Добавить моба
  void add_mob(t_client_id id) {
    mobs.emplace(id, Mob{id});
  }

  // Шаг симуляции сервера
  void sim_step() {
    ++step_counter;

    // 1. Каждый моб действует
    for (auto& [id, mob] : mobs) {
      mob.act(world);
    }

    // 2. Собираем ходы от игроков
    std::vector<t_env::t_move::t_rec> moves;
    for (auto& [id, pdata] : players) {
      if (!pdata.active) continue;

      // Модель входного мира (stub)
      t_client_world inp_world{};
      
      // Решающая функция
      t_client_move move = pdata.brain.brain(inp_world);
      
      // Запоминаем ход
      t_step current_step{inp_world, move};
      pdata.brain.remember(current_step);
      
      // Добавляем в общие ходы
      moves.push_back({t_client_name{std::to_string(id)}, move});
    }
    t_env::t_move m; m.arr = moves;

    // 3. Мир применяет ходы
    world.use(m);
    world.sim_step();

    // 4. Дамажим память игроков случайным образом (шум, атаки, etc)
    for (auto& [id, pdata] : players) {
      pdata.brain.damage_memory(0.1); // 10% шанс «порчи» шага
    }

    // 5. Обновить инофрмацию об игроках (покидание, появление новых) (stub)
    update_player_activity();

    // 6. Админы наблюдают/модерируют
    for (auto& [id, admin] : admins) {
      admin.observe(world);
      admin.moderate();
    }
  }

  void update_player_activity() {
    // Заглушка: тут вы можете логик поменять активность игроков
    // Например, через время отключать, включать или добавить новых.
  }

  // Получить текущее состояние мира для клиента (stub)
  t_client_world get_client_world_view(t_client_id /*id*/) {
    return t_client_world{};
  }

  // Добавить волну мобов (в заглушке просто push_back)
  void add_wave(int wave_number) {
    t_env::t_world::wave_t w;
    w.wave_number = wave_number;
    w.mob_strength_factor = 1.0 + wave_number * 0.2; // простое увеличение силы с каждой волной
    world.waves.push_back(w);
    world.generate_wave(wave_number);
  }
};

// Главная программа (упрощённый пример)
int main() {
  GameServer server;

  // Инициализация игроков и админов
  server.add_player(1);
  server.add_player(2);
  server.add_player(3);
  server.add_admin(100, "SuperAdmin");
  server.add_mob(200);

  // Добавляем пару волн мобов
  server.add_wave(1);
  server.add_wave(2);

  // Основной цикл — предположим 100 шагов
  for (int i = 0; i < 100; ++i) {
    server.sim_step();
    // Вставить обработку сетевых событий и отправку клиентам здесь
  }

  std::cout << "Simulation ended\n";
  return 0;
}

orig.cpp

---
2025.07.16 19:54:57.702 // промт к ИИ
сейчас я бы ещё добавил код который:
  не присылает в мозг массив шагов, а заставляет игрока их запоминать в своей ограниченной памяти.
  игроку приходиться хранить только самое важно.
  внешний код постоянно дамажит эту память.
  игроков много.
  есть админы/наблюдатели/мобы.
  игроки иногда выходят из игры.
  иногда появляються новые игроки.
  ...
---
2025.07.16 20:00:37.184
оригинальный код:
struct t_env{
  struct t_move{
    struct t_rec{
      t_client_name id;
      t_client_move m;
    };
    vector<t_rec> arr;
  };
  struct t_world{
    void use(t_move m){/*...*/}
    void sim_step(){/*...*/}
  };
  t_world w;
  static bool ok(t_world w,vector<t_move> way){
    /*...*/
    return true;
  }
  static double sqrdiff(t_world a,t_world b){/*...*/}
};

struct t_step{
  t_client_world inp;
  t_client_move out;
};

t_client_move brain(vector<t_step> arr,t_client_world inp){
  vector<t_world> cur_front=get(arr,inp);
  
}
int main(){
  vector<t_step> mem;
  for(;;){
    t_step cur;
    t_client_world w;
    
    network.recv(w);
    {
      cur.inp=w;
      rec.out=brain(mem,cur.inp);
      mem.push_back(cur);
    }
    network.send(rec.out);
  }
}