def activate(self):
Collider.activate(self)
GameManager.register_collider(self.gameobject)
# todo maybe inject only .collider not .aabb?
self.gameobject.aabb = self.calculate_aabb()
self.gameobject.calculate_aabb = self.calculate_aabb
self.gameobject.get_overlapping_rect = self.get_overlapping_rect
def __init__(self):
self.active = False
self.gameobject = None
self.components = []
# todo do i need this? every (sub) component inside scope?
GameManager.register_entity(self)
def deactivate(self):
del self.gameobject.aabb
del self.gameobject.calculate_aabb
del self.gameobject.get_overlapping_rect
GameManager.deregister_collider(self.gameobject)
Collider.deactivate(self)
def activate(self):
Component.activate(self)
GameManager.spawn_entity(self.gameobject.uid,
self.gameobject.pos[0],
self.gameobject.pos[1],
self.gameobject.angle,
self.gameobject.vertices)
def activate(self):
self.active = True
if not self.gameobject:
GameManager.register_gameobject(self)
#self.gameobject = self # TODO should .gameobject be None or self
for component in self.components:
component.activate()
def reset(self):
self.clear_gui()
self.p1_lives = 3
self.p2_lives = 3
self.fill_gui()
if not GameManager.find("Ship1"): # todo crap string comparison
build_ship("Ship1")
if not GameManager.find("Ship2"): # todo crap string comparison
build_ship("Ship2")
def deactivate(self):
self.active = False
for component in reversed(self.components):
component.deactivate()
if not self.gameobject:
GameManager.deregister_gameobject(self)
GameManager.deregister_entity(self)
def deactivate(self):
del self.gameobject.paused
del self.gameobject.elapsedtime
del self.gameobject.frequency
del self.gameobject.timescale
del self.gameobject.elapse_time
del self.gameobject.pause
del self.gameobject.unpause
del self.gameobject.time_till_next_call
del self.gameobject.reset_timeline
GameManager.deregister_timeline(self.gameobject.name)
Updater.deactivate(self)
def activate(self):
Updater.activate(self)
self.gameobject.paused = self.paused
self.gameobject.elapsedtime = self.elapsedtime
self.gameobject.frequency = self.frequency
self.gameobject.timescale = self.timescale
self.gameobject.elapse_time = self.elapse_time
self.gameobject.pause = self.pause
self.gameobject.unpause = self.unpause
self.gameobject.time_till_next_call = self.time_till_next_call
self.gameobject.reset_timeline = self.reset
GameManager.register_timeline(self.gameobject)
def test_random_agent(self):
# game should take agent as a parameter
gm = GameManager(player=agent)
gm.add_object({
'dimensions': (1,3,1,1),
'type': 'player',
'color': COLORS['blue']
})
gm.add_object({
'dimensions': (0,1,1,1),
'type': 'enemy',
'color': COLORS['red']
})
self.assertEqual(1, 1)
def deactivate(self):
del self.gameobject.mass
del self.gameobject.velocity
del self.gameobject.ang_velocity
del self.gameobject.acceleration
del self.gameobject.ang_acc
del self.gameobject.linear_damping
del self.gameobject.ang_damping
del self.gameobject.add_force
del self.gameobject.add_torque
del self.gameobject.clear_forces
del self.gameobject.physics_timestep
GameManager.deregister_body(self.gameobject)
Component.deactivate(self)
def activate(self):
Component.activate(self)
self.gameobject.mass = self.mass
self.gameobject.velocity = self.velocity
self.gameobject.ang_velocity = self.ang_velocity
self.gameobject.acceleration = self.acceleration
self.gameobject.ang_acc = self.ang_acc
self.gameobject.linear_damping = self.linear_damping
self.gameobject.ang_damping = self.ang_damping
self.gameobject.add_force = self.add_force
self.gameobject.add_torque = self.add_torque
self.gameobject.clear_forces = self.clear_forces
self.gameobject.physics_timestep = self.physics_timestep
GameManager.register_body(self.gameobject)
def main():
print()
print()
print(' ***************************')
print(' *** Welcome To Wagerer! ***')
print()
print('Please add a few players, then play a game.')
game = GameManager()
action = 'X'
while action != 'Q':
print()
print('What would you like to do:')
print('A : Add a Player')
print('P : Play A Game')
print('C : Check Player Balances')
print('D : Deposit Into An Account')
print('Q : Quit')
action = input('Enter Your Choice: ')
action = action.upper()
if action == 'A':
name = input('Enter the player name: ')
player_name = game.create_player(name)
if action == 'C':
game.check_accounts()
if action == 'D':
name = input('Please enter the player name: ')
print()
game.deposit(name, 20)
if action == 'P':
game.bet()
print()
print(' ** Thanks for Playing Wagerer **')
print(' *********** Goodbye ************')
print()
def main():
# Create window at center
os.environ['SDL_VIDEO_CENTERED'] = '1'
# Initialize Pygame and set up the window
pygame.init()
size = [SCREEN_WIDTH, SCREEN_HEIGHT]
screen = pygame.display.set_mode(size)#trello
pygame.mouse.set_visible(False)
# Read resource
ResourceManager.read_resources(RM_path)
# Create an instance of the Game class
game = GameManager()
game.change_state(Scene())
done = False
clock = pygame.time.Clock()
# Main game loop
while not done:
pygame.display.set_caption("Troll Shooting - FPS : " + str(round(clock.get_fps(), 1)))
# Process events (keystrokes, mouse clicks, etc)
done = game.process_events()
# Update object positions, check for collisions
game.update()
# Draw the current frame
game.draw(screen)
# Pause for the next frame
clock.tick(60)
# Close window and exit
pygame.quit()
def main():
pygame.init()
game_manager = GameManager.GameManager()
game_manager.main_loop()
pygame.quit()
def joinGame(playerName, game: Dungeon):
GameManager.addPlayer(playerName, game)
return True
def cast(self):
GameManager.draw_cards(AsceticOfTheLidlessEye.CARDS_DRAWN)
return Hero.cast(self)
import random
import sys
from flask import render_template, request, make_response, Blueprint, redirect
import Common.common
import GameManager
from Common.db_connector import DbConnector
from Common.query_generator import QueryGenerator
NUM_QUESTIONS_PER_GAME = 5
GAME_ID = 3
game_manager = GameManager.GameManager(GAME_ID)
pairs_game = Blueprint('pairs_game', __name__, template_folder='templates')
pairs_game_ = Blueprint('pairs_game_', __name__, template_folder='templates')
# initialize game
@pairs_game.route('/pairs_game')
def pairs_game_start():
game_manager.start_new_game()
return create_game_page()
# Get here in middle of game. Checks if user got here legally and calculates current score
@pairs_game_.route('/pairs_game_')
def pairs_game_mid():
allow_access = request.cookies.get('allowAccess')
points = int(request.cookies.get('points'))
response = game_manager.calc_mid_game(allow_access, points,
NUM_QUESTIONS_PER_GAME, request)
def cambio_de_fichas(window, letras, cambios_de_fichas, gm, pj, bolsa,
img_nros, puntos_por_letra, turno_pc, turno_jugador,
guardado, pred):
"""
Se realizan los cambios de fichas que desea el jugador y éste pierde un turno
"""
letras_a_cambiar = []
for elem in ['-c', '-d', '-paso', '-p', '-t']:
window[elem].update(disabled=True)
for elem in ['-selec', '-deshacer-selec']:
window[elem].update(visible=True)
sg.Popup('Cambio de fichas:',
'Seleccione las letras que quiere cambiar o el boton ',
'\"seleccionar todas las fichas\" y vuelva a clickear',
'en \"Cambiar fichas\" para confirmar el cambio',
keep_on_top=True)
# para que no se minimice despues del popup
window.BringToFront()
cerro_ventana = False
while True:
event = window.read()[0]
if event is None:
cerro_ventana = True
break
elif event in letras.keys():
letras_a_cambiar.append(event)
window[event].update(disabled=True)
elif event == '-selec':
for ficha in letras.keys():
if ficha not in letras_a_cambiar:
letras_a_cambiar.append(ficha)
window[ficha].update(disabled=True)
elif event == '-deshacer-selec':
for ficha in letras_a_cambiar:
window[ficha].update(disabled=False)
letras_a_cambiar = []
elif event == '-cf':
window['-selec'].update(visible=False)
window['-deshacer-selec'].update(visible=False)
if letras_a_cambiar:
letras = gm.devolver_fichas(letras, letras_a_cambiar, bolsa)
gm.dar_fichas(letras, bolsa)
pj.setFichas(letras)
for f in letras_a_cambiar:
window[f].update(
letras[f],
disabled=False,
image_size=(50, 50),
image_subsample=21,
image_filename=img_nros[puntos_por_letra[letras[f]]])
cambios_de_fichas -= 1
window['cfichas'].update(str(cambios_de_fichas))
if cambios_de_fichas == 0:
window['-cf'].update(disabled=True)
window['-cf'].set_tooltip(
'Ya realizaste 3 cambios de fichas.')
break
else:
mostrar_popups_info(event, guardado, pred)
if not cerro_ventana:
turno_jugador, turno_pc = gm.cambiar_turno(turno_jugador, turno_pc,
window)
window['-paso'].update(disabled=False)
window['-p'].update(disabled=False)
window['-t'].update(disabled=False)
return cambios_de_fichas, turno_pc, turno_jugador
def main():
GameManager.main()
def cast(self):
GameManager.add_runes(Apprentice.RUNES_ADDED)
return Hero.cast(self)
def activate(self):
Component.activate(self)
self.gameobject.tag = self._tag
GameManager.register_tag(self._tag, self.gameobject)
def deactivate(self):
GameManager.deregister_tag(self._tag, self.gameobject)
del self.gameobject.tag
Component.deactivate(self)
def deactivate(self):
del self.gameobject.vertices
GameManager.deregister_shape(self.gameobject)
xprotocol.destroy_entity(self.gameobject.name)
Component.deactivate(self)
def activate(self):
Component.activate(self)
self.gameobject.vertices = self.vertices
GameManager.register_shape(self.gameobject)
xprotocol.spawn_entity(self.gameobject.name, self.gameobject.pos.x, self.gameobject.pos.y, self.gameobject.angle, self.vertices)
def GameLoop():
#Initialize game variables
turn = ''
winner = False
maxIteration = 1000
## Initialize the gameboard
gameboard = GameManager.Gameboard()
gameboard.__init__()
## Initialize the decks
obj = GameManager.Card(card1)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card1)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card2)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card2)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card3)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card3)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card3)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card4)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card4)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card5)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card5)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card6)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card7)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card7)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card8)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card9)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card10)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card10)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card11)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card11)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card12)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card13)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card13)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card14)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card15)
obj.setOwner('p')
gameboard.playerDeck.append(obj)
obj.setOwner('o')
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card15)
obj.setOwner('p')
gameboard.playerDeck.append(obj)
obj.setOwner('o')
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card16)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card17)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
for i in range(3):
obj = GameManager.Card(card18)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card19)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card19)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card20)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card20)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card21)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card22)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card22)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card23)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card23)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
for i in range(12):
obj = GameManager.Card(card24)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
for i in range(8):
obj = GameManager.Card(card25)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
# Set the gameboard to the default state
gameboard.setup()
#Control game variable
go = True
while go == True:
# Get players board state from the user
getPlayerActive(gameboard)
# Get players benched pokemon
getPlayerBench(gameboard)
#Get player's hand
getPlayerHand(gameboard)
#Get player's discard
getPlayerDiscard(gameboard)
#Get stadium in play
getStadium(gameboard)
#get player's prizes
getPlayerPrize(gameboard)
#find out if energy was played this turn
getEnergyPlayed(gameboard)
#find out if supporter was played this turn
getSupporterPlayed(gameboard)
# Get opponents active pokemon
getOppActive(gameboard)
#Get opponent's benched pokemon
getOppBench(gameboard)
#Get opponents discard
getOppDiscard(gameboard)
#Get opponent's hand
getOppHand(gameboard)
#Get opponents prizes
getOppPrize(gameboard)
## Check for win condition
gameOver = gameboard.checkWinCon(gameboard.turn)
if gameOver != 1 and gameOver != 0:
selectedMove, name = mcts.uct(gameboard, maxIteration)
move = parseMove(selectedMove, name)
print("The suggested move is " + move)
print("Ratio: " + mcts.repr())
elif gameOver == 1:
print("Player has won")
newGame()
elif gameOver == 0:
print("Opponent has won")
newGame()
temp = input("Press enter to continue. Enter 'quit' to exit\n")
if temp.lower() == 'quit':
sys.exit()
resetState(gameboard)
GameLoop()
import pygame
import time
import GameManager
import InputManager
import traceback
pygame.init()
running = True
screen_width = 1300
screen_height = 700
screen = pygame.display.set_mode([screen_width, screen_height])
pygame.display.set_caption("I love Monkeys... and turtles")
try:
im = InputManager.InputManager()
gm = GameManager.GameManager((screen_width, screen_height), im)
t = pygame.time.get_ticks()
while running:
oldtime = t
t = pygame.time.get_ticks()
#TODO add event processing system
for e in pygame.event.get():
if pygame.QUIT == e.type:
running = False
elif e.type == pygame.KEYDOWN and e.key == pygame.K_ESCAPE:
running = False
else:
im.process(e)
from GameManager import * gm = GameManager() # main processing while 1: gm.draw() gm.update()
def geneticAlgortihmTest():
newGame = GameManager()
genny = GeneticAlgorithmAgent(newGame,
verbose=True,
firstGuess=makeCode([1, 1, 2, 2]))
genny.play()
def cast(self):
GameManager.add_power(HeavyInfantry.POWER_ADDED)
return Hero.cast(self)
import time
import daemon
import GameManager
from GameBase import GameBase
while not GameBase.login_action():
time.sleep(5)
with daemon.DaemonContext():
GameManager.start_all_game()
def deactivate(self):
GameManager.destroy_entity(self.gameobject.uid)
Component.deactivate(self)
string = ""
for i in range(self.len * self.len):
if i % self.len == 0:
string += "\n"
string += self.getPiece(i % self.len, i // self.len)
return string
def hash(self):
string = ""
for row in self.board:
for char in row:
if char == " ":
string += "0"
if char == "X":
string += "1"
if char == "O":
string += "2"
return string
def moveFromInput(self, prompt):
print(prompt)
return [int(x.strip()) for x in input().split(',')]
if __name__ == '__main__':
game = TicTacToe(3)
solver = Solver.Solver()
gameManager = GameManager(game, solver)
gameManager.play()
def main():
pygame.init()
fpsClock = pygame.time.Clock()
pygame.mouse.set_visible(False)
#screen = pygame.display.set_mode((1280,720))
screen = pygame.display.set_mode((1280, 720), pygame.FULLSCREEN)
workSurface = pygame.Surface((1280, 720))
shaderSurface = pygame.Surface((1280, 720))
crtTile = pygame.image.load(
os.path.join('res', 'image', 'crtsim_scanlines.png'))
crtTile = pygame.transform.scale(crtTile, (20, 10))
crtPixelShader = OverlayShader(crtTile)
activeScreen = None
loggedOutScreen = screens.LoggedOutScreen()
loggingInTransition = screens.LoggingInTransitionScreen()
loggedInScreen = screens.LoggedInScreen()
activeScreen = loggedOutScreen
#activeScreen=loggedInScreen
#loggedInScreen.showFinalPuzzle()
transitionCounter = 0
gameManager = GameManager.GameManager()
running = True
while running:
if activeScreen == loggedOutScreen:
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE and pygame.key.get_mods(
) & (pygame.KMOD_RSHIFT | pygame.KMOD_RCTRL):
running = False
sys.exit(0)
#check for a device connected
if gameManager.rfidTracker.rfidTagIsActive():
loggingInTransition.resetAnimation()
activeScreen = loggingInTransition
transitionCounter = 30
elif activeScreen == loggingInTransition:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
transitionCounter -= 1
if transitionCounter <= 0:
transitionCounter = 0
loggedInScreen.reset()
loggedInScreen.sendLineToTerminal(
"STATUS: ARTIFACT CONNECTED.")
score = gameManager.getActiveDeviceScore()
loggedInScreen.sendLineToTerminal("DECRYPTION PROGRESS " +
str(score) + " / 8")
if (score is 8):
loggedInScreen.showFinalPuzzle()
activeScreen = loggedInScreen
elif activeScreen == loggedInScreen:
if not gameManager.rfidTracker.rfidTagIsActive():
activeScreen = loggedOutScreen
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_BACKSPACE:
loggedInScreen.textBoxBackspace()
elif event.key == pygame.K_RETURN:
if loggedInScreen.getPassword().lower(
) == "exitprogram":
running = False
loggedInScreen.sendLineToTerminal(
"TRYING PASSWORD: "******"PASSWORD ACCEPTED. UNLOCKING RUNE.")
score = gameManager.getActiveDeviceScore()
loggedInScreen.sendLineToTerminal(
"DECRYPTION PROGRESS " + str(score) + " / 8")
if (score is 8):
loggedInScreen.showFinalPuzzle()
else:
loggedInScreen.sendLineToTerminal(
"PASSWORD INVALID. TRY AGAIN.")
loggedInScreen.clearTextBox()
else:
if event.unicode.upper() in string.printable:
loggedInScreen.sendKeyToTextBox(
event.unicode.upper())
else:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
workSurface.fill(colors.green_bg)
activeScreen.draw(workSurface)
shaderSurface.blit(workSurface, (0, 0))
shaderSurface = crtPixelShader.apply(shaderSurface)
screen.blit(shaderSurface, (0, 0))
pygame.display.update()
gameManager.tick(60)
fpsClock.tick(60)
#cleanup when finished
gameManager.rfidTracker.stop()
def main(guardado):
"""
Desarrollo del juego y tablero principal
"""
colores = cm.cargar_colores()
import random
#-----------------------------------------------------------
# Configuracion de bolsa puntos y Imagen de numeros
#-----------------------------------------------------------
bolsa = {
'E': 0,
'A': 0,
'I': 0,
'O': 0,
'U': 0,
'S': 0,
'N': 0,
'R': 0,
'L': 0,
'T': 0,
'C': 0,
'D': 0,
'M': 0,
'B': 0,
'G': 0,
'P': 0,
'F': 0,
'H': 0,
'V': 0,
'J': 0,
'Y': 0,
'K': 0,
'Ñ': 0,
'Q': 0,
'W': 0,
'X': 0,
'Z': 0,
'LL': 0,
'RR': 0
}
puntos_por_letra = {
'E': 0,
'A': 0,
'I': 0,
'O': 0,
'U': 0,
'S': 0,
'N': 0,
'R': 0,
'L': 0,
'T': 0,
'C': 0,
'D': 0,
'M': 0,
'B': 0,
'G': 0,
'P': 0,
'F': 0,
'H': 0,
'V': 0,
'J': 0,
'Y': 0,
'K': 0,
'Ñ': 0,
'Q': 0,
'W': 0,
'X': 0,
'Z': 0,
'LL': 0,
'RR': 0
}
img_nros = {
1: os.path.join(absolute_path, 'lib', 'media', 'nros_png', 'uno.png'),
2: os.path.join(absolute_path, 'lib', 'media', 'nros_png', 'dos.png'),
3: os.path.join(absolute_path, 'lib', 'media', 'nros_png', 'tres.png'),
4: os.path.join(absolute_path, 'lib', 'media', 'nros_png',
'cuatro.png'),
5: os.path.join(absolute_path, 'lib', 'media', 'nros_png',
'cinco.png'),
6: os.path.join(absolute_path, 'lib', 'media', 'nros_png', 'seis.png'),
7: os.path.join(absolute_path, 'lib', 'media', 'nros_png',
'siete.png'),
8: os.path.join(absolute_path, 'lib', 'media', 'nros_png', 'ocho.png'),
9: os.path.join(absolute_path, 'lib', 'media', 'nros_png',
'nueve.png'),
10: os.path.join(absolute_path, 'lib', 'media', 'nros_png',
'diez.png'),
11: os.path.join(absolute_path, 'lib', 'media', 'nros_png',
'vacio.png')
}
# cargamos las configuraciones correspondientes
bolsa, puntos_por_letra, tiempo, dificultad, config, pred = \
cm.cargar_configuraciones(bolsa, puntos_por_letra, guardado)
# ----------------------------------------------------------------------
# Cargo dificultad para despues diferenciar que tablero cargar y
# mandarselo al objeto
# Abro el tablero correspondiente a la dificultad seleccionada
# ----------------------------------------------------------------------
if guardado: #Si hay partida guardada carga el tablero guardado
tab = cm.cargar_tablero('guardado')
else:
if dificultad == 'facil':
tab = cm.cargar_tablero('facil')
elif dificultad == 'medio':
tab = cm.cargar_tablero('medio')
else:
tab = cm.cargar_tablero('dificil')
if (tab is None):
sg.popup(f'No se encontro el tablero {dificultad}')
Menu.main()
return None
# ----------------------------------------------------------------------
# Opciones de dificultad --> lista de tags
# ----------------------------------------------------------------------
dificultad_random = {
'sust': ['NC', 'NN', 'NCS', 'NCP', 'NNS', 'NP', 'NNP', 'W'],
'adj': ['JJ', 'AO', 'AQ', 'DI', 'DT'],
'verbo': [
'VAG', 'VBG', 'VAI', 'VAN', 'MD', 'VAS', 'VMG', 'VMI', 'VB', 'VMM',
'VMN', 'VMP', 'VBN', 'VMS', 'VSG', 'VSI', 'VSN', 'VSP', 'VSS'
]
}
if dificultad == 'dificil':
tipo_palabra = random.choice(list(dificultad_random.keys())) \
if not guardado else config['tipo']
tipo = dificultad_random[tipo_palabra]
elif dificultad == 'facil':
tipo_palabra = ''
tipo = dificultad_random['sust'] + dificultad_random['adj'] + \
dificultad_random['verbo']
else:
tipo_palabra = ''
tipo = dificultad_random['adj'] + dificultad_random['verbo']
if not guardado:
nombre = sg.popup_get_text(
'ScrabbleAR está por comenzar, ingrese su nombre de jugador',
title='Ingrese su nombre',
default_text='Invitado',
size=(None, None),
keep_on_top=True,
no_titlebar=True)
nombre = "" if nombre == None else nombre
if nombre.strip() in (None, ''):
nombre = 'Invitado'
else:
nombre = config['nombre']
# ----------------------------------------------------------------------
# Instanciacion de objetos y creacion del layout
# ----------------------------------------------------------------------
palabras_usadas = []
palabras_usadas_pc = []
layout, letras, letras_pc, botones, long_tablero = gm.crear_layout(
bolsa, tab, dificultad, tipo_palabra, img_nros, puntos_por_letra,
nombre, palabras_usadas, palabras_usadas_pc, guardado)
from JugadorPC import PC
from Jugador import Jugador
window = sg.Window('Ventana de juego',
layout,
icon=icono_ventana,
finalize=True)
pj = Jugador(letras, long_tablero, botones, puntos_por_letra, dificultad,
tipo, guardado, window)
pc = PC(letras_pc, long_tablero, botones, puntos_por_letra, dificultad,
tipo, guardado, window)
botones_aux = botones.copy(
) #-----> Botones_aux lo uso para el boton deshacer
# ----------------------------------------------------------------------
# Manejo de puntajes, si hay partida guardada setea los puntos
# Sino es 0
# ----------------------------------------------------------------------
if guardado:
pj.puntos = int(config['puntos_j'])
pc.puntos = int(config['puntos_pc'])
window['p_pc'].update(pc.getPuntos())
window['p_j'].update(pj.getPuntos())
# ----------------------------------------------------------------------
#Configuracion de ventana y turnos
# ----------------------------------------------------------------------
letras_usadas = {} # pares (clave, valor) de las letras selecs del atril
palabra_nueva = {} # pares (clave, valor) de las letras puestas en el tab
puntos_jugador = dict()
puntos_jugador = cm.cargar_puntuaciones()
lista_puntajes = puntos_jugador['puntos']
terminar = False
# cambios de fichas
if guardado:
cambios_de_fichas = int(config["cambios_fichas"])
window["cfichas"].update(cambios_de_fichas)
if cambios_de_fichas == 0:
window["-cf"].update(disabled=True)
else:
cambios_de_fichas = 3
# aca vamos almacenando las posiciones (i,j) ocupadas en el tablero:
# posiciones_ocupadas_tablero = []
fin_fichas = False
fin_juego = False
guardar_partida = False
# Configuracion del tiempo
if not guardado:
tiempo = tiempo.split(":")
cont_tiempo_min = int(tiempo[0])
if cont_tiempo_min > 0:
cont_tiempo_seg = 59
cont_tiempo_min -= 1
else:
cont_tiempo_seg = 0
else:
aux_tiempo = config['tiempo'].split(':')
cont_tiempo_min = int(aux_tiempo[0])
cont_tiempo_seg = int(aux_tiempo[1])
window.finalize()
# se decide de forma aleatoria quien comienza la partida si no se abrio
# el archivo guardado
if guardado:
primer_turno = True if config['primer_turno'] == 'True' else False
turno_pc = True if config['turno_pc'] == 'True' else False
turno_jugador = True if config['turno_jugador'] == 'True' else False
else:
primer_turno = True
turno = random.choice([True, False])
turno_jugador, turno_pc = gm.cambiar_turno(turno, not (turno), window)
sg.popup(
"Se eligió aleatoriamente que {} coloque sus fichas en el primer turno."
.format('la maquina' if turno_pc else 'el jugador \'' + nombre +
'\''),
'¡A jugar!',
title='Empieza la partida',
line_width=100)
if (dificultad == 'dificil'):
if (tipo_palabra == 'sust'):
sg.Popup('Dificultad: Dificil, tipo de palabras: solo sustantivos',
no_titlebar=True,
keep_on_top=True)
elif (tipo_palabra == 'adj'):
sg.Popup('Dificultad: Dificil, tipo de palabras: solo adjetivos',
no_titlebar=True,
keep_on_top=True)
else:
sg.Popup('Dificultad: Dificil, tipo de palabras: solo verbos',
no_titlebar=True,
keep_on_top=True)
# ----------------------------------------------------------------------
#Loop de ventana
# ----------------------------------------------------------------------
while True:
event, values = window.read(timeout=1000)
# actualizamos el tiempo:
cont_tiempo_min, cont_tiempo_seg, tiempo_seg_final = contar_tiempo(
cont_tiempo_min, cont_tiempo_seg)
tiempo_str = '{}:{}'.format(cont_tiempo_min, tiempo_seg_final)
window['tiempo'].update(tiempo_str)
# chequeamos que no se acabe el tiempo:
if (cont_tiempo_min == 0) and (cont_tiempo_seg == 0):
sg.popup('Se termino el tiempo', keep_on_top=True)
# para que entre al if de terminar juego
# dentro del if del turno_jugador
fin_juego = turno_jugador = True
turno_pc = False
#------------------------------------------------------
# mientras sea el turno del jugador, podrá realizar
# todos los eventos del tablero
#------------------------------------------------------
if turno_jugador:
if event is None or terminar:
guardar_partida = gm.salir_del_juego()
if not guardar_partida:
sg.popup_no_frame('Salió de la partida', keep_on_top=True)
break
# boton de guardar partida
if event == '-p' or guardar_partida:
posponer_partida(pc, pj, cm, config, tipo_palabra, tiempo_str,
nombre, turno_jugador, turno_pc,
cambios_de_fichas, primer_turno)
break
# si selecciona botones del atril del jugador
elif event in letras.keys():
cont_tiempo_seg, cont_tiempo_min, terminar = \
seleccion_de_fichas(window, event, letras_usadas,
palabra_nueva, letras, botones, terminar,
cont_tiempo_seg, cont_tiempo_min, colores)
# boton de deshacer las palabras puestas en el tablero
elif event == '-d':
letras_usadas, palabra_nueva = gm.sacar_del_tablero(
window, letras.keys(), palabra_nueva, botones_aux,
dificultad)
# boton de pasar el turno a la pc
elif event == '-paso':
turno_jugador, turno_pc = gm.cambiar_turno(
turno_jugador, turno_pc, window)
letras_usadas, palabra_nueva = gm.sacar_del_tablero(
window, letras.keys(), palabra_nueva, botones_aux,
dificultad)
# boton cambio de fichas
elif (event == '-cf') and (cambios_de_fichas != 0):
# si ya hay fichas jugadas en el tablero volveran al atril
letras_usadas, palabra_nueva = gm.sacar_del_tablero(
window, letras.keys(), palabra_nueva, botones_aux,
dificultad)
cambios_de_fichas, turno_pc, turno_jugador = cambio_de_fichas(
window, letras, cambios_de_fichas, gm, pj, bolsa, img_nros,
puntos_por_letra, turno_pc, turno_jugador, guardado, pred)
# boton de terminar partida
elif event == '-t' or fin_fichas or fin_juego:
seguir = False
if event == '-t':
# le preguntamos si realmente quiere finalizar el juego
seguir = gm.preguntar_si_sigue_el_juego()
window.BringToFront()
if not seguir:
finalizar_juego(pj, pc, gm, cm, window, img_nros,
puntos_por_letra, nombre, dificultad,
lista_puntajes, puntos_jugador, guardado,
absolute_path)
break
# boton de confirmar palabra
elif event == '-c':
letras_usadas, palabra_nueva, turno_jugador, turno_pc, \
fin_fichas, primer_turno = analizar_palabra(
window, letras, botones, palabra_nueva, letras_usadas,
puntos_por_letra, pj, pc, bolsa, primer_turno, img_nros,
botones_aux, turno_pc, dificultad)
elif event in ('como_jugar', 'botonera', 'ver_config'):
mostrar_popups_info(event, guardado, pred)
if turno_pc:
time.sleep(0.5) # maquina pensando la jugarreta
primer_turno, fichas_devolver_bolsa = pc.jugar(
window, primer_turno)
fichas_pc = pc.getFichas()
gm.dar_fichas(fichas_pc, bolsa)
pc.setFichas(fichas_pc)
if fichas_devolver_bolsa != '':
gm.devolver_fichas(fichas_devolver_bolsa,
[10, 11, 12, 13, 14, 15, 16], bolsa)
fin_fichas = gm.pocas_fichas(pc.getFichas())
if (fin_fichas):
finalizar_juego(pj, pc, gm, cm, window, img_nros,
puntos_por_letra, nombre, dificultad,
lista_puntajes, puntos_jugador, guardado,
absolute_path)
break
else:
turno_jugador, turno_pc = gm.cambiar_turno(
turno_jugador, turno_pc, window)
window.close()
Menu.main()
def save(GM, Accounts):
while True:
serializeObject(GM, "Game.pickle")
#print("Game Was Autosaved")
serializeObject(Accounts, "Accounts.pickle")
#print("Accounts Were Autosaved")
time.sleep(7.5)
if __name__ == "__main__":
pickledGame = Path(os.getcwd() + "/Game.pickle")
GM = None
if (pickledGame.exists() != True):
GM = GameManager()
serializeObject(GM, "Game.pickle")
print("Created and Serialized Game Manager")
else:
print("Loaded Pickled Game File")
pickledFile = open(pickledGame, "rb")
GM = pickle.load(pickledFile)
GM.purgePlayers()
GM.clearSessions()
pickledAccounts = Path(os.getcwd() + "/Accounts.pickle")
Accounts = None
if (pickledAccounts.exists() != True):
Accounts = AccountManager()
def main():
GameManager.initialize()
GameManager.run()
def GameLoop():
# Game loop should keep track of whose turn it is
# using the turn flag. We can then use this flag to
# set up the functions in the Gamemanager file to
# condense the fuctions that are currently seperated
# like player and opp prize setups. At the begining of
# the game we can have a random number generator acting
# as a coin to select who goes first and sets the flag.
# Then all the setups will take place for that player then
# change the flag and setup the next player and so on.
# We just need to make sure we setup the boardstate before hand,
# ie have prizes layed out and determine mulligans.
#Start a new game
turn = ''
winner = False
## Initialize the gameboard
gameboard = GameManager.Gameboard()
## Initialize the decks
obj = GameManager.Card(card1)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card1)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card2)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card2)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card3)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card3)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card3)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card4)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card4)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card5)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card5)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card6)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card7)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card7)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card8)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card9)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card10)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card10)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card11)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card11)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card12)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card13)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card13)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card14)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card15)
obj.setOwner('p')
gameboard.playerDeck.append(obj)
obj.setOwner('o')
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card15)
obj.setOwner('p')
gameboard.playerDeck.append(obj)
obj.setOwner('o')
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card16)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card17)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
for i in range(3):
obj = GameManager.Card(card18)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card19)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card19)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card20)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card20)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card21)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card22)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card22)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card23)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
obj = GameManager.Card(card23)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
for i in range(12):
obj = GameManager.Card(card24)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
for i in range(8):
obj = GameManager.Card(card25)
gameboard.playerDeck.append(obj)
gameboard.oppDeck.append(obj)
# Set the gameboard to the default state
gameboard.setup()
#Control game
go = True
while go == True:
# Get players board state from the user
getPlayerActive(gameboard)
# Get players benched pokemon
getPlayerBench(gameboard)
#Get player's hand
getPlayerHand(gameboard)
#Get player's discard
getPlayerDiscard(gameboard)
#Get stadium in play
getStadium(gameboard)
#get player's prizes
getPlayerPrize(gameboard)
# Get opponents active pokemon
getOppActive(gameboard)
#Get opponent's benched pokemon
getOppBench(gameboard)
#Get opponents discard
getOppDiscard(gameboard)
#Get opponent's hand
getOppHand(gameboard)
#Get opponents prizes
getOppPrize(gameboard)
## Check for win condition
gameOver = gameboard.checkWinCon(gameboard.turn)
if gameOver != 1 and gameOver != 0:
selectedMove = str(mcts.uct(gameboard,50))
move = parseMove(selectedMove)
print("The suggested move is " + move)
elif gameOver == 1:
print("Player has won")
newGame()
elif gameOver == 0:
print("Opponent has won")
newGame()
del gameboard
input("Press enter to continue.")
GameLoop()
def startGame(level):
GameManager.startGame(level)
return None
def cast(self):
GameManager.add_runes(Mystic.RUNES_ADDED)
return Hero.cast(self)
#support
import os
import time
import random
import pygame
import math
# initial
page = 0
# screening properties
seeing_size = (constants.SCREEN_WIDTH, constants.SCREEN_HEIGHT)
screen = pygame.display.set_mode(seeing_size)
pygame.display.set_caption("Template")
gm = GameManager(screen)
all_sprites = pygame.sprite.Group()
all_sprites.add(gm)
def game_keys_out(ev, lst, amount):
out = []
char = 0
for i in range(amount):
player = lst[char]
out.append(game_keys(ev, player))
char += 1
return out
def knuthAgentTest():
newGame = GameManager()
knuth = Knuth(newGame, verbose=True)
knuth.play()
def delta_time():
game_manager_instance = GameManager.GameManager()
return game_manager_instance.delta_time
def main():
fileConfig("logging_config.ini")
manager = GameManager()
manager.run()
