def example_data():
"""Create example data for the test database."""
dob = datetime.strptime('16Sep2012', '%d%b%Y')
u = User(username='******',
password='******',
name='Test',
date_of_birth=dob)
g = Game(num_players=4, difficulty='h')
g2 = Game(num_players=4, difficulty='e')
g3 = Game(num_players=4, difficulty='e')
db.session.add_all([u, g, g2, g3])
db.session.commit()
p = HumanPlayer(name='Test', user_id=1, game_id=1, position=1)
o_1 = AIPlayer(name="opponent_1", difficulty='h', game_id=1, position=2)
o_2 = AIPlayer(name="opponent_2", difficulty='h', game_id=1, position=3)
o_3 = AIPlayer(name="opponent_3", difficulty='h', game_id=1, position=4)
p_2 = HumanPlayer(name='Test', user_id=1, game_id=2, position=1)
o_1_2 = AIPlayer(name="opponent_1", difficulty='e', game_id=2, position=2)
o_2_2 = AIPlayer(name="opponent_2", difficulty='e', game_id=2, position=3)
o_3_2 = AIPlayer(name="opponent_3", difficulty='e', game_id=2, position=4)
p_3 = HumanPlayer(name='Test', user_id=1, game_id=3, position=1)
o_1_3 = AIPlayer(name="opponent_1", difficulty='e', game_id=3, position=2)
o_2_3 = AIPlayer(name="opponent_2", difficulty='e', game_id=3, position=3)
o_3_3 = AIPlayer(name="opponent_3", difficulty='e', game_id=3, position=4)
db.session.add_all(
[p, o_1, o_2, o_3, p_2, o_1_2, o_2_2, o_3_2, p_3, o_1_3, o_2_3, o_3_3])
db.session.commit()
def prepare_image(self):
self.image = pygame.Surface((self.width, self.height))
self.a = pygame.sprite.Group(
graphic.Character_Sprite('actor2'),
graphic.Character_Sprite('actor1'),
graphic.Character_Sprite('actor3'),
#graphic.Character_Sprite('evil'),
)
i = 0
for sprite in self.a:
sprite.data = Game().npcs[i]
i += 1
playersprite = graphic.Character_Sprite('evil')
playersprite.data = Game().player
self.a.add(playersprite)
Camera().update(Game().player.get_pos())
map_drawer = self.controller.map_drawer
self.bg = map_drawer.get_all_map_image(self.tile_size)
self.image.blit(self.bg, (-Camera().dx, -Camera().dy))
self.data1 = map_drawer.prepare_map_objects(self.tile_size)
'''test=ImageStorage()['plants']
for i in range(len(test)):
testrow=test[i]
for j in range(len(testrow)):
testimg = testrow[j]
self.bg.blit(testimg,(i*40,j*40))'''
self.a.draw(self.image)
def update_image(self):
if not Game().paused:
if Game().counter % Game().animate_divider == 0:
animate = True
else:
animate = False
self.image.fill((0, 0, 0)) #for clearing sprites
self.a.clear(self.image, self.image)
self.a.update(animate)
self.image.blit(self.bg, (-Camera().dx, -Camera().dy)) #pos bg
#objects
self.data = []
player_x, player_y = Game().player.get_pos()
for y in range((player_y - self.height / 2) / self.tile_size,
(player_y + self.height / 2) / self.tile_size):
for x in range((player_x - self.width / 2) / self.tile_size,
(player_x + self.width / 2) / self.tile_size):
if (x, y) in self.data1:
btn = self.data1[x, y]
self.data.append(btn)
img = btn.get_image()
self.image.blit(img,
(x * self.tile_size - Camera().dx,
y * self.tile_size - Camera().dy))
self.a.draw(self.image)
def main(gameid, name, new, test):
global p1, p2, p3, p4, p5, p6, p7, p8
if test:
gameid = Game(**SHPlayer.new_game()).uuid
p1 = player_thread(gameid, "Player 1")
p2 = player_thread(gameid, "Player 2")
p3 = player_thread(gameid, "Player 3")
p4 = player_thread(gameid, "Player 4")
p5 = player_thread(gameid, "Player 5")
p6 = player_thread(gameid, "Player 6")
p7 = player_thread(gameid, "Player 7")
p8 = player_thread(gameid, "Player 8")
p1.start()
time.sleep(0.35)
p2.start()
time.sleep(0.35)
p3.start()
time.sleep(0.35)
p4.start()
time.sleep(0.35)
p5.start()
time.sleep(0.35)
p6.start()
time.sleep(0.35)
p7.start()
time.sleep(0.35)
p8.start()
p8.start_game = True
p1.join()
p2.join()
p3.join()
p4.join()
p5.join()
p6.join()
p7.join()
p8.join()
sys.exit(0)
if new:
gameid = Game(**SHPlayer.new_game()).uuid
print("Created a new game with UUID: {}".format(gameid))
if gameid is not None:
player = SHPlayer(gameid, name)
player.join_game()
else:
print("Please specify GAMEID or use --new flag")
exit()
def example_data():
"""Create example data for the test database."""
# If data already exists, delete it.
Game.query.delete()
g1 = Game(name="Super Smash Bros",
description="A party fighting game by Nintendo.")
g2 = Game(name="Set", description="A speed matching card game.")
g3 = Game(name="Monopoly", description="A terrible game about capitalism.")
db.session.add_all([g1, g2, g3])
db.session.commit()
def create_new_game(num_players, difficulty, username):
"""Create new game, create players, and save to DB. Return new game obj.
Args: number of players in game, difficulty, and username of player creating
the game
Returns the new game object"""
#Create new Game object
new_game = Game(num_players=num_players, difficulty=difficulty)
db.session.add(new_game)
db.session.commit()
game_id = new_game.id
#Create new Player object (based on signed in user information)
user_info = User.query.filter(User.username == username).first()
player = HumanPlayer(user_info.name, user_info.id, game_id, 1)
db.session.add(player)
opponent_names = {
1: 'Harry (AI)',
2: 'Hermione (AI)',
3: 'Ron (AI)',
4: 'Voldemort (AI)',
5: 'Snape (AI)'
}
#Create new AI objects
for i in range(1, num_players):
AI_i = AIPlayer(opponent_names[i], difficulty, game_id, i + 1)
db.session.add(AI_i)
db.session.commit()
return new_game
def get_players(game_id):
try:
game = Game(**games.get(where('uuid') == game_id))
except Exception as err:
return {"error": err}, 404
return game.players.dict()
def load_games():
"""Load games from ign.csv into database."""
print "Games"
Game.query.delete() # Start with a fresh database
with open('seed_data/ign.csv') as csvfile:
game_data = reader(csvfile, dialect='excel')
next(game_data) # Skips header row
# ID(0), descriptive score(1), title(2), ign URL(3), platform(4),
# critic score(5), genre(6), editors choice(7), year(8), month(9), day(10)
for row in game_data:
title = row[2]
platform = row[4]
critic_score = row[5]
game = Game(title=title,
platform=platform,
critic_score=critic_score)
db.session.add(game)
db.session.commit()
def load_games(api_data, game_modes):
"""Transferring game data into database"""
print("Games")
# store json values into temporary dictionary before transferring into DB
for game_data in api_data:
game_info = create_game_json(game_data)
# variables to add to game table
game = Game(igdb_id=game_info['game_id'],
title=game_info['name'],
slug=game_info['slug'],
artwork_urls=game_info['artworks'],
popularity=game_info['popularity'],
screenshot_urls=game_info['screenshots'],
release_date=game_info['release_date'],
summary=game_info['summary'])
if game_info['game_modes']:
for mode_name in game_info['game_modes']:
mode = game_modes[mode_name]
game.game_modes.append(mode)
# #################################################3
# for genre_name in game_info['genres']:
# genre = game_genres[genre_name]
# game.game_genres.append(genre)
db.session.add(game)
db.session.commit()
print(f'Created {game}!')
def create_game(current_user):
data = request.get_json()
now_time = datetime.datetime.now()
# start_time = datetime.datetime.strptime(
# data['start_time'], "%Y-%m-%d %H:%M:%S")
blackone_id = data['opponent'][0]['name']
whiteone_id = data['opponent'][1]['name']
blacktwo_id = data['opponent'][2]['name']
whitetwo_id = data['opponent'][3]['name']
new_game = Game(name=data['name'],
comment=data['comment'],
start_time=now_time,
blackone_id=blackone_id,
blacktwo_id=blacktwo_id,
whiteone_id=whiteone_id,
whitetwo_id=whitetwo_id,
total_time=int(data['total_time']) * 60,
public=data['public'],
password=data['password'],
status='未开始',
create_date=now_time,
user_id=current_user.id)
db.session.add(new_game)
db.session.commit()
return jsonify({'message': "对局创建成功！"})
def create_game(name,
description=None,
publish_year=None,
min_age=None,
min_players=None,
max_players=None,
min_playtime=None,
max_playtime=None,
image_url=None,
msrp=None,
atlas_id=None):
"""Create and return a new game"""
game = Game(name=name,
description=description,
publish_year=publish_year,
min_age=min_age,
min_players=min_players,
max_players=max_players,
min_playtime=min_playtime,
max_playtime=max_playtime,
image_url=image_url,
msrp=msrp,
atlas_id=atlas_id)
db.session.add(game)
db.session.commit()
return game
def main():
screen = app_init()
board_view = BoardView(screen, 'static/chessboard.png')
game = Game()
while not game.end():
handle_user_events(game)
board_view.update_screen(game)
def __init__(self):
self.game = Game()
self.done = False
self.state = None
self.states = []
self.moves = []
self.rewards = []
self.generate_choices()
def create_game(self, request):
"""Creates a new game for Hangman users"""
user = User.query(User.user_name == request.user_name).get()
if not user:
raise endpoints.NotFoundException('User does not exist')
game = Game(user_name=user.key, target=random_word())
game.put()
return game.to_form()
def get_search_result():
"""Add search results into db."""
current_id = request.form.get('title')
print(current_id)
if current_id == 'None':
flash('Please search again')
return redirect('/game/search')
title = seed.get_game_by_id(current_id)
print(title)
current_game = Game.query.filter_by(game_id=current_id).first()
if current_game is None:
search_results = seed.get_game_by_id(current_id)[0]
title = search_results['name']
igdb_id = search_results['id']
consoles = None
game_available_date = None
genres = None
url_image_id = None
if 'platforms' in search_results.keys():
console_ids = search_results['platforms']
consoles = seed.get_console(console_ids)
if 'first_release_date' in search_results.keys():
game_available_unix = search_results['first_release_date']
game_available_date = seed.get_released_date(game_available_unix)
if 'genres' in search_results.keys():
genre_ids = search_results['genres']
genres = seed.get_genre(genre_ids)
if 'cover' in search_results.keys():
cover_id = search_results['cover']
url_image = seed.get_cover_url_by_id(igdb_id)
# url_image = seed.get_image(url_image_id)
new_game = Game(title=title,
igdb_id=igdb_id,
console=consoles,
game_available_date=game_available_date,
genre=genres,
url_image=url_image)
db.session.add(new_game)
db.session.commit()
session['title'] = title
return redirect('/game/review')
def __init__(self):
pygame.init()
self.screen = pygame.display.set_mode((600, 600))
pygame.display.set_caption('Tic Tac Toe')
self.screen.fill(BACKGROUND_COLOR)
self.game = Game()
self.player = Human('X')
self.comp = Comp('O')
self.level = None
def add_game():
"""Add a game to a competition"""
competition = request.form.get('competitionId', None)
competitor_h = request.form.get('competitorHome', None)
competitor_a = request.form.get('competitorAway', None)
game = Game(competition, competitor_h, competitor_a)
DB.session.add(player)
DB.session.commit()
return jsonify(status="OK")
def create_game(user_id): """Returns game and guesses objects which have a 1-to-1 relationship""" game = Game(status='in-progress', user=get_user(user_id)) db.session.add(game) db.session.commit() guesses = Guesses(game) db.session.add(guesses) db.session.commit() return game, guesses
def game_submit():
title = request.form.get("name")
description = request.form.get("description")
game = Game(name=title, description=description)
db.session.add(game)
db.session.commit()
return redirect('/games')
def init_game(request):
print "Init game..."
player1 = Player("Player 1")
player2 = Player("Player 2")
game = Game(player1, player2)
# Store game object to session
request.session['game'] = game
# Print game id for DEBUG
print game.id()
return game.toJSON()
def add_game():
new_game = request.form.get("game_name")
new_game_description = request.form.get("game_description")
g = Game(name=new_game, description=new_game_description)
db.session.add(g)
db.session.commit()
flash("Game successfully added!")
return redirect("/games")
def create_new_game(self, listing, price, country):
game = Game(title=listing["game_title"],
min_price=price,
min_price_country_id=country,
last_updated=self.date)
game.id = self.db_util.save(game)
self.existing_games.append(game)
return game
async def post(self, request):
'''
新增游戏
'''
game = Game()
# print(type(request.json))
result = game.replace_one(request.json, request.json, True)
print(result.matched_count)
print(result.modified_count)
return json(request.json, 201)
def create_game(
players_info: dict,
num_disasters: int,
num_catastrophes: int,
num_safe: int,
) -> Game:
if num_safe < SHOP_SIZE:
raise RuntimeError("At least the first shop must be safe")
deck = []
for room_id in ROOM_LIST:
room = int(room_id)
if room < THRONE_ROOM_ID_START:
deck.append(room)
random.shuffle(deck)
safe = deck[:num_safe]
deck = deck[num_safe:]
disasters = []
catastrophes = []
for card in DISASTER_LIST:
if card[0] == "d":
disasters += [card]
elif card[0] == "c":
catastrophes += [card]
deck += random.sample(disasters, num_disasters) + random.sample(
catastrophes, num_catastrophes)
random.shuffle(deck)
deck = deck + safe
shop = []
while len(shop) < SHOP_SIZE:
shop.append(deck.pop())
players = {}
for player_id in players_info:
info = players_info[player_id]
players[player_id] = Player(
info["username"],
int(info["throne_room_id"]),
Castle(int(info["throne_room_id"])).to_json_obj(),
[],
)
turn_order = [player_id for player_id in players_info]
random.shuffle(turn_order)
return Game(
players,
turn_order,
0,
shop,
[],
deck,
num_disasters,
num_catastrophes,
[],
[],
)
def get_game_data(self):
"""
Get the current game state
"""
response = self.send_message("/games/{0}".format(self.gameid),
httptype="GET")
self.game = Game(**response)
if self.last_phase != self.game.phase:
print(self.game.players[self.uuid])
print(self.game.notifications)
self.last_phase = self.game.phase
def add_game_db():
""" Adds game to games database """
game = request.form.get("game")
description = request.form.get("description")
new_game = Game(name=game, description=description)
db.session.add(new_game)
db.session.commit()
return redirect('/games')
def player_mouse_move(self, x, y):
player = Game().player
px, py = Camera().coord_transform(player.get_pos())
dx = x - px
dy = y - py
norm = max(abs(dx), abs(dy))
dx /= norm
dy /= norm
player.order_to_go(dx, dy)
Camera().update(player.get_pos())
self.move_mini_map_to_player()
def player_keyboard_move(self, direction):
player = Game().player
if direction == 'up':
player.order_to_go(0, -1)
if direction == 'down':
player.order_to_go(0, 1)
if direction == 'left':
player.order_to_go(-1, 0)
if direction == 'right':
player.order_to_go(1, 0)
Camera().update(player.get_pos())
self.move_mini_map_to_player()
def update_image(self):
tile_size = self.controller.game_field.tile_size
self.image.fill((0, 0, 0))
player_x, player_y = Game().player.get_pos()
pixel = pygame.Surface((self.zoom, self.zoom))
pixel.fill((255, 0, 0))
self.image.blit(self.all_map_image,
(-self.start_x * self.zoom, -self.start_y * self.zoom))
self.image.blit(pixel,
((player_x / tile_size - self.start_x) * self.zoom,
(player_y / tile_size - self.start_y) * self.zoom))
def createGame(game_title, game_short_descr, game_long_descr, game_category_id,
game_user_id):
try:
game = Game(title=game_title,
short_description=game_short_descr,
long_description=game_long_descr,
category_id=game_category_id,
user_id=game_user_id)
session.add(game)
session.commit()
except Exception as err:
return err
