def test_generate_id_method(self):
from models import Game, Cell
game = Game(size=3)
cells_state = [True, False, True,
False, True, False,
True, False, True]
for cell, cell_state in zip(game.cells, cells_state):
cell.is_on = cell_state
game.generate_id()
expected_id = 2**0 * cells_state[0] + 2**1 * cells_state[1] + \
2**2 * cells_state[2] + 2**3 * cells_state[3] + \
2**4 * cells_state[4] + 2**5 * cells_state[5] + \
2**6 * cells_state[6] + 2**7 * cells_state[7] + \
2**8 * cells_state[8]
self.assertEqual(expected_id, game.id)
def new_game(self, request):
"""Creates new game"""
user = User.query(User.screen_name == request.user_name).get()
if not user:
raise endpoints.NotFoundException(
'A User with that name does not exist!')
random_word = random.choice(WORD_LIST)
game = Game(game_word=random_word,
correct_guesses=['_' for i in random_word],
incorrect_guesses=[],
attempts_remaining=len(STICK_MAN_PARTS),
hangman=[],
game_over=False,
parent=user.key)
game.put()
score = Score(date=datetime.today(), parent=game.key)
score.put()
return game.to_form('Good luck playing Hang Man!')
def post_game(jwt):
body = request.get_json()
try:
title = body.get('title')
genre = body.get('genres')
rating = body.get('rating')
completed = body.get('completed')
game = Game(title=title,
genres=genre,
rating=rating,
completed=completed)
game.insert()
return jsonify({
'success': True,
'game_id': game.id,
'game_title': game.title
})
except:
abort(400)
def newgame():
if request.method == 'POST':
username = session['username']
currentUser = User.query.filter_by(username=username).first()
currentUserID = currentUser.id
char = request.form['char']
#TODO add information to enable selection of which other players
#TODO
numPlayers = request.form['numPlayers']
newGame = Game(currentUserID, char, numPlayers)
db.session.add(newGame)
db.session.commit()
#TODO create a board
game = Game.query.order_by(Game.id.desc()).first()
gameID = game.id
newGame.addChar(currentUserID, char,gameID)
return redirect("/")
else:
return render_template("newgame.html")
def post(self, gid, pid):
game = Game(gid)
state = game.get_state()
if state == 'setup':
return jsonify({'messages': ["The game hasn't started yet"]}), 400
if state == 'ended':
return jsonify({'messages': ['The game has ended']}), 400
if not game.get_current_pid() == pid:
return jsonify({'messages': ['It is not your turn']}), 400
player = Player(gid, pid)
user = player.get_user()
if not authorize(request.authorization, user):
return auth_response()
move = request.get_json()
valid, errors = player.validate_move(move)
if valid:
messages = player.execute_move(move)
return jsonify({'messages': messages})
else:
return jsonify({'messages': errors}), 400
def test_head_to_body():
game = Game(width=10, height=10)
g = Engine.create_game_state(game.id, game.width, game.height)
Engine.add_snakes_to_board(g, [SNAKE_1, SNAKE_3])
g.sanity_check()
with open('lib/game/data/head_to_body.in') as f:
start_state = f.read().strip()
assert(g.to_string().strip() == start_state)
g = Engine.resolve_moves(g, [MOVE_RIGHT_1, MOVE_UP_3])
g.sanity_check()
g = Engine.resolve_moves(g, [MOVE_RIGHT_1])
g.sanity_check()
with open('lib/game/data/head_to_body.out') as f:
end_state = f.read().strip()
assert(g.to_string().strip() == end_state.strip())
def ai_plays(app_logger):
"""Search for games with AI turn. Execute a play."""
client = MongoClient(CONNECTION_STRING)
database = client.othello
games = database.games
for game in games.find({'gameover': False, 'turn': 'AI'}):
game_id = game['_id']
game['matrix'] = pickle.loads(game['matrix'])
game = Game(game['white'], game['black'], game['matrix'], game['turn'])
app_logger.info('AI juega al juego {0}'.format(str(game_id)))
game.play_ai()
copy_save = dict(game)
copy_save['matrix'] = Binary(
pickle.dumps(copy_save['matrix'], protocol=2))
copy_save['possible_moves'] = numpy.array(
copy_save['possible_moves']).tolist()
games.update_one({'_id': game_id}, {'$set': copy_save})
client.close()
def start(self):
"""
Start new Game with width, height
Initial the State from the Game
Build all the blocks one by one
Pick weak robot as a default Robot
Let the player play first as default
Set the result label to 'Playing'
Unlock the application
"""
self.game = Game(self.width, self.height)
self.state = State(self.game)
# generate the blocks
self.block = {}
for k in self.state.board.keys():
self.block[k] = Block(self, k)
self.pick_weak_robot()
self.player_first()
self.result_label.config(text='Playing')
self.lock = False
def create_view(request):
logger.debug('enter create view')
if request.method == 'POST':
logger.debug('submit create post form')
form = CreateForm(request.POST)
if form.is_valid():
game = Game(name=form.cleaned_data['name'],
circle=form.cleaned_data['circle'],
base=form.cleaned_data['base'],
member1=form.cleaned_data['member1'],
member2=form.cleaned_data['member2'],
member3=form.cleaned_data['member3'],
member4=form.cleaned_data['member4'])
game.save()
logger.debug('save game success')
return HttpResponseRedirect('/record/list')
else:
logger.error('save game fail')
return HttpResponseRedirect('/record/list')
return render(request, 'record/create.html')
def init_game(identifier, bet):
steamid = identifier_to_steamid(identifier)
remove_user_from_active_games(steamid)
cpu_hand_identifier = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for _ in range(45))
remove_balance(identifier, bet)
print('Removed bet amount from user')
db.session.add(Game(steamid, bet, cpu_hand_identifier))
db.session.commit()
print('Init game + commited to database')
return db.session.query(Game).filter(
Game.player_steamid == steamid).one().deck_identifier
def addGame():
if request.method == 'GET':
context = []
teamInfoList = Team.query.all()
for team in teamInfoList:
vulhubList = Vulhub.query.filter(Vulhub.tid == team.id)
teamInfo = {
'id': team.id,
'teamname': team.teamname,
'vulhubList': vulhubList,
'token': team.token
}
context.append(teamInfo)
return render_template('T_add_game.html', context=context)
else:
gametitle = request.form.get('gametitle')
tempgame = Game(gametitle=gametitle)
db.session.add(tempgame)
db.session.commit()
return redirect(url_for('start'))
def single_player(player_id, app_logger):
"""Starts a new game with the AI player.
:param player_id: ID of player
:param app_logger: Flask app logger
"""
game_id = None
client = MongoClient(CONNECTION_STRING)
database = client.othello
games = database.games
players = database.players
new_game = dict(Game(player_id, "AI"))
new_game['matrix'] = Binary(pickle.dumps(new_game['matrix'], protocol=2))
new_game['possible_moves'] = numpy.array(
new_game['possible_moves']).tolist()
result = players.find_one({'_id': player_id})
if result:
if result['game_id'] is None and not result['online_mode']:
games.insert_one(new_game)
game_id = new_game['_id']
players.update_one({'_id': player_id},
{'$set': {
'game_id': game_id
}})
game_id = str(game_id)
else:
if result['online_mode']:
app_logger.error(
"Single player requested online play: {0}".format(
str(player_id)))
if result['game_id'] != None:
app_logger.error(
"Single player already in a game. game_id: {0} player_id: {1}"
.format(str(result['game_id']), str(player_id)))
else:
app_logger.error("Requested single player doesnt exist: {0}".format(
str(player_id)))
client.close()
return game_id
def create_match(payload):
data = request.json
# Prepare game
game = Game.query.filter(Game.id == data['gameId']).first()
if not game:
game = Game.query.filter(Game.name.ilike(
data['gameName'].strip())).first()
if not game:
game = Game(name=data['gameName'])
db.session.add(game)
match = Match(name=data)
uuid_len = 6
tries = 0
max_tries = 10
match_found = True
uuid = ''
while (match_found):
if tries >= max_tries:
tries = 0
uuid_len += 1
tries += 1
uuid = generate_uuid(uuid_len)
match_found = db.session.query(Match).filter(
Match.uuid == uuid).first()
match.uuid = uuid
match.name = data['name']
match.max_participants = data[
'maxParticipants'] if 'maxParticipants' in data else 2
match.game_id = game.id
if 'isPrivate' in data:
match.is_private = data['isPrivate']
else:
match.is_private = False
user = auth.get_logged_user()
match.creator_id = user.id
user.matches.append(match)
db.session.add(match)
db.session.commit()
return jsonify(match.long()), 201
def getNewCardForUser(self, jive_profile_id, filtr):
""" Get a new "flashcard" for the user"""
game = Game()
#all players you've already correctly identified enough times
done_players = "SELECT p_shown_id FROM " + config.MEDIFACES_REVIEW_TBL + " WHERE jive_profile_id = {} and done = TRUE"
done_players_inter = [jive_profile_id]
filtr_query = ""
# in case location and department don't show up in filtr
if filtr.get("location") is None and filtr.get("department") is None:
logging.info("WARNING: location and department not found in filtr")
filtr["location"] = "All"
filtr["department"] = "All"
filtr_query_inter = []
# add location to filtr_query if location is not "All"
if filtr.get("location") != "All":
if filtr.get("location") == "Remote":
filtr_query += " AND location like 'Remote%'" #only remote employees
elif filtr.get("location") == "Other":
filtr_query += " AND location in ('Paradigm','C3i')" #only Paradigm or C3i employees
else:
filtr_query += " AND location = {}" #only employees in specified location
filtr_query_inter.append(filtr.get("location"))
# add department to filtr_query if department is not "All"
if filtr.get("department") != "All":
filtr_query += " AND department = {}" # only employees in specified department
filtr_query_inter.append(filtr.get("department"))
logging.info(filtr_query)
done_str = ""
if done_players:
done_str = "j.id NOT IN (" + ",".join(["{}"] * len(done_players)) + ") AND"
#info of a random player not in query and not yourself and has a good avatar
player_info = game.selectOneJoin("j.fullname, j.title, j.picture_binary, j.id", "j.id NOT IN (" + done_players + ") AND j.id != {} AND m.bad_avatar='0'" + filtr_query + " ORDER BY RAND()", done_players_inter + [jive_profile_id] + filtr_query_inter)
if player_info is None:
raise NoPlayersLeft("No players you haven't seen yet in this category.")
return player_info
def register():
if request.method == "GET":
if "user_id" in session:
flash("You are already logged in!")
return redirect(url_for("dashboard"))
else:
return render_template("register.html")
else:
roll_number = request.form["roll_number"]
password = request.form["password"]
hashed_password = sha256_crypt.hash(password)
first_name = request.form["first_name"]
last_name = request.form["last_name"]
phone_number = request.form["phone_number"]
user = User.query.filter_by(roll_number=roll_number).first()
if not user:
if len(phone_number) != 10:
flash("Phone number must be of 10 digits!")
return redirect(url_for("register"))
for dig in phone_number:
if not dig.isdigit():
flash("Invalid Phone number!")
return redirect(url_for("register"))
user = User(roll_number=roll_number,
password=hashed_password,
phone_number=phone_number,
first_name=first_name,
last_name=last_name)
db.session.add(user)
db.session.commit()
for game in GameFeature.query.all():
user_game = Game(user_id=user.user_id,
game_id=game.game_id,
high_score=0)
db.session.add(user_game)
db.session.commit()
flash("Successfully registered!")
return redirect(url_for("login"))
else:
flash("This roll number is already registered!")
return redirect(url_for("register"))
def play(ip_address, web_browser, coor_x, coor_y, app_logger):
"""Update the information of the game of the player.
:param ip_address: IP Adress of actual player
:param web_browser: User-Agent Header of player request
:param coor_x: X Coordinate of piece
:param coor_y: Y Coordinate of piece
:param app_logger: Flask app logger
"""
player = find_player_by_ip(ip_address, web_browser)
if player:
client = MongoClient(CONNECTION_STRING)
database = client.othello
games = database.games
game = games.find_one({'_id': player['game_id']})
if game:
game_id = game['_id']
game['matrix'] = pickle.loads(game['matrix'])
game = Game(game['white'], game['black'], game['matrix'],
game['turn'])
result = game.play(Piece(coor_x, coor_y, player['_id']))
copy_save = dict(game)
copy_save['matrix'] = Binary(
pickle.dumps(copy_save['matrix'], protocol=2))
copy_save['possible_moves'] = numpy.array(
copy_save['possible_moves']).tolist()
games.update_one({'_id': game_id}, {'$set': copy_save})
game.matrix = game.matrix.tolist()
result['matrix'] = game.matrix
client.close()
return result
client.close()
app_logger.error(
"/play: Game not found. game_id: {0} player_id: {1}".format(
player['game_id'], player['_id']))
return {'success': False, 'code': 500}
app_logger.error(
"/play: Player not found. ip_address: {0} \nweb_browser: {1}".format(
ip_address, web_browser))
return {'success': False, 'code': 500}
def start():
logger.info('start a game')
if request.method == 'POST':
data = request.data
game_id = data.get("game").get("id", -1)
game_info = {
'you': data.get('you', None),
'board': data.get('board', None)
}
try:
game = Game(game_uuid=game_id, game_info=game_info)
db.session.add(game)
db.session.commit()
except Exception:
logger.debug('db is not running.')
return {
"color": "#800000",
"headType": "safe",
"tailType": "skinny",
'message': 'Starting the game.'
}
def game_frame(game_id):
user_id = session['user_id']
# print user_id,game_id
# print len(Game.query.filter_by(user_id = user_id , game_id =game_id).all())
if len(Game.query.filter_by(user_id=user_id, game_id=game_id).all()) != 0:
game = Game.query.filter_by(user_id=user_id, game_id=game_id).first()
else:
game = Game(user_id=user_id, game_id=game_id, high_score=0)
db.session.add(game)
db.session.commit()
token = os.urandom(16)
token = base64.b64encode(token)
token = token.decode()
session["sid"] = game.s_id
session["token"] = token
print(session["token"])
print(session["sid"])
# print game.s_id, game.user_id, game.game_id
return render_template("game" + str(game.game_id) + ".html",
game=game,
token=token)
def create_game(self, player, access_token, opponent_fb_id):
ordem_aleatoria = ['0', '1']
random.shuffle(ordem_aleatoria)
game = Game(status=ordem_aleatoria[0])
game.save()
player1 = Player(user=player, game=game, last_round=1)
player1.save()
op_user = User.objects.get(username=opponent_fb_id)
player2 = Player(user=op_user, game=game, last_round=1)
player2.save()
f1 = self.__create_cards(player1, access_token)
f2 = self.__create_cards(player2, access_token)
Round(round_number=1, game=game).save()
players = game.player_set.all()
return game.id
def create_game(self, request):
"""Create a Game between two Users"""
# Check player_name
if request.player_1_name == request.player_2_name:
raise endpoints.ConflictException(
'Cannot create a game between a player and themselves!')
for player_name in [request.player_1_name, request.player_2_name]:
if not User.query(User.name == player_name).get():
raise endpoints.ConflictException(
'No user named {} exists!'.format(player_name))
game = Game(player_1_name=request.player_1_name,
player_2_name=request.player_2_name,
player_1_rock=3,
player_1_paper=3,
player_1_scissors=3,
player_2_rock=3,
player_2_paper=3,
player_2_scissors=3,
player_1_round_score=0,
player_2_round_score=0,
round=0,
is_active=True,
round_result='Not all players have played yet.')
game_key = game.put()
return StringMessage(
message='Game created! '
'{}\'s cards remain '
'(Rock{} : Paper{} : Scissors{}). '
'{}\'s cards '
'(Rock{} : Paper{} : Scissors{}). '
'{} rounds have been finished. '
'(key={})'.format(request.player_1_name, game.player_1_rock,
game.player_1_paper, game.player_1_scissors,
request.player_2_name, game.player_2_rock,
game.player_2_paper, game.player_2_scissors,
game.round, game_key.urlsafe()))
def upload():
game = Game()
# save response to file if debugging
debug = False
if debug:
now = datetime.datetime.now()
fo = open('data/test/' + str(now) + '.json', 'w')
fo.write(json.dumps(request.json, indent=2, sort_keys=True))
fo.close()
# save the game to the database
game.league = request.json['league']
game.week = request.json['week']
game.home_team = request.json['homeTeam']
game.away_team = request.json['awayTeam']
game.home_score = request.json['homeScore']
game.away_score = request.json['awayScore']
game.home_roster = json.dumps(request.json['homeRoster'])
game.away_roster = json.dumps(request.json['awayRoster'])
points = request.json['points']
game.points = json.dumps(points)
db.session.add(game)
db.session.commit()
# calculate and save stats
stats = StatsCalculator(points, game.id).run()
for name, player_stats in stats:
db.session.add(player_stats)
db.session.commit()
# clear the stats cache
cache.clear()
return ('', 201)
def create_tournament(payload):
data = request.json
# Prepare game
game = Game.query.filter(Game.id == data['gameId']).first()
if not game:
game = Game.query.filter(Game.name.ilike(data['gameName'].strip())).first()
if not game:
game = Game(name=data['gameName'])
db.session.add(game)
db.session.flush()
tournament = Tournament(name=data)
# Generate the UUID
uuid_len = 6
tries = 0
max_tries = 10
tournament_found = True
uuid = ''
while tournament_found:
if tries >= max_tries:
tries = 0
uuid_len += 1
tries += 1
uuid = generate_uuid(uuid_len)
tournament_found = db.session.query(Tournament).filter(tournament.uuid == uuid).first()
tournament.uuid = uuid
tournament.name = data['name']
tournament.max_participants = data['maxParticipants']
if 'startDate' in data:
tournament.start_date = data['startDate']
if 'startDateTz' in data:
tournament.start_date_tz = data['startDateTz']
tournament.game_id = game.id
user = auth.get_logged_user()
tournament.creator_id = user.id
db.session.add(tournament)
db.session.flush()
db.session.commit()
return jsonify(tournament.long()), 201
def test_DB_create_games_03(self):
newGame = Game(gameId=1,
date="1900-10-05T12:34:45.000Z",
season=99,
homeTeamAbbr="ABC",
awayTeamAbbr="CBA",
homeTeamScore=1,
awayTeamScore=0,
postseason=True,
city="Austin")
db.session.add(newGame)
db.session.commit()
query1 = Game.query.filter_by(gameId=1).first()
self.assertEqual(newGame, query1)
db.session.delete(newGame)
db.session.commit()
query2 = Game.query.filter_by(gameId=1).first()
self.assertNotEqual(newGame, query2)
def get_open_game(self):
self._end_games_that_shouldnt_be_open()
cur = self.con.cursor()
cur.execute(
"SELECT game_id, timestamp, left_team_id, right_team_id, left_score, right_score, ended "
+ "FROM games WHERE ended=:ended ORDER BY game_id desc",
dict(ended=0))
open_game = cur.fetchone()
if open_game:
game_id, timestamp, left_team_id, right_team_id, left_score, right_score, ended = open_game
return Game(game_id=game_id,
timestamp=timestamp,
left_team=self.get_team(left_team_id),
right_team=self.get_team(right_team_id),
left_score=left_score,
right_score=right_score,
ended=ended)
else:
return None
def collect_game_data(opponent_uid=0, game=None):
if not game:
uid_list = [current_user.id, opponent_uid]
user1_id = random.choice(uid_list)
uid_list.remove(user1_id)
game = Game(
user1_id=user1_id,
user2_id=uid_list[0],
)
db.session.add(game)
db.session.commit()
return {
'gid': game.id,
'uid': current_user.id,
'oid': opponent_uid,
'udata': collect_user_data(),
'odata': collect_user_data(opponent_uid),
'state': game.state,
'X': game.user1.username,
'O': game.user2.username
}
def postGame():
try:
# Add players
addPlayer1 = Players(request.json['players'][0])
addPlayer2 = Players(request.json['players'][1])
db.session.add(addPlayer1)
db.session.add(addPlayer2)
# Add new Game
newGame = Game('IN PROGRESS', '', request.json['columns'],
request.json['rows'])
db.session.add(newGame)
db.session.commit()
# Star new game session
session = GameSession(addPlayer1.id, addPlayer2.id, newGame.id)
db.session.add(session)
db.session.commit()
return jsonify({'gameId': str(newGame.id)})
except:
return jsonify({"Error": "400"}), 400
def test_DB_create_games_02(self):
newGame = Game(gameId=10101,
date="2000-01-01T00:00:00.000Z",
season=1,
homeTeamAbbr="",
awayTeamAbbr="",
homeTeamScore=12,
awayTeamScore=15,
postseason=False,
city="")
db.session.add(newGame)
db.session.commit()
query1 = Game.query.filter_by(gameId=10101).first()
self.assertEqual(newGame, query1)
db.session.delete(newGame)
db.session.commit()
query2 = Game.query.filter_by(gameId=10101).first()
self.assertNotEqual(newGame, query2)
def get(self):
user = users.get_current_user()
email = user.email()
logging.info("user: "******"email: " + str(email))
game = Game()
player = game.selectOneJoin("m.bad_avatar, m.registered", "j.email = {}", [email])
if player is None:
logging.info("couldn't find player in jive_profile table (email: '{0}')".format(email))
self.redirect('/register')
return
if player[0] != 0:
self.redirect('/badavatar')
#logging.info(player[1])
template_values = {'selected': 'home', 'user_registered': player[1]}
template = JINJA_ENVIRONMENT.get_template('index.html')
self.response.write(template.render(template_values))
def index():
errors = []
if request.method == 'POST':
try:
number_players = request.form['nr-players']
game = Game(
nrplayer=number_players,
nrround=1
)
db.session.add(game)
db.session.commit()
print(game.id)
create_words(game.id)
return render_template("shuffle.html", round=1, gameid=game.id)
except:
errors.append(
"Falsche Spieleranzahl. Mögliche Anzahl sind 4-8 Spieler"
)
return render_template('index.html')
def api(request):
q = json.loads(request.POST['json'])
action = q['action']
response = {'success': False}
if action == 'create':
g = Game(name=q['name'], max_players=q['max_players'])
g.save()
response['id'] = g.pk
response['success'] = True
if action == 'list':
pass
if action == 'join':
pass
if action == 'ready':
pass
if action == 'leave':
pass
if action == 'send':
pass
if action == 'poll':
pass
return HttpResponse(json.dumps(response))
