LoL_combat_simulator/user_instance_settings.py at master · FermiParadox/LoL_combat_simulator · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
import importlib
import os

import palette


def _add_champion_and_attr_class(champion_name, modified_dct):
    """
    Inserts champion name as key and his attrs' class as value.

    :return: (None)
    """
    player_champ_module = importlib.import_module('champions.' + champion_name)
    player_champ_tot_attr_class = getattr(player_champ_module, 'ChampionAttributes')

    modified_dct.update({champion_name: player_champ_tot_attr_class})

# All available champion modules are stored.
ALL_CHAMPIONS_TOTAL_ATTRIBUTES_CLASSES = {}
for champ_name in palette.ALL_CHAMPIONS_NAMES:
    champ_name = champ_name.lower()

    # Filters out non implemented champions
    if champ_name + '.py' in palette.FILES_IN_CHAMPIONS_DIR:
        _add_champion_and_attr_class(champion_name=champ_name, modified_dct=ALL_CHAMPIONS_TOTAL_ATTRIBUTES_CLASSES)

# Adds melee_creep.
_add_champion_and_attr_class(champion_name='melee_creep', modified_dct=ALL_CHAMPIONS_TOTAL_ATTRIBUTES_CLASSES)


class UserSession(object):

    @staticmethod
    def combiner_class(input_dct):

        player_champ_name = input_dct['selected_champions_dct']['player']

        return ALL_CHAMPIONS_TOTAL_ATTRIBUTES_CLASSES[player_champ_name](input_dct)

    def reversed_combat_instance(self, input_dct, enemy_name):
        new_input_dct = {}

        enemy_champion = input_dct['selected_champions_dct'][enemy_name]
        player_champion = input_dct['selected_champions_dct']['player']
        new_input_dct.update({'selected_champions_dct': {'player': enemy_champion, 'enemy_1': player_champion}})

        player_lvl = input_dct['champion_lvls_dct']['player']
        enemy_lvl = input_dct['champion_lvls_dct'][enemy_name]
        new_input_dct.update({'champion_lvls_dct': {'player': enemy_lvl, 'enemy_1': player_lvl}})

        chosen_items_dct = input_dct['chosen_items_dct']
        if enemy_name in chosen_items_dct:
            enemy_items = chosen_items_dct[enemy_name]
        else:
            enemy_items = []
        new_input_dct.update({'chosen_items_dct': {'player': enemy_items, }})

        new_input_dct.update({'_reversed_combat_mode': True})
        new_input_dct.update({'ability_lvls_dct': {}})
        new_input_dct.update({'rotation_lst': []})

        for key in input_dct:
            if key not in new_input_dct:
                value = input_dct[key]
                new_input_dct.update({key: value})

        instance = self.combiner_class(new_input_dct)
        instance.run_combat()

        return instance

    def all_enemy_stats(self, input_dct):
        """
        Combines all enemy induced dmg, and enemies' stats on player into a single dict.

        :return: (dict)
        """
        enemies_base_stats = {}
        dmg_data = {}

        enemy_target_names = tuple(tar for tar in sorted(input_dct['selected_champions_dct']) if tar != 'player')

        for enemy_name in enemy_target_names:
            instance = self.reversed_combat_instance(input_dct=input_dct, enemy_name=enemy_name)

            # Stats
            stats_dct = instance.reversed_precombat_player_stats
            enemies_base_stats.update({enemy_name: stats_dct})

            # Dmg
            enemy_dmg_results = instance.combat_results
            dmg_data.update({enemy_name: enemy_dmg_results})

        return {'all_stats': enemies_base_stats, 'all_dmg_results': dmg_data}

    def finalized_input_dct(self, input_dct):
        """
        Creates final input dict for the player's combat instance, by inserting buffs and stats originating from enemy.

        :return: (dict)
        """

        dct = {}

        stats_and_buffs_dct = self.all_enemy_stats(input_dct=input_dct)
        enemies_stats_dct = stats_and_buffs_dct['all_stats']
        dmg_data_dct = stats_and_buffs_dct['all_dmg_results']

        dct.update({'initial_enemies_total_stats': enemies_stats_dct})
        dct.update({'enemies_originating_dmg_data': dmg_data_dct})

        for key in input_dct:
            if key not in dct:
                value = input_dct[key]

                dct.update({key: value})

        return dct

    def instance_after_combat(self, input_dct):
        """
        Returns instance after running combat.

        :param input_dct:
        :return:
        """

        input_dct = self.finalized_input_dct(input_dct=input_dct)

        instance = self.combiner_class(input_dct)
        instance.run_combat()

        return instance

    def create_instance_and_represent_results(self, input_dct):

        instance = self.instance_after_combat(input_dct=input_dct)
        instance.represent_results_visually()

        return instance

    def create_instance_and_return_image_name(self, input_dct):
        instance = self.instance_after_combat(input_dct=input_dct)
        instance.store_results_as_image()

        return instance.temp_image_name