def get_opponents(data):
opponents = []
opponentLocations = data['OpponentLocations']
for locationString in opponentLocations:
parsedLocation = get_location_from_string(locationString)
location = Location(parsedLocation[0], parsedLocation[1])
opponent = Opponent(location)
opponent.print_debug()
opponents.append(opponent)
return opponents
def test_computer_make_move():
# Test The AI find a correct empty place
a = Table(params['x'], params['y'], params['w'], params['h'])
a.grid = [[0, 0, 0, 0, 0, 0, 0], [0, 0, 2, 0, 0, 0, 0],
[0, 0, 2, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0],
[0, 0, 2, 0, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0]]
a.get_empty_row_index(2)
ai = Opponent()
ai.computer_make_move(a)
assert ai.x != 2
assert ai.x not in a.full_columns
def __init__(self):
""" Initialize board-specific variables. """
self.board = []
self.board_height = constants.BOARD_HEIGHT
self.board_width = constants.BOARD_WIDTH
self.human_piece = constants.HUMAN_PIECE
self.computer_piece = constants.COMPUTER_PIECE
self.open_space = constants.OPEN_SPACE
self.pieces = constants.PIECES
# Maybe query the user for desired opponent type
self.AI_type = 'random'
self.AI = Opponent(self.AI_type)
self.players = ['Human', 'Computer']
self.state = States.ongoing
# who goes first. (0 is human). maybe parameterize this
self.player_index = 0
# Initialize the board as a grid of blank cells
for nrow in range(self.board_height):
self.board.append([self.open_space for i in
range(self.board_width)])
def __init__(self):
'''Iniitalize the game controller'''
line_size = 200
self.table = Table(0, line_size, line_size * 7, line_size * 6)
self.circles = []
self.winner_color = -1
self.opponent = Opponent()
self.winner = 0
self.can_drop = True
self.mouse_drag = False
self.mouse_release = False
self.mouse_pressed = True
self.user_name = ""
self.score = Score("scores.txt")
self.txt_update_called = True
self.game_over = False
self.computer_turn = False
self.winner_counter = 0
def load(self):
for x in range(0, 2800, 70):
platform = Platform(self.player, wielkosc_bloku, wielkosc_bloku,
-wielkosc_bloku,
self.player.screen_height - wielkosc_bloku - x,
image_ground, 0, 0 * wielkosc_bloku)
self.set_of_platforms.add(platform)
for p in self.wp:
platform = Platform(self.player, *p)
self.set_of_platforms.add(platform)
tmp = 0
for y in self.op:
try:
opponent = Opponent(y[0], self.rm[tmp][1], y[2], y[3],
self.rm[tmp][0])
except:
self.rm.append([False, False])
opponent = Opponent(*y)
finally:
tmp += 1
self.opponents.add(opponent)
for o in self.so:
static_object = Static_object(*o)
self.static_objects.add(static_object)
for s in self.sp:
spike = Spike(s[0], s[1], s[2])
self.spikes.add(spike)
for c in self.cr:
if c[3]:
crystal = Crystal(*c)
self.crystals.add(crystal)
def __init__(self):
#game window
pygame.init()
self.size = self.width, self.height = (640, 480)
self.screen = pygame.display.set_mode(self.size)
self.black = (0,0,0)
#game scores
self.score_p1 = 0
self.score_p2 = 0
#paddle
self.paddle = Paddle()
#player2 paddle
self.opponent = Opponent()
#ball
self.ball = Ball()
pygame.key.set_repeat(10,5)
#opponent presses space
self.space_host = False
self.space_client = False
self.direction = None
def __init__(self):
global manager
spyral.Scene.__init__(self, SIZE)
self.hero = Hero(self)
self.hero.pos = (WIDTH-180, HEIGHT - 395)
self.hero.scale_x = .80;
self.hero.scale_y = .80;
# Create Opponent Sprite
self.opponent = Opponent(self);
self.correct = False
self.fireball1 = Fireball(self,1)
self.fireball2 = Fireball(self,2)
self.background = model.resources[model.currentOpponent + "bg"]
self.layers = ["bottom", "text"]
## Adds widgets to screen
class RegisterForm(spyral.Form):
#Buttons
selectButton = spyral.widgets.Button("Select Card")
backButton = spyral.widgets.Button("Back")
answerButton = spyral.widgets.Button("Submit")
easyButton = spyral.widgets.Button("Easy")
mediumButton = spyral.widgets.Button("Medium")
hardButton = spyral.widgets.Button("Hard")
#Fields
answerField = spyral.widgets.TextInput(50, "")
self.form = RegisterForm(self)
# Setting positions
self.form.selectButton.pos = (WIDTH/2-70, HEIGHT/2)
self.form.backButton.pos = (10, 10)
self.form.answerButton.pos = (WIDTH/2+150, HEIGHT/2)
self.form.answerField.pos = (WIDTH/2+70, HEIGHT/2)
self.form.easyButton.pos = (WIDTH/3, HEIGHT/2)
self.form.mediumButton.pos = (WIDTH/2, HEIGHT/2)
self.form.hardButton.pos = (WIDTH*2/3, HEIGHT/2)
# Setting visible
self.form.answerButton.visible = False
self.form.answerField.visible = False
self.form.easyButton.visible = False
self.form.mediumButton.visible = False
self.form.hardButton.visible = False
self.deck = {}
self.opponentcards = {}
# Initalize Hero cards
for card_guts in model.deck:
card_guts = model.deck[card_guts]
self.deck[card_guts[0]] = (Card(self, card_guts[0], card_guts[1], card_guts[2]))
# Initialize Opponent cards
for card_guts in self.opponent.deck:
card_guts = self.opponent.deck[card_guts]
self.opponentcards[card_guts[0]] = (Card(self, card_guts[0], card_guts[1], card_guts[2]))
self.showOppHealth = [0, 0, 0]
self.showHealth = [0, 0, 0]
count = 0
for card in self.deck:
self.showHealth[count] = (drawFont(self.scene, "Extras/Comic_Book.ttf", "HP: "+str(self.deck[card].health), 25))
count = 0
for card in self.opponentcards:
self.showOppHealth[count] = (drawFont(self.scene, "Extras/Comic_Book.ttf", "HP: "+str(self.opponentcards[card].health), 25))
self.drawAllCards()
spyral.event.register("system.quit", spyral.director.quit)
spyral.event.register("form.RegisterForm.selectButton.changed", self.startBattle)
spyral.event.register("form.RegisterForm.backButton.changed", self.backClicked)
spyral.event.register("form.RegisterForm.answerButton.changed", self.submitAnswer)
spyral.event.register("form.RegisterForm.easyButton.changed", self.initEasy)
spyral.event.register("form.RegisterForm.mediumButton.changed", self.initMedium)
spyral.event.register("form.RegisterForm.hardButton.changed", self.initHard)
class FaceoffScreen(spyral.Scene):
def __init__(self):
global manager
spyral.Scene.__init__(self, SIZE)
self.hero = Hero(self)
self.hero.pos = (WIDTH-180, HEIGHT - 395)
self.hero.scale_x = .80;
self.hero.scale_y = .80;
# Create Opponent Sprite
self.opponent = Opponent(self);
self.correct = False
self.fireball1 = Fireball(self,1)
self.fireball2 = Fireball(self,2)
self.background = model.resources[model.currentOpponent + "bg"]
self.layers = ["bottom", "text"]
## Adds widgets to screen
class RegisterForm(spyral.Form):
#Buttons
selectButton = spyral.widgets.Button("Select Card")
backButton = spyral.widgets.Button("Back")
answerButton = spyral.widgets.Button("Submit")
easyButton = spyral.widgets.Button("Easy")
mediumButton = spyral.widgets.Button("Medium")
hardButton = spyral.widgets.Button("Hard")
#Fields
answerField = spyral.widgets.TextInput(50, "")
self.form = RegisterForm(self)
# Setting positions
self.form.selectButton.pos = (WIDTH/2-70, HEIGHT/2)
self.form.backButton.pos = (10, 10)
self.form.answerButton.pos = (WIDTH/2+150, HEIGHT/2)
self.form.answerField.pos = (WIDTH/2+70, HEIGHT/2)
self.form.easyButton.pos = (WIDTH/3, HEIGHT/2)
self.form.mediumButton.pos = (WIDTH/2, HEIGHT/2)
self.form.hardButton.pos = (WIDTH*2/3, HEIGHT/2)
# Setting visible
self.form.answerButton.visible = False
self.form.answerField.visible = False
self.form.easyButton.visible = False
self.form.mediumButton.visible = False
self.form.hardButton.visible = False
self.deck = {}
self.opponentcards = {}
# Initalize Hero cards
for card_guts in model.deck:
card_guts = model.deck[card_guts]
self.deck[card_guts[0]] = (Card(self, card_guts[0], card_guts[1], card_guts[2]))
# Initialize Opponent cards
for card_guts in self.opponent.deck:
card_guts = self.opponent.deck[card_guts]
self.opponentcards[card_guts[0]] = (Card(self, card_guts[0], card_guts[1], card_guts[2]))
self.showOppHealth = [0, 0, 0]
self.showHealth = [0, 0, 0]
count = 0
for card in self.deck:
self.showHealth[count] = (drawFont(self.scene, "Extras/Comic_Book.ttf", "HP: "+str(self.deck[card].health), 25))
count = 0
for card in self.opponentcards:
self.showOppHealth[count] = (drawFont(self.scene, "Extras/Comic_Book.ttf", "HP: "+str(self.opponentcards[card].health), 25))
self.drawAllCards()
spyral.event.register("system.quit", spyral.director.quit)
spyral.event.register("form.RegisterForm.selectButton.changed", self.startBattle)
spyral.event.register("form.RegisterForm.backButton.changed", self.backClicked)
spyral.event.register("form.RegisterForm.answerButton.changed", self.submitAnswer)
spyral.event.register("form.RegisterForm.easyButton.changed", self.initEasy)
spyral.event.register("form.RegisterForm.mediumButton.changed", self.initMedium)
spyral.event.register("form.RegisterForm.hardButton.changed", self.initHard)
def initEasy(self, event):
if (event.value == "down"):
self.initQ("easy")
def initMedium(self, event):
if (event.value == "down"):
self.initQ("medium")
def initHard(self, event):
if (event.value == "down"):
self.initQ("hard")
def initQ(self, diff):
self.form.easyButton.visible = False
self.form.mediumButton.visible = False
self.form.hardButton.visible = False
self.deck[self.selectedSubject].initQuestion(diff)
##Screen testcase##
# while(self.deck[self.selectedSubject].q.randomOpKey != "-"):
# self.deck[self.selectedSubject].initQuestion(diff)
##endtestcase##
if self.selectedSubject == "Multiplication":
spyral.director.push(division.sinkingScreen(self.deck[self.selectedSubject].q, diff))
elif self.selectedSubject == "Subtraction":
spyral.director.push(subtraction.mainScene(self.deck[self.selectedSubject].q, diff))
elif self.selectedSubject == "Division":
spyral.director.push(mult.mainScreen(self.deck[self.selectedSubject].q, diff))
elif self.selectedSubject == "Integer":
spyral.director.push(integer.mainScreen(self.deck[self.selectedSubject].q, diff))
self.showQuestion = drawFont(self.scene, "Extras/Comic_Book.ttf", self.deck[self.selectedSubject].question, 25)
if self.selectedSubject == "Statistics" or self.selectedSubject == "Geometry":
self.showQuestion.pos = (20, HEIGHT/2 - 20)
self.form.answerField.pos = (WIDTH/2 - 50, HEIGHT/2 + 20)
self.form.answerButton.pos = (WIDTH/2 + 50, HEIGHT/2 + 20)
else:
self.showQuestion.pos = (WIDTH/2 - 150, HEIGHT/2)
self.form.answerButton.pos = (WIDTH/2+150, HEIGHT/2)
self.form.answerField.pos = (WIDTH/2+70, HEIGHT/2)
self.form.answerField.visible = True
self.form.answerButton.visible = True
################### Battle Logic #########################################
#### Deal Hero Damage to Opponent
def dealDamage(self, damage):
#Draw damage from hero to opponent
#if hero is correct
try:
self.herocorrect.visible = False
self.opponentcorrect.visible = False
except:
pass
if self.correct:
#tell hero he is correct
self.herocorrect = drawFont(self.scene, "Extras/Comic_Book.ttf", "Correct!", 25)
self.herocorrect.pos = (WIDTH-150, HEIGHT - 450)
#show fireball/damage
self.fireball1.pos = (WIDTH-100, HEIGHT - 100)
self.fireball1.draw_linearly(HEIGHT - 100, 15)
# modify numbers (damage)
self.opponentcards[self.opponent.selectedSubject].applyDamage(damage)
else:
#tell hero he is wrong
self.herocorrect = drawFont(self.scene, "Extras/Comic_Book.ttf", "Wrong", 25)
self.herocorrect.pos = (WIDTH-150, HEIGHT - 450)
#if opponent is correct
if self.opponent.correct:
#show opponent is correct
self.opponentcorrect = drawFont(self.scene, "Extras/Comic_Book.ttf", "Correct!", 25)
self.opponentcorrect.pos = (50, HEIGHT - 450)
#show fireball/damage
self.fireball2.draw_linearly(100, HEIGHT - 100)
# modify numbers (damage)
self.deck[self.selectedSubject].applyDamage(self.opponentcards[self.opponent.selectedSubject].damage)
else:
#show opponent is wrong
self.opponentcorrect = drawFont(self.scene, "Extras/Comic_Book.ttf", "Wrong", 25)
self.opponentcorrect.pos = (50, HEIGHT - 450)
print "Successfully dealt damage"
###
#### Starts the battle
def startBattle(self, event):
subj = self.opponent.pickCard()
while not self.opponentcards[subj].alive:
subj = self.opponent.pickCard()
if (event.value == "down"):
count = 0
c = 0
subjects = []
# If no card selected, don't show anything
try:
self.form.answerField.visible = False
self.showQuestion.visible = False
self.showDamage.visible = False
del self.showQuestion
del self.showDamage
except:
pass
# If there is more than one card selected, don't run
for card in self.deck:
self.showHealth[c].visible = False
self.deck[card].visible = False
if self.deck[card].clicked:
subjects.append(self.deck[card].subject)
self.deck[card].visible = True
self.showHealth[c].visible = True
count += 1
c += 1
# If there is one card selected, start battle
if count == 1:
self.selectedSubject = subjects[0]
self.deck[self.selectedSubject].visible = True
self.form.selectButton.visible = False
self.form.easyButton.visible = True
self.form.mediumButton.visible = True
self.form.hardButton.visible = True
c = 0
# Show opponent's selected card
for card in self.opponentcards:
if not card == subj:
self.opponentcards[card].visible = False
self.showOppHealth[c].visible = False
c += 1
# If there are no card selected, show all cards
if count == 0:
for card in self.deck:
self.deck[card].visible = True
self.showHealth[count].visible = True
count += 1
################### Event Handlers ############################################
#### Submit answer to system
def submitAnswer(self, event):
self.opponent.answerQuestion()
if (event.value == "down"):
# if answer is correct
try:
if float(self.form.answerField.value) == float(self.deck[self.selectedSubject].answer):
self.correct = True
else:
self.correct = False
self.dealDamage(self.deck[self.selectedSubject].damage)
print "Opponent's answer: " + str(self.opponent.correct)
self._reset()
except(ValueError):
pass
def submitScreenAnswer(self, correct):
self.opponent.answerQuestion()
if correct:
self.correct = True
else:
self.correct = False
self.dealDamage(self.deck[self.selectedSubject].damage)
self._reset()
################### Drawing Functions #########################################
#### Resets screen
def _reset(self):
dead = True
for card in self.deck:
if self.deck[card].alive:
dead = False
if dead:
model.opponentDead = False
spyral.director.replace(endGameScreen.EndGameScreen())
dead = True
for card in self.opponentcards:
if self.opponentcards[card].alive:
dead = False
if dead:
model.opponentDead = True
spyral.director.replace(endGameScreen.EndGameScreen())
# Show appropriate buttons and titles
self.form.selectButton.visible = True
self.form.answerButton.visible = False
self.form.answerField.visible = False
self.form.easyButton.visible = False
self.form.mediumButton.visible = False
self.form.hardButton.visible = False
self.showQuestion.visible = False
# reset values
self.form.answerField.value = ""
for card in self.deck:
self.deck[card].handle_deselect()
self.drawAllCards()
#### Draws all cards on screen
def drawAllCards(self):
x = WIDTH/12
y = HEIGHT - 320
count = 0
## Draw Hero's deck cards
for card in self.deck:
try:
self.showHealth[count].visible = False
# del self.showHealth[count]
except:
pass
# Init health counters
self.showHealth[count] = (drawFont(self.scene, "Extras/Comic_Book.ttf","HP: "+str(self.deck[card].health), 25))
# Draw Health counters on screen
self.showHealth[count].layer = "text"
self.showHealth[count].pos = (x + 70, y - 35)
# Draw cards on screen
self.deck[card].layer = "text"
if self.deck[card].alive:
self.deck[card].visible = True
else:
self.deck[card].visible = False
self.deck[card].pos = (x, y)
x = x + 320
count += 1
# Opponent cards
x = WIDTH/4
y = 15
count = 0
for card in self.opponentcards:
try:
self.showOppHealth[count].visible = False
# del self.showHealth[count]
except:
pass
# Init health counters
self.showOppHealth[count] = (drawFont(self.scene, "Extras/Comic_Book.ttf", "HP: "+str(self.opponentcards[card].health), 25))
self.showOppHealth[count].layer = "text"
self.showOppHealth[count].pos = (x + 70, y + 300)
# Draw cards on screen
self.opponentcards[card].layer = "text"
if self.opponentcards[card].alive:
self.opponentcards[card].visible = True
else:
self.opponentcards[card].visible = False
#Card placement
self.opponentcards[card].pos = (x, y)
x = x + 400
count += 1
count = 0
################### Exit ###################################################
#### Go back to controlPanelScreen
def backClicked(self, event):
if (event.value == "down"):
spyral.director.pop()
class GameController:
'''Manitain the state of the game and manage
how the game work'''
def __init__(self):
'''Iniitalize the game controller'''
line_size = 200
self.table = Table(0, line_size, line_size * 7, line_size * 6)
self.circles = []
self.winner_color = -1
self.opponent = Opponent()
self.winner = 0
self.can_drop = True
self.mouse_drag = False
self.mouse_release = False
self.mouse_pressed = True
self.user_name = ""
self.score = Score("scores.txt")
self.txt_update_called = True
self.game_over = False
self.computer_turn = False
self.winner_counter = 0
def update(self):
'''Updates game state on every frame'''
text_size_number = 100
size_circle = 200
fill_number = 4
yellow_number = 255
counter_max = 90
for i in self.circles:
if i.color_2 == yellow_number:
# It cause the yellow circle drope after a while
if i.counter < counter_max:
i.counter = i.counter + 1
continue
if i.x < size_circle:
i.x = size_circle // 2
elif i.x >= size_circle and i.x < size_circle * 2:
i.x = size_circle + size_circle / 2
elif i.x >= size_circle * 2 and i.x < size_circle * 3:
i.x = size_circle * 2 + size_circle / 2
elif i.x >= size_circle * 3 and i.x < size_circle * 4:
i.x = size_circle * 3 + size_circle / 2
elif i.x >= size_circle * 4 and i.x < size_circle * 5:
i.x = size_circle * 4 + size_circle / 2
elif i.x >= size_circle * 5 and i.x < size_circle * 6:
i.x = size_circle * 5 + size_circle / 2
else:
i.x = size_circle * 6 + size_circle / 2
i.displayMe()
if i.y <= i.cap and self.can_drop:
i.y = min(i.cap, i.y + i.rate)
i.rate = i.rate + 5
if len(self.circles) > 0:
if self.circles[-1].color_2 == yellow_number and \
self.circles[-1].y >= self.circles[-1].cap:
self.mouse_pressed = True
self.computer_turn = False
self.table.display()
if self.winner == 1:
if self.winner_counter < counter_max:
self.winner_counter = self.winner_counter + 1
return
if self.txt_update_called:
self.update_txtfile()
self.txt_update_called = False
fill(fill_number)
textSize(text_size_number)
if self.winner_color == 0:
string_text = "Red won!"
else:
string_text = "Yellow won!"
text(string_text, text_size_number * 5,
text_size_number + text_size_number / 2)
return
if self.game_over is True:
fill(fill_number)
textSize(text_size_number)
string_text = "Game Over!"
text(string_text, text_size_number * 5,
text_size_number + text_size_number / 2)
return
if self.computer_turn:
fill(fill_number * 4)
textSize(text_size_number / 2)
string_text = "computer's turn"
text(string_text, text_size_number * 10,
text_size_number + text_size_number / 2)
elif self.computer_turn is False:
fill(fill_number * 4)
textSize(text_size_number / 2)
string_text = "your turn"
text(string_text, text_size_number * 10,
text_size_number + text_size_number / 2)
def handle_mousePressed(self):
'''Add the circle to the game'''
x_number = 200
color_number = 255
if self.mouse_pressed is False:
return
if mouseY > x_number:
self.mouse_drag = False
self.mouse_release = False
return
if self.winner == 0:
column = mouseX // x_number
if column in self.table.full_columns:
return
else:
self.can_drop = False
circle = Circle(mouseX, x_number // 2, color_number, 0, 0)
self.circles.append(circle)
self.mouse_drag = True
self.mouse_release = True
def handle_mouseDragged(self):
'''move the circle befor it release'''
x_number = 200
if self.mouse_drag is False or self.mouse_pressed is False:
return
if self.winner == 0:
if (mouseX > x_number * 7 or mouseX < 0 or mouseY > x_number
or mouseY < 0):
self.circles[-1].seen = False
self.mouse_release = False
return
else:
self.circles[-1].seen = True
self.mouse_release = True
column = mouseX // x_number
if column not in self.table.full_columns:
self.circles[-1].x = mouseX
self.mouse_release = True
def handle_mouseRealeased(self):
'''Droped the circle after mouse released'''
x_number = 200
if self.mouse_pressed is False:
return
if self.mouse_release is False:
if self.mouse_drag is True:
self.circles.pop()
return
if self.winner == 0:
index_column = mouseX // x_number
empty_row = self.table.get_empty_row_index(index_column)
self.circles[-1].x = mouseX
self.circles[-1].cap = empty_row * x_number + (x_number +
x_number // 2)
self.table.grid[empty_row][index_column] = 1
self.can_drop = True
self.win(empty_row, index_column, self.circles[-1].color_2)
if len(self.table.full_columns) == 7:
self.game_over = True
if self.winner == 0 and self.game_over is False:
self.make_yellow_circle()
self.computer_turn = True
def make_yellow_circle(self):
'''make yellow circle and decide when it droped'''
color_number = 255
x_number = 200
self.mouse_pressed = False
self.mouse_drag = False
self.mouse_release = False
self.opponent.computer_make_move(self.table)
x = self.opponent.x
circle = Circle(x * x_number, x_number // 2, color_number,
color_number, 0)
self.circles.append(circle)
self.circles[-1].cap = self.opponent.y * x_number + (x_number +
x_number // 2)
self.table.grid[self.opponent.y][self.opponent.x] = 2
self.win(self.opponent.y, self.opponent.x, self.circles[-1].color_2)
def win(self, y_pos, x_pos, winner_color):
'''described all the rulles for circles. If place four of circles with
the same color in a row either horizontally, vertically, or diagonally
that color win the game'''
list_direction = [1] * 8
color = self.table.grid[y_pos][x_pos]
for i in range(1, 4):
if (x_pos + i) >= len(self.table.grid[0]):
list_direction[1] = 0
list_direction[2] = 0
list_direction[3] = 0
if (y_pos + i) >= len(self.table.grid):
list_direction[3] = 0
list_direction[4] = 0
list_direction[5] = 0
if (x_pos - i) < 0:
list_direction[5] = 0
list_direction[6] = 0
list_direction[7] = 0
if (y_pos - i) < 0:
list_direction[0] = 0
list_direction[1] = 0
list_direction[7] = 0
if (list_direction[0] == 1):
if (self.table.grid[y_pos - i][x_pos] != color):
list_direction[0] = 0
if (list_direction[1] == 1):
if i == 3:
if ((y_pos + 1) < len(self.table.grid)
and (x_pos - 1) >= 0):
if (self.table.grid[y_pos + 1][x_pos - 1] == color):
break
if (self.table.grid[y_pos - i][x_pos + i] != color):
list_direction[1] = 0
if (list_direction[2] == 1):
if i == 3:
if ((x_pos - 1) >= 0):
if (self.table.grid[y_pos][x_pos - 1] == color):
break
if (self.table.grid[y_pos][x_pos + i] != color):
list_direction[2] = 0
if (list_direction[3] == 1):
if i == 3:
if ((y_pos - 1) >= 0 and (x_pos - 1) >= 0):
if (self.table.grid[y_pos - 1][x_pos - 1] == color):
break
if (self.table.grid[y_pos + i][x_pos + i] != color):
list_direction[3] = 0
if (list_direction[4] == 1):
if (self.table.grid[y_pos + i][x_pos] != color):
list_direction[4] = 0
if (list_direction[5] == 1):
if i == 3:
if ((x_pos + 1) < len(self.table.grid[0])
and (y_pos - 1) >= 0):
if (self.table.grid[y_pos - 1][x_pos + 1] == color):
break
if (self.table.grid[y_pos + i][x_pos - i] != color):
list_direction[5] = 0
if (list_direction[6] == 1):
if i == 3:
if ((x_pos + 1) < len(self.table.grid[0])):
if (self.table.grid[y_pos][x_pos + 1] == color):
break
if (self.table.grid[y_pos][x_pos - i] != color):
list_direction[6] = 0
if (list_direction[7] == 1):
if i == 3:
if ((x_pos + 1) < len(self.table.grid[0])
and (y_pos + 1) < len(self.table.grid)):
if (self.table.grid[y_pos + 1][x_pos + 1] == color):
break
if (self.table.grid[y_pos - i][x_pos - i] != color):
list_direction[7] = 0
for i in list_direction:
if i == 1:
self.winner = 1
self.winner_color = winner_color
def update_txtfile(self):
# When the user win, winner's name add to the score.txt
if self.winner == 1 and self.winner_color == 0:
self.score.write_name(self.user_name)
from opponent import Opponent
from player import Player, humanPlayer
from qLearner import QLearner
import environment as en
import numpy as np
opp = Opponent()
ply = QLearner()
env = en.Environment(np.random.choice(2))
def playGame(ply, opp, startingPlayer, dialog=False):
#choose players from ['human', 'defaultOpp', 'opponent', 'qOpp', 'deepQopp']
#ply is player 0, opp is player 1
opp.player = 1
reward = 0
def _dialog(ply='Player', dialog=dialog):
if dialog:
if reward: print('Reward: ', reward)
else: print(ply, 'bet: ', env.state[-1])
if startingPlayer == 0:
called, bet = ply.makeTurn(env)
env.finishTurn(bet)
_dialog()
while True:
# for debugging insert: print('current state :', env.state)
def run_fight(opponent=Opponent(screen)):
'''Main loop code for each fight. Takes an Opponent to use.'''
window_size = (1080, 911)
screen = pygame.display.set_mode(window_size, flags)
screen.set_alpha(None)
menu_button_rect = pygame.Rect(0, 0, 148, 40)
resume_button_rect = pygame.Rect(156, 336, 766, 103)
help_button_rect = pygame.Rect(156, 460, 766, 103)
quit_button_rect = pygame.Rect(156, 583, 766, 103)
menu_button_rect.right = screen.get_rect().right
sf = calculate_scale_factor(DEFAULT_WINDOW_SIZE, DEFAULT_WINDOW_SIZE)
menu_rects = {'menu': scale_rect(menu_button_rect, sf[0], sf[1]),
'resume': scale_rect(resume_button_rect, sf[0], sf[1]),
'help': scale_rect(help_button_rect, sf[0], sf[1]),
'quit': scale_rect(quit_button_rect, sf[0], sf[1])}
paused = False
hud.set_opponent_name(opponent.opponent_name)
c_output.add_line('Fight initiated')
while 1:
# Event handling
for event in pygame.event.get():
if event.type is QUIT:
pygame.quit()
sys.exit()
if event.type is VIDEORESIZE:
# The game window is being resized
window_size = event.dict['size']
sf = calculate_scale_factor(DEFAULT_WINDOW_SIZE, window_size)
menu_rects = {'menu': scale_rect(menu_button_rect, sf[0], sf[1]),
'resume': scale_rect(resume_button_rect, sf[0], sf[1]),
'help': scale_rect(help_button_rect, sf[0], sf[1]),
'quit': scale_rect(quit_button_rect, sf[0], sf[1])}
screen = pygame.display.set_mode(window_size, flags)
elif event.type in mouse_list:
mouse_x, mouse_y = event.pos
mouse_event = event
if event.type in mouse_button_list:
mouse_button = event.button
if event.type is MOUSEBUTTONDOWN:
if menu_rects['menu'].collidepoint(event.pos):
# Toggle pause menu
paused = not paused
elif menu_rects['resume'].collidepoint(event.pos):
paused = False
elif menu_rects['help'].collidepoint(event.pos):
if paused:
help_location = os.path.join(os.getcwd(), 'help/typefight.html')
webbrowser.open_new(help_location)
elif menu_rects['quit'].collidepoint(event.pos):
if paused:
pygame.quit()
sys.exit()
else:
# TODO: Assume mouse button up
pass
else:
# TODO: Handle mouse movement event
pass
elif event.type is KEYDOWN:
if not paused:
paused = c_entry.handle_keydown_event(event,
player,
opponent,
c_output)
# State updating
if not paused:
opponent.update_state(player, c_output)
# Draw graphics
if not paused:
c_entry.render()
c_output.render()
game_surface.blit(fight_bkg, game_surface.get_rect())
hud_surface = hud.render(c_entry,
c_output,
player.health_percent,
opponent)
game_surface.blit(opponent.render(), opponent.get_rect())
if not paused:
player.render()
game_surface.blit(player.left_arm_image, player.la_center_rect)
game_surface.blit(player.right_arm_image, player.ra_center_rect)
game_surface.blit(hud_surface, hud_surface.get_rect())
if paused:
game_surface.blit(pause_fg, screen.get_rect())
if opponent.state == 'defeated':
game_surface.blit(win_fg, screen.get_rect())
elif player.health_percent <= 0:
game_surface.blit(lose_fg, screen.get_rect())
# Display all rendered graphics
screen.blit(pygame.transform.scale(game_surface, window_size), (0,0))
pygame.display.flip()
# Proceed to next frame. We are aiming to run at 60 FPS
fps_clock.tick(FPS_TARGET)
hud_surface = hud.render(c_entry,
c_output,
player.health_percent,
opponent)
game_surface.blit(opponent.render(), opponent.get_rect())
if not paused:
player.render()
game_surface.blit(player.left_arm_image, player.la_center_rect)
game_surface.blit(player.right_arm_image, player.ra_center_rect)
game_surface.blit(hud_surface, hud_surface.get_rect())
if paused:
game_surface.blit(pause_fg, screen.get_rect())
if opponent.state == 'defeated':
game_surface.blit(win_fg, screen.get_rect())
elif player.health_percent <= 0:
game_surface.blit(lose_fg, screen.get_rect())
# Display all rendered graphics
screen.blit(pygame.transform.scale(game_surface, window_size), (0,0))
pygame.display.flip()
# Proceed to next frame. We are aiming to run at 60 FPS
fps_clock.tick(FPS_TARGET)
#*****************
# Main game code *
#*****************
run_fight(Opponent(screen))
