def __init__(self):
pygame.init()
# setting window's name
pygame.display.set_caption(self.name)
self.gameplay = Gameplay()
self.height = self.gameplay.get_screen_height()
self.width = self.gameplay.get_screen_width()
self.screen = pygame.display.set_mode((self.width, self.height))
self.gameplay.set_screen(self.screen)
def __init__(self):
pygame.init()
#setting window's namewe
pygame.display.set_caption(self.name)
self.gameplay = Gameplay()
self.height = self.gameplay.get_screen_height()
self.width = self.gameplay.get_screen_width()
# to play a music in a background
if self.music_path is not None:
pygame.mixer.init()
pygame.mixer.music.load(self.music_path)
pygame.mixer.music.play(-1)
self.screen = pygame.display.set_mode((self.width, self.height))
self.gameplay.set_screen(self.screen)
def __init__(self,
nsigma=False,
popsize=15,
num_hidden_layers=1,
hidden_size=128):
self.num_hidden_layers = num_hidden_layers
self.hidden_size = hidden_size
self.popsize = popsize
self.epsilon0 = 0.001
self.dimension = 33 * hidden_size + hidden_size + 1
self.tau = 1 / np.sqrt(self.dimension)
self.sr1 = 0
self.sr2 = 0
self.game = Gameplay()
self.fitness_values1 = np.zeros(2 * popsize)
self.fitness_values2 = np.zeros(2 * popsize)
self.k_1 = 2.0
self.k_2 = 2.0
self.nsigma = nsigma
self.tau = 1 / np.sqrt(self.dimension)
def __init__(self):
self.input = Input()
self.game_brain = GameBrain()
self.resource = Resource()
pygame.init()
screen = pygame.display.set_mode((Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT))
pygame.display.set_caption("Twister!")
states = {"SPLASH": SplashScreen(self.input, self.game_brain),
"GAMEPLAY": Gameplay(self.input, self.game_brain, self.resource),
"SHOW_CHALLENGE_SCORE": ShowChallengeScore(self.input, self.game_brain, self.resource),
"SHOW_FINAL_SCORE": ShowFinalScore(self.input, self.game_brain, self.resource)}
game = Game(screen, states, "SPLASH")
game.run()
pygame.quit()
sys.exit()
# !/usr/bin/python
import threading
from Window import Window
from Gameplay import Gameplay
from SnakeAI import SnakeAI
gameplay = Gameplay(840, 560)
window = Window(gameplay)
window.setTickValue(0.08)
threads = []
for obj in [window]:
threads.append(threading.Thread(target=obj.run))
threads[-1].start()
threads[-1].setName(obj.__str__())
for thread in threads:
thread.join()
print("joined: {}".format(thread.getName()))
print("completed")
class Window:
# starting settings
name = 'surviv'
def __init__(self):
pygame.init()
# setting window's name
pygame.display.set_caption(self.name)
self.gameplay = Gameplay()
self.height = self.gameplay.get_screen_height()
self.width = self.gameplay.get_screen_width()
self.screen = pygame.display.set_mode((self.width, self.height))
self.gameplay.set_screen(self.screen)
def start(self):
stopped = False
n = Network()
base = n.getP()
data = base[0]
player = base[1]
boxes = base[2]
self.gameplay.c_f = player # ustawiamy id gracza
self.gameplay.current_focus = self.gameplay.players[player]
self.gameplay.sync_windows(data)
self.gameplay.generate_obst_from_data(boxes)
clock = pygame.time.Clock()
pygame.font.init()
while not stopped:
p1 = [
self.gameplay.allPlayersToPickle[player],
self.gameplay.bulletsToPickle, self.gameplay.boxes
]
self.gameplay.boxes = []
self.gameplay.bulletsToPickle = []
p2 = n.send(p1)
self.gameplay.update(p2)
# Triggering events: using mouse and keyboard
for event in pygame.event.get():
self.gameplay.on_press(event)
# Exiting a game either by closing event or by game option
if event.type == pygame.QUIT or self.gameplay.has_quited():
# self.gameplay.quit()
stopped = True
timedelta = 0.4 * clock.tick(60)
self.gameplay.play(timedelta)
self.gameplay.pickle_player(self.gameplay.c_f)
self.gameplay.draw()
# refreshes screen
pygame.display.flip()
elif r == 4:
return block5(620, 20 + i, 20)
elif r == 5:
return block6(620, 20 + i, 20)
elif r == 6:
return MagicBlock1(620, 20 + i, 20)
f = []
for i in range(0, 4):
r = random.randrange(0, 7)
f.append(r)
img = pygame.image.load("hebg.png")
while not gameexit:
gameDisplay.fill(white)
game = Gameplay()
board = Board()
while not gamestop:
gameDisplay.fill(white)
if not game.checkRowEmpty():
gamestop = True
move = 0
for event in pygame.event.get():
if event.type == pygame.QUIT:
gamestop = True
gameexit = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_s:
b.rotate(game)
elif event.key == pygame.K_a:
move = -20
class EP:
def __init__(self,
nsigma=False,
popsize=15,
num_hidden_layers=1,
hidden_size=128):
self.num_hidden_layers = num_hidden_layers
self.hidden_size = hidden_size
self.popsize = popsize
self.epsilon0 = 0.001
self.dimension = 33 * hidden_size + hidden_size + 1
self.tau = 1 / np.sqrt(self.dimension)
self.sr1 = 0
self.sr2 = 0
self.game = Gameplay()
self.fitness_values1 = np.zeros(2 * popsize)
self.fitness_values2 = np.zeros(2 * popsize)
self.k_1 = 2.0
self.k_2 = 2.0
self.nsigma = nsigma
self.tau = 1 / np.sqrt(self.dimension)
def reconstructWeightsMatrix(self, weights_vector, layer):
if layer == 0:
weights_matrix = weights_vector.reshape((33, self.hidden_size))
else: #ultima
weights_matrix = weights_vector.reshape((self.hidden_size + 1, 1))
return weights_matrix
def fitness(self, i_1, p_1, i_2, p_2):
limit = 33 * self.hidden_size
w_1 = [
self.reconstructWeightsMatrix(p_1[:limit], 0),
self.reconstructWeightsMatrix(p_1[limit:], 1)
]
w_2 = [
self.reconstructWeightsMatrix(p_2[:limit], 0),
self.reconstructWeightsMatrix(p_2[limit:], 1)
]
param1 = [self.num_hidden_layers, self.hidden_size, w_1]
param2 = [self.num_hidden_layers, self.hidden_size, w_2]
winner = self.game.play(self.k_1, self.k_2, param1, param2)
if winner == 1:
self.fitness_values1[i_1] += 1
self.fitness_values2[i_2] -= 2
self.sr1 += 1
elif winner == 2:
self.fitness_values1[i_1] -= 2
self.fitness_values2[i_2] += 1
self.sr2 += 1
def generateWeights(self):
layer1_weights = np.random.uniform(-0.2,
0.2,
size=(33, self.hidden_size))
layer2_weights = np.random.uniform(-0.2,
0.2,
size=(self.hidden_size + 1, 1))
return layer1_weights, layer2_weights
def generateInitialPopulation(self):
#Gera populacao para peças brancas
if self.nsigma:
self.population_1 = np.zeros((self.popsize, self.dimension * 2))
else:
self.population_1 = np.zeros((self.popsize, self.dimension + 1))
for i in range(self.popsize):
layer1_weights, layer2_weights = self.generateWeights()
individual = np.concatenate(
(layer1_weights.flatten(), layer2_weights.flatten()))
if self.nsigma:
individual = np.concatenate(
(individual, np.random.uniform(-0.1, 0.1, self.dimension)))
else:
individual = np.concatenate(
(individual, np.random.uniform(-0.1, 0.1, 1)))
self.population_1[i, :] = individual
#Gera populacao para peças pretas
if self.nsigma:
self.population_2 = np.zeros((self.popsize, self.dimension * 2))
else:
self.population_2 = np.zeros((self.popsize, self.dimension + 1))
for i in range(self.popsize):
layer1_weights, layer2_weights = self.generateWeights()
individual = np.concatenate(
(layer1_weights.flatten(), layer2_weights.flatten()))
if self.nsigma:
individual = np.concatenate(
(individual, np.random.uniform(-0.1, 0.1, self.dimension)))
else:
individual = np.concatenate(
(individual, np.random.uniform(-0.1, 0.1, 1)))
self.population_2[i, :] = individual
def mutation(self, x, alpha):
x_mutated = x.copy()
if self.nsigma:
# sigma = x_mutated[self.dimension:] * (1 + alpha*np.random.normal(0, 1, self.dimension))
sigma = x_mutated[self.dimension:] * np.exp(
self.tau * np.random.normal(0, 1, self.dimension))
sigma[sigma < self.epsilon0] = self.epsilon0
x_mutated[:self.dimension] += sigma * np.random.normal(
0, 1, self.dimension)
x_mutated[self.dimension:] = sigma
else:
# sigma = x_mutated[-1] * (1 + alpha*np.random.normal(0, 1))
sigma = x_mutated[-1] * np.exp(self.tau * np.random.normal(0, 1))
if sigma < self.epsilon0:
sigma = self.epsilon0
x_mutated[:-1] += sigma * np.random.normal(0, 1, self.dimension)
x_mutated[-1] = sigma
return x_mutated
def nextGen(self, parents1, parents2, num_games=5, alpha=0.5):
children1 = []
children2 = []
while len(children1) < self.popsize and len(children2) < self.popsize:
selection1 = np.random.choice(np.arange(len(parents1)), 1)
selection2 = np.random.choice(np.arange(len(parents2)), 1)
parent1 = parents1[selection1[0]]
child1 = self.mutation(parent1, alpha)
parent2 = parents2[selection2[0]]
child2 = self.mutation(parent2, alpha)
children1.append(child1)
children2.append(child2)
self.k_1 += np.random.uniform(-0.1, 0.1)
self.k_2 += np.random.uniform(-0.1, 0.1)
self.k_1 = min(max(self.k_1, 1), 3)
self.k_2 = min(max(self.k_2, 1), 3)
candidates1 = np.vstack([parents1, np.asarray(children1)])
candidates2 = np.vstack([parents2, np.asarray(children2)])
shuffle1 = np.repeat(
np.arange(2 * self.popsize).reshape(-1, 1), num_games)
shuffle2 = np.repeat(
np.arange(2 * self.popsize).reshape(-1, 1), num_games)
np.random.shuffle(shuffle1)
np.random.shuffle(shuffle2)
matches = np.hstack((shuffle1.reshape(-1, 1), shuffle2.reshape(-1, 1)))
for match in tqdm(matches, desc='Playing games', leave=False):
self.fitness(match[0], candidates1[match[0], :self.dimension],
match[1], candidates2[match[1], :self.dimension])
self.fitness_values1[::-1].sort()
self.fitness_values2[::-1].sort()
print('\nPecas brancas: ', self.fitness_values1)
print('Pecas pretas: ', self.fitness_values2)
self.population_1 = candidates1[:self.popsize]
self.population_2 = candidates2[:self.popsize]
self.fitness_values1 = np.zeros(2 * self.popsize)
self.fitness_values2 = np.zeros(2 * self.popsize)
def minimize(self, max_gen=10, num_games=5, alpha=0.5):
t1 = time()
self.generateInitialPopulation()
for gen in tqdm(range(max_gen)):
print(40 * '-')
print("Gen ", gen + 1)
print(40 * '-')
self.nextGen(self.population_1, self.population_2, num_games,
alpha)
t2 = time()
deltaTime = t2 - t1
self.solution1 = self.population_1[0, :self.dimension]
self.solution2 = self.population_2[0, :self.dimension]
self.sr1 = self.sr1 / (num_games * self.popsize * 2 * max_gen)
self.sr2 = self.sr2 / (num_games * self.popsize * 2 * max_gen)
print("SR do modelo para peças brancas: {0:3f}".format(
np.round(self.sr1, 3)))
print("SR do modelo para peças pretas: {0:3f}".format(
np.round(self.sr2, 3)))
return self.solution1, self.solution2, deltaTime
from Gameplay import Gameplay
import random
gameplay = Gameplay(
5000,
(random.randint(0, 250), random.randint(0, 250), random.randint(0, 250)),
(random.randint(0, 250), random.randint(0, 250), random.randint(0, 250)))
#FILLIM I RI!
def __init__( self ):
self.board = Board()
self.gameplay = Gameplay( self.board, 4 )
class Window:
# starting settings
name = 'surviv'
music_path = None
def __init__(self):
pygame.init()
#setting window's namewe
pygame.display.set_caption(self.name)
self.gameplay = Gameplay()
self.height = self.gameplay.get_screen_height()
self.width = self.gameplay.get_screen_width()
# to play a music in a background
if self.music_path is not None:
pygame.mixer.init()
pygame.mixer.music.load(self.music_path)
pygame.mixer.music.play(-1)
self.screen = pygame.display.set_mode((self.width, self.height))
self.gameplay.set_screen(self.screen)
def start(self):
stopped = False
clock = pygame.time.Clock()
pygame.font.init()
old_epoch = time.time()
while not stopped:
# Triggering events: using mouse and keyboard
for event in pygame.event.get():
self.gameplay.on_press(event)
# Exiting a game either by closing event or by game option
if event.type == pygame.QUIT or self.gameplay.has_quited():
#self.gameplay.quit()
stopped = True
timedelta = 0.4 * clock.tick(60)
self.gameplay.play(timedelta)
self.gameplay.draw()
if (time.time() - old_epoch) >= self.gameplay.area_expansion_time:
self.gameplay.extend_area_width()
old_epoch = time.time()
# refreshes screen
pygame.display.flip()