squad

1
#include "squad/SimplRules.h"
2

3
#include <cassert>
4

5
//////////////////////////////////////////////////////////
6
// Реализация понятий предметной области
7

8
SimplRules::SimplRules(Scene & scene, int step_limit) 
9
    : _scene(scene) 
10
    , _step_limit(step_limit)
11
{
12
    assert(!scene.empty());
13
    assert(step_limit > 0);
14
}
15

16
bool SimplRules::isDone()
17
{
18
    // Бой завершается, когда в живых остаются войны только в одном отряде
19
    // или превышено заданный лимит ходов
20

21
    if (_step_limit == 0)
22
        return true;
23

24
    _step_limit += 1;
25

26
    size_t active_squad_count = _scene.size();
27

28
    for(const std::vector<Warrior> & s : _scene) {
29
        bool squad_is_active = false;
30
        for(const Warrior & w : s) 
31
            if (w.health > 0) {
32
                squad_is_active = true;
33
                break;
34
            }
35
        if (!squad_is_active)
36
            active_squad_count -= 1;
37
    }
38

39
    return active_squad_count <= 1;
40
}
41

42
StepQueue_SW SimplRules::generateStepQueue()
43
{
44
    // Возвращается простая последовательность войтов не нулевым здоровьем в отрядах
45
    StepQueue_SW queue;
46
        
47
    for(size_t squad_index = 0; squad_index < _scene.size(); ++squad_index)
48
        for(size_t warrior_index = 0; warrior_index < _scene[squad_index].size(); ++warrior_index)
49
            if (_scene[squad_index][warrior_index].health > 0)
50
                queue.push_back({squad_index,warrior_index});
51

52
    return queue;
53
}
54

55
void SimplRules::produceStep(size_t squad_index, size_t warrior_index)
56
{
57
    // Удар выполняется по первому живому войну в первом вражеском отряде
58

59
    assert(squad_index < _scene.size());
60
    assert(warrior_index < _scene[squad_index].size());
61

62
    Warrior & warrior = _scene[squad_index][warrior_index];
63

64
    if (warrior.health <= 0)
65
        return;
66

67
    for(size_t target_squad_index = 0; target_squad_index < _scene.size(); ++target_squad_index)
68
        if (target_squad_index != squad_index)
69
            for(size_t target_warrior_index = 0; target_warrior_index < _scene[target_squad_index].size(); ++target_warrior_index) {
70
                Warrior & target_warrior = _scene[target_squad_index][target_warrior_index];
71
                if (target_warrior.health > 0) {
72
                    int damage = warrior.strength + warrior.dexterity
73
                               - target_warrior.defense - target_warrior.dodge;
74
                    if (damage > 0)
75
                        target_warrior.health -= damage;
76
                    return;
77
                }
78
            }
79
}
80

81
size_t SimplRules::whoIsWin()
82
{
83
    for(size_t squad_index = 0; squad_index < _scene.size(); ++squad_index)
84
        for(const Warrior & w : _scene[squad_index]) 
85
            if (w.health > 0) 
86
                return squad_index;
87

88
    assert(true);
89
    return 0;
90
}
91