dt.py

@@ -1,160 +0,0 @@
-import numpy as np
-import pandas as pd
-from sklearn.model_selection import train_test_split
-from sklearn.metrics import accuracy_score
-
-class GadId3Classifier:
-  def fit(self, input, output):
-    data = input.copy()
-    data[output.name] = output
-    self.tree = self.decision_tree(data, data, input.columns, output.name)
-
-  def predict(self, input):
-    # convert input data into a dictionary of samples
-    samples = input.to_dict(orient='records')
-    predictions = []
-
-    # make a prediction for every sample
-    for sample in samples:
-      predictions.append(self.make_prediction(sample, self.tree, 1.0))
-
-    return predictions
-
-  def entropy(self, attribute_column):
-    # find unique values and their frequency counts for the given attribute
-    values, counts = np.unique(attribute_column, return_counts=True)
-
-    # calculate entropy for each unique value
-    entropy_list = []
-
-    for i in range(len(values)):
-      probability = counts[i]/np.sum(counts)
-      entropy_list.append(-probability*np.log2(probability))
-
-    # calculate sum of individual entropy values
-    total_entropy = np.sum(entropy_list)
-
-    return total_entropy
-
-  def information_gain(self, data, feature_attribute_name, target_attribute_name):
-    # find total entropy of given subset
-    total_entropy = self.entropy(data[target_attribute_name])
-
-    # find unique values and their frequency counts for the attribute to be split
-    values, counts = np.unique(data[feature_attribute_name], return_counts=True)
-
-    # calculate weighted entropy of subset
-    weighted_entropy_list = []
-
-    for i in range(len(values)):
-      subset_probability = counts[i]/np.sum(counts)
-      subset_entropy = self.entropy(data.where(data[feature_attribute_name]==values[i]).dropna()[target_attribute_name])
-      weighted_entropy_list.append(subset_probability*subset_entropy)
-
-    total_weighted_entropy = np.sum(weighted_entropy_list)
-
-    # calculate information gain
-    information_gain = total_entropy - total_weighted_entropy
-
-    return information_gain
-
-  def decision_tree(self, data, orginal_data, feature_attribute_names, target_attribute_name, parent_node_class=None):
-    # base cases:
-    # if data is pure, return the majority class of subset
-    unique_classes = np.unique(data[target_attribute_name])
-    if len(unique_classes) <= 1:
-      return unique_classes[0]
-    # if subset is empty, ie. no samples, return majority class of original data
-    elif len(data) == 0:
-      majority_class_index = np.argmax(np.unique(original_data[target_attribute_name], return_counts=True)[1])
-      return np.unique(original_data[target_attribute_name])[majority_class_index]
-    # if data set contains no features to train with, return parent node class
-    elif len(feature_attribute_names) == 0:
-      return parent_node_class
-    # if none of the above are true, construct a branch:
-    else:
-      # determine parent node class of current branch
-      majority_class_index = np.argmax(np.unique(data[target_attribute_name], return_counts=True)[1])
-      parent_node_class = unique_classes[majority_class_index]
-
-      # determine information gain values for each feature
-      # choose feature which best splits the data, ie. highest value
-      ig_values = [self.information_gain(data, feature, target_attribute_name) for feature in feature_attribute_names]
-      best_feature_index = np.argmax(ig_values)
-      best_feature = feature_attribute_names[best_feature_index]
-
-      # create tree structure, empty at first
-      tree = {best_feature: {}}
-
-      # remove best feature from available features, it will become the parent node
-      feature_attribute_names = [i for i in feature_attribute_names if i != best_feature]
-
-      # create nodes under parent node
-      parent_attribute_values = np.unique(data[best_feature])
-      for value in parent_attribute_values:
-        sub_data = data.where(data[best_feature] == value).dropna()
-
-        # call the algorithm recursively
-        subtree = self.decision_tree(sub_data, orginal_data, feature_attribute_names, target_attribute_name, parent_node_class)
-
-        # add subtree to original tree
-        tree[best_feature][value] = subtree
-
-      return tree
-
-  def make_prediction(self, sample, tree, default=1):
-    # map sample data to tree
-    for attribute in list(sample.keys()):
-      # check if feature exists in tree
-      if attribute in list(tree.keys()):
-        try:
-          result = tree[attribute][sample[attribute]]
-        except:
-          return default
-
-        result = tree[attribute][sample[attribute]]
-
-        # if more attributes exist within result, recursively find best result
-        if isinstance(result, dict):
-          return self.make_prediction(sample, result)
-        else:
-          return result
-
-#data_url = "https://archive.ics.uci.edu/ml/machine-learning-databases/heart-disease/processed.cleveland.data"
-#df = pd.read_csv(data_url, header=None)
-df = pd.read_csv("data_dd3.csv", header=None)
-
-# rename known columns
-columns = ['p_strength','p_agility','p_wisdom','p_health','p_melee_damage','p_ranged_damage','p_magic_damage',
-           'p_armor_defence','p_armor_magic_protection','e_strength','e_agility','e_wisdom','e_health','e_melee_damage',
-           'e_ranged_damage','e_magic_damage','e_armor_defence','e_armor_magic_protection','e_attack_type','strategy']
-#columns = ['age', 'sex', 'cp', 'trestbps', 'chol', 'fbs', 'restecg',
-           #'thalach', 'exang', 'oldpeak', 'slope', 'ca', 'thal', 'disease_present']
-df.columns = columns
-
-# convert disease_present feature to binary
-# df['disease_present'] = df.disease_present.replace([1,2,3,4], 1)
-
-# drop rows with missing values, missing = ?
-df = df.replace("?", np.nan)
-df = df.dropna()
-
-# organize data into input and output
-#X = df.drop(columns="disease_present")
-#y = df["disease_present"]
-X = df.drop(columns="strategy")
-y = df["strategy"]
-
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)
-
-# initialize and fit model
-model = GadId3Classifier()
-model.fit(X_train, y_train)
-
-# return accuracy score
-y_pred = model.predict(X_test)
-a = accuracy_score(y_test, y_pred)
-
-print(a)
-#print(y_pred)
-#print(y_test)

server.py

@@ -2,62 +2,31 @@ from src.agent.map.gameMap import GameMap
 from mesa.visualization.modules import CanvasGrid
 from mesa.visualization.modules.TextVisualization import TextElement
 from mesa.visualization.ModularVisualization import ModularServer
-#from src.decisiontree import create_model
+
-from src.direction import Direction
-from collections import defaultdict
-import src.agent.ga_chromosome as ga
 
 def player_representation(agent):
-    portrayal = {"Shape": "sprites/heroE.png",
+    portrayal = {"Shape": "sprites/hero.png",
                  "Layer": 1}
-    if agent.isPlayer and agent.direction==Direction.N:
+    if agent.isBox:
-        portrayal["Shape"] = "sprites/heroN.png"
-    elif agent.isPlayer and agent.direction == Direction.W:
-        portrayal["Shape"] = "sprites/heroW.png"
-    elif agent.isPlayer and agent.direction == Direction.S:
-        portrayal["Shape"] = "sprites/heroS.png"
-    elif agent.isBox:
         portrayal["Shape"] = "sprites/box.png"
         portrayal["Layer"] = 0
     elif agent.isCreature:
-        if agent.name=='Goblin':
         portrayal["Shape"] = 'sprites/goblin.png'
-        elif agent.name=='Skeleton':
-            portrayal["Shape"] = 'sprites/skeletonArcher.png'
     return portrayal
 
-def chest_content(agent):
+grid = CanvasGrid(player_representation, 10, 10, 500, 500)
-    if agent.isBox:
-        portrayal = {"Shape": "sprites/coin.jpg",
-                 "Layer": 1}
-    return portrayal
 
-grid = CanvasGrid(player_representation, 10, 10, 700, 700)
+class MyTextElement(TextElement):
-image=CanvasGrid(chest_content, 1, 1, 200, 200)
-class Stats(TextElement):
     def render(self, model):
         hp = str(model.get_hp())
         position = str(model.get_position())
         gold = str(model.get_gold())
+
         return "Player hp: {}<br>Current position: {}<br>Player's gold: {}".format(
             hp, position, gold)
-# class ChestContent(CanvasGrid):
+
-#     def render(self,model):
-#         grid_state = defaultdict(list)
-#         portrayal = self.chest_content(agent)
-#         portrayal["x"] = 0
-#         portrayal["y"] = 0
-#         grid_state[portrayal["Layer"]].append(portrayal)
-#         return
-# class FightStats(TextElement):
-#     def render(self, model):
-#         if model.player.combat:
-#             return model.player.describe_situation(model.player.opponent, model.player.strategy)
-#         else:
-#             return "Not fighting"
-ga.create_model()
 server = ModularServer(GameMap,
-                       [grid,Stats()],
+                       [grid, MyTextElement()],
                        "Map",
                        {"x": 10, "y": 10})
 server.port = 8081

src/agent/ga_chromosome.py

@@ -1,215 +0,0 @@
-import numpy.random
-import random
-import pandas as pd
-import os
-import rpy2.robjects as robjects
-from rpy2.robjects.packages import importr
-from rpy2.robjects import pandas2ri
-from rpy2.robjects.conversion import localconverter
-from rpy2.robjects.packages import importr
-from src.nominalize import nominalize
-from src.decisiontree import create_model
-MAX_COMBAT_TIME = 20
-attack_types=["MELEE", "RANGED","MAGIC"]
-class EnemyStats:
-    def __init__(self):
-        self.strength = random.randint(1, 7)
-        self.agility = random.randint(1, 7)
-        self.wisdom = random.randint(1, 7)
-        self.max_health = random.randint(5, 30)
-        self.health=self.max_health
-        self.melee_wep_damage = 1
-        self.ranged_wep_damage = 1
-        self.magic_wep_damage = 2
-        self.armor_defence = 0
-        self.armor_magic_protection = 1
-        self.attack_type=random.choice(attack_types)
-
-    def meleeAttack(self, opponent):
-        attackValue = self.strength + random.randint(1, 6)
-        defenseValue = opponent.strength + opponent.armor_defence
-        damage = attackValue - defenseValue
-        if damage > 0:
-            opponent.health -= (damage + self.melee_wep_damage)
-
-    def rangeAttack(self, opponent):
-        attackValue = self.agility + random.randint(1, 6)
-        defenseValue = opponent.agility
-        damage = attackValue - defenseValue
-        if (damage > 0) and (damage + self.ranged_wep_damage - opponent.armor_defence > 0):
-            opponent.health -= (damage + self.ranged_wep_damage - opponent.armor_defence)
-
-    def magicAttack(self, opponent):
-        attackValue = self.wisdom + random.randint(1, 6)
-        defenseValue = opponent.wisdom
-        damage = attackValue - defenseValue
-        if (damage > 0) and (damage + self.magic_wep_damage - opponent.armor_magic_protection > 0):
-            opponent.health -= (damage + self.magic_wep_damage - opponent.armor_magic_protection)
-
-    def reset(self):
-        self.health = self.max_health
-
-def try_combat(my_seed, p, e, player_att_type, enemy_att_type):
-    random.seed(my_seed)
-    current_iteration = 0
-    while True:
-        if player_att_type == 0:
-            p.meleeAttack(e)
-        elif player_att_type == 1:
-            p.rangeAttack(e)
-        else:
-            p.magicAttack(e)
-
-        if e.health<=0:
-            return p.health
-
-        if enemy_att_type == 0:
-            e.meleeAttack(p)
-        elif enemy_att_type == 1:
-            e.rangeAttack(p)
-        else:
-            e.magicAttack(p)
-
-        if p.health<=0:
-            return 0
-
-        current_iteration += 1
-        if current_iteration >= MAX_COMBAT_TIME:
-            return 0
-    p.reset()
-    e.reset()
-
-class PlayerStats(EnemyStats):
-    def __init__(self, s, a, w):
-        self.strength = 1+s
-        self.agility = 1+a
-        self.wisdom = 1+w
-        self.max_health = 50
-        self.health = 50
-        self.melee_wep_damage = 1
-        self.ranged_wep_damage = 1
-        self.magic_wep_damage = 2
-        self.armor_defence = 0
-        self.armor_magic_protection = 0
-
-    def predict_strategy(self, opponent):
-        testcase = pd.DataFrame({'p_strength': nominalize(self.strength,7),
-                         'p_agility':nominalize(self.agility, 7),
-                         'p_wisdom':nominalize(self.wisdom,7),
-                         'p_health':nominalize(self.health,50),
-                         'p_melee_damage':nominalize(self.melee_wep_damage, 10),
-                         'p_ranged_damage':nominalize(self.ranged_wep_damage,10),
-                         'p_magic_damage':nominalize(self.magic_wep_damage,10),
-                         'p_armor_defence':nominalize(self.armor_defence,5),
-                         'p_armor_magic_protection':nominalize(self.armor_magic_protection,5),
-                         'e_strength':nominalize(opponent.strength, 10),
-                         'e_agility':nominalize(opponent.agility, 10),
-                         'e_wisdom':nominalize(opponent.wisdom,10),
-                         'e_health':nominalize(opponent.health, 50),
-                         'e_damage':nominalize(opponent.melee_wep_damage,10),
-                         'e_armor_defence':nominalize(opponent.armor_defence, 5),
-                         'e_armor_magic_protection':nominalize(opponent.armor_magic_protection, 5),
-                         'e_attack_type':opponent.attack_type.upper(),
-                         'strategy':"PASS"}, index=[1])
-        with localconverter(robjects.default_converter + pandas2ri.converter):
-            r_dataframe = robjects.conversion.py2rpy(testcase)
-            robjects.globalenv['r_dataframe']=r_dataframe
-            result=robjects.r('predict(fights.id3, r_dataframe)')
-            return result[0]
-
-def fitness_function(chromosome):
-    s=chromosome.count(1)
-    a=chromosome.count(2)
-    w=chromosome.count(3)
-    p=PlayerStats(s, a, w)
-    # wins=[0,0,0]
-    # current_seed=os.urandom(16)
-    # for i in range(3):
-    #     random.seed(current_seed)
-    #     while p.health>0:
-    #         e=EnemyStats()
-    #         try_combat(current_seed, p, e, i, e.attack_type) #walka iles razy
-    #         if p.health>0:
-    #             wins[i]+=1
-    #     p.reset()
-    # return max(wins)
-    wins=0
-    while p.health > 0:
-        e=EnemyStats()
-        player_attack=p.predict_strategy(e)
-        try_combat(os.urandom(16), p, e, attack_types.index(player_attack), attack_types.index(e.attack_type)) #walka iles razy
-        if p.health>0:
-            wins+=1
-    return wins
-
-# tournament selection
-def selection(pop, scores, k=3):
-    # first random selection
-    selection_ix = numpy.random.randint(len(pop))
-    for ix in numpy.random.randint(0, len(pop), k-1):
-        # check if better (e.g. perform a tournament)
-        if scores[ix] > scores[selection_ix]:
-            selection_ix = ix
-    return pop[selection_ix]
-
-# crossover two parents to create two children
-def crossover(p1, p2, r_cross):
-    # children are copies of parents by default
-    c1, c2 = p1.copy(), p2.copy()
-    # check for recombination
-    if numpy.random.rand() < r_cross:
-        # select crossover point that is not on the end of the string
-        pt = numpy.random.randint(1, len(p1)-2)
-        # perform crossover
-        c1 = p1[:pt] + p2[pt:]
-        c2 = p2[:pt] + p1[pt:]
-    return [c1, c2]
-# mutation operator
-def mutation(bitstring, r_mut):
-    for i in range(len(bitstring)):
-        # check for a mutation
-        if numpy.random.rand() < r_mut:
-            # flip the bit
-            bitstring[i] = random.randint(1,4)
-# genetic algorithm
-
-def genetic_algorithm(objective, n_bits, n_iter, n_pop, r_cross, r_mut):
-    # initial population of random bitstring
-    pop = [numpy.random.randint(1, 3, n_bits).tolist() for _ in range(n_pop)]  # tworzy sie lista n_pop list szesciocyfrowych
-    # keep track of best solution
-    best, best_eval = 0, objective(pop[0])
-    # enumerate generations
-    for gen in range(n_iter):
-        # evaluate all candidates in the population
-        scores = [objective(c) for c in pop]
-        # check for new best solution
-        for i in range(n_pop):
-            if scores[i] > best_eval:
-                best, best_eval = pop[i], scores[i]
-                print(">%d, new best f(%s) = %d" % (gen,  pop[i], scores[i]))
-        # select parents
-        selected = [selection(pop, scores) for _ in range(n_pop)]
-        # create the next generation
-        children = list()
-        for i in range(0, n_pop, 2):
-            # get selected parents in pairs
-            p1, p2 = selected[i], selected[i+1]
-            # crossover and mutation
-            for c in crossover(p1, p2, r_cross):
-                # mutation
-                mutation(c, r_mut)
-                # store for next generation
-                children.append(c)
-        # replace population
-        pop = children
-    return [best, best_eval]
-# define the total iterations
-n_iter = 10
-# bits
-n_bits = 6
-# define the population size
-n_pop = 20
-# crossover rate
-r_cross = 0.9
-# mutation rate
-r_mut = 0.05

src/agent/hero.py

@@ -1,29 +1,12 @@
 import random
-import pandas as pd
+
-import rpy2.robjects as robjects
-from rpy2.robjects.packages import importr
-from rpy2.robjects import pandas2ri
-from rpy2.robjects.conversion import localconverter
-from rpy2.robjects.packages import importr
 from src.agent.model import *
 from src.agent.state import AgentState
 from src.direction import Direction
-from src.items.armory import WM9
 from src.treesearch.actionsInterpreter import ActionInterpreter
 from src.agent.model.dice.dice import roll_the_dice
 from src.treesearch.bfs import BFS
-from src.nominalize import nominalize
-import matplotlib.pyplot as plt
-import numpy as np
-import os
-import PIL
-import tensorflow as tf
 
-from tensorflow import keras
-from tensorflow.keras import layers
-from tensorflow.keras.models import Sequential
-
-import pathlib
 
 class Player(Creature):
     def __init__(self, unique_id, model, n, s, a, w, max_hp, hp, weapon, arm, g, w2, w3, list_of_chests):
@@ -48,214 +31,92 @@ class Player(Creature):
         self.opened_chests = 0
         self.__listOfChests = list_of_chests
         self.__actionsCollection = []
-        self.combat=False
-        self.opponent=None
-        self.strategy="PASS"
-
-    def identify_content(self, chest):
-        dataset_url = "https://drive.google.com/uc?export=download&id=1b6w1FbupRmgVC-q9Lpdlg5OBK_gRKEUy"
-        data_dir = tf.keras.utils.get_file(fname='loot', origin=dataset_url, untar=True)
-        data_dir = pathlib.Path(data_dir)
-
-        #image_count = len(list(data_dir.glob('*/*.jpg')))
-        #print(image_count)
-
-        batch_size = 32
-        img_height = 180
-        img_width = 180
-
-        train_ds = tf.keras.preprocessing.image_dataset_from_directory(
-            data_dir,
-            validation_split=0.2,
-            subset="training",
-            seed=123,
-            image_size=(img_height, img_width),
-            batch_size=batch_size)
-
-        val_ds = tf.keras.preprocessing.image_dataset_from_directory(
-            data_dir,
-            validation_split=0.2,
-            subset="validation",
-            seed=123,
-            image_size=(img_height, img_width),
-            batch_size=batch_size)
-
-        class_names = train_ds.class_names
-        #print(class_names)
-
-        normalization_layer = layers.experimental.preprocessing.Rescaling(1. / 255)
-
-        normalized_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))
-        image_batch, labels_batch = next(iter(normalized_ds))
-        first_image = image_batch[0]
-        # Notice the pixels values are now in `[0,1]`.
-        #print(np.min(first_image), np.max(first_image))
-
-        #num_classes = 3
-
-        # Recreate the exact same model, including its weights and the optimizer
-        new_model = tf.keras.models.load_model('nn_model.h5')
-
-        # Show the model architecture
-        #new_model.summary()
-
-        # loss, acc = new_model.evaluate(test_images, test_labels, verbose=2)
-        # print('Restored model, accuracy: {:5.2f}%'.format(100 * acc))
-
-        object_url = chest.type
-        object_path = tf.keras.utils.get_file(chest.file_name, origin=object_url)
-
-        img = keras.preprocessing.image.load_img(
-            object_path, target_size=(img_height, img_width)
-        )
-        img_array = keras.preprocessing.image.img_to_array(img)
-        img_array = tf.expand_dims(img_array, 0)  # Create a batch
-
-        predictions = new_model.predict(img_array)
-        score = tf.nn.softmax(predictions[0])
-
-        print(
-            "This image most likely belongs to {} with a {:.2f} percent confidence."
-                .format(class_names[np.argmax(score)], 100 * np.max(score))
-        )
-
-        return class_names[np.argmax(score)]
-
-    def predict_strategy(self, opponent):
-        testcase = pd.DataFrame({'p_strength': nominalize(self.get_strength(),10),
-                         'p_agility':nominalize(self.get_agility(), 10),
-                         'p_wisdom':nominalize(self.get_wisdom(),10),
-                         'p_health':nominalize(self.get_health(),50),
-                         'p_melee_damage':nominalize(self.get_melee_damage(), 10),
-                         'p_ranged_damage':nominalize(self.get_ranged_damage(),10),
-                         'p_magic_damage':nominalize(self.get_magic_damage(),10),
-                         'p_armor_defence':nominalize(self.get_armor_defence(),5),
-                         'p_armor_magic_protection':nominalize(self.get_armor_magic_protection(),5),
-                         'e_strength':nominalize(opponent.get_strength(), 10),
-                         'e_agility':nominalize(opponent.get_agility(), 10),
-                         'e_wisdom':nominalize(opponent.get_wisdom(),10),
-                         'e_health':nominalize(opponent.get_health(), 50),
-                         'e_damage':nominalize(opponent.get_damage(),10),
-                         'e_armor_defence':nominalize(opponent.get_armor_defence(), 5),
-                         'e_armor_magic_protection':nominalize(opponent.get_armor_magic_protection(), 5),
-                         'e_attack_type':opponent.get_attack_type().upper(),
-                         'strategy':"PASS"}, index=[1])
-        with localconverter(robjects.default_converter + pandas2ri.converter):
-            r_dataframe = robjects.conversion.py2rpy(testcase)
-            robjects.globalenv['r_dataframe']=r_dataframe
-            print(r_dataframe)
-            result=robjects.r('predict(fights.id3, r_dataframe)')
-            print(result)
-            return result[0]
-    def describe_situation(self, opponent):
-        situation = {# 'p_strength': self.get_strength(),
-                                    #  'p_agility': self.get_agility(),
-                                    #  'p_wisdom': self.get_wisdom(),
-                                    #  'p_health': self.get_health(),
-                                    #  'p_melee_damage': self.get_melee_damage(),
-                                    #  'p_ranged_damage': self.get_ranged_damage(),
-                                    #  'p_magic_damage': self.get_magic_damage(),
-                                    #  'p_armor_defence': self.get_armor_defence(),
-                                    #  'p_armor_magic_protection': self.get_armor_magic_protection(),
-                                     'e_strength': opponent.get_strength(),
-                                     'e_agility': opponent.get_agility(),
-                                     'e_wisdom': opponent.get_wisdom(),
-                                     'e_health': opponent.get_health(),
-                                     'e_damage': opponent.get_damage(),
-                                     'e_armor_defence': opponent.get_armor_defence(),
-                                     'e_armor_magic_protection': opponent.get_armor_magic_protection(),
-                                     'e_attack_type': opponent.get_attack_type().upper()}
-        return situation
 
     def melee_attack(self, opponent):
         attack_value = self.strength + roll_the_dice(6)
-        defense_value = opponent.strength + opponent.armor.get_defence()
+        defense_value = opponent.strength + opponent.armor.defence
         damage = attack_value - defense_value
         if damage > 0:
-            opponent.health = opponent.health - (damage + self.weapon1.get_damage())
+            opponent.health = opponent.health - (damage + self.weapon1.damage)
-            print("damage done by the player: ", damage)
 
     def range_attack(self, opponent):
         attack_value = self.agility + roll_the_dice(6)
         defense_value = opponent.agility
         damage = attack_value - defense_value
-        if (damage > 0) and (damage + self.weapon2.get_damage() - opponent.armor.get_defence() > 0):
+        if (damage > 0) and (damage + self.weapon2.damage - opponent.armor.defence > 0):
-            opponent.health = opponent.health - (damage + self.weapon2.get_damage() - opponent.armor.get_defence())
+            opponent.health = opponent.health - (damage + self.weapon2.damage - opponent.armor.defence)
-            print("damage done by the player: ", damage)
 
     def magic_attack(self, opponent):
         attack_value = self.wisdom + roll_the_dice(6)
         defense_value = opponent.wisdom
         damage = attack_value - defense_value
-        if (damage > 0) and (damage + self.weapon3.get_damage() - opponent.armor.get_mag_protection() > 0):
+        if (damage > 0) and (damage + self.weapon3.damage - opponent.armor.mag_protection > 0):
-            opponent.health = opponent.health - (damage + self.weapon3.get_damage() - opponent.armor.get_mag_protection())
+            opponent.health = opponent.health - (damage + self.weapon3.damage - opponent.armor.mag_protection)
-            print("damage done by the player: ", damage)
 
-    def fight_or_flight(self, opponent, strategy):
+    def fight_or_flight(self, opponent):
-        self.combat = True
+        combat = True
-        while self.combat:
+        while combat:
-            if strategy=="MELEE":
+            choice = roll_the_dice(4)
+            print("roll_the_dice rolled:", choice)
+            if choice == 1:
+                running_speed = self.agility + roll_the_dice(6)
+                opponent_speed = opponent.agility + roll_the_dice(6)
+                if running_speed > opponent_speed:
+                    combat = False
+                    print("Player ran away")
+                    self.step()
+                else:
+                    opponent.default_attack(self)
+                    if self.health <= 0:
+                        combat = False
+                        print("Player died :/")
+            elif choice == 2:
                 self.melee_attack(opponent)
                 if opponent.health > 0:
                     opponent.default_attack(self)
                     if self.health <= 0:
-                        self.combat = False
+                        combat = False
                         print("Player died :/")
                 else:
-                    self.combat = False
+                    combat = False
                     self.gold = self.gold + opponent.gold
                     opponent.gold = 0
                     opponent.model.grid.remove_agent(opponent)
                     print("Fight won")
-            elif strategy=="RANGED":
+            elif choice == 3:
                 self.range_attack(opponent)
                 if opponent.health > 0:
                     opponent.default_attack(self)
                     if self.health <= 0:
-                        self.combat = False
+                        combat = False
                         print("Player died :/")
                 else:
-                    self.combat = False
+                    combat = False
                     self.gold = self.gold + opponent.gold
                     opponent.gold = 0
                     opponent.model.grid.remove_agent(opponent)
                     print("Fight won")
-            elif strategy=='MAGIC':
+            else:
                 self.magic_attack(opponent)
                 if opponent.health > 0:
                     opponent.default_attack(self)
                     if self.health <= 0:
-                        self.combat = False
+                        combat = False
                         print("Player died :/")
                 else:
-                    self.combat = False
+                    combat = False
                     self.gold = self.gold + opponent.gold
                     opponent.gold = 0
                     opponent.model.grid.remove_agent(opponent)
                     print("Fight won")
-            else:
-                running_speed = self.agility + roll_the_dice(6)
-                opponent_speed = opponent.agility + roll_the_dice(6)
-                if running_speed > opponent_speed:
-                    self.combat = False
-                    print("Player ran away")
-                    self.step()
-                else:
-                    print("Player was too slow to run away")
-                    opponent.default_attack(self)
-                    if self.health <= 0:
-                        self.combat = False
-                        print("Player died :/")
 
     def open_chest(self, chest):
-        if chest.type == 1:
+        self.gold = self.gold + chest.gold
-            ch_gold = 3 * roll_the_dice(6)
+        print("------Chest opened. Gold inside:", chest.gold, "-----")
-            self.gold = self.gold + ch_gold
+        chest.gold = 0
-            print("------Chest opened. Gold inside:", ch_gold, "-----")
+        self.opened_chests += 1
-        elif chest.type == 2:
+        self.has_goal_chest = False
-            self.weapon1 = WM9
+        chest.model.grid.remove_agent(chest)
-        else:
-            self.health = 0
         # self.direction = 0  # po osiągnięciu jednego celu 'restartuje sie' na szukanie ścieżki do kolejnego -- NIE ZEROWAĆ OBROTU - to psuje goldState w bfs!!!
         # if isinstance(chest.loot,Armor):
         #     buffer = self.armor
@@ -323,28 +184,17 @@ class Player(Creature):
                 self.model.grid.move_agent(self, (new_state.get_x(), new_state.get_y()))
                 self.direction = new_state.get_direction()
 
-                #print("moved to - ", [new_state.get_x(), new_state.get_y()])
+                print("moved to - ", [new_state.get_x(), new_state.get_y()])
 
             cellmates = self.model.grid.get_cell_list_contents([self.pos])
             if len(cellmates) > 1:
                 if isinstance(cellmates[0], Box):
-                    decision = self.identify_content(cellmates[0])
-                    print("Content of chest: "+cellmates[0].address)
-                    if (decision == 'coins') or (decision == 'weapons'):
-                        print("I will open this chest!")
                     self.open_chest(cellmates[0])
-                        print("Type of opened chest: ", cellmates[0].type)
                 else:
-                        print("Probably a trap - chest skipped!")
+                    opponent = cellmates[0]
-                        print("Type of skipped chest: ", cellmates[0].type)
+                    print("Fighting")
-                    self.opened_chests += 1
+                    self.fight_or_flight(opponent)
-                    self.has_goal_chest = False
+            # print("HP: " + str(self.health) + " / " + str(self.maxHealth))
-                    cellmates[0].model.grid.remove_agent(cellmates[0])
+            print("Gold: " + str(self.gold))
-                else:
-                    self.opponent = cellmates[0]
-                    self.strategy=self.predict_strategy(self.opponent)
-                    print("Current enemy stats:\n", self.describe_situation(self.opponent))
-                    print("Strategy returned from the tree: ", self.strategy)
-                    self.fight_or_flight(self.opponent, self.strategy)
         else:
             print("HP: 0 / " + str(self.maxHealth))

src/agent/map/gameMap.py

@@ -1,6 +1,6 @@
 from mesa import Model
 from mesa.datacollection import DataCollector
-import src.agent.ga_chromosome as ga
+
 from src.agent.hero import Player
 
 from src.agent.model.dice.dice import roll_the_dice
@@ -8,19 +8,18 @@ from src.agent.model.creature import Creature
 
 from src.agent.model.box import Box
 
-from src.items.armory import *#WM1, A1, WR1, S1, WM2, A2
+from src.items.armory import WM1, A1, WR1, S1, WM2, A2
 from mesa.time import RandomActivation
 from mesa.space import MultiGrid
 
-import random
-
 # from mesa.datacollection import DataCollector
 
 x = 10
 y = 10
 step_counter = 0
-boxes_number = 6
+boxes_number = 4
-creatures_number = 35
+creatures_number = 5
+
 
 class GameMap(Model):
     def __init__(self, x, y):
@@ -30,20 +29,15 @@ class GameMap(Model):
         self.boxes_number = boxes_number
         self.creatures_number = creatures_number
         self.running = True
-        best, score = ga.genetic_algorithm(ga.fitness_function, ga.n_bits, ga.n_iter, ga.n_pop, ga.r_cross, ga.r_mut)
+        # player = Player(1000, self)
-        s=1+best.count(1)
+        self.player = Player(1000, self, "Janusz", 3, 3, 3, 20, 20, WM1, A1, 0, WR1, S1, self.listOfChests)
-        a=1+best.count(2)
-        w=1+best.count(3)
-        print("player optimised stats:", s, a, w)
-        self.player = Player(1000, self, "Janusz", s, a, w, 50, 50, WM1, A1, 0, WR1, S1, self.listOfChests)
-        print('Player stats:',self.player.strength, self.player.agility, self.player.wisdom)
         self.schedule.add(self.player)
         x = self.random.randrange(self.grid.width)
         y = self.random.randrange(self.grid.height)
         self.grid.place_agent(self.player, (x, y))
+
         for i in range(self.boxes_number):
-            r_type = random.randrange(1, 4)
+            box = Box(i, self)
-            box = Box(i, self, r_type)
             x = self.random.randrange(self.grid.width)
             y = self.random.randrange(self.grid.height)
             if self.grid.is_cell_empty((x, y)):
@@ -54,12 +48,9 @@ class GameMap(Model):
                 pass
 
         for i in range(self.boxes_number,
-                       self.boxes_number + self.creatures_number-20):  # taki range, żeby każdy agent miał poprawne unique_id
+                       self.boxes_number + self.creatures_number):  # taki range, żeby każdy agent miał poprawne unique_id
             # creature = Creature(i, self)
-            creature = Creature(i, self, "Goblin",
+            creature = Creature(i, self, "Goblin", 1, 1, 1, 1, 1, WM2, A2, roll_the_dice(6))
-                                roll_the_dice(3), roll_the_dice(3), roll_the_dice(3), 15, roll_the_dice(3),
-                                WM2, A2, roll_the_dice(5))
-
             x = self.random.randrange(self.grid.width)
             y = self.random.randrange(self.grid.height)
             if self.grid.is_cell_empty((x, y)):
@@ -67,19 +58,8 @@ class GameMap(Model):
                 self.schedule.add(creature)
             else:
                 pass
-        for i in range(self.boxes_number + self.creatures_number-20, self.creatures_number):  # taki range, żeby każdy agent miał poprawne unique_id
-            creature = Creature(i, self, "Skeleton",
-                                roll_the_dice(7), roll_the_dice(7), roll_the_dice(7), 15, roll_the_dice(7),
-                                WR4, A8, roll_the_dice(10))
 
-            x = self.random.randrange(self.grid.width)
+        self.datacollector=DataCollector(model_reporters={"HP":self.player.health, "Gold":self.player.gold, "Position (x, y)":self.player.pos}) #informacje o stanie planszy, pozycja agenta
-            y = self.random.randrange(self.grid.height)
-            if self.grid.is_cell_empty((x, y)):
-                self.grid.place_agent(creature, (x, y))
-                self.schedule.add(creature)
-            else:
-                pass
-        #self.datacollector=DataCollector(model_reporters={"HP":self.player.health, "Gold":self.player.gold, "Position (x, y)":self.player.pos}) #informacje o stanie planszy, pozycja agenta
 #other data: position, strength & other parameters
     def get_list_of_chests(self):
         return self.listOfChests
@@ -93,5 +73,5 @@ class GameMap(Model):
 
     def step(self):
         self.schedule.step()
-        #self.datacollector.collect(self)
+        self.datacollector.collect(self)
         #print(str(self.datacollector.model_reporters))

src/agent/model/box.py

@@ -1,42 +1,14 @@
 from mesa import Agent
-import random
+from .dice.dice import roll_the_dice
-#from .dice.dice import roll_the_dice
 
-golds = [("https://drive.google.com/uc?export=download&id=1fWeew0jXZ1lZBmv6CG5viLGloJAex6ao",'moneta'),
-         ("https://drive.google.com/uc?export=download&id=1UrXbbfJhfCuDZSnxund7sVk40QMS3R2Q", 'moneta2'),
-         ("https://drive.google.com/uc?export=download&id=1qH0OP4X1NQqpHtUkwD8SryJtKCKcZzVe", 'moneta3'),
-         ("https://drive.google.com/uc?export=download&id=1b9tZf639mEWgiWq_EYyqjeKYPEMi7dX9", 'moneta4'),
-         ("https://drive.google.com/uc?export=download&id=1z9jt-j3aS1fRUgVA_t1zR7TS5QzuXW5b", 'moneta5')]
-weapons = [("https://drive.google.com/uc?export=download&id=1TA-ObC33FaiHmgQ6i71Kcb32VrHsKUd1", 'miecz'),
-           ("https://drive.google.com/uc?export=download&id=1oyv15FSPJ84xx1tQLJW8Wlbb1JUx2xCy", 'miecz2'),
-           ("https://drive.google.com/uc?export=download&id=1Ha0eeLRLcidrMAN1P59V9zB8uSQq3GM5", 'miecz3'),
-           ("https://drive.google.com/uc?export=download&id=1GetUWnglUtqWqcK4sd5HsdVuaUpU5Ec_", 'miecz4'),
-           ("https://drive.google.com/uc?export=download&id=1RImo84OykYICvwfLycDEb5tr4tPbGVy1", 'miecz5')]
-traps = [("https://drive.google.com/uc?export=download&id=1G-AxY712V-eT2ylW0VXn4o2V_4pvy7lz", 'kwiat'),
-         ("https://drive.google.com/uc?export=download&id=1i7MwzJRPBZ-KrCDqhT5RCXLstLlWCsx9", 'kwiat2'),
-         ("https://drive.google.com/uc?export=download&id=1zF7wQuG1gtQ796m6TM08FOUOVK8s_qhT", 'kwiat3'),
-         ("https://drive.google.com/uc?export=download&id=1qwrIThsoKg44b57JXvbXe--TIplacd-i", 'kwiat4'),
-         ("https://drive.google.com/uc?export=download&id=1YsqdQaLyD8Es4w09p4Zdw2CufNkl_avN", 'kwiat5')]
 
 class Box(Agent):
-    def __init__(self, unique_id,  model, type):
+    def __init__(self, unique_id, model):
         super().__init__(unique_id, model)
-        #self.gold = 3 * roll_the_dice(6)
+        self.gold = 3 * roll_the_dice(6)
         self.isBox = True
         self.isCreature = False
         self.isPlayer = False
-        self.type = type
-        r_img = random.randrange(0,4)
-        if type == 1:
-            self.address = golds[r_img][0]
-            self.file_name = golds[r_img][1]
-        elif type == 2:
-            self.address = weapons[r_img][0]
-            self.file_name = weapons[r_img][1]
-        else:
-            self.address = traps[r_img][0]
-            self.file_name = traps[r_img][1]
 
     def step(self):
         pass
-

src/agent/model/creature.py

@@ -18,63 +18,31 @@ class Creature(Agent):
         self.isCreature = True
         self.isPlayer = False
 
-    def get_strength(self):
-        return self.strength
-
-    def get_agility(self):
-        return self.agility
-
-    def get_wisdom(self):
-        return self.wisdom
-
-    def get_health(self):
-        return self.health
-
-    def get_damage(self):
-        return self.weapon1.get_damage()
-
-    def get_melee_damage(self):
-        return self.weapon1.get_damage()
-
-    def get_ranged_damage(self):
-        return self.weapon2.get_damage()
-
-    def get_magic_damage(self):
-        return self.weapon3.get_damage()
-
-    def get_armor_defence(self):
-        return self.armor.get_defence()
-
-    def get_armor_magic_protection(self):
-        return self.armor.get_mag_protection()
-
-    def get_attack_type(self):
-        return self.weapon1.get_type()
     def melee_attack(self, opponent):
         attack_value = self.strength + roll_the_dice(6)
-        defense_value = opponent.strength + opponent.armor.get_defence()
+        defense_value = opponent.strength + opponent.armor.defence
         damage = attack_value - defense_value
         if damage > 0:
-            opponent.health = opponent.health - (damage + self.weapon1.get_damage())
+            opponent.health = opponent.health - (damage + self.weapon1.damage)
-            print("damage done by the monster: ", damage)
+
     def range_attack(self, opponent):
         attack_value = self.agility + roll_the_dice(6)
         defense_value = opponent.agility
         damage = attack_value - defense_value
-        if (damage > 0) and (damage + self.weapon1.get_damage() - opponent.armor.get_defence() > 0):
+        if (damage > 0) and (damage + self.weapon1.damage - opponent.armor.defence > 0):
-            opponent.health = opponent.health - (damage + self.weapon1.get_damage() - opponent.armor.get_defence())
+            opponent.health = opponent.health - (damage + self.weapon1.damage - opponent.armor.defence)
-            print("damage done by the monster: ", damage)
+
     def magic_attack(self, opponent):
         attack_value = self.wisdom + roll_the_dice(6)
         defense_value = opponent.wisdom
         damage = attack_value - defense_value
-        if (damage > 0) and (damage + self.weapon1.get_damage() - opponent.armor.get_mag_protection() > 0):
+        if (damage > 0) and (damage + self.weapon1.damage - opponent.armor.mag_protection > 0):
-            opponent.health = opponent.health - (damage + self.weapon1.get_damage() - opponent.armor.get_mag_protection())
+            opponent.health = opponent.health - (damage + self.weapon1.damage - opponent.armor.mag_protection)
-            print("damage done by the monster: ", damage)
+
     def default_attack(self, opponent):
-        if self.weapon1.get_type() == "Meele":
+        if self.weapon1.type == "Meele":
             self.melee_attack(opponent)
-        elif self.weapon1.get_type() == "Ranged":
+        elif self.weapon1.type == "Range":
             self.range_attack(opponent)
         else:
             self.magic_attack(opponent)

src/decisiontree.py

@@ -1,20 +0,0 @@
-import rpy2.robjects as robjects
-from rpy2.robjects.packages import importr
-import pickle
-
-def create_model():
-    RWeka = importr('RWeka')
-    robjects.r('WPM("refresh-cache")')
-    robjects.r('WPM("install-package", "simpleEducationalLearningSchemes")')
-    robjects.r('WPM("load-package", "simpleEducationalLearningSchemes")')
-    robjects.r('ID3<-make_Weka_classifier("weka/classifiers/trees/Id3")')
-    robjects.r('fights<-read.arff("C:/Users/X260/Downloads/currentdata.arff")')
-    robjects.r('fights.id3 <- ID3(strategy ~ p_strength + p_agility + p_wisdom+ p_health + '
-               'p_melee_damage + p_ranged_damage + p_magic_damage + p_armor_defence + p_armor_magic_protection + '
-               'e_strength+ e_agility + e_wisdom + e_health + e_damage + e_armor_defence + e_armor_magic_protection + '
-               'e_attack_type, data = fights)')
-    # robjects.r('.jcache(fights.id3)')
-    #robjects.r('save(fights.id3, file="tree.rda)')
-    # with open('tree.rda','wb') as f:
-    #     pickle.dump(robjects.r('fights.id3'), f)
-    #todo: zapisać w rpythonie do pliku, raz zrobić i nie odpalać za każdym razem w serverze

src/items/armory.py

@@ -14,16 +14,16 @@ WM10 = Weapon("Axe", "Melee", 3)
 WM11 = Weapon("Axe", "Melee", 3)
 WM12 = Weapon("Battle axe", "Melee", 4)
 
-WR1 = Weapon("Sling", "Ranged", 1)
+WR1 = Weapon("Sling", "Range", 1)
-WR2 = Weapon("Sling", "Ranged", 1)
+WR2 = Weapon("Sling", "Range", 1)
-WR3 = Weapon("Sling", "Ranged", 1)
+WR3 = Weapon("Sling", "Range", 1)
-WR4 = Weapon("Bow", "Ranged", 2)
+WR4 = Weapon("Bow", "Range", 2)
-WR5 = Weapon("Bow", "Ranged", 2)
+WR5 = Weapon("Bow", "Range", 2)
-WR6 = Weapon("Bow", "Ranged", 2)
+WR6 = Weapon("Bow", "Range", 2)
-WR7 = Weapon("Bow", "Ranged", 2)
+WR7 = Weapon("Bow", "Range", 2)
-WR8 = Weapon("Longbow", "Ranged", 3)
+WR8 = Weapon("Longbow", "Range", 3)
-WR9 = Weapon("Longbow", "Ranged", 3)
+WR9 = Weapon("Longbow", "Range", 3)
-WR10 = Weapon("Crossbow", "Ranged", 4)
+WR10 = Weapon("Crossbow", "Range", 4)
 
 S1 = Weapon("Push", "Magic", 2)
 S2 = Weapon("Push", "Magic", 2)
@@ -61,7 +61,7 @@ A16 = Armor("Magical Plate Armor", 3, 2)
 # C10 = Box(A8)
 # C11 = Box(A12)
 # C12 = Box(A14)
-#
+
 # Gracz = Player(1000, self, "Janusz",3,3,3,20,20,WM1,A1,0,WR1,S1)
 #    def __init__(self, unique_id, model, n, s, a, w, max_hp, hp, weapon, arm, g):
 # M1 = Creature("Goblin",2,2,1,10,10,WM2,A2,dice(6))

src/nominalize.py

@@ -1,9 +0,0 @@
-def nominalize(val, max_val):
-    return_value = "NONE"
-    if val > 0.66 * max_val:
-        return_value = "HIGH"
-    elif val > 0.33 * max_val:
-        return_value = "MEDIUM"
-    elif val > 0:
-        return_value = "LOW"
-    return return_value

src/treesearch/bfs.py

@@ -103,7 +103,7 @@ class BFS:
                         self.__agent.model.grid.get_cell_list_contents(
                             [(new_state[1].get_x(), new_state[1].get_y())])]):
                     if new_state[0] == 0:
-                        monster = 0
+                        monster = 10
                 p = manhattan(new_state[1], goal_state) + tmp_node.get_cost() + monster + 1
 
                 r = 0

tree_data_gen.py

@@ -1,192 +0,0 @@
-import random
-from os import urandom
-import statistics
-import csv
-
-
-def nominalizeOld(val, max_val):
-    return_value = "NONE"
-    if val > 0.8 * max_val:
-        return_value = "VERY_HIGH"
-    elif val > 0.6 * max_val:
-        return_value = "HIGH"
-    elif val > 0.4 * max_val:
-        return_value = "MEDIUM"
-    elif val > 0.2 * max_val:
-        return_value = "LOW"
-    elif val > 0:
-        return_value = "VERY_LOW"
-    return return_value
-
-def nominalize(val, max_val):
-    return_value = "NONE"
-    if val > 0.66 * max_val:
-        return_value = "HIGH"
-    elif val > 0.33 * max_val:
-        return_value = "MEDIUM"
-    elif val > 0:
-        return_value = "LOW"
-    return return_value
-
-
-class Stats:
-    def __init__(self):
-        self.strength = random.randint(1, 10)
-        self.agility = random.randint(1, 10)
-        self.wisdom = random.randint(1, 10)
-        self.health = random.randint(1, 50)
-        self.melee_wep_damage = random.randint(1, 10)
-        self.ranged_wep_damage = random.randint(1, 10)
-        self.magic_wep_damage = random.randint(1, 10)
-        self.armor_defence = random.randint(0, 5)
-        self.armor_magic_protection = random.randint(0, 5)
-
-        self.damage = 0
-
-
-    def meleeAttack(self, opponent):
-        attackValue = self.strength + random.randint(1, 6)
-        defenseValue = opponent.strength + opponent.armor_defence
-        damage = attackValue - defenseValue
-        if damage > 0:
-            opponent.damage += (damage + self.melee_wep_damage)
-
-    def rangeAttack(self, opponent):
-        attackValue = self.agility + random.randint(1, 6)
-        defenseValue = opponent.agility
-        damage = attackValue - defenseValue
-        if (damage > 0) and (damage + self.ranged_wep_damage - opponent.armor_defence > 0):
-            opponent.damage += (damage + self.ranged_wep_damage - opponent.armor_defence)
-
-    def magicAttack(self, opponent):
-        attackValue = self.wisdom + random.randint(1, 6)
-        defenseValue = opponent.wisdom
-        damage = attackValue - defenseValue
-        if (damage > 0) and (damage + self.magic_wep_damage - opponent.armor_magic_protection > 0):
-            opponent.damage += (damage + self.magic_wep_damage - opponent.armor_magic_protection)
-
-    def reset(self):
-        self.damage = 0
-
-
-FIELDNAMES = ["p_strength",
-              "p_agility",
-              "p_wisdom",
-              "p_health",
-              "p_melee_damage",
-              "p_ranged_damage",
-              "p_magic_damage",
-              "p_armor_defence",
-              "p_armor_magic_protection",
-              "e_strength",
-              "e_agility",
-              "e_wisdom",
-              "e_health",
-              "e_damage",
-              "e_armor_defence",
-              "e_armor_magic_protection",
-              "e_attack_type",
-              "strategy"]
-RESULT_FILE = open('data.csv', 'w', newline='')
-FILE_WRITER = csv.writer(RESULT_FILE, dialect='excel', delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL)
-FILE_WRITER.writerow(FIELDNAMES)
-
-
-SETUP_RESULTS = [[], [], []]
-
-MAX_COMBAT_TIME = 20
-
-def try_combat(my_seed, p, e, player_att_type, enemy_att_type):
-    random.seed(my_seed)
-    current_iteration = 0
-    while True:
-        if player_att_type == 0:
-            p.meleeAttack(e)
-        elif player_att_type == 1:
-            p.rangeAttack(e)
-        else:
-            p.magicAttack(e)
-
-        if e.damage >= e.health:
-            SETUP_RESULTS[player_att_type].append(p.health - p.damage)
-            break
-
-        if enemy_att_type == 0:
-            e.meleeAttack(p)
-        elif enemy_att_type == 1:
-            e.rangeAttack(p)
-        else:
-            e.magicAttack(p)
-
-        if p.damage >= p.health:
-            SETUP_RESULTS[player_att_type].append(0)
-            break
-
-        current_iteration += 1
-        if current_iteration >= MAX_COMBAT_TIME:
-            SETUP_RESULTS[player_att_type].append(0)
-            break
-
-    p.reset()
-    e.reset()
-
-for trial in range(10000):
-    stat_seed = urandom(16)
-    random.seed(stat_seed)
-
-    player = Stats()
-    enemy = Stats()
-    enemy_attack_type = random.randint(0, 2)  # Enemy weapon choice
-
-    for i in range(30):
-        combat_seed = urandom(16)
-        try_combat(combat_seed, player, enemy, 0, enemy_attack_type)
-        try_combat(combat_seed, player, enemy, 1, enemy_attack_type)
-        try_combat(combat_seed, player, enemy, 2, enemy_attack_type)
-
-    for i, series in enumerate(SETUP_RESULTS):
-        SETUP_RESULTS[i] = statistics.mean(series)
-
-    strategy = "PASS"
-    if any(SETUP_RESULTS):
-        max_index = SETUP_RESULTS.index(max(SETUP_RESULTS))
-        if max_index == 0:
-            strategy = "MELEE"
-        elif max_index == 1:
-            strategy = "RANGED"
-        elif max_index == 2:
-            strategy = "MAGIC"
-
-    enemy_damage = 0
-    if enemy_attack_type == 0:
-        enemy_attack_type = "MELEE"
-        enemy_damage = enemy.melee_wep_damage
-    elif enemy_attack_type == 1:
-        enemy_attack_type = "RANGED"
-        enemy_damage = enemy.ranged_wep_damage
-    elif enemy_attack_type == 2:
-        enemy_attack_type = "MAGIC"
-        enemy_damage = enemy.magic_wep_damage
-
-    FILE_WRITER.writerow([nominalize(player.strength, 10),
-                          nominalize(player.agility, 10),
-                          nominalize(player.wisdom, 10),
-                          nominalize(player.health, 50),
-                          nominalize(player.melee_wep_damage, 10),
-                          nominalize(player.ranged_wep_damage, 10),
-                          nominalize(player.magic_wep_damage, 10),
-                          nominalize(player.armor_defence, 5),
-                          nominalize(player.armor_magic_protection, 5),
-                          nominalize(enemy.strength, 10),
-                          nominalize(enemy.agility, 10),
-                          nominalize(enemy.wisdom, 10),
-                          nominalize(enemy.health, 50),
-                          nominalize(enemy_damage, 10),
-                          nominalize(enemy.armor_defence, 5),
-                          nominalize(enemy.armor_magic_protection, 5),
-                          enemy_attack_type,
-                          strategy])
-    SETUP_RESULTS = [[], [], []]
-    if trial%100 == 0:
-        print("Trials done: " + str(trial))
-