def get_computer_move():
state = json.load(request.body)
print(state)
board_array = state['game_board']
to_play_id = state['to_play_id']
current_state = GameState(board_array, to_play_id)
_, preds, moves = ai_player.get_preds(current_state)
computer_move = np.argmax(preds)
board_array[computer_move] = to_play_id
new_game_state = GameState(board_array, -to_play_id)
to_play = 'player2' if state['to_play'] == 'player1' else 'player1'
rv = {
'player1': state['player1'],
'player2': state['player2'],
'game_board': new_game_state.board,
'endgame': new_game_state.isEndGame,
'to_play': to_play,
'legal_moves': new_game_state._allowedActions(),
'to_play_id': -to_play_id
}
if rv[to_play] == 'assisted':
_, preds, moves = ai_player.get_preds(new_game_state)
print(preds)
print(list(np.argpartition(preds, -3)[-3:]))
rv['legal_moves'] = list(np.argpartition(preds, -3)[-3:])
return json.dumps(rv)
def play():
req = json.load(request.body)
print(req)
state = req['current_state']
board_array = state['game_board']
board_array[req['move']] = 1 if state['to_play'] == 'player1' else -1
to_play_id = -state['to_play_id']
new_game_state = GameState(board_array, to_play_id)
to_play = 'player2' if state['to_play'] == 'player1' else 'player1'
rv = {
'player1': state['player1'],
'player2': state['player2'],
'game_board': new_game_state.board,
'endgame': new_game_state.isEndGame,
'to_play': to_play,
'legal_moves': new_game_state._allowedActions(),
'to_play_id': to_play_id
}
if rv[to_play] == 'assisted':
_, preds, moves = ai_player.get_preds(new_game_state)
print(preds)
print(list(np.argpartition(preds, -3)[-3:]))
rv['legal_moves'] = list(np.argpartition(preds, -3)[-3:])
return json.dumps(rv)
def backFill(self, leaf, value, breadcrumbs):
lg.logger_mcts.debug('------DOING BACKFILL------')
currentPlayer = GameState.current_player_from_id(leaf.state_id)
for edge in breadcrumbs:
playerTurn = GameState.current_player_from_id(edge.inNode.state_id)
if playerTurn == currentPlayer:
direction = 1
else:
direction = -1
edge.stats['N'] = edge.stats['N'] + 1
edge.stats['W'] = edge.stats['W'] + value * direction
edge.stats['Q'] = edge.stats['W'] / edge.stats['N']
lg.logger_mcts.debug(
'updating edge with value %f for player %d... N = %d, W = %f, Q = %f',
value * direction, playerTurn, edge.stats['N'],
edge.stats['W'], edge.stats['Q'])
if lg.logger_mcts.isEnabledFor(logging.DEBUG):
lg.logger_mcts.debug(
GameState.from_id(edge.outNode.state_id,
config.GRID_SHAPE).render())
def test_id(self):
"""Je transforme les victoires de test_victory_true_4 en id"""
"""Puis je crée un GameState à partir de cet id"""
"""Et je teste si le nouveau GameState est égal à l'ancien"""
for ligne in range(GRID_SHAPE[0] + 1 - NB_TOKENS_VICTORY,
GRID_SHAPE[0]):
for column in range(0, GRID_SHAPE[1] + 1 - NB_TOKENS_VICTORY):
#On aligne 4 PLAYER_1 dans la diagonale dont le point de départ (bas,gauche) est (ligne,column)
board = np.full(GRID_SHAPE, NONE, dtype=np.int8)
for i, j in zip(range(ligne, ligne - NB_TOKENS_VICTORY, -1),
range(column, column + NB_TOKENS_VICTORY)):
board[i, j] = PLAYER_1
board[0:i, j] = PLAYER_2
board[i, 0:j] = PLAYER_2
#On remplit les lignes sous ligne avec PLAYER_2
board[0:ligne - 3, :] = PLAYER_2
game_state = GameState(currentPlayer=PLAYER_1, board=board)
id = game_state.id
new_game_state = GameState.from_id(id, board.shape)
# See https://stackoverflow.com/questions/3302949/best-way-to-assert-for-numpy-array-equality
self.assertIsNone(
np.testing.assert_array_equal(new_game_state.board,
game_state.board))
self.assertEqual(new_game_state.currentPlayer,
game_state.currentPlayer)
def route(game_id, data, userid, username):
command = None
params = []
if data:
command = COMMAND_MAPPINGS.get(data[0].lower())
if len(data) > 1:
params = data[1:]
if command:
game_state = GameState()
game_state.load(game_id)
try:
return command(commands.Game(game_state), params, userid, username).to_json()
finally:
game_state.save(game_id)
return {
"text": u"""Usage: /slack command, where commands are:
reset [confirm]: reset the game if "confirm" is passed as the parameter
setup [add|remove]: display the current setup. If add is the parameter, add rest of text as setup text. If remove, remove the nth item.
pool [reroll|setup]: show the current dice pool. if setup passed as a parameter, setup the initial pool. if reroll passed in, reroll all dice in the pool.
register [name]: register your player name with the game
unregister [name]: unregister yourself or the specified user
status: output current status to channel
take [color number]: take a die from the pool
give [color number] [user]: give a die to another player. use "pool" as player name to return to the pool.
roll: roll all your dice and give the aggregate score
spend: spend one your dice (so you no longer have it)"""
}
def evaluateLeaf(self, leaf, value, done, breadcrumbs):
lg.logger_mcts.debug('------EVALUATING LEAF------')
if not done:
state = GameState.from_id(leaf.state_id, config.GRID_SHAPE)
value, probs, allowedActions = self.get_preds(state)
lg.logger_mcts.debug('PREDICTED VALUE FOR %d: %f',
state.currentPlayer, value)
for idx, allowedAction in enumerate(allowedActions):
if allowedAction:
newState, _, _ = state.takeAction(idx)
if newState.id not in self.mcts.tree:
node = mc.Node(newState)
self.mcts.addNode(node)
lg.logger_mcts.debug('added node...%s...p = %f',
node.state_id, probs[idx])
else:
node = self.mcts.tree[newState.id]
lg.logger_mcts.debug('existing node...%s...',
node.state_id)
newEdge = mc.Edge(leaf, node, probs[idx], idx)
leaf.edges.append((idx, newEdge))
else:
lg.logger_mcts.debug(
'GAME VALUE FOR %d: %f',
GameState.current_player_from_id(leaf.state_id), value)
return ((value, breadcrumbs))
def init_new_game(self):
self.game = GameState(self.display,
level=([(2, 2)] if self.dev else None))
self.game.listen('menu-click', self.on_menu_click)
self.game.listen('game-over', self.on_game_over)
self.solver.game = self.game
self.game_over_state.game = self.game
def test_victory_false_3(self):
grid_shape = GRID_SHAPE
board = np.full(grid_shape, NONE, dtype=np.int8)
board[0, 3] = PLAYER_1
game_state = GameState(grid_shape=grid_shape,
currentPlayer=PLAYER_1,
board=board)
is_victory = game_state._isVictory(3, PLAYER_1)
self.assertEqual(is_victory, False)
def state(slug):
valid_chars(slug)
body = request.json
if body['newOrLoad'] == 'new':
game_state = GameState.new(slug, body['password'])
if body['newOrLoad'] == 'load':
game_state = GameState.load(slug, body['password'])
if game_state is None:
raise NotFound("Game %s does not exist" % slug)
db.save(slug, game_state.data)
return make_response(game_state)
def __init__(self):
super().__init__()
self.setWindowTitle('Space Invaders')
self.ui = GUI()
self.setFixedSize(Constants.WINDOW_WIDTH, Constants.WINDOW_HEIGHT)
self.setWindowIcon(self.ui.icon)
self.current_mode = WindowMode.CHOICE_LEVEL
self.update_timer = QtCore.QTimer()
self.update_timer.timeout.connect(self.update)
self.update_timer.start(10)
self.button_record = Rectangle(90, 430, 430, 53)
self.button_select = Rectangle(90, 500, 430, 53)
self.current_level = 0
try:
levels = AllLevels(AllLevels.LEVELS_FILE)
except EmptyLevelsFile as e:
QtWidgets.QMessageBox.critical(
self, "Failed to launch the game",
f"{AllLevels.LEVELS_FILE} is empty. Write levels for the game",
QtWidgets.QMessageBox.Ok)
sys.exit(8)
except Exception as e:
QtWidgets.QMessageBox.critical(
self, "Failed to launch the game",
f"{AllLevels.LEVELS_FILE} not found: \n{e}",
QtWidgets.QMessageBox.Ok)
sys.exit(7)
self.count_levels = levels.get_count_level()
self.game = GameState(levels, QtCore.QTimer.stop, QtCore.QTimer.start)
self.game.init_game(**self.get_game_timer())
self.update_timer = QtCore.QTimer()
self.update_timer.timeout.connect(self.update_timeout)
self.update_timer.start(10)
self.previous_score = self.game.score
self.previous_ship_live = self.game.ship.live
self.previous_game_mode = self.game.current_mode
self.music = Music()
self.music.play_background()
self.scoreboard = Scoreboard(self.count_levels)
self.current_player = None
self.names_players = self.scoreboard.get_players()
self.show()
self.show_name_choice()
def minimax_alpha_beta(moves_log,
state: game.GameState,
max_player: MinimaxPlayer,
max_depth=5,
depth=0,
alpha=-INF,
beta=INF) -> (int, int):
winner = state.get_winner()
if winner is not None:
# TODO: consider depth
score = INF - depth if winner is max_player else -INF + depth
return NO_MOVE, score # state.eval_state()
moves = game.to_non_empty(state.get_moves())
if not moves:
return NO_MOVE, TIE_SCORE
moves = list(moves)
random.shuffle(moves)
if depth >= max_depth:
return NO_MOVE, state.eval()
is_max_player = (depth % 2 == 0)
best_moves = []
best_score = None
for move in moves:
recursive_score = \
minimax_alpha_beta(moves_log + [move], state.move(move), max_player, max_depth, depth + 1, alpha, beta)[1]
if is_max_player:
if best_score is None or recursive_score > best_score:
best_score = recursive_score
best_moves = [move]
if best_score > alpha:
alpha = recursive_score
elif recursive_score == best_score:
best_moves.append(move)
else:
if best_score is None or recursive_score < best_score:
best_score = recursive_score
best_moves = [move]
if best_score < beta:
beta = recursive_score
elif recursive_score == best_score:
best_moves.append(move)
if alpha > beta:
break
# print(f'Depth {depth}/{max_depth}: [{",".join(str(i) for i in moves_log)}] | '
# f'As {state.get_curr_player().get_char()}, '
# f'my best moves are: [{",".join(str(i) for i in best_moves)}] with score: {best_score}')
return random.choice(best_moves) if best_moves else None, best_score
class TestHit(unittest.TestCase):
def setUp(self):
self.mock_1 = GameState(['AB', 'CD'], 301, 'fake1', True)
self.mock_1.advance_player()
self.mock_1.add_dart('T20', 60)
self.mock_1.add_dart('T20', 60)
self.res = hit(self.mock_1)
def test_a(self):
assert len(self.res) > 0
self.assertIn({'use': False, 'text': 'score_120', 'weight': 150}, self.res)
def test_b(self):
for e in self.res:
self.assertIn(e['text'], texts)
def test_angle():
state = GameState(1, 1)
print "Convert 45 to simple ", state.angle_to_simp(45)
print "Convert 45 to geo ", state.angle_to_geo(45)
print "Convert 90 to simple ", state.angle_to_simp(90)
print "Convert 90 to geo ", state.angle_to_geo(90)
print "Convert 270 to simple ", state.angle_to_simp(270)
print "Convert 270 to geo ", state.angle_to_geo(270)
def get_action(self, state: GameState, connection):
# TODO: Doc
options = state.get_valid_actions()[:]
for option in options:
new_state = state.apply_action(option, self.other_type)
is_term, winner = new_state.is_terminal()
if is_term and winner > 0:
return option
new_state = state.apply_action(option, self.type)
is_term, winner = new_state.is_terminal()
if is_term and winner < 0:
return option
choice = random.choice(options)
return choice
def start(player_token, gm_token, state_file_path, name, token_path):
logging.basicConfig(
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
if Path(state_file_path).exists():
with open(state_file_path, 'r') as f:
game_state = json.load(f)
logger.info('Loaded existing state.')
else:
game_state = GameState(name)
logger.info('Created new state.')
session.state = game_state
session.player_token = player_token
session.gm_token = gm_token
session.state_file_path = state_file_path
initialize_handlers()
with open(token_path, 'r') as f:
telegram_token = f.read()
start_server(telegram_token)
def test_game_starts_at_default_start(self):
from game import GameState
game = new_game(configuration={'default': 'test'})
test = GameState('test')
game.add_state(test)
self.assertEquals('test', game.state)
self.assertEquals('sms', game.type)
def create_phase_loader(self) -> PhaseLoader:
if not self.tiles:
location_map = DEFAULT_LOCATIONS
else:
location_map = self.load_tiles(self.tiles)
assert self._location_spec in {LocationTransformer.ROLL_SPEC, LocationTransformer.DIRECT_SPEC}, \
f'Unknown location spec {self._location_spec}'
location_transformer = LocationTransformer(self._location_spec, location_map)
assert 0 < len(self.players) == len(self.cards) <= 5, 'Improper number of players/cards'
assert len(set(self.players)) == len(self.players), 'Players not unique'
player_hands = dict(zip(self.players, self.cards))
assert self.governor_location is not None and self.smuggler_location is not None, \
'Missing location of governor or smuggler'
governor_location = location_transformer.apply(self.governor_location)
smuggler_location = location_transformer.apply(self.smuggler_location)
assert sum(self.small_demand.values()) == sum(self.large_demand.values()) == 5, 'Missing large or small demand'
game_state = GameState(
self.players,
location_map,
self.small_demand,
self.large_demand,
governor_location,
smuggler_location,
player_hands,
)
return PhaseLoader(game_state, location_transformer)
def harvest():
data = request.json # data={slug,x,y,password}
game_state = GameState.load(data['slug'], data['password'])
message = game_state.harvest(data['x'], data['y'])
game_state.add_recipes()
db.save(data['slug'], game_state.data)
return make_response(game_state, message)
def test_act_game_mid_3(self):
"""PLAYER_2 should chose action 4, in order to win"""
"""Because whatever PLAYER_1 does after that, PLAYER_2 wins"""
agent = self.init_random_agent(mcts_sims=5000)
board = np.full(config.GRID_SHAPE, config.NONE, dtype=np.int8)
# X = PLAYER_1 , O = PLAYER_2
#['-', '-', '-', '-', '-', '-', '-']
#['-', '-', '-', '-', '-', '-', '-']
#['-', '-', '-', 'X', '-', '-', '-']
#['-', '-', '-', 'O', '-', '-', '-']
#['X', 'X', '-', 'X', '-', '-', '-']
#['X', 'O', '-', 'O', '-', 'O', '-']
board[0,
0] = board[1,
0] = board[1,
1] = board[1,
3] = board[3,
3] = config.PLAYER_1
board[0, 1] = board[0, 3] = board[2, 3] = board[0, 5] = config.PLAYER_2
game_state = GameState(grid_shape=config.GRID_SHAPE,
currentPlayer=config.PLAYER_2,
board=board)
# act(game_state, 1) : learning mode
# act(game_state, 0) : deterministic
action, pi, MCTS_value, NN_value = agent.act(game_state, 1)
self.assertEqual(action, 4)
self.assertNotEqual(MCTS_value, config.VALUE_VICTORY)
def is_winner(self, player: str) -> bool:
""" Check if player is the winner
"""
enemy = GameState(player).get_next_player()
return self.is_over(self.current_state)\
and self.current_state.hands[enemy][LEFT_HAND] == 0 \
and self.current_state.hands[enemy][RIGHT_HAND] == 0
def unlock():
data = request.json # data={slug,x,y,password}
game_state = GameState.load(data['slug'], data['password'])
message = game_state.unlock(data['x'], data['y'])
game_state.check_cash()
db.save(data['slug'], game_state.data)
return make_response(game_state, message)
def test_overharvest(self):
slug = "TEST" + uuid.uuid4().hex
gs = GameState.new(slug, 'pwd')
recipe_id = CONFIG.general['firstRecipe']
seed_id = CONFIG.recipes[recipe_id]['seedId']
seed_data = CONFIG.seeds[seed_id]
gs.buy(recipe_id)
gs.sow(seed_id, 0, 0)
plot = gs.get_plot(0, 0)
plot['sowTime'] -= seed_data[
'harvestTimeSeconds'] * 1000 + 3000 # set plant time to long enough ago that we can harvest
cash_before = gs.data['resources'][CONFIG.CASH_RESOURCE]
gs.data['seedCounts'][seed_id] = CONFIG.general['max_seed_count']
msg = gs.harvest(0, 0)
# hacky way to extract number of seeds harvested
seeds_generated = seed_data['seed']
if 'Got ' in msg:
seeds_generated += int(msg.split('Got ')[1].split()[0])
cash_after = gs.data['resources'][CONFIG.CASH_RESOURCE]
expected_cash_after = cash_before + seed_data['yield'][
CONFIG.CASH_RESOURCE] + seeds_generated * seed_data['sellCost']
self.assertEqual(
cash_after, expected_cash_after,
"Did not get the correct amount of money when breaking seed limit. Got $%s, expected $%s"
% (cash_after, expected_cash_after))
def _game_state(board):
return GameState(board=board,
offense=None,
defense=None,
turn_count=1,
move_count=1,
to_move=None)
def sell():
data = request.json # data={slug,seed,password}
game_state = GameState.load(data['slug'], data['password'])
message = game_state.sell(data['seed'])
game_state.check_cash()
db.save(data['slug'], game_state.data)
return make_response(game_state, message)
def board_demo():
gs = GameState()
zidaan_player = gs.players['Zidaan']
zidaan_player.create_unit(Worker, location=3)
zidaan_player.create_unit(Worker, location=5)
zidaan_player.create_unit(Combat, location=0)
zidaan_player.create_unit(Combat, location=11)
zidaan_player.create_unit(Hero, location=10)
print("\n=============== BOARD DEMO ===============")
print("\nZidaan Resource Layout")
zidaan_player.board.display('board')
print("\nZidaan Unit Layout")
zidaan_player.board.display('units')
print("\nPlayer Resource Count BEFORE Gathering")
zidaan_player.display_resource_count()
print("\nPlayer Resource Count AFTER Gathering")
zidaan_player.gather_resources()
zidaan_player.display_resource_count()
print("")
def state_value(self, state: GameState) -> float:
"""Return the probability of the state being winning from the neural network"""
prob_distribution = self.neural_network.predict_proba([state.vector_representation()])[0]
# The first value in prob_distribution is the probability of the value being -1
# and the second is the probability of the value being 1
if self.is_player1:
return prob_distribution[1]
return prob_distribution[0]
def __init__(self, model):
if model is None: #create new model
# init
garbage = GameState()
shape = garbage.board.shape
output_size = garbage.action_size()
del garbage
# Neural net
input_board = Input(shape=shape)
input_board_reshaped = Reshape(
(shape[0], shape[1], 1))(input_board)
conv1 = Activation('relu')(BatchNormalization(axis=3)(
Conv2D(nnet_args.filters, (4, 4),
padding='same')(input_board_reshaped)))
conv2 = Activation('relu')(BatchNormalization(axis=3)(Conv2D(
nnet_args.filters, (3, 3), padding='same')(conv1)))
conv3 = Activation('relu')(BatchNormalization(axis=3)(Conv2D(
nnet_args.filters, (3, 3), padding='same')(conv2)))
conv4 = Activation('relu')(BatchNormalization(axis=3)(Conv2D(
nnet_args.filters, (3, 3), padding='same')(conv3)))
#conv4 -> pi
conv_pi = Activation('relu')(BatchNormalization(axis=3)(Conv2D(
nnet_args.pi_filters, (1, 1))(conv4)))
conv_pi_flat = Flatten()(conv_pi)
pi = Dense(output_size, activation='softmax',
name='pi')(conv_pi_flat)
#conv4 -> v
conv_v = Activation('relu')(BatchNormalization(axis=3)(Conv2D(
nnet_args.v_filters, (1, 1))(conv4)))
conv_v_flat = Flatten()(conv_v)
hidden_v = Dense(nnet_args.hidden_dense,
activation='relu')(conv_v_flat)
v = Dense(1, activation='sigmoid', name='v')(hidden_v)
self.model = Model(inputs=input_board, outputs=[pi, v])
self.model.compile(
loss=['categorical_crossentropy', 'mean_squared_error'],
optimizer=Adam(nnet_args.lr)) #maybe todo loss function
else:
self.model = load_model(global_args.save_dir + str(model) + '.h5')
class Game:
"""
The core of the application.
"""
def __init__(self, layout, agents, display_class, turn=AgentRole.Mr_X):
self.gameState = GameState(GameStateData(layout, agents))
self.turn = turn
# create a new <type>+Display object
self.display = display_class(self.gameState.data)
self.MOD = len(agents) # number of players
def run(self):
"""
The main loop of the application.
"""
self.display.start()
counter = 0
while self.gameState.isEndState(self.turn) == (False, None, ""):
# ask for an action and create the new game state
self.display.wait()
new_action = self.gameState.data.getAgent(counter).getAction(
self.gameState, self.display)
if not new_action is None: # if there is a possible action, do it
self.gameState = self.gameState.generateSuccessor(
counter, new_action)
else:
self.display.wait()
# update the display
self.display.update(self.gameState.data)
self.display.wait()
# update the player turn
counter += 1
counter = counter % self.MOD
self.turn = AgentRole.Mr_X if counter == 0 else AgentRole.COP
# end of the main while loop
self.display.showMessage("GAME OVER\n\n" +
self.gameState.isEndState(self.turn)[2])
self.display.waitQuit()
self.display.finish()
def recipe():
data = request.json # data={slug,password}
game_state = GameState.load(data['slug'], data['password'])
known_recipes = {}
for recipe_id in CONFIG.recipes:
if game_state.is_known_recipe(recipe_id):
known_recipes[recipe_id] = CONFIG.recipes[recipe_id]
return make_response(game_state, recipes=known_recipes)
def test_victory_true_2(self):
"""Victoires en colonne"""
grid_shape = GRID_SHAPE
for ligne in range(0, GRID_SHAPE[0] + 1 - NB_TOKENS_VICTORY):
for column in range(0, GRID_SHAPE[1]):
#On met toutes les façons d'aligner 4 PLAYER_1 dans la colonne column
board = np.full(grid_shape, NONE, dtype=np.int8)
board[ligne:ligne + NB_TOKENS_VICTORY, column] = PLAYER_1
#On remplit les lignes sous ligne avec PLAYER_2
board[0:ligne, :] = PLAYER_2
game_state = GameState(grid_shape=grid_shape,
currentPlayer=PLAYER_1,
board=board)
is_victory = game_state._isVictory(column, PLAYER_1)
self.assertEqual(is_victory, True)
def test_coord():
state = GameState(1, 1)
pt = [0, 0]
state.pt_to_geo(pt)
print "origin ", pt
pt = [1, 0]
state.pt_to_geo(pt)
print "x limit ", pt
pt = [0, 1]
state.pt_to_geo(pt)
print "y limit ", pt
def test_angle():
state = GameState(1,1)
print "Convert 45 to simple ", state.angle_to_simp(45)
print "Convert 45 to geo ", state.angle_to_geo(45)
print "Convert 90 to simple ", state.angle_to_simp(90)
print "Convert 90 to geo ", state.angle_to_geo(90)
print "Convert 270 to simple ", state.angle_to_simp(270)
print "Convert 270 to geo ", state.angle_to_geo(270)
def __init__(self, game_state: GameState, move: int, parent):
self.game_state = game_state
self.move = move
self.parent = parent
self.is_expanded = False
self.is_terminal = game_state.get_result() is not None
self.children = DictWithDefault(lambda move: UCTNode(
self.game_state.play(move), move, parent=self))
self.child_priors = np.zeros(
game_state.get_actions_size(), dtype=np.float32)
self.child_total_value = np.zeros(
game_state.get_actions_size(), dtype=np.float32)
self.child_number_visits = np.zeros(
game_state.get_actions_size(), dtype=np.int32)
self.child_player_changed = np.ones(
game_state.get_actions_size(), dtype=np.int32)
if tree_stats_enabled:
self.deepness = parent.deepness + 1
class TestSounds(unittest.TestCase):
def setUp(self):
self.mock_1 = GameState(['AB', 'CD'], 301, 'fake1', True)
self.mock_1.advance_player()
self.mock_1.add_dart('T20', 60)
self.mock_1.add_dart('T20', 60)
self.snd = ISATSounds(test=True)
def test_events_0(self):
methods = ['DartStuck', 'ManualNextPlayer']
for m in methods:
getattr(self.snd, m)()
def test_events_1(self):
methods = ['FrameStarted']
for m in methods:
getattr(self.snd, m)(self.mock_1)
def test_events_2(self):
methods = ['Hit', 'HitBust', 'HitWinner', 'EnterHold']
for m in methods:
getattr(self.snd, m)(self.mock_1, 'T20')
def test_coord():
state = GameState(1,1)
pt = [0, 0]
state.pt_to_geo(pt)
print "origin ", pt
pt = [1, 0]
state.pt_to_geo(pt)
print "x limit ", pt
pt = [0, 1]
state.pt_to_geo(pt)
print "y limit ", pt
def process_message(self):
'''
Recieve xml data as parameter and calls appropriate methods
for specific type of messges
'''
messageType = self.root.tag
if messageType == "ChatMessage":
self.messageDispley.insert(END,self.root[0].text+'\n')
# if game is full we receive message and set shared object canJoin to false
if self.root[0].text.startswith('Unable to join'):
print "SANJA"
self.canJoin = False
#unable to join massage processed so enable joinEvent,
self.joinEvent.set()
#trying to start game ****TO BE CHANGED***
if self.root[0].text.startswith('Start game'):
self.game = None
self.gameThread = thread.start_new_thread(self.start_game, (2,))
elif messageType == "ListOfGames":
#****Mora posebna metoda koja nema parametre jedino tako radi***
self.list_all_games(self.gameList)
elif messageType == "ListOfPlayers":
self.list_all_games(self.playersList)
#if there is more then tow players in game enable startGameButton
if len(self.playersList.get(0, END)) > 1:
self.startGameButton.config(state=NORMAL)
elif messageType == "GameState":
if self.initialGameState:
self.gameStateEvent.clear()
self.game = GameState(self.root,self.client.comSocket.getsockname()[1])
self.gameStateEvent.set()
self.initialGameState = False
else:
self.game.changeGameState(self.root)
print str(self.game.playersList[self.game.ourIndex].fingersRight) + '->' + self.game.playersList[self.game.ourIndex].playerName
else:
print "Error while processing massages"
def __init__(self, parent, image_repository):
super(Board, self).__init__(parent)
self.started = True
self.paused = False
self.image_repository = image_repository
self.config = Config.get()
self.size = 50
self.grid = Grid.random(self.config.properties['board_width'], self.config.properties['board_height'],
self.config.properties['rock_count'], self.config.properties['diamond_count'])
self.game_state = GameState(self.grid, self.grid.cells[1][1], self)
for x in range(self.grid.width):
for y in range(self.grid.height):
self.grid.cells[x][y].game_state = self.game_state
self.initUI()
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.update_game)
self.timer.start(100)
def setUp(self):
self.mock_1 = GameState(['AB', 'CD'], 301, 'fake1', True)
self.mock_1.advance_player()
self.mock_1.add_dart('T20', 60)
self.mock_1.add_dart('T20', 60)
self.res = hit(self.mock_1)
#!/usr/bin/env python import sys from eval import I, is_int from game import GameState #DEBUG = sys.argv[1] == '0' DEBUG = False g= GameState(sys.argv[1],debug=DEBUG,eval_=True) g.start() Turn=g.turn def buildno(n,m=0): if n==m: if m==0: return ['zero'] else: return [] elif (n%2==0) and ((m==0) or (n/m>=2)): return ['dbl']+buildno(n/2,m) else: return ['succ']+buildno(n-1,m) def log(msg, s='x'): if DEBUG: print >>sys.stderr, s*70, 'OP', msg class comb(int): def __init__(self,i,clear=False):
def test_put(self):
mf = GameState({})
mf.put('foo','bar',{'quux': True})
self.assertEquals({'foo': {'bar': {'quux': True}}},mf.data)
def test_delete(self):
mf = GameState({'a': {'b':True}})
mf.delete('a','b')
self.assertEquals(mf.data, {'a': {}})
class App(object):
def __init__(self, dev=False):
self.dev = dev
pygame.init()
self.display = pygame.display.set_mode((320, 420))
pygame.display.set_caption('Lights poof!')
self.init_bg_surface()
self.solver = SolverState(self.display)
self.solver.listen('done-solving', self.on_solver_done)
self.game_over_state = GameOverState(self.display)
self.game_over_state.listen('resume-click', self.on_resume_click)
self.game_over_state.listen('new-click', self.on_new_click)
self.game_over_state.listen('restart-click', self.on_restart_click)
self.game_over_state.listen('solve-click', self.on_solve_click)
self.init_new_game()
self.menu = MenuState(self.display)
self.menu.listen('resume-click', self.on_resume_click)
self.menu.listen('new-click', self.on_new_click)
self.menu.listen('restart-click', self.on_restart_click)
self.menu.listen('solve-click', self.on_solve_click)
self.current_state = None
self.set_state(self.game)
def main_loop(self):
while True:
for event in pygame.event.get():
self.handle(event)
self.draw()
time.sleep(.01)
def draw(self):
# Draw background.
self.display.blit(self.bg_surface, (0, 0))
# Draw the state.
self.current_state.draw()
# Update the display.
pygame.display.update()
def handle(self, event):
if event.type == QUIT or (event.type == KEYUP and event.key == 27):
pygame.quit()
sys.exit()
else:
self.current_state.handle(event)
def init_bg_surface(self):
bg_image = pygame.image.load('img/bg.png')
self.bg_surface = pygame.Surface(self.display.get_size())
x = y = 0
image_width, image_height = bg_image.get_size()
bg_width, bg_height = self.display.get_size()
while x < bg_width:
y = 0
while y < bg_height:
self.bg_surface.blit(bg_image, (x, y))
y += image_height
x += image_width
def init_new_game(self):
self.game = GameState(self.display,
level=([(2, 2)] if self.dev else None))
self.game.listen('menu-click', self.on_menu_click)
self.game.listen('game-over', self.on_game_over)
self.solver.game = self.game
self.game_over_state.game = self.game
def set_state(self, state):
old_state = self.current_state
self.current_state = state
if hasattr(old_state, 'deactivated'):
old_state.deactivated()
if hasattr(self.current_state, 'activated'):
self.current_state.activated()
def on_menu_click(self, event):
self.set_state(self.menu)
def on_game_over(self, event):
self.set_state(self.game_over_state)
def on_resume_click(self, event):
self.set_state(self.game)
def on_new_click(self, event):
self.init_new_game()
self.set_state(self.game)
def on_restart_click(self, event):
self.game.restart()
self.set_state(self.game)
def on_solve_click(self, event):
self.set_state(self.solver)
def on_solver_done(self, event):
self.set_state(self.game)
def test_get(self):
mf = GameState({'foo': {'bar': {'quux': True}}})
self.assertEquals({'quux': True}, mf.get('foo','bar'))
class Board(QtGui.QFrame):
status_bar = QtCore.pyqtSignal(str)
def __init__(self, parent, image_repository):
super(Board, self).__init__(parent)
self.started = True
self.paused = False
self.image_repository = image_repository
self.config = Config.get()
self.size = 50
self.grid = Grid.random(self.config.properties['board_width'], self.config.properties['board_height'],
self.config.properties['rock_count'], self.config.properties['diamond_count'])
self.game_state = GameState(self.grid, self.grid.cells[1][1], self)
for x in range(self.grid.width):
for y in range(self.grid.height):
self.grid.cells[x][y].game_state = self.game_state
self.initUI()
self.timer = QtCore.QTimer()
self.timer.timeout.connect(self.update_game)
self.timer.start(100)
def initUI(self):
pal = QtGui.QPalette(self.palette())
pal.setColor(QtGui.QPalette.Background, QtCore.Qt.black)
self.setAutoFillBackground(True)
self.setPalette(pal)
self.show()
def update_game(self):
if not self.paused:
self.game_state.update()
if self.started and self.game_state.score < self.config.properties['diamond_count']:
self.status_bar.emit("Score: " + str(self.game_state.score) +
"/" + str(self.config.properties['diamond_count']))
elif self.started and self.game_state.score == self.config.properties['diamond_count']:
self.status_bar.emit("You win!!!")
self.timer.stop()
else:
self.status_bar.emit("Game over")
self.timer.stop()
self.update()
else:
self.status_bar.emit("Paused")
def paintEvent(self, e):
qp = QtGui.QPainter()
qp.begin(self)
self.drawBrushes(qp)
qp.end()
def drawBrushes(self, qp):
for x in range(self.grid.width):
for y in range(self.grid.height):
if self.grid.cells[x][y]:
pixmap = self.image_repository.get_pixmap(self.grid.cells[x][y].PIXMAP,
self.size, self.size)
qp.drawPixmap((x - self.game_state.camera_x + 9) * self.size,
(y - self.game_state.camera_y + 7) * self.size, pixmap)
pixmap = self.image_repository.get_pixmap('gameHero', self.size, self.size)
qp.drawPixmap((self.game_state.hero.x - self.game_state.camera_x + 9) * self.size,
(self.game_state.hero.y - self.game_state.camera_y + 7) * self.size, pixmap)
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_P:
self.paused = not self.paused
if not self.paused:
try:
self.game_state.player_displacement = {
QtCore.Qt.Key_Left: (-1, 0),
QtCore.Qt.Key_Right: (1, 0),
QtCore.Qt.Key_Down: (0, 1),
QtCore.Qt.Key_Up: (0, -1)
}[event.key()]
except:
pass
try:
player_num = int(raw_input(players_prompt))
except:
print "Please enter a value that makes sense."
players = []
for i in range(0, player_num):
pname = raw_input(name_prompt)
pcolor = raw_input(color_prompt)
player = Player(pname, pcolor)
players.append(player)
generator = MapGenerator()
game_map = generator.create_map('dirt', 40)
state = GameState(game_map=game_map, players=players)
print "\nBeginning deployment phase"
for i in range(0, player_num):
print player_deployments[i] % players[i].name
deploy_units(state, players[i])
while True:
for player in state.players:
player.begin_turn()
display_turn_menu(state, player)
if not player.is_alive():
game_over(state, player)
state.play()
class ChatMainForm(Template):
'''
Class for graphic presentation of chat client.
Main form with chat, list of created games, button for creating game.
If you created game button becomes start game.
ChatMainForm form with textbox, entry, listbox and button.
'''
def __init__(self, parent,name):
'''
Initialize all gui components...
parent represents root of tk window
name is name that client entered
Creates instance of client class and starts thread for receiving messages
'''
Template.__init__(self, parent)
self.client = ChatClient.ChatClient()
#where to put try block here or in connect method
self.client.connect_to_server()
self.end = False #for stopping receiving thread
self.name = name
#start new thread
self.thread=thread.start_new_thread( self.receive_server_messages, (1,) )#!!!doesn't work without second argument
#send first message with name
self.client.send_message(self.name)
self.parent = parent
self.initUI()
def initUI(self):
'''
Initialize all gui components
'''
self.nameText = Label(self, text="Chat")
self.nameText.place(x=270, y=10)
self.nameText3 = Label(self, text="Players in game")
self.nameText3.place(x=50,y=10)
self.nameText2 = Label(self, text="Game list ")# **********Popravi ovo!!!!!!********
self.nameText2.place(x=50,y=10)
#display chat messages
self.messageDispley = Text(self,font=tkFont.Font(family="Calibri",size=10),width=28,height=13)
self.messageDispley.place(x=270, y=40)
self.messageDispley.insert(END,"Welcome...\n")
#write text messages
self.message = StringVar()
self.messageText =Entry(self, textvariable=self.message, width=28)
self.messageText.place(x=270, y=275)
#send chat massage
self.nameButton = Button(self, text="Send", width=26, command=self.send_chat_message)
self.nameButton.place(x=270, y=300)
#lists players in specific game
self.playersList = Listbox(self)
self.playersList.place(x=50, y=30)
#lists all games
self.gameList = Listbox(self)
self.gameList.place(x=50, y=30)
#join created game
self.joinGameButton = Button(self,text="Join game",width=15, command=self.send_join_message)
self.joinGameButton.place(x=50, y=230)
#start created game
self.startGameButton = Button(self,text="Start game",width=15, command=self.send_game_start_message)
self.startGameButton.place(x=50, y=270)
#create new game
self.createGameButton = Button(self,text="Create new game",width=15, command=self.create_new_game)
self.createGameButton.place(x=50, y=270)
def send_game_start_message(self):
'''
Sends signal to server that game is starting
'''
self.startGameButton.config(state=DISABLED)
self.client.send_message("Start game")
def send_join_message(self):
'''
Hides 'create new game' and 'Join game' buttons and
shows 'Players list' listbox.
Send message with selected game to server
'''
#first we think you can join
self.canJoin = True
items = self.gameList.curselection()
#if nothing is selected
if items == tuple():
return
# creating xml document to be send
root2 = etree.Element("JoinGame")
ge = etree.SubElement(root2, "game").text = self.gameList.get(items[0])
self.client.send_message(etree.tostring(root2))
#join massage send
self.joinEvent.clear()
#first receive_server_messages thread needs to finish processing message from server
self.joinEvent.wait()
print "BUHA"
#if we don't receive message from server we hide fields
if self.canJoin:
self.joinGameButton.place_forget()
self.createGameButton.place_forget()
self.gameList.place_forget()
self.nameText2.place_forget()
self.startGameButton.place_forget()
def create_new_game(self):
'''
Hides 'create new game' and 'Join game' buttons and
shows 'Start game' button and 'Players list' listbox.
'''
self.joinGameButton.place_forget()
self.createGameButton.place_forget()
self.gameList.place_forget()
self.nameText2.place_forget()
self.startGameButton.place(x=50, y=270)
#can't start until somebody joins
self.startGameButton.config(state=DISABLED)
self.client.send_message("Create game")
def send_chat_message(self):
'''
sends chat message to server
if message is 'Bye' ends program**to be changed**
'''
# creating xml document to be send
root2 = etree.Element("ChatMessage")
etree.SubElement(root2, "message").text = self.message.get()
self.client.send_message(etree.tostring(root2))
if self.message.get() =='Bye':
print 'sss'
self.client.comSocket.close
self.end = True
self.parent.destroy()
self.message.set('')
def find_next_player_index(self,currentPlayerIndex):
'''
finds index of next player on turn in playersList
'''
index = currentPlayerIndex + 1
if index == len(self.game.playersList):
index = 0
while index != currentPlayerIndex:
#print self.game.playersList[index].isOut
#print type(self.game.playersList[index].isOut)
if index == len(self.game.playersList):
index = 0
if str(self.game.playersList[index].isOut) == 'false':
#print 'aaaaaaaaa'
break
else:
index += 1;
#print index
return index
def start_game(self,id):
try:
white = (255, 255, 255)
# Call this function so the Pygame library can initialize itself
pygame.init()
# Create an 800x600 sized screen
self.screen = pygame.display.set_mode([800, 600])
# This sets the name of the window
pygame.display.set_caption('Fingers game')
clock = pygame.time.Clock()
done = False
firstClick = True
secondClick = False
# waits until process_message finish with game object
self.gameStateEvent.wait()
currentPlayer = self.game.playersList[self.game.ourIndex];
ourField = currentPlayer.field
nextField = None
hitting = None
hitted = None
print "AAAAAAAAAAA"
while done == False:
clock.tick(10)
nextIndex = self.find_next_player_index(self.game.ourIndex)
nextPlayer = self.game.playersList[nextIndex]
nextField = nextPlayer.field
for event in pygame.event.get():
if event.type == pygame.QUIT:
#enable all filed for choosing game
self.createGameButton.place(x=50, y=270)
self.joinGameButton.place(x=50, y=230)
self.nameText2.place(x=50,y=10)
self.gameList.place(x=50, y=30)
self.initialGameState = True
self.game = None
self.client.send_message("QUIT")
pygame.quit()
if event.type == pygame.MOUSEBUTTONDOWN:
x, y = event.pos
# if game is over we can't play
if self.game.gameOver == 'false':
if self.client.comSocket.getsockname()[1] == self.game.playerTurn:
if firstClick:
# check if left hand picture is clicked
if ourField.image1.get_rect(center=ourField.get_centers()[0]).collidepoint(x, y):
hitting = 'left'
firstClick = False
secondClick = True
# check if right hand picture is clicked
elif ourField.image2.get_rect(center=ourField.get_centers()[1]).collidepoint(x, y):
hitting = 'right'
firstClick = False
secondClick = True
elif secondClick:
# check if left hand picture is clicked
if nextField.image1.get_rect(center=nextField.get_centers()[0]).collidepoint(x, y) and nextPlayer.fingersLeft != 0:
hitted = 'left'
secondClick = False
#this turn over reset firstClick and secondClick
firstClick = True
secondClick = False
self.send_move_message(hitting, hitted)
# check if right hand picture is clicked
elif nextField.image2.get_rect(center=nextField.get_centers()[1]).collidepoint(x, y) and nextPlayer.fingersRight != 0:
hitted = 'right'
secondClick = False
#this turn over reset firstClick and secondClick
firstClick = True
secondClick = False
self.send_move_message(hitting, hitted)
#check if second hand is from same player and if separation is possible
elif ourField.image1.get_rect(center=ourField.get_centers()[0]).collidepoint(x, y):
if currentPlayer.fingersRight == 0 and (currentPlayer.fingersLeft == 2 or currentPlayer.fingersLeft == 4):
hitted = 'separation'
secondClick = False
print "SANJA"
#this turn over reset firstClick and secondClick
firstClick = True
secondClick = False
self.send_move_message(hitting, hitted)
else:
firstClick = True
elif ourField.image2.get_rect(center=ourField.get_centers()[1]).collidepoint(x, y):
print "BUHA1"
print currentPlayer.fingersLeft
if currentPlayer.fingersLeft == 0 and (currentPlayer.fingersRight== 2 or currentPlayer.fingersRight == 4):
print "SANJA"
hitted = 'separation'
secondClick = False
#this turn over reset firstClick and secondClick
firstClick = True
secondClick = False
self.send_move_message(hitting, hitted)
else:
firstClick = True
#write text on screen
myfont = pygame.font.SysFont("Comic Sans MS", 20)
winnerFont = pygame.font.SysFont("Comic Sans MS", 36)
#refresh screen
self.screen.fill((0, 0, 0))
if self.game.gameOver == 'true':
if not self.all_out():
labelWinner = winnerFont.render("**** Game over ****", 1, white)
labelWinner2 = winnerFont.render("**** somebody left :( *****", 1, white)
else:
labelWinner = winnerFont.render("*****Winner is " + self.return_winner_name() + " *****", 1, white)
labelWinner2 = winnerFont.render(" ", 1, white)
self.screen.blit(labelWinner, (180, 220))
self.screen.blit(labelWinner2, (180, 250))
label1 = myfont.render("You: " + self.game.playersList[self.game.ourIndex].playerName, 1, white)
label2 = myfont.render("Players turn: " + self.game.playersList[self.game.find_index(self.game.playerTurn)].playerName, 1, white)
#add text
self.screen.blit(label1, (40, 450))
self.screen.blit(label2, (40, 480))
#draw hands
self.game.draw_state(self.screen)
pygame.display.flip()
except:
traceback.print_exc()
def all_out(self):
'''
checks if only one player
is left in game
'''
return len([x for x in self.game.playersList if x.isOut == 'false']) == 1
def return_winner_name(self):
'''
returns winers name
'''
return next(x.playerName for x in self.game.playersList if x.isOut == 'false')
def send_move_message(self,hitting,hitted):
'''
creates and sends move message
based on hitting and hitted hands
'''
xmlroot = etree.Element("Move")
etree.SubElement(xmlroot, "playerPlayed").text = str(self.game.playerTurn)
etree.SubElement(xmlroot, "hittingHand").text = hitting
etree.SubElement(xmlroot, "hittedHand").text = hitted
print etree.tostring(xmlroot)
self.client.send_message(etree.tostring(xmlroot))
def process_message(self):
'''
Recieve xml data as parameter and calls appropriate methods
for specific type of messges
'''
messageType = self.root.tag
if messageType == "ChatMessage":
self.messageDispley.insert(END,self.root[0].text+'\n')
# if game is full we receive message and set shared object canJoin to false
if self.root[0].text.startswith('Unable to join'):
print "SANJA"
self.canJoin = False
#unable to join massage processed so enable joinEvent,
self.joinEvent.set()
#trying to start game ****TO BE CHANGED***
if self.root[0].text.startswith('Start game'):
self.game = None
self.gameThread = thread.start_new_thread(self.start_game, (2,))
elif messageType == "ListOfGames":
#****Mora posebna metoda koja nema parametre jedino tako radi***
self.list_all_games(self.gameList)
elif messageType == "ListOfPlayers":
self.list_all_games(self.playersList)
#if there is more then tow players in game enable startGameButton
if len(self.playersList.get(0, END)) > 1:
self.startGameButton.config(state=NORMAL)
elif messageType == "GameState":
if self.initialGameState:
self.gameStateEvent.clear()
self.game = GameState(self.root,self.client.comSocket.getsockname()[1])
self.gameStateEvent.set()
self.initialGameState = False
else:
self.game.changeGameState(self.root)
print str(self.game.playersList[self.game.ourIndex].fingersRight) + '->' + self.game.playersList[self.game.ourIndex].playerName
else:
print "Error while processing massages"
def list_all_games(self,listBox):
'''
Reads all <game> elements from xml
and shows them in gameList listbox
'''
#******Ovov nekad radi nekad ne*********
lis = []
print self.root[0]
for el in iter(self.root[0]):
lis.append(el.text)
listBox.delete(0, END)
for e in lis:
#t = e.text
listBox.insert(END,e)
def receive_server_messages(self,id):
'''
receives messages while main thread is running
'''
#event must be defined here because in process_message we
# create another event for every message, no good.
self.gameStateEvent = threading.Event()
#creating event for disabling thread while event is not set
self.joinEvent = threading.Event()
self.initialGameState = True
while not self.end:
try:
mes = self.client.comSocket.recv(1024)
# http://lxml.de/tutorial.html
print mes + '*****'
self.root = etree.fromstring(mes)
self.gameStateEvent.clear()
self.process_message()
#massage processed so enable joinEvent,
self.joinEvent.set()
except:
traceback.print_exc()
def setUp(self):
self.mock_1 = GameState(['AB', 'CD'], 301, 'fake1', True)
self.mock_1.advance_player()
self.mock_1.add_dart('T20', 60)
self.mock_1.add_dart('T20', 60)
self.snd = ISATSounds(test=True)
def main():
parse_args() # Sets CONFIG options.
# Must be called before UIManager instantiated.
pygame.init()
pygame.display.set_caption('Flippyflap Wivs')
environ['SDL_VIDEO_WINDOW_POS'] = 'center'
# Load high score
pd = PersistentData(DATA_PATH)
if path.exists(DATA_PATH):
pd.load()
else:
pd.high_score = 0
clock = pygame.time.Clock()
dt = 1
gdt = 60 / CONFIG.FPS_LIMIT
gs = GameState()
gd = GameData(pd.high_score)
uim = UIManager(gd.n_columns, gdt*gd.scroll_speed)
end = False
# Prep for game loop
pygame.mouse.set_visible(0)
pygame.event.set_allowed(None)
pygame.event.set_allowed(
(pygame.KEYDOWN, pygame.QUIT, pygame.MOUSEBUTTONDOWN)
)
# Game loop
while not end:
# Transition state
gs.transition_state()
# Handle Events
for event in pygame.event.get():
if event.type == pygame.QUIT:
end = True
elif event.type == pygame.KEYDOWN:
handle_event_keydown(gs, event)
elif event.type == pygame.MOUSEBUTTONDOWN:
handle_event_mousebuttondown(gs, event)
if gs.state == gs.QUIT:
end = True
if gs.state != gs.PAUSE:
# Update
gd.update(gs, gdt)
uim.update(gs, gd, dt)
gd.postupdate(gs, gdt)
# Draw
uim.draw()
# Cleanup
clock.tick(CONFIG.FPS_LIMIT)
fps = clock.get_fps()
gdt = 60 / (fps if fps > 15 else CONFIG.FPS_LIMIT)
dt = fps / CONFIG.FPS_LIMIT
pygame.event.pump()
# Save high score
pd.high_score = gd.high_score
pd.save()
pygame.quit()
