def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init()
self.settings = settings.Settings()
# Start game in an inactive state.
self.game_active = False
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height)
)
# self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
# self.settings.screen_width = self.screen.get_rect().width
# self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Alien Invasion")
# Create an instance to store game statistics and create a scoreboard.
self.stats = game_stats.GameStats(self)
self.sb = scoreboard.Scoreboard(self)
self.ship = ship.Ship(self)
self.background = background.Background(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
# Make the Play button.
self.play_button = button.Button(self, "Play")
def run_game():
pygame.init() # 初始化
set = settings.Settings() # 创建对象set获取Settings中的info
screen = pygame.display.set_mode(
(set.screen_width, set.screen_height)) # 这里填的是元组
pygame.display.set_caption("Chenlicheng") # 设置标题
ship_1 = ship.Ship(screen, set) # 创建了一艘船的实例
bullets = pygame.sprite.Group() # 创建了一个精灵的编组
aliens = pygame.sprite.Group() # 创建了一个外星人的编组
stats = game_stats.GameStats(set)
sb = scoreboard.Scoreboard(stats, set, screen) #创建一个积分的实例
play_button = button.Button(screen, "play")
game_functions.create_fleet(screen, set, aliens,
ship_1) # 创建了一些外星人,并且把它放到编组里
while True:
# 检查必须保持活跃,不然无法回到游戏中
game_functions.check_events(ship_1, screen, bullets, set, play_button,
stats) # 位置实参
if stats.game_active: # 飞船,子弹,外星人不再刷新,但是保持屏幕active
ship_1.update() # 更新ship的位置
game_functions.update_bullets(bullets, aliens, set, screen, ship_1,
stats, sb)
game_functions.update_aliens(aliens, set, ship_1, stats, bullets,
screen, sb)
game_functions.update_screen(set, screen, ship_1, bullets, aliens,
stats, play_button, sb)
def run_game():
pygame.init()
pygame.display.set_caption('Alien Invasion')
ai_setting = setting.Setting()
screen = pygame.display.set_mode(
(ai_setting.screen_width, ai_setting.screen_height))
ship = Ship(ai_setting, screen)
bullets = Group()
aliens = Group()
stats = game_stats.GameStats(ai_setting)
play_button = button.Button(ai_setting, screen, "Play")
sb = scoreboard.Scoreboard(ai_setting, screen, stats)
game_functions.create_fleet(ai_setting, screen, ship, aliens)
while True:
game_functions.check_events(ai_setting, screen, stats, sb,
play_button, ship, aliens, bullets)
if stats.game_active:
ship.update()
game_functions.update_bullets(ai_setting, screen, stats,
sb, ship, aliens, bullets)
game_functions.update_aliens(ai_setting, screen, stats,
sb, ship, aliens, bullets)
game_functions.update_screen(ai_setting, screen, stats, sb,
ship, aliens, bullets, play_button)
def rungame():
pygame.init()
score = 0
game_settings = settings.Settings()
screen = pygame.display.set_mode(
(game_settings.screen_w, game_settings.screen_h))
sb = scoreboard.Scoreboard(screen, score)
ship = Ship(screen, game_settings)
d_n_f = dnf.Dnf(screen, game_settings)
play_button = Button(screen, 'PLAY')
exit_button = Button(screen, 'exit')
pygame.display.set_caption("avoid the dnfs!")
while game_running:
gf.check_events(ship)
d_n_f.update(game_settings, score, sb, ship, game_running, hs,
exit_button)
sb.update(score, hs)
ship.update(game_settings)
gf.update_screen(screen, game_settings, ship, d_n_f, sb)
def run_game():
# 初始化游戏并创建一个屏幕对象
# 实例化类
ai_settings = settings.Settings()
pygame.init()
screen = pygame.display.set_mode((ai_settings.screen_width,
ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# 创建一个船的实例
aship = ship.Ship(ai_settings, screen)
# 创建一个用于存储子弹的编组
bullets = pygame.sprite.Group()
# 创建一个用于储存外星人的编组
aliens = pygame.sprite.Group()
# 创建一个外星人群
gf.create_fleet(ai_settings, screen, aliens, aship)
# 创建一个用于统计游戏信息的实例
game_stats = geme_stats.GameStats(ai_settings)
#绘制play按钮
play_button = button.Button(screen, "Play")
#实例化scoreboard
sb = scoreboard.Scoreboard(screen, ai_settings, game_stats)
# 开始游戏的主循环
while True:
# 监视键盘和鼠标的实践
gf.check_events(ai_settings, screen, aship, bullets, game_stats,
play_button, aliens, sb)
if game_stats.game_active:
# 检查键盘输入，调整飞船的位置,此条代码是更新ship的位置数据
aship.update()
# 调入子弹更新和删除无用的子弹，此条代码是更新bullet的数量数据
gf.update_bullets(ai_settings, screen, aliens, aship, bullets,
game_stats, sb)
# 更新外星人
gf.update_aliens(ai_settings, game_stats, aliens, bullets,
screen, aship, sb)
# 调入屏幕更新和飞船更新函数，每次重画面
gf.update_screen(ai_settings, screen, aship, bullets, aliens,
game_stats, play_button, sb)
char_width = 111
char_height = 139 # размеры героя
char_x = 3 * display_width // 10
char_y = display_height - 60 - char_height # координата местоположения героя
do_jump = False # индикатор прыжка
jump_count = 33 # счетчик смены координаты прыжка прыжка
score = 0 # счет
max_score = 0 # максимальный счет при запуске окна
save_data = saving.Save()
high_scores = scoreboard.Scoreboard(save_data.get_data('score'))
# сохраненная таблица рекордов
def jump() -> None:
"""Do jump"""
global jump_count, do_jump, char_y
if jump_count >= -33: # пока счетчик не достиг -33 меняем координату героя
char_y -= jump_count / 1.7
jump_count -= 1
else:
jump_count = 33
do_jump = False
def count_score() -> None:
import scoreboard
t = Turtle()
screen = Screen()
screen.tracer(0)
screen.setup(width=1000, height=600)
screen.title("Pong Game")
screen.bgcolor("black")
screen.listen()
p1 = paddle.Paddle(480, 0)
p2 = paddle.Paddle(-490, 0)
p3 = Turtle()
b = ball.Ball()
player_1 = scoreboard.Scoreboard(-250, 250)
player_2 = scoreboard.Scoreboard(250, 250)
screen.onkey(p1.up, "Up")
screen.onkey(p1.down, "Down")
screen.onkey(p2.up, "w")
screen.onkey(p2.down, "s")
game_on = True
while game_on:
b.refresh()
screen.update()
time.sleep(b.move_speed)
if b.ycor() > 290 or b.ycor() < -290:
def __init__(self, handle):
Activity.__init__(self, handle)
self.play_mode = None
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
self.activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(self.activity_button, -1)
self._memorizeToolbarBuilder = \
memorizetoolbar.MemorizeToolbarBuilder(self)
toolbar_box.toolbar.insert(Gtk.SeparatorToolItem(), -1)
self._edit_button = ToggleToolButton('view-source')
self._edit_button.set_tooltip(_('Edit game'))
self._edit_button.set_active(False)
toolbar_box.toolbar.insert(self._edit_button, -1)
self._createToolbarBuilder = \
createtoolbar.CreateToolbarBuilder(self)
separator = Gtk.SeparatorToolItem()
separator.set_expand(True)
separator.set_draw(False)
separator.set_size_request(0, -1)
toolbar_box.toolbar.insert(separator, -1)
toolbar_box.toolbar.insert(StopButton(self), -1)
self.game = game.MemorizeGame()
# Play game mode
self.table = cardtable.CardTable()
self.scoreboard = scoreboard.Scoreboard()
self.cardlist = cardlist.CardList()
self.createcardpanel = createcardpanel.CreateCardPanel(self.game)
self.cardlist.connect('pair-selected',
self.createcardpanel.pair_selected)
self.cardlist.connect(
'update-create-toolbar',
self._createToolbarBuilder.update_create_toolbar)
self.createcardpanel.connect('add-pair',
self.cardlist.add_pair)
self.createcardpanel.connect('update-pair',
self.cardlist.update_selected)
self.createcardpanel.connect('change-font',
self.cardlist.change_font)
self.createcardpanel.connect('pair-closed',
self.cardlist.rem_current_pair)
self._createToolbarBuilder.connect('create_new_game',
self.cardlist.clean_list)
self._createToolbarBuilder.connect('create_new_game',
self.createcardpanel.clean)
self._createToolbarBuilder.connect(
'create_new_game',
self._memorizeToolbarBuilder.reset)
self._createToolbarBuilder.connect('create_equal_pairs',
self.change_equal_pairs)
self._edit_button.connect('toggled', self._change_mode_bt)
self.connect('key-press-event', self.table.key_press_event)
self.table.connect('card-flipped', self.game.card_flipped)
self.table.connect('card-highlighted', self.game.card_highlighted)
self.game.connect('set-border', self.table.set_border)
self.game.connect('flop-card', self.table.flop_card)
self.game.connect('flip-card', self.table.flip_card)
self.game.connect('cement-card', self.table.cement_card)
self.game.connect('highlight-card', self.table.highlight_card)
self.game.connect('load_mode', self.table.load_msg)
self.game.connect('msg_buddy', self.scoreboard.set_buddy_message)
self.game.connect('add_buddy', self.scoreboard.add_buddy)
self.game.connect('rem_buddy', self.scoreboard.rem_buddy)
self.game.connect('increase-score', self.scoreboard.increase_score)
self.game.connect('wait_mode_buddy', self.scoreboard.set_wait_mode)
self.game.connect('change-turn', self.scoreboard.set_selected)
self.game.connect('change_game', self.scoreboard.change_game)
self.game.connect('reset_scoreboard', self.scoreboard.reset)
self.game.connect('reset_table', self.table.reset)
self.game.connect('load_game', self.table.load_game)
self.game.connect('change_game', self.table.change_game)
self.game.connect('load_game',
self._memorizeToolbarBuilder.update_toolbar)
self.game.connect('change_game',
self._memorizeToolbarBuilder.update_toolbar)
self.game.connect('change_game',
self.createcardpanel.update_font_combos)
self._memorizeToolbarBuilder.connect('game_changed',
self.change_game)
self.box = Gtk.HBox(orientation=Gtk.Orientation.VERTICAL,
homogeneous=False)
width = Gdk.Screen.width()
height = Gdk.Screen.height() - style.GRID_CELL_SIZE
self.table.resize(width, height - style.GRID_CELL_SIZE)
self.scoreboard.set_size_request(-1, style.GRID_CELL_SIZE)
self.box.pack_start(self.table, True, True, 0)
self.box.pack_start(self.scoreboard, False, False, 0)
self.set_canvas(self.box)
# connect to the in/out events of the memorize activity
self.connect('focus_in_event', self._focus_in)
self.connect('focus_out_event', self._focus_out)
self.connect('destroy', self._cleanup_cb)
self.add_events(Gdk.EventMask.POINTER_MOTION_MASK)
self.connect('motion_notify_event',
lambda widget, event: face.look_at())
Gdk.Screen.get_default().connect('size-changed',
self.__configure_cb)
# start on the game toolbar, might change this
# to the create toolbar later
self._change_mode(_MODE_PLAY)
# Get the Presence Service
self.pservice = presenceservice.get_instance()
self.initiating = None
# Buddy object for you
owner = self.pservice.get_owner()
self.owner = owner
self.current = 0
self.game.set_myself(self.owner)
self.connect('shared', self._shared_cb)
# Owner.props.key
if self.get_shared_activity():
# We are joining the activity
self.connect('joined', self._joined_cb)
if self.get_shared():
# We've already joined
self._joined_cb(self)
elif not self._jobject.file_path:
logging.debug('buddy joined - __init__: %s', self.owner.props.nick)
game_file = os.path.join(os.path.dirname(__file__), 'demos',
'addition.zip')
self.game.load_game(game_file, 4, 'demo')
logging.debug('loading conventional')
self.game.add_buddy(self.owner)
else:
self.game.add_buddy(self.owner)
self.show_all()
def main():
global PLAYER_NAMES
global CURRENT_GAME_BYTES
global PLAYERS_CORRECT_IDX
global PLAYER_END_TIMES
global PLAYER_COUNT_DONE
global EVENT_GAME_ACTIVE
global EVENT_GAME_READY
global CURRENT_GAME_NUM
global FORTEGO_PLAYER_IDS
print('... main()')
mqtt_host = args.host
mqtt_port = args.port
db_filepath = 'game_%d_%d_%s' % (NUM_BYTES, GAME_DURATION_SECS,
args.database)
MQTT_CLIENT.on_connect = on_connect
MQTT_CLIENT.on_disconnect = on_disconnect
MQTT_CLIENT.on_subscribe = on_subscribe
MQTT_CLIENT.on_message = on_message
#MQTT_CLIENT.on_log = on_log
# set callback handlers for each topic here
# can't set these in callback functions
# bug that causes deadlock
# https://bugs.eclipse.org/bugs/show_bug.cgi?id=459012
print('... setting callback handlers')
# set callback handlers for individual topics
for item in INITIAL_SUBSCRIBE_TOPICS:
if item.callback_func:
MQTT_CLIENT.message_callback_add(item.topic, item.callback_func)
# connect to the mqtt broker
print('... connecting to %s:%d' % (mqtt_host, mqtt_port))
MQTT_CLIENT.will_set('battlebits/game/state',
payload='offline',
qos=2,
retain=True)
MQTT_CLIENT.connect(mqtt_host, mqtt_port)
MQTT_CLIENT.loop_start()
# wait until we are connected
EVENT_CONNECTED.wait()
print('... watch battlebits/debug/controller for debugging messages')
publish_debug_message('[+] connected to %s:%d' % (mqtt_host, mqtt_port))
sb = scoreboard.Scoreboard(db_filepath)
try:
rows = sb.get_top_rows(3)
for row in rows:
publish_controller_message(
'SCOREBOARD top 3: game:%s player:%s seconds:%s bytes:%s' %
(row[0], row[1], row[2], row[3]))
rows = sb.get_top_rows(25)
sb_json = json.dumps([{
'game_num': row[0],
'player_name': row[1],
'seconds': row[2],
'num_bytes': row[3]
} for row in rows])
MQTT_CLIENT.publish('battlebits/scoreboard',
payload=sb_json,
qos=2,
retain=False)
CURRENT_GAME_NUM = sb.get_last_game_num() + 1
finally:
sb.close()
MQTT_CLIENT.publish('battlebits/game/reset',
payload='1',
qos=2,
retain=False)
#
# game loop
#
while True:
#
# wait for players to join
#
# tell everyone the game is ready
MQTT_CLIENT.publish('battlebits/game/state',
payload='ready',
qos=2,
retain=True)
EVENT_GAME_READY.set()
# wait for first player
publish_controller_message('waiting for first player to join')
EVENT_PLAYER_JOINED.wait()
# first player joined
EVENT_PLAYER_JOINED.clear()
publish_controller_message(
'first player has joined, waiting %d seconds for more players to join'
% SECS_WAIT_PLAYERS_JOIN)
# wait for others to join
time.sleep(SECS_WAIT_PLAYERS_JOIN)
# tell everyone we are no longer accepting players
EVENT_PLAYER_JOINED.clear()
EVENT_GAME_READY.clear()
publish_controller_message('%d players entered for game # %d' %
(len(PLAYER_NAMES), CURRENT_GAME_NUM))
for player_name in PLAYER_NAMES:
PLAYERS_CORRECT_IDX[player_name] = 0
PLAYER_END_TIMES[player_name] = 0
#EVENTS_PLAYERS_WON[player_name] = threading.Event()
#
# now that we have players, choose and publish game parameters
#
# choose the list of bytes for this game
publish_controller_message('generating randomized game bytes')
CURRENT_GAME_BYTES = get_random_game_bytes_by_difficulty(
NUM_BYTES, MAX_DIFFICULTY)
# publish list of bytes
j = json.dumps(CURRENT_GAME_BYTES, separators=(',', ':'))
print(j)
MQTT_CLIENT.publish('battlebits/game/bytes', j, qos=2, retain=False)
printable_bytes = get_printable_bytes(CURRENT_GAME_BYTES)
publish_debug_message('set of bytes: %s' % printable_bytes)
# publish the duration of the game
MQTT_CLIENT.publish('battlebits/game/duration',
str(GAME_DURATION_SECS),
qos=2,
retain=False)
MQTT_CLIENT.publish('battlebits/game/number',
str(CURRENT_GAME_NUM),
qos=2,
retain=False)
#
# start game
#
# publish start time
# if we need to sync start times, we could send a start time
# but that would require the clocks on each device to be synchronized
# for now we will just publish a game start signal
# since player_decks and display will get signal at about the same delay
publish_debug_message(
'... starting game # %d at %s; duration: %d secs; players: %s' %
(CURRENT_GAME_NUM, str(datetime.datetime.now()),
GAME_DURATION_SECS, ','.join(PLAYER_NAMES)))
MQTT_CLIENT.publish('battlebits/game/state',
payload='started',
qos=2,
retain=True)
# publish message starting game at <time>
publish_controller_message('CURRENT_BYTE: %02X' %
CURRENT_GAME_BYTES[0])
game_start_time = datetime.datetime.now()
for player_name in PLAYER_NAMES:
PLAYER_END_TIMES[player_name] = game_start_time
# wait for all players to be done, or the game duration expires
EVENT_GAME_ACTIVE.set()
EVENT_ALL_PLAYERS_DONE.wait(GAME_DURATION_SECS)
EVENT_GAME_ACTIVE.clear()
EVENT_ALL_PLAYERS_DONE.clear()
# game is over
print('... publishing battlebits/game/state = finished')
MQTT_CLIENT.publish('battlebits/game/state',
payload='finished',
qos=2,
retain=True)
game_end_time = datetime.datetime.now()
game_time_elapsed = game_end_time - game_start_time
publish_controller_message('finished game at %s' %
(str(game_end_time)))
publish_controller_message('game lasted for %s' %
str(game_time_elapsed))
sb = scoreboard.Scoreboard(db_filepath)
try:
for player_name in PLAYER_NAMES:
num_correct = PLAYERS_CORRECT_IDX[player_name]
player_game_time = min(game_time_elapsed.total_seconds(),
GAME_DURATION_SECS)
if PLAYER_END_TIMES[player_name] > game_start_time:
player_game_time = (PLAYER_END_TIMES[player_name] -
game_start_time).total_seconds()
if num_correct > 0:
secs_per_byte = player_game_time / num_correct
bytes_per_min = num_correct * (60 / player_game_time)
else:
secs_per_byte = 0
bytes_per_min = 0
publish_controller_message(
'player \'%s\' completed %d bytes in %s seconds, '
'%d secs per byte, '
'%d bytes per minute ' %
(player_name, num_correct, player_game_time, secs_per_byte,
bytes_per_min))
print(FORTEGO_PLAYER_IDS)
#if player_name is in FORTEGO_PLAYER_IDS, it was a fortego player
if player_name in FORTEGO_PLAYER_IDS and FORTEGO_PLAYER_IDS[
player_name]:
# insert into fortego DB
fortego_player_name = scoreboard.FortegoNamesMap.get(
FORTEGO_PLAYER_IDS[player_name], 'guest')
# get existing row for player
row = sb.get_fortego_row(fortego_player_name)
print('fortego_row for player %s' % str(row))
if row:
if num_correct > row[4] or player_game_time < float(
row[3]):
publish_debug_message(
'updating row: game:%d, player:%s, seconds:%s, bytes:%s'
% (CURRENT_GAME_NUM, fortego_player_name,
player_game_time, num_correct))
sb.update_row_fortego(CURRENT_GAME_NUM,
player_name,
fortego_player_name,
player_game_time,
num_correct)
else:
publish_debug_message(
'not updating because not a high score old:%s/%s; new %s/%s'
% (row[4], row[3], num_correct,
player_game_time))
else:
publish_debug_message(
'inserting row: game:%d, deck:%s, player:%s, seconds:%s, bytes:%s'
% (CURRENT_GAME_NUM, player_name,
fortego_player_name, player_game_time,
num_correct))
sb.insert_row_fortego(CURRENT_GAME_NUM, player_name,
fortego_player_name,
player_game_time, num_correct)
else:
publish_debug_message(
'inserting row: game:%d, deck:%s, player:%s, seconds:%s, bytes:%s'
% (CURRENT_GAME_NUM, player_name, player_name,
player_game_time, num_correct))
sb.insert_row_anonymous(CURRENT_GAME_NUM, player_name,
player_name, player_game_time,
num_correct)
#rows = sb.get_top_rows(3)
#for row in rows:
# publish_controller_message('SCOREBOARD top 3: game:%s player:%s seconds:%s bytes:%s' % (row[0], row[1], row[2], row[3]))
# print('SCOREBOARD top 3: game:%s player:%s seconds:%s bytes:%s' % (row[0], row[1], row[2], row[3]))
rows = sb.get_top_rows(25)
for a in sb.get_game_rows(CURRENT_GAME_NUM):
if a not in rows:
rows.append(a)
print('added')
print('rows %s' % str(rows))
sb_json = json.dumps([{
'game_num': row[0],
'deck': row[1],
'player_name': row[2],
'seconds': row[3],
'num_bytes': row[4]
} for row in rows])
MQTT_CLIENT.publish('battlebits/scoreboard',
payload=sb_json,
qos=2,
retain=False)
# send out the battlebits/fortegoscoreboard
fortego_rows = sb.get_all_rows_fortego()
print('fortego_rows %s' % str(fortego_rows))
fortego_json = json.dumps([{
'game_num': row[0],
'deck': row[1],
'player_name': row[2],
'seconds': row[3],
'num_bytes': row[4]
} for row in fortego_rows])
MQTT_CLIENT.publish('battlebits/fortegoscoreboard',
payload=fortego_json,
qos=2,
retain=False)
# get the last game played rows
last_game = []
last_game.extend(sb.get_game_rows(CURRENT_GAME_NUM))
last_game.extend(sb.get_game_rows_fortego(CURRENT_GAME_NUM))
print('last_game %s' % str(last_game))
last_game_json = json.dumps([{
'game_num': row[0],
'deck': row[1],
'player_name': row[2],
'seconds': row[3],
'num_bytes': row[4]
} for row in last_game])
MQTT_CLIENT.publish('battlebits/lastgame',
payload=last_game_json,
qos=2,
retain=False)
CURRENT_GAME_NUM = sb.get_last_game_num() + 1
MQTT_CLIENT.publish('battlebits/game/reset',
payload='1',
qos=2,
retain=False)
except Exception, e:
print(traceback.format_exc())
raise e
finally:
def run(self):
'''
Main loop for running the game/training the agent.
'''
self.window.fill(BLACK)
self.clock = pygame.time.Clock()
self.player_1 = player.Player(100, 100, 5, 150, self.window, WHITE, 5)
self.player_2 = player.Player(900, 100, 5, 150, self.window, WHITE, 5)
self.pong_ball = ball.Ball(500, 100, 10, 10, self.window, WHITE, -1, 1)
self.score_board = scoreboard.Scoreboard(
500, 10,
str(self.player_1.score) + " - " + str(self.player_2.score), 30,
self.window)
self.agent_1 = q_agent.QAgent(self)
self.agent_2 = q_agent.QAgent(self)
self.p1_wins = 0
self.p2_wins = 0
for i in range(self.agent_1.EPISODES):
if i % self.agent_1.SHOW_EVERY == 0:
self.render = True
else:
self.render = False
self.running = True
while self.running:
current_state = self.observe()
current_discrete_state = self.agent_1.get_discrete_state(
current_state)
agent_1_action = self.agent_1.select_action(
current_discrete_state)
agent_2_action = self.agent_2.select_action(
current_discrete_state)
self.player_1.perform_action(agent_1_action,
self.pong_ball.rect.y, self,
'agent_1')
self.player_2.perform_action(agent_2_action,
self.pong_ball.rect.y, self,
'agent_2')
self.event_handler()
self.pong_ball.move_ball()
self.check_collision()
new_state = app.observe()
new_discrete_state = self.agent_1.get_discrete_state(new_state)
if self.running:
self.agent_1.adjust_table(new_discrete_state,
current_discrete_state,
agent_1_action,
self.agent_1_reward)
self.agent_2.adjust_table(new_discrete_state,
current_discrete_state,
agent_2_action,
self.agent_2_reward)
if self.render:
self.window.fill(BLACK)
self.player_1.draw_self()
self.player_2.draw_self()
self.pong_ball.draw_self()
self.score_board.display_scoreboard()
pygame.display.update()
print("P1: ", self.p1_wins, " - P2: ", self.p2_wins)
print(i)
divider.up()
divider.goto(0, int(GAME_SCREEN_HEIGHT / 2))
divider.down()
divider.ht()
divider.color("grey")
divider.width(3)
divider.setheading(270)
for i in range(1, GAME_SCREEN_HEIGHT, 10):
if divider.isdown():
divider.up()
else:
divider.down()
divider.forward(10)
left_score = scoreboard.Scoreboard((-40, int(GAME_SCREEN_HEIGHT / 2) - 60))
right_score = scoreboard.Scoreboard((40, int(GAME_SCREEN_HEIGHT / 2) - 60))
left_player = players.Player((-int(GAME_SCREEN_WIDTH / 2) + 50, 0))
right_player = players.Player((int(GAME_SCREEN_WIDTH / 2) - 50, 0))
max_score = int(
game_screen.textinput("SCORE TO WIN",
"Put maximum score to win the game: "))
game_screen.onkey(left_player.move_up, "w")
game_screen.onkey(left_player.move_down, "s")
game_screen.onkey(right_player.move_up, "Up")
game_screen.onkey(right_player.move_down, "Down")
game_screen.listen()
def __init__(self, app):
self.app = app
self.board = board.Board(app)
self.wheel = wheel.Wheel(app)
self.scoreboard = scoreboard.Scoreboard(app)
self.backgroundImage = pygame.image.load("resources/background.jpg")
screen.onkey(key="w", fun=serpent.turn_up)
screen.onkey(key="d", fun=serpent.turn_right)
screen.onkey(key="a", fun=serpent.turn_left)
screen.onkey(key="s", fun=serpent.turn_down)
screen.onkey(key="Up", fun=viper.turn_up)
screen.onkey(key="Right", fun=viper.turn_right)
screen.onkey(key="Left", fun=viper.turn_left)
screen.onkey(key="Down", fun=viper.turn_down)
screen.listen()
game_continues = True
dinner = food.Food()
viper_score = scoreboard.Scoreboard(alignment="right")
serpent_score = scoreboard.Scoreboard(alignment="left")
while game_continues:
if not dinner.isvisible():
while viper.head.distance(dinner) < 15 or serpent.head.distance(
dinner) < 15:
dinner.change_location()
dinner.showturtle()
if viper.alive:
viper.move_forward()
if serpent.alive:
serpent.move_forward()
if viper.head.distance(dinner) < 15:
dinner.hideturtle()
viper.grow_segment()
import turtle as t
from snake import Snake
from food import Food
import scoreboard
import time
screen = t.Screen()
screen.setup(width=600, height=600)
screen.bgcolor("black")
screen.title("My Snake Game")
screen.tracer(0)
snake = Snake()
snake_food = Food()
scores = scoreboard.Scoreboard()
screen.listen()
screen.onkey(snake.up, "Up")
screen.onkey(snake.down, "Down")
screen.onkey(snake.left, "Left")
screen.onkey(snake.right, "Right")
game_is_on = True
while game_is_on:
screen.update()
time.sleep(0.1)
snake.move()
if snake.all_turtles[0].distance(snake_food) < 15:
scores.increase_score()
snake_food.refresh_location()
snake.extend()
import time
import snake
import food
import scoreboard
screen = Screen()
screen.setup(width=600, height=600)
screen.bgcolor("black")
screen.title("Sssssssssssssnake")
screen.tracer(0)
screen.listen()
snake = snake.Snake()
food = food.Food()
score = scoreboard.Scoreboard()
screen.onkey(key="Up", fun=snake.up)
screen.onkey(key="Down", fun=snake.down)
screen.onkey(key="Right", fun=snake.right)
screen.onkey(key="Left", fun=snake.left)
game_is_on = True
while game_is_on:
screen.update()
time.sleep(0.1)
snake.move()
if snake.head.distance(food) >= 15:
pass
INITIAL_POSITION_LEFT = [-350, 0]
# Create a screen objet from turtle module
screen = turtle.Screen()
# Setting up screen elements
screen.bgcolor("black")
screen.setup(width=800, height=600)
screen.title("Pong Game")
screen.tracer(0)
# Creating a ball object
ball = ball.Ball()
# Creating a scoreboar
scoreboard = scoreboard.Scoreboard()
right_paddle = paddle.Paddle(INITIAL_POSITION_RIGHT[0], INITIAL_POSITION_RIGHT[1])
left_paddle = paddle.Paddle(INITIAL_POSITION_LEFT[0], INITIAL_POSITION_LEFT[1])
# Setting up a screen listener
screen.listen()
screen.onkey(right_paddle.move_up, "Up")
screen.onkey(right_paddle.move_down, "Down")
screen.onkey(left_paddle.move_up, "w")
screen.onkey(left_paddle.move_down, "s")
game_is_on = True
while game_is_on:
screen.update()
def __init__(self, handle):
Activity.__init__(self, handle)
self.play_mode = None
toolbar_box = ToolbarBox()
self.set_toolbar_box(toolbar_box)
self.activity_button = ActivityToolbarButton(self)
toolbar_box.toolbar.insert(self.activity_button, -1)
self._memorizeToolbarBuilder = \
memorizetoolbar.MemorizeToolbarBuilder(self)
toolbar_box.toolbar.insert(Gtk.SeparatorToolItem(), -1)
self._edit_button = ToggleToolButton('view-source')
self._edit_button.set_tooltip(_('Edit game'))
self._edit_button.set_active(False)
toolbar_box.toolbar.insert(self._edit_button, -1)
self._createToolbarBuilder = \
createtoolbar.CreateToolbarBuilder(self)
separator = Gtk.SeparatorToolItem()
separator.set_expand(True)
separator.set_draw(False)
separator.set_size_request(0, -1)
toolbar_box.toolbar.insert(separator, -1)
toolbar_box.toolbar.insert(StopButton(self), -1)
self.game = game.MemorizeGame()
# Play game mode
self.table = cardtable.CardTable()
self.scoreboard = scoreboard.Scoreboard()
self.cardlist = cardlist.CardList()
self.createcardpanel = createcardpanel.CreateCardPanel(self.game)
self.cardlist.connect('pair-selected',
self.createcardpanel.pair_selected)
self.cardlist.connect('update-create-toolbar',
self._createToolbarBuilder.update_create_toolbar)
self.createcardpanel.connect('add-pair', self.cardlist.add_pair)
self.createcardpanel.connect('update-pair',
self.cardlist.update_selected)
self.createcardpanel.connect('change-font', self.cardlist.change_font)
self.createcardpanel.connect('pair-closed',
self.cardlist.rem_current_pair)
self._createToolbarBuilder.connect('create_new_game',
self.cardlist.clean_list)
self._createToolbarBuilder.connect('create_new_game',
self.createcardpanel.clean)
self._createToolbarBuilder.connect('create_new_game',
self._memorizeToolbarBuilder.reset)
self._createToolbarBuilder.connect('create_equal_pairs',
self.change_equal_pairs)
self._edit_button.connect('toggled', self._change_mode_bt)
self.connect('key-press-event', self.table.key_press_event)
self.table.connect('card-flipped', self.game.card_flipped)
self.table.connect('card-highlighted', self.game.card_highlighted)
self.game.connect('set-border', self.table.set_border)
self.game.connect('flop-card', self.table.flop_card)
self.game.connect('flip-card', self.table.flip_card)
self.game.connect('cement-card', self.table.cement_card)
self.game.connect('highlight-card', self.table.highlight_card)
self.game.connect('load_mode', self.table.load_msg)
self.game.connect('msg_buddy', self.scoreboard.set_buddy_message)
self.game.connect('add_buddy', self.scoreboard.add_buddy)
self.game.connect('rem_buddy', self.scoreboard.rem_buddy)
self.game.connect('increase-score', self.scoreboard.increase_score)
self.game.connect('wait_mode_buddy', self.scoreboard.set_wait_mode)
self.game.connect('change-turn', self.scoreboard.set_selected)
self.game.connect('change_game', self.scoreboard.change_game)
self.game.connect('reset_scoreboard', self.scoreboard.reset)
self.game.connect('reset_table', self.table.reset)
self.game.connect('load_game', self.table.load_game)
self.game.connect('change_game', self.table.change_game)
self.game.connect('load_game',
self._memorizeToolbarBuilder.update_toolbar)
self.game.connect('change_game',
self._memorizeToolbarBuilder.update_toolbar)
self.game.connect('change_game',
self.createcardpanel.update_font_combos)
self._memorizeToolbarBuilder.connect('game_changed', self.change_game)
self.box = Gtk.HBox(orientation=Gtk.Orientation.VERTICAL,
homogeneous=False)
width = Gdk.Screen.width()
height = Gdk.Screen.height() - style.GRID_CELL_SIZE
self.table.resize(width, height - style.GRID_CELL_SIZE)
self.scoreboard.set_size_request(-1, style.GRID_CELL_SIZE)
self.set_canvas(self.box)
# connect to the in/out events of the memorize activity
self.connect('focus_in_event', self._focus_in)
self.connect('focus_out_event', self._focus_out)
self.connect('destroy', self._cleanup_cb)
self.add_events(Gdk.EventMask.POINTER_MOTION_MASK)
self.connect('motion_notify_event',
lambda widget, event: face.look_at())
Gdk.Screen.get_default().connect('size-changed', self.__configure_cb)
# start on the game toolbar, might change this
# to the create toolbar later
self._change_mode(_MODE_PLAY)
def on_activity_joined_cb(me):
logging.debug('activity joined')
self.game.add_buddy(self._collab.props.owner)
self.connect('joined', on_activity_joined_cb)
def on_activity_shared_cb(me):
logging.debug('activity shared')
self.connect('shared', on_activity_shared_cb)
self._collab = CollabWrapper(self)
self.game.set_myself(self._collab.props.owner)
def on_message_cb(collab, buddy, msg):
logging.debug('on_message_cb buddy %r msg %r' % (buddy, msg))
action = msg.get('action')
if action == 'flip':
n = msg.get('n')
self.game.card_flipped(None, n, True)
elif action == 'change':
self.get_canvas().hide()
def momentary_blank_timeout_cb():
self.set_data(msg)
self.get_canvas().show()
GLib.timeout_add(100, momentary_blank_timeout_cb)
self._collab.connect('message', on_message_cb)
def on_joined_cb(collab, msg):
logging.debug('joined')
self._collab.connect('joined', on_joined_cb, 'joined')
def on_buddy_joined_cb(collab, buddy, msg):
logging.debug('on_buddy_joined_cb buddy %r msg %r' % (buddy, msg))
self.game.add_buddy(buddy)
self._collab.connect('buddy_joined', on_buddy_joined_cb,
'buddy_joined')
def on_buddy_left_cb(collab, buddy, msg):
logging.debug('on_buddy_left_cb buddy %r msg %r' % (buddy, msg))
self.game.rem_buddy(buddy)
self._collab.connect('buddy_left', on_buddy_left_cb, 'buddy_left')
self._files = {} # local temporary copies of shared games
self._collab.setup()
def on_flip_card_cb(game, n):
logging.debug('on_flip_card_cb n %r' % (n))
self._collab.post({'action': 'flip', 'n': n})
self.game.connect('flip-card-signal', on_flip_card_cb)
def on_change_game_cb(sender, mode, grid, data, waiting_list, zip):
logging.debug('on_change_game_cb')
blob = self.get_data()
blob['action'] = 'change'
self._collab.post(blob)
self.game.connect('change_game_signal', on_change_game_cb)
if self._collab.props.leader:
logging.debug('is leader')
game_file = os.path.join(os.path.dirname(__file__), 'demos',
'addition.zip')
self.game.load_game(game_file, 4, 'demo')
self.game.add_buddy(self._collab.props.owner)
self.show_all()
