Compare commits

..

No commits in common. "master" and "jakfit-dev" have entirely different histories.

19 changed files with 100 additions and 6957 deletions

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

160
dt.py
View File

@ -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)

Binary file not shown.

View File

@ -2,62 +2,31 @@ from src.agent.map.gameMap import GameMap
from mesa.visualization.modules import CanvasGrid from mesa.visualization.modules import CanvasGrid
from mesa.visualization.modules.TextVisualization import TextElement from mesa.visualization.modules.TextVisualization import TextElement
from mesa.visualization.ModularVisualization import ModularServer 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): def player_representation(agent):
portrayal = {"Shape": "sprites/heroE.png", portrayal = {"Shape": "sprites/hero.png",
"Layer": 1} "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["Shape"] = "sprites/box.png"
portrayal["Layer"] = 0 portrayal["Layer"] = 0
elif agent.isCreature: elif agent.isCreature:
if agent.name=='Goblin': portrayal["Shape"] = 'sprites/goblin.png'
portrayal["Shape"] = 'sprites/goblin.png'
elif agent.name=='Skeleton':
portrayal["Shape"] = 'sprites/skeletonArcher.png'
return portrayal 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): def render(self, model):
hp = str(model.get_hp()) hp = str(model.get_hp())
position = str(model.get_position()) position = str(model.get_position())
gold = str(model.get_gold()) gold = str(model.get_gold())
return "Player hp: {}<br>Current position: {}<br>Player's gold: {}".format( return "Player hp: {}<br>Current position: {}<br>Player's gold: {}".format(
hp, position, gold) 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, server = ModularServer(GameMap,
[grid,Stats()], [grid, MyTextElement()],
"Map", "Map",
{"x": 10, "y": 10}) {"x": 10, "y": 10})
server.port = 8081 server.port = 8081

View File

Before

Width:  |  Height:  |  Size: 208 B

After

Width:  |  Height:  |  Size: 208 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 292 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 286 B

Binary file not shown.

Before

Width:  |  Height:  |  Size: 293 B

View File

@ -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

View File

@ -1,29 +1,12 @@
import random 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.model import *
from src.agent.state import AgentState from src.agent.state import AgentState
from src.direction import Direction from src.direction import Direction
from src.items.armory import WM9
from src.treesearch.actionsInterpreter import ActionInterpreter from src.treesearch.actionsInterpreter import ActionInterpreter
from src.agent.model.dice.dice import roll_the_dice from src.agent.model.dice.dice import roll_the_dice
from src.treesearch.bfs import BFS 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): class Player(Creature):
def __init__(self, unique_id, model, n, s, a, w, max_hp, hp, weapon, arm, g, w2, w3, list_of_chests): 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.opened_chests = 0
self.__listOfChests = list_of_chests self.__listOfChests = list_of_chests
self.__actionsCollection = [] 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): def melee_attack(self, opponent):
attack_value = self.strength + roll_the_dice(6) 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 damage = attack_value - defense_value
if damage > 0: 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): def range_attack(self, opponent):
attack_value = self.agility + roll_the_dice(6) attack_value = self.agility + roll_the_dice(6)
defense_value = opponent.agility defense_value = opponent.agility
damage = attack_value - defense_value 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): def magic_attack(self, opponent):
attack_value = self.wisdom + roll_the_dice(6) attack_value = self.wisdom + roll_the_dice(6)
defense_value = opponent.wisdom defense_value = opponent.wisdom
damage = attack_value - defense_value 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) self.melee_attack(opponent)
if opponent.health > 0: if opponent.health > 0:
opponent.default_attack(self) opponent.default_attack(self)
if self.health <= 0: if self.health <= 0:
self.combat = False combat = False
print("Player died :/") print("Player died :/")
else: else:
self.combat = False combat = False
self.gold = self.gold + opponent.gold self.gold = self.gold + opponent.gold
opponent.gold = 0 opponent.gold = 0
opponent.model.grid.remove_agent(opponent) opponent.model.grid.remove_agent(opponent)
print("Fight won") print("Fight won")
elif strategy=="RANGED": elif choice == 3:
self.range_attack(opponent) self.range_attack(opponent)
if opponent.health > 0: if opponent.health > 0:
opponent.default_attack(self) opponent.default_attack(self)
if self.health <= 0: if self.health <= 0:
self.combat = False combat = False
print("Player died :/") print("Player died :/")
else: 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':
self.magic_attack(opponent)
if opponent.health > 0:
opponent.default_attack(self)
if self.health <= 0:
self.combat = False
print("Player died :/")
else:
self.combat = False
self.gold = self.gold + opponent.gold self.gold = self.gold + opponent.gold
opponent.gold = 0 opponent.gold = 0
opponent.model.grid.remove_agent(opponent) opponent.model.grid.remove_agent(opponent)
print("Fight won") print("Fight won")
else: else:
running_speed = self.agility + roll_the_dice(6) self.magic_attack(opponent)
opponent_speed = opponent.agility + roll_the_dice(6) if opponent.health > 0:
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) opponent.default_attack(self)
if self.health <= 0: if self.health <= 0:
self.combat = False combat = False
print("Player died :/") print("Player died :/")
else:
combat = False
self.gold = self.gold + opponent.gold
opponent.gold = 0
opponent.model.grid.remove_agent(opponent)
print("Fight won")
def open_chest(self, chest): 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!!! # 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): # if isinstance(chest.loot,Armor):
# buffer = self.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.model.grid.move_agent(self, (new_state.get_x(), new_state.get_y()))
self.direction = new_state.get_direction() 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]) cellmates = self.model.grid.get_cell_list_contents([self.pos])
if len(cellmates) > 1: if len(cellmates) > 1:
if isinstance(cellmates[0], Box): if isinstance(cellmates[0], Box):
decision = self.identify_content(cellmates[0]) self.open_chest(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!")
print("Type of skipped chest: ", cellmates[0].type)
self.opened_chests += 1
self.has_goal_chest = False
cellmates[0].model.grid.remove_agent(cellmates[0])
else: else:
self.opponent = cellmates[0] opponent = cellmates[0]
self.strategy=self.predict_strategy(self.opponent) print("Fighting")
print("Current enemy stats:\n", self.describe_situation(self.opponent)) self.fight_or_flight(opponent)
print("Strategy returned from the tree: ", self.strategy) # print("HP: " + str(self.health) + " / " + str(self.maxHealth))
self.fight_or_flight(self.opponent, self.strategy) print("Gold: " + str(self.gold))
else: else:
print("HP: 0 / " + str(self.maxHealth)) print("HP: 0 / " + str(self.maxHealth))

View File

@ -1,6 +1,6 @@
from mesa import Model from mesa import Model
from mesa.datacollection import DataCollector from mesa.datacollection import DataCollector
import src.agent.ga_chromosome as ga
from src.agent.hero import Player from src.agent.hero import Player
from src.agent.model.dice.dice import roll_the_dice 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.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.time import RandomActivation
from mesa.space import MultiGrid from mesa.space import MultiGrid
import random
# from mesa.datacollection import DataCollector # from mesa.datacollection import DataCollector
x = 10 x = 10
y = 10 y = 10
step_counter = 0 step_counter = 0
boxes_number = 6 boxes_number = 4
creatures_number = 35 creatures_number = 5
class GameMap(Model): class GameMap(Model):
def __init__(self, x, y): def __init__(self, x, y):
@ -30,20 +29,15 @@ class GameMap(Model):
self.boxes_number = boxes_number self.boxes_number = boxes_number
self.creatures_number = creatures_number self.creatures_number = creatures_number
self.running = True 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) self.schedule.add(self.player)
x = self.random.randrange(self.grid.width) x = self.random.randrange(self.grid.width)
y = self.random.randrange(self.grid.height) y = self.random.randrange(self.grid.height)
self.grid.place_agent(self.player, (x, y)) self.grid.place_agent(self.player, (x, y))
for i in range(self.boxes_number): 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) x = self.random.randrange(self.grid.width)
y = self.random.randrange(self.grid.height) y = self.random.randrange(self.grid.height)
if self.grid.is_cell_empty((x, y)): if self.grid.is_cell_empty((x, y)):
@ -54,12 +48,9 @@ class GameMap(Model):
pass pass
for i in range(self.boxes_number, 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)
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) x = self.random.randrange(self.grid.width)
y = self.random.randrange(self.grid.height) y = self.random.randrange(self.grid.height)
if self.grid.is_cell_empty((x, y)): if self.grid.is_cell_empty((x, y)):
@ -67,19 +58,8 @@ class GameMap(Model):
self.schedule.add(creature) self.schedule.add(creature)
else: else:
pass 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 #other data: position, strength & other parameters
def get_list_of_chests(self): def get_list_of_chests(self):
return self.listOfChests return self.listOfChests
@ -93,5 +73,5 @@ class GameMap(Model):
def step(self): def step(self):
self.schedule.step() self.schedule.step()
#self.datacollector.collect(self) self.datacollector.collect(self)
#print(str(self.datacollector.model_reporters)) #print(str(self.datacollector.model_reporters))

View File

@ -1,42 +1,14 @@
from mesa import Agent 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): class Box(Agent):
def __init__(self, unique_id, model, type): def __init__(self, unique_id, model):
super().__init__(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.isBox = True
self.isCreature = False self.isCreature = False
self.isPlayer = 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): def step(self):
pass pass

View File

@ -18,63 +18,31 @@ class Creature(Agent):
self.isCreature = True self.isCreature = True
self.isPlayer = False 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): def melee_attack(self, opponent):
attack_value = self.strength + roll_the_dice(6) 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 damage = attack_value - defense_value
if damage > 0: 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): def range_attack(self, opponent):
attack_value = self.agility + roll_the_dice(6) attack_value = self.agility + roll_the_dice(6)
defense_value = opponent.agility defense_value = opponent.agility
damage = attack_value - defense_value 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): def magic_attack(self, opponent):
attack_value = self.wisdom + roll_the_dice(6) attack_value = self.wisdom + roll_the_dice(6)
defense_value = opponent.wisdom defense_value = opponent.wisdom
damage = attack_value - defense_value 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): def default_attack(self, opponent):
if self.weapon1.get_type() == "Meele": if self.weapon1.type == "Meele":
self.melee_attack(opponent) self.melee_attack(opponent)
elif self.weapon1.get_type() == "Ranged": elif self.weapon1.type == "Range":
self.range_attack(opponent) self.range_attack(opponent)
else: else:
self.magic_attack(opponent) self.magic_attack(opponent)

View File

@ -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

View File

@ -14,16 +14,16 @@ WM10 = Weapon("Axe", "Melee", 3)
WM11 = Weapon("Axe", "Melee", 3) WM11 = Weapon("Axe", "Melee", 3)
WM12 = Weapon("Battle axe", "Melee", 4) 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) S1 = Weapon("Push", "Magic", 2)
S2 = Weapon("Push", "Magic", 2) S2 = Weapon("Push", "Magic", 2)
@ -61,7 +61,7 @@ A16 = Armor("Magical Plate Armor", 3, 2)
# C10 = Box(A8) # C10 = Box(A8)
# C11 = Box(A12) # C11 = Box(A12)
# C12 = Box(A14) # C12 = Box(A14)
#
# Gracz = Player(1000, self, "Janusz",3,3,3,20,20,WM1,A1,0,WR1,S1) # 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): # 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)) # M1 = Creature("Goblin",2,2,1,10,10,WM2,A2,dice(6))

View File

@ -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

View File

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

View File

@ -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))