1

Controllers/Enums.h

@@ -0,0 +1,95 @@
+#ifndef ENUMS_H
+#define ENUMS_H
+
+struct CountInEnums
+{
+  int resources() { return 10; }
+};
+
+
+enum class Contents
+{
+  Resource,
+  Unit,
+  Building
+};
+
+
+enum class MainLandscapes
+{
+  Plain,
+  Mountain,
+  Tundra,
+  Snow,
+  Ice,
+  Coast,
+  Desert,
+  Ocean
+};
+
+
+enum class OtherLandscapes
+{
+  Nothing,
+  Forest,
+  Jungles,
+  Hills,
+  ForestAndHills,
+  JunglesAndHills
+};
+
+
+enum class Units
+{
+  Bowman,
+  Citizen,
+  Swordsman,
+  Worker,
+};
+
+
+enum class Resources
+{
+  Fish,
+  Oil,
+  Aluminum,
+  Coal,
+  Horses,
+  Gold,
+  Iron,
+  Silver,
+  Stone,
+  Uranium,
+};
+
+
+enum class Buildings
+{
+  Farm,
+  FishingBoat,
+  Fort,
+  LumberMill,
+  Mine,
+  OilWell,
+  Pasture,
+  Quarry,
+  Town,
+  TradingPost
+};
+
+
+enum class Countries
+{
+  Nothing,
+  Russia,
+  America,
+  China,
+  England
+};
+
+enum class Mod{
+  Show,
+  Play
+};
+
+#endif // ENUMS_H

Controllers/FindUnitWay.cpp

@@ -0,0 +1,67 @@
+#include "FindUnitWay.h"
+#include "iostream"
+
+
+void OneMove::add_move(Position pos)
+{
+  minimove.push_back(pos);
+  end = pos;
+}
+
+OneMove Way::get_move_in_way(size_t num_move) const{
+  if(num_move > way.size())
+    throw std::runtime_error("get_move_in_way(): The path has fewer moves");
+  return way[num_move];
+}
+
+size_t Way::get_count_moves_in_way() const
+{
+  return way.size();
+}
+
+void Way::add_move(OneMove move)
+{
+  way.push_back(move);
+}
+
+Way FindUnitWay::get_way(class Unit *unit, IMapForFind *map, Position start, Position end)
+{
+  Position go{start};
+  Way way;
+  OneMove onemove{start};
+
+  int movement_points = unit->get_movement();
+  if (!movement_points)
+    movement_points = unit->get_max_movement();
+  while(go != end)
+  {
+    std::vector<Position> neighbors =  map->adjacent_cells(go);
+    Position min_distance{neighbors[0]};
+    for(size_t i{1}; i < neighbors.size(); ++i)
+    {
+      Position temp{neighbors[i]};
+      if(abs(int(temp.y) - int(end.y)) < abs(int(min_distance.y) - int(end.y)))
+        min_distance = temp;
+      if(abs(int(temp.y) - int(end.y)) == abs(int(min_distance.y) - int(end.y)))
+        if(abs(int(temp.x) - int(end.x)) < abs(int(min_distance.x) - int(end.x)))
+          min_distance = temp;
+    }
+    onemove.add_move(min_distance);
+    onemove.spent_movement_points++;
+    go = min_distance;
+    --movement_points;
+    if(!movement_points)
+    {
+      movement_points = unit->get_max_movement();
+      way.add_move(onemove);
+      onemove = OneMove{min_distance};
+    }
+  }
+  way.add_move(onemove);
+  return way;
+}
+
+OneMove FindUnitWay::get_first_move(class Unit* unit, IMapForFind* map, Position start, Position end)
+{
+  return get_way(unit, map, start, end).get_move_in_way(0);
+}

Controllers/FindUnitWay.h

@@ -0,0 +1,55 @@
+#ifndef FINDUNITWAY_H
+#define FINDUNITWAY_H
+
+#include <vector>
+
+#include "../Graphics/Map/IMap.h"
+#include "../Graphics/Units/Unit.h"
+#include "../IObject.h"
+
+
+struct OneMove
+{
+  Position start;
+  Position end;
+  int spent_movement_points = 0;
+
+  /*
+   * массив который хранит подперемещения в одном перемещении
+   * первый элемент равняется start
+   * последний элемент равняется end
+  */
+  std::vector<Position> minimove;
+
+  OneMove(Position _start, Position _end,
+          int _spent_movement_points, std::vector<Position> _minimove)
+    :start{_start}, end{_end}, spent_movement_points{_spent_movement_points},
+      minimove{_minimove}
+  {}
+  OneMove(Position _start)
+    :start{_start}, end{_start}
+  { minimove.push_back(start); }
+
+  void add_move(Position pos);
+};
+
+
+class Way : public IObject
+{
+  std::vector<OneMove> way;
+public:
+  /// number_move с нуля
+  OneMove get_move_in_way(size_t number_move) const;
+  size_t get_count_moves_in_way() const;
+  void add_move(OneMove move);
+};
+
+
+class FindUnitWay : public IObject
+{
+public:
+  Way get_way(class Unit* unit, IMapForFind* map, Position start, Position end);
+  OneMove get_first_move(class Unit* unit, IMapForFind* map, Position start, Position end);
+};
+
+#endif // FINDUNITWAY_H

Controllers/FindVision.cpp

@@ -0,0 +1,56 @@
+#include "FindVision.h"
+#include <iostream>
+
+
+std::vector<Position> FindVision::unit_vision(class Unit* unit, Position pos_unit, IMapForFind* map) const
+{
+  std::vector<Position> res;
+
+  std::queue<std::pair<Position, int>> queue;
+  queue.push({pos_unit, unit->get_vision()});
+  while(!queue.empty()){
+    std::pair<Position, int> pair = queue.front();
+    queue.pop();
+    if(std::find(res.begin(), res.end(), pair.first) == res.end())
+      res.push_back(pair.first);
+
+    if(pair.second != 0)
+      for(Position pos : map->adjacent_cells(pair.first))
+        queue.push({pos, pair.second-1});
+  }
+  return res;
+}
+
+std::vector<Position> FindVision::town_vision(PlayerTown* town, IMapForFind* map) const
+{
+  std::vector<Position> res;
+
+  std::queue<std::pair<Position, int>> queue;
+  queue.push({town->position_town(), 3});
+  while(!queue.empty()){
+    std::pair<Position, int> pair = queue.front();
+    queue.pop();
+    if(std::find(res.begin(), res.end(), pair.first) == res.end())
+    {
+      Countries country_cell = map->get_cell_country(pair.first);
+      bool is_visible = false;
+
+      if(town->get_country() == country_cell)
+        is_visible = true;
+
+      for(auto pos : map->adjacent_cells(pair.first))
+      {
+        country_cell = map->get_cell_country(pos);
+        if(town->get_country() == country_cell)
+          is_visible = true;
+      }
+      if(is_visible)
+        res.push_back(pair.first);
+    }
+
+    if(pair.second != 0)
+      for(Position pos : map->adjacent_cells(pair.first))
+        queue.push({pos, pair.second-1});
+  }
+  return res;
+}

Controllers/FindVision.h

@@ -0,0 +1,20 @@
+#ifndef FINDUNITVISION_H
+#define FINDUNITVISION_H
+
+#include <queue>
+#include <vector>
+
+#include "Player/PlayerTown.h"
+#include "../IObject.h"
+#include "../Graphics/Map/IMap.h"
+#include "../Graphics/Units/Unit.h"
+
+
+class FindVision : public IObject
+{
+public:
+  std::vector<Position> unit_vision(class Unit* unit, Position pos_unit, IMapForFind* map) const;
+  std::vector<Position> town_vision(PlayerTown* town, IMapForFind* map) const;
+};
+
+#endif // FINDUNITVISION_H