예제 #1
0
def _get_team_map_win_loss(team, map):
    team_a_count = Game.query().filter(Game.map == map).filter(Game.team_a == team.name).count()
    team_b_count = Game.query().filter(Game.map == map).filter(Game.team_b == team.name).count()
    win_count = Game.query().filter(Game.map == map).filter(Game.winner == team.name).count()
    game_count = team_b_count + team_a_count
    per = 0 if not game_count else round(100 * float(win_count)/game_count)
    return [map, game_count, win_count, per]
예제 #2
0
 def cancel_game(self, request):
     """
     Cancels a Blackjack Marathon game based on key.
     """
     profile_key = Profile.get_profile_from_user().key
     Game.cancel_game(profile_key, request.urlsafe_game_key)
     return StringMessage(message='Game cancelled successfully.')
예제 #3
0
    def get(self):     
      # Can't provide an ordering here in case inequality filters are used.      
       base_query = Game.all()
       count = base_query.count()
       
       results = base_query.fetch(count)
       #db.delete(results)
   #    for game in results:
    #   	 		resultsobj = resultsobj + simplejson.dumps({"latitude":game.location.lat,"longitude":game.location.lon,"name":game.name,"type":game.game_type})
    #   objs = simplejson.dumps(resultsobj)
       
       public_attrs = Game.public_attributes()
      
       results_obj = [
          _merge_dicts({
            'lat': result.location.lat,
            'lng': result.location.lon,
            },
            dict([(attr, getattr(result, attr))
                  for attr in public_attrs]))
          for result in results]
		#for song in results:
    	#print song.type
  #     for result in query:
  # 				 resultsobj.push( "Title: " + result.address
       self.response.out.write(simplejson.dumps({
       'status': 'success',
       'count': count,
       'results': results_obj
     	}))
예제 #4
0
파일: tests.py 프로젝트: gloggi/habatu
 def test_points_multiple_games(self):
     game1 = Game(
         #tournament = self.tournament1,
         time = self.time,
         location = self.location,
         teamA=self.team1,
         teamB=self.team2,
         score_teamA=3,
         score_teamB=1,
     )
     
     game2 = Game(
         #tournament = self.tournament1,
         time = self.time,
         location = self.location,
         teamA=self.team1,
         teamB=self.team2,
         score_teamA=1,
         score_teamB=1,
     )
     
     game1.save()
     game2.save()
     self.assertEquals(self.team1.points, 4)
     self.assertEquals(self.team2.points, 1)
     game1.delete()
     game2.delete()
예제 #5
0
파일: views.py 프로젝트: kbarr/PSAM-5150
class GameView(TemplateView):
    template_name = 'gameshow/game.html'

    def _start_game(self):
        player = Player.objects.create(name="Some Name", score=0)
        self.thegame = Game()
        self.thegame.players = player
        self.thegame.title = 'My Game Title'
        self.thegame.description = "Blah Blah Blah"
        self.thegame.save()

    def post(self, request, *args, **kwargs):
        form = GameScore(request.POST)
        if form.is_valid():
            messages.add_message(self.request, messages.INFO, message="Enjoy your game!")
            return redirect('game_main')
        else:
            return self.get(request, form=form)

    def get_context_data(self, **kwargs):
        self._start_game()
        return {
            'form': GameScore() if not kwargs.get('form') else kwargs['form'],
            'game': self.thegame,
            }
    def createGame(self, request):
        """
        a player creates a game of a unique name
        """
        if request.game_name is None:
            raise endpoints.UnauthorizedException(
                'game_name is required to create a game')
        player = Player.query(Player.displayName == request.player_name).get()
        if not player:
            raise endpoints.NotFoundException(
                'No player found with name: {}' .format(request.player_name))
        elif Game.query(Game.name == request.game_name).get():
            raise endpoints.ConflictException(
                    'A Game with that name already exists!')
        else:
            # allocate new Game ID with Player key as parent
            # allocate_ids(size=None, max=None, parent=None, **ctx_options)
            # returns a tuple with (start, end) for the allocated range,
            # inclusive.
            p_key = player.key
            g_id = Game.allocate_ids(size=1, parent=p_key)[0]
            # make Game key from ID; assign initial values to the game entity
            g_key = ndb.Key(Game, g_id, parent=p_key)
            data = {}  # is a dict
            data['key'] = g_key
            data['name'] = request.game_name
            data['board'] = ['' for _ in range(9)]
            Game(**data).put()

            taskqueue.add(params={'email': player.mainEmail,
                          'gameInfo': repr(request)},
                          url='/tasks/send_confirmation_email')
            game = g_key.get()
            return game._copyGameToForm
예제 #7
0
def open_or_new_games(request):
    if not request.COOKIES.get('nickname', ''):
        return HttpResponseRedirect(reverse(set_nickname))

    if request.method == 'POST':
        form = NewGameForm(request.POST)
        if form.is_valid():
            nickname = re.sub(r'\W', '', request.COOKIES.get('nickname', ''))
            num_players = form.cleaned_data['number_of_players']
            game = Game(name=nickname, num_players=num_players)
            game.save()
            try:
                player = game.add_player(nickname, True)
                request.session['player_id'] = player.id
                request.session['game_id'] = game.id
            except Game.InvalidPlayer as x:
                pass
                #TODO: add session error message

            return HttpResponseRedirect(reverse(current_game))
    else:
        form = NewGameForm()

    return direct_to_template(request, 
            'open_or_new_games.html', {'form': form })
예제 #8
0
  def create_game(self, request) :
    """Create new conference."""
    #get the user ID first and make sure they're authorised
    user = endpoints.get_current_user()
    if not user:
      raise endpoints.UnauthorizedException('Authorization required')
    
    user_id = getUserId(user)

    #now create the game entity and insert it
    game = Game(owner=user_id, 
      player1=GameMiniForm.get('player1'), 
      player2=GameMiniForm.get('player2'),
      name=GameMiniForm.get('name'))

    playerTurn = 1
    #set the player turn randomly
    if bool(random.getrandbits(1)) :
      playerTurn = 1
    else :
      playerTurn = 2

    game.playerTurn = playerTurn

    game_key = game.put()
    url_key = game_key.urlsafe() 

    #return all of the game details, including a game key
    return GameForm(id=url_key, owner=user_id, 
      player1=game.player1, 
      player2=game.player2,
      name=game.name) 
예제 #9
0
    def get(self, name):
        if not users.get_current_user():
            self.redirect(users.create_login_url(self.request.uri))
        logging.info('Iniciando busca')
        results = search_metacritic(name, 'game')
        logging.info('Fetch concluido')
        output = []

        for result in results:
            query = Img.all()
            query.filter('url =', result[1])
            img = query.fetch(1)[0]
            query = Game.all()
            query.filter('cover =', img)
            if not query.count():
                platform = str(result[1])[:str(result[1]).rfind('/')].replace('/game/','')
                game = Game(name=str(result[0]),cover=img,platform=platform,score=str(result[2]))
                game.put()
            else:
                game = query.fetch(1)[0]
            output.append([img.key().id(), result[0], game.key().id()])

        template_values = {'results': output}

        path = os.path.join(os.path.dirname(__file__), 'search.html')
        self.response.out.write(template.render(path, template_values))
예제 #10
0
파일: views.py 프로젝트: mdsol/jive
    def post(self):
        """reset points/refresh image"""
        user = users.get_current_user()
        game = Game()
        this_player = game.selectOne(config.JIVE_PROFILE_TBL, "fullname, title, picture_binary, id", "`email` = {}", [user.email()])

        jsonstring = self.request.body
        jsdict = json.loads(jsonstring)

        if jsdict.get("reset-game"):
            game.deleteGameProgress(str(this_player[3]))
            base64string = base64.encodestring('{0}:{1}'.format(config.jive_username,config.jive_password))[:-1]

            name    = this_player[0]
            content = "<body><p>" + name + " just reset their game in <a href='https://medifaces-demo-1.appspot.com/' class='jive-link-community-small'>Medifaces</a></p><p></p><p><em>Posted by <a href='https://mdsol.jiveon.com/docs/DOC-14722'>ExpressBot</a>​</em></p></body>"
            data    = json.dumps({"visibility": "place", "parent": config.jive_placeUrl + "/"+ str(config.jive_medifaces_space), "type":"update", "content":{ "type":"text/html", "text":content}})

            result  = urlfetch.fetch(method=urlfetch.POST, url=config.jive_contentUrl, deadline=15, headers={"X-Jive-Run-As": "email " + user.email(), 'Authorization': 'Basic ' + base64string, "Content-Type": "application/json"}, payload=data).content
            broadcast('%s just reset their game!' % user.email())
            ret = {"result": "Game progress successfully reset"}
        elif jsdict.get("refresh-img"):
            ret = self.refreshPhoto(this_player, user.email(), game)
        elif jsdict.get("gender"):
            gender = jsdict.get("gender")
            ret = self.changeGender(this_player, user.email(), game, gender)
        else:
            logging.error("POST request without correct data")
            ret = {"error": "Something went wrong. Sorry about that. Try reloading this page."}

        self.response.write(json.dumps(ret))
예제 #11
0
파일: cards_app.py 프로젝트: maddencs/cards
def create_game(game_type, room_id):
    if request.method == 'GET':
        dealer = Player()
        session.add(dealer)
        game = Game(game_type)
        session.add(game)
        deck = Hand()
        session.add(deck)
        game.deck = deck
        if game_type == 'Blackjack':
            i = 1
            while i <= 5:
                seat = Seat(i)
                game.seats.append(seat)
                session.commit()
                i += 1
        game.time = datetime.datetime.now()
        game.dealer = dealer
        dealer_hand = Hand()
        dealer.hands.append(dealer_hand)
        game.players.append(current_user)
        session.commit()
        if room_id != 0:
            room = session.query(GameRoom).filter(GameRoom.id == room_id).all()[0]
            room.current_game = game
            return redirect(url_for('game_room', room_id=room_id))
        else:
            room = GameRoom()
            room.current_game = game
            session.commit()
            return redirect(url_for('game_room', room_id=room.id))
예제 #12
0
파일: views.py 프로젝트: mdsol/jive
    def post(self):
        game = Game()

        #Check logged in
        user = users.get_current_user()
        if not user:
            self.response.write(json.dumps(dict(error="Dude, you gotta be logged in! Try reloading this page.")))
            return

        this_player = game.selectOne(config.JIVE_PROFILE_TBL, "fullname, title, picture_binary, id", "`email` = {}", [user.email()])
        if this_player is None:
            logging.info("couldn't find player in jive_profile table (email: '{0}')".format(email))
            self.response.write(json.dumps({"result":"refresh"}))
            return

        #Get the json passed from the client page
        jsonstring = self.request.body
        jsdict = json.loads(jsonstring)

        if 'filterchange' not in jsdict:
            ret = self.choice_picked(game, this_player, jsdict)
        else:
            ret = self.new_filter(game, this_player, jsdict)
            
        self.response.write(json.dumps(ret))
예제 #13
0
파일: tests.py 프로젝트: maddencs/cards
 def test_make_deck_shuffle_hit(self):
     # setup
     player = Player('cory', 'password')
     game = Game('Blackjack')
     game.players.append(player)
     h = Hand()
     h2 = Hand()
     game.hands.append(h)
     player.hands.append(h2)
     cards = piece_maker(suits, card_values, 1)
     h.cards.extend(cards)
     cards_app.session.commit()
     # end of setup
     # deck is made in setUp() with piece_maker() ha
     game.deck = h
     game.hands.append(h2)
     deck = game.deck
     hand2 = h2
     cards_app.session.flush()
     assert deck.cards != shuffle(deck)
     hand_before_hit = len(hand2.cards)
     deck_before_hit = len(deck.cards)
     hit(hand2, 1)
     cards_app.session.commit()
     # do we still have 52 cards after hitting?
     assert len(set(deck.cards)) + len(set(hand2.cards)) == 52
     assert len(deck.cards) == deck_before_hit-1
     assert len(hand2.cards) == hand_before_hit+1
예제 #14
0
파일: game.py 프로젝트: Vycas/online1000
def startGame(session):
    """
    Starts the new game in one of the sessions.
    """

    game = Game()
    game.session = session
예제 #15
0
def _get_team_win_loss(team):
    team_a_count = Game.query().filter(Game.team_a == team.name).count()
    team_b_count = Game.query().filter(Game.team_b == team.name).count()
    game_count = team_b_count + team_a_count
    win_count = Game.query().filter(Game.winner == team.name).count()
    per = round(100 * float(win_count)/game_count)
    return [_get_team_name_link(team.name), team.elo, game_count, win_count, per]
예제 #16
0
def game(request):

    #check if authed
    # print "user " + str(request.user)
    if not request.user.is_authenticated():
        return HttpResponse('Unauthorized', status=401)

    if request.method == 'GET':
        #return a list of games available
        return get_json(list(Game.objects.all()))
    elif request.method == 'POST':
        # make sure authed

        try:
            json_data = json.loads(request.body)
            # user = this user
            new_game = Game(status = Game.OPEN)
            new_game.save()
            new_game.players.add(request.user)
            amounts = json_data['amounts']
            for i, amount in enumerate(amounts):
                new_pile = Pile(
                    position = i,
                    amount = amount,
                    game = new_game
                )
                new_pile.save()
            return get_json(new_game)
        except Exception, e:
            return HttpResponseServerError("Malformed data!")
예제 #17
0
    def post(self):
        user = users.get_current_user()
        if not user:
            self.redirect(users.create_login_url("/"))
            return

        game_name = self.request.get("game_name")
        if not game_name:
            self.response.write("No game name specified")
            return

        game_key = db.Key.from_path("Game", game_name)
        game = db.get(game_key)

        if not game:
            game = Game(key_name=game_name)
            game.put()

        logging.info("Game: {0}".format(game))

        player = Player(user=user, parent=game)
        player.put()

        token = channel.create_channel("{0}:{1}".format(game_name, user.user_id()))

        logging.info("/game?gamename={0}&token={1}".format(game.key().id_or_name(), token))
        self.redirect("/game?gamename={0}&token={1}".format(game.key().id_or_name(), token))
예제 #18
0
 def post(self):
     """
     CREATE a new Game entity 
     """
     self.record_usage()
     namespace_manager.set_namespace(users.get_current_user().user_id())
     param_map = {}
     param_map['player_faction'] = self.request.get('player_faction')
     param_map['player_warcaster'] = self.request.get('player_warcaster')
     param_map['opponent_name'] = self.request.get('opponent_name', '')
     param_map['opponent_faction'] = self.request.get('opponent_faction')
     param_map['opponent_warcaster'] = self.request.get('opponent_warcaster')
     param_map['result'] = self.request.get('result')
     param_map['size'] = int(self.request.get('size', 0))
     param_map['won'] = self.request.get('won') == 'true'
     param_map['draw'] = self.request.get('draw') == 'true'
     param_map['teaching'] = self.request.get('teaching') == 'true'
     param_map['location'] = self.request.get('location', '')
     param_map['game_type'] = self.request.get('game_type', '')
     date = self.request.get('date')
     try:
         real_date = datetime.datetime.strptime(date,'%m/%d/%Y')
     except (ValueError):
         real_date = datetime.datetime.strptime(date,'%Y-%m-%d')
     param_map['date'] = real_date
     param_map['created_at'] = datetime.datetime.now()
     logging.error(param_map)
     game = Game(**param_map)
     game.put()
     self.response.out.write(game.key.urlsafe())
예제 #19
0
def get_sendable_board(game, side):
    board = game.get_board()

    # Only continue if the game hasn't finished
    if game.has_ended():
        if side == 1:
            return Game.reverse_board(board)
        else:
            return board

    if side == 0 and not game.blue_setup:
        board[0] = unknown_row(side)
        board[1] = unknown_row(side)
        board[2] = unknown_row(side)
        board[3] = unknown_row(side)

        return board

    else:
        hidden_side_board = hide_side(board, side)

        if side == 1:
            return Game.reverse_board(hidden_side_board)
        else:
            return hidden_side_board
예제 #20
0
파일: tests.py 프로젝트: maddencs/cards
 def test_blackjack_player_wins(self):
     player = Player('cory','password')
     game = Game('Blackjack')
     hand = Hand()
     player.bank = 100
     player.hands.append(hand)
     game.hands.append(hand)
     game.players.append(player)
     bank_before_bet = player.bank
     # cards_app.session.commit()
     cards_app.session.flush()
     bet(hand, 50)
     cards = [Card(sequence=1), Card(sequence=10)]
     hand.cards.extend(cards)
     count_blackjack(hand)
     evaluate_hit(hand)
     # player wins with nautral evaluate_hit
     assert player.bank == bank_before_bet - 50
     # player stands on 18, dealer stands on 17
     hand.cards = [Card(sequence=10), Card(sequence=8)]
     bet(hand, 50)
     game.dealer = Player('cory','password')
     dealer = game.dealer
     dealer.cards = [Card(sequence=10), Card(sequence=17)]
     dealer_hand = Hand()
     dealer_hand.cards = dealer.cards
예제 #21
0
def __setupNewGame(player):
    game = Game(player1=player)

    # Randomize whether computer starts, or player
    if random.randint(1,2) == 1:
        game.nextTurn()

    return game
예제 #22
0
 def __setupGame(self, startingBoard, turns):
     startingBoard = self.__translateBoard(startingBoard)
     player1 = Player(name="player1")
     player2 = Player(name="player2")
     game = Game(player1=player1, player2=player2)
     game.board = startingBoard
     game.turn = turns
     return game
예제 #23
0
def save_product(product_info, imgs_no_downloand):
    from models import GameImage, PricesGame, Game
    import requests
    prices = None
    imgs_downloand = None
    game = None
    try:
        if 'gift' not in product_info:
            product_info['gift'] = None
        if 'stock' not in product_info:
            from product import STOCK_CHOICE
            product_info['stock'] = STOCK_CHOICE.get('reserva')
        if 'pegi' not in product_info:
            product_info['pegi'] = None

        if not Game.objects.filter(Q(name=product_info['title']) &
                Q(plataform=product_info['platform'])).exists():
            imgs_downloand = []
            if imgs_no_downloand:
                for img in imgs_no_downloand:
                    filename = get_filename(img)
                    request_imagen = requests.get(img)
                    if request_imagen.status_code is 200:
                        image = GameImage(name=product_info['title'])
                        image.save_image(filename, request_imagen.content)
                        imgs_downloand.append(image)
            product_info['imagenes'] = imgs_downloand if imgs_downloand else None
            img = product_info['src']
            filename = get_filename(img)
            request = requests.get(img)
            if request.status_code is 200:
                image = GameImage(name=product_info['title'][:15])
                image.save_image("main." + filename.split('.')[1], request.content)
                product_info['imagen'] = image
            else:
                product_info['imagen'] = None
            prices = PricesGame()
            prices.add_price(product_info)
            product_info['prices'] = prices
            game = Game()
            game.add_game(product_info)
        else:

            prices = PricesGame()
            prices.add_price(product_info)
            product_info['prices'] = prices
            game = Game.objects.get(Q(name=product_info['title'])&Q(plataform=product_info['platform']))
            game.prices.add(prices)
    except Exception:
        if prices:
            prices.delete()
        if 'imagen' in product_info:
            product_info['imagen'].delete()
        if imgs_downloand:
            for imagen in imgs_downloand:
                imagen.delete()
        if game:
            game.delete()
예제 #24
0
def handlefbrequestcallback(request):
    fp = open( 'tmp.3.log', 'w' ) 
    print >> fp, request
    request_str   = ( request.GET.get('request') )
    request_to    = ( request.GET.get('to') )
    #request_from  = ( request.GET.get('from') )
    request_id    = ( request.GET.get('id') )
    request_from  = request.session['fb_id']
 
    #if request_to:
    #   request_to = int(request_to.encode('ascii'))

    #if request_from:
    #   request_from = int(request_from.encode('ascii'))

    #if request_id:
    #   request_id = int(request_id.encode('ascii'))

    print >> fp, "request id", request_id
    print >> fp, "request string", request_str
    print >> fp, "request to", request_to
    print >> fp, "request from", request_from
    print >> fp, "request fb id", request.session['fb_id']

    try:
    	m_to   = Member.objects.get(fb_id=request_to)
    except: 
	# need to make member    	
        m_to   = Member(fb_id=request_to)
  
    try: 
        m_from = Member.objects.get(fb_id=request_from)
    except:
	# need to make member    	
        m_from = Member(fb_id=request_from)

    # name is set
    gamename = "%s_%s_%s" % ( request_from, request_to, time.asctime(time.gmtime()) ) 
    r = Room(name=gamename)
    r.fb_request_id = request_id
    r.save()

    g = Game(room=r)
    # game name and room name duplicated 
    g.name = gamename
    g.save()

    p = Player(game=g,turn=0)
    p.member = m_from
    p.save()

    # TODO assumes two player game - generalize
    p = Player(game=g,turn=1)
    p.member = m_to
    p.save()

    #return HttpResponseRedirect('requestpage.html')
    return HttpResponseRedirect( reverse('lupalo.views.lupalo') ) # Redirect after POST
예제 #25
0
 def post(self): 
     gameName = self.request.get("gameTitle") 
     creator = self.request.get("user")
     newGame = Game(parent = PARENT_KEY,
                    gameName = gameName,     
                    goals = [],
                    gameCreator = creator)
     newGame.put()
     self.redirect(self.request.referer)
예제 #26
0
  def DoGet(self):

    additional_values = {
      'active_games': Game.all_active(),
      'available_games': Game.all_available(),
      'completed_games': Game.all_completed(),
    }

    self.template_values.update(additional_values)
    self.render_to_response("games.html")
예제 #27
0
 def get_game(self, request):
     """
         gets a single game
     """
     game = get_by_urlsafe(request.urlsafeKey, Game)
     if game == 'Invalid Key':
         game = Game()
         return game.get_form(message="Game not found.")
     else:
         return game.get_form(message="game retrieved.")
예제 #28
0
def make_game_with_master(session, add_gm_to_game=True):
    game_master = make_users(1)[0]
    session.add(game_master)
    session.flush()
    game = Game(title='test game', password='******', starting_money=3)
    session.add(game)
    session.flush()
    if add_gm_to_game:
        game.add_game_master(user_id=game_master.id)
    return (game_master, game)
예제 #29
0
파일: tests.py 프로젝트: Edinunzio/redlight
 def test_registering_second_player(self):
     game = Game()
     game.register_player()
     self.assertEqual('Player 1', game.player_1.name)
     self.assertEqual('Player 2', game.player_2.name)
     self.assertEqual(0, game.player_1.location)
     self.assertEqual(False, game.player_1.in_motion)
     self.assertEqual(0, game.player_2.location)
     self.assertEqual(False, game.player_2.in_motion)
     self.assertEqual('locked', game.status)
예제 #30
0
파일: tictactoe.py 프로젝트: NojNo/Project4
 def new_game(self, request):
     """Creates new game. Tipp: You need the urlsafe_key later"""
     player1 = Player.query(Player.name == request.player1).get()
     player2 = Player.query(Player.name == request.player2).get()
     if not (player1 and player2):
         raise endpoints.NotFoundException('No user with this name in the database')
     game = Game.new_game(player1.key, player2.key)
     # player.key gives a specific entity from the kind (Player)
     # and inputs this to new_game
     return Game.to_form(game, 'Good luck playing TICTACTOE!')
예제 #31
0
    def get(self):
        """Send a reminder email to each User with an email about games.
        Called every hour using a cron job"""
        app_id = app_identity.get_application_id()
        users = User.query(User.email != None)
        for user in users:
            games = Game.query(Game.user == user.key).filter(Game.game_over != True).fetch()

            print(games)

            if len(games) > 0:
                print('remind me')

                subject = 'This is a reminder!'
                body = 'Hello {}, {} games of tictactoe are still active!'.format(user.name, len(games))

                # This will send test emails, the arguments to send_mail are:
                # from, to, subject, body
                mail.send_mail('noreply@{}.appspotmail.com'.format(app_id),
                           user.email,
                           subject,
                           body)
예제 #32
0
    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)
예제 #33
0
    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)
예제 #34
0
    def get(self):
        today = datetime.date.today()
        statMap = {}
        game_list = []
        namespace_manager.set_namespace(users.get_current_user().user_id())
        query = Game.query()
        games = query.fetch(1000)
        for game in games:
            faction = game.player_faction
            if not faction in statMap:
                statMap[faction] = self.initialize_stats()
            statMap[game.player_faction]['count'] += 1
            if game.won:
                statMap[game.player_faction]['wins'] += 1
            if not game.teaching and not game.draw:
                statMap[game.player_faction]['nt_count'] += 1

            months_ago = self.how_many_months_ago(game.date, today)
            if months_ago < 12:
                statMap[game.player_faction]['history'][months_ago] += 1

        self.response.out.write(json.dumps(statMap))
예제 #35
0
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
    }
예제 #36
0
    def get(self):
        """Send a reminder email to player who currently has games
        in progress"""
        players = Player.query(Player.email != None)

        for player in players:
            games = Game.query(
                ndb.OR(Game.playerOne == player.key,
                       Game.playerTwo == player.key)).filter(
                           Game.gameOver == False)
            if games.count() > 0:
                subject = 'Tic Tac Toe Reminder'
                body = 'Hello {}, you have {} games in progress. Their' \
                       ' keys are: {}'.format(player.name,
                                              games.count(),
                                              ', '.join(game.key.urlsafe() for game in games))
                logging.debug(body)

                mail.send_mail(
                    'noreply@{}.appspotmail.com'.format(
                        app_identity.get_application_id()), player.email,
                    subject, body)
예제 #37
0
    def all_v2(self, lang, lang_name, page, page_size):
        data = self.game_table.scan(
            FilterExpression=Attr('language').eq(lang))['Items']
        totalCount = len(data)

        if not 1 < page_size <= totalCount:
            page_size = totalCount

        start_index = page_size * (page - 1)
        end_index = page_size * page

        data = data[start_index:end_index]
        return {
            "totalCount": totalCount,
            "page": page,
            "pageSize": page_size,
            "language": {
                "code": lang,
                "name": lang_name
            },
            "results": [Game.to_api_structure(x) for x in data]
        }
예제 #38
0
파일: app.py 프로젝트: tonp/point
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 createGame(self, request, context):

        print("Create game request received")
        account = self.__get_account(request.playerID)

        ###
        # Code to create game and player entries goes here
        game = Game(status=GameStatus.CREATED,
                    suspect_id=random.randrange(start=1, stop=6, step=1),
                    room_id=random.randrange(start=7, stop=15, step=1),
                    weapon_id=random.randrange(start=16, stop=21, step=1))
        self.session.add(game)

        player = Player(account_id=account.id,
                        game_id=game.id,
                        number=1,
                        name=request.name)
        self.session.add(player)
        ###

        self.session.commit()
        return self.__stream_updates(player)
예제 #40
0
def __email_task():
    try:
        logging.info("Email task started")
        yesterday = datetime.datetime.now() - datetime.timedelta(days=1)
        stale_game_q = Game.query(Game.active == True,
                                  Game.updated < yesterday)
        stale_games = {}
        for game in stale_game_q.iter():
            player_key = game.active_player_key
            if not player_key in stale_games:
                stale_games[player_key] = []
            stale_games[player_key].append(game.key.id())
        __send_emails(stale_games)
        logging.info("Email task complete")
    except Exception as e:
        # It can be dangerous to allow exceptions to bubble up to the job
        # scheduler in this case -- depending on what happens, it can get
        # stuck in a retry loop and start spamming our users.
        # Instead, log the problem and raise a "stop doing that!" exception.
        msg = "Unhandled exception during email task, aborting"
        logging.exception(msg)
        raise deferred.PermanentTaskFailure(msg)
예제 #41
0
def test_eat_food():
    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])
    Engine.add_food_to_board(g, [3, 1])
    g.sanity_check()

    with open('lib/game/data/eat_food.in') as f:
        start_state = f.read().strip()

    assert(g.to_string().strip() == start_state)

    g = Engine.resolve_moves(g, [MOVE_RIGHT_1])
    g.sanity_check()
    g = Engine.resolve_moves(g, [MOVE_RIGHT_1])
    g.sanity_check()

    with open('lib/game/data/eat_food.out') as f:
        end_state = f.read().strip()

    assert(g.to_string().strip() == end_state.strip())
    assert(len(g.food) == 0)
예제 #42
0
    def get(self):
        """Send a reminder email to each User with an email about games.
        Called every 3 hours using a cron job"""
        app_id = app_identity.get_application_id()
        # Get unfinished games

        users = User.query()
        for user in users:
            # Get all the users games.
            games = Game.query(Game.user == user.key, Game.game_over == False)

            for game in games:
                logging.debug(game)
                subject = 'This is a reminder from HangmanApi!'
                body = ('Hello {}, ready to finish your game? '
                        'Your topic was {}, and you still have'
                        ' {} attempts left!').format(user.name, game.topic,
                                                     game.attempts_remaining)
                # This will send test emails, the arguments to send_mail are:
                # from, to, subject, body
                mail.send_mail('noreply@{}.appspotmail.com'.format(app_id),
                               user.email, subject, body)
예제 #43
0
def create_game(current_user):
    if not current_user.is_authenticated:
        return error("User must be authenticated", 403)

    body = flask.request.get_json()
    if body is None:
        return error("Could not decode body as JSON", 400)

    title = body.get("title")
    if (title is None) or (type(title) is not str):
        return error("Title required", 400)

    user_emails = body.get("users")
    if (user_emails is None) or (type(user_emails) is not list):
        return error("Emails of other players required", 400)

    if len(user_emails) < 1 or len(user_emails) > 5:
        return error("Player count is out of range", 400)

    users = [current_user]
    for user_email in user_emails:
        user = User.get_or_none(User.email == user_email)
        if user is None:
            return error("Unknown user", 400)
        else:
            users.append(user)

    game = Game.create(title, users)
    UserGame.create(current_user, game, UserRole.OWNER)

    # TODO: [1:] is kinda gross
    for user in users[1:]:
        UserGame.create(user, game, UserRole.PLAYER)

    for usergame in game.usergames:
        send_sync_notification(usergame.user_id)

    return success(game_id=game.id)
예제 #44
0
    def new_game(self, request):
        """Creates new game"""
        user = User.query(User.name == request.name).get()
        if not user:
            raise endpoints.NotFoundException(
                'A User with that name does not exist!')
        try:
            # create hidden blanks array
            hidden = []
            # applylowercase to answer
            request.answer.lower()
            # fill hidden array with blanks
            for char in request.answer:
                if char == " ":
                    hidden.append(",")
                else:
                    hidden.append("_")

            guesses = []
            date = datetime.datetime.now()

            # check if request.attempts_remaining is empty
            if not request.attempts_remaining:
                request.attempts_remaining = 6
            game = Game.new_game(user.key, request.topic, request.answer,
                                 hidden, guesses, date,
                                 request.attempts_remaining)

            # store active game urlsafe into user for reference later
            user.activeGameKeys.append(game.key.urlsafe())
            user.put()

        except ValueError:
            raise endpoints.BadRequestException('Cant create game')

        msg = 'Good luck playing Hangman!'
        game.add_to_history(msg, 'NONE')
        return game.to_form(msg)
예제 #45
0
 def get(self):
     self.response.headers['Content-Type'] = 'application/json'
     param_key = SeedGenParams.from_url(self.request.GET)
     verbose_paths = self.request.GET.get("verbose_paths") is not None
     params = param_key.get()
     if params.generate(preplaced={}):
         players = []
         resp = {}
         if params.tracking:
             game = Game.from_params(params,
                                     self.request.GET.get("game_id"))
             key = game.key
             resp["map_url"] = uri_for("map-render",
                                       game_id=key.id(),
                                       paths=" ".join(params.logic_paths))
             resp["history_url"] = uri_for("game-show-history",
                                           game_id=key.id())
         for p in range(1, params.players + 1):
             if params.tracking:
                 seed = params.get_seed(p, key.id(), verbose_paths)
             else:
                 seed = params.get_seed(p, verbose_paths=verbose_paths)
             spoiler = params.get_spoiler(p).replace("\n", "\r\n")
             players.append({
                 "seed":
                 seed,
                 "spoiler":
                 spoiler,
                 "spoiler_url":
                 uri_for('gen-params-get-spoiler',
                         params_id=param_key.id(),
                         player=p)
             })
         resp["players"] = players
         self.response.out.write(json.dumps(resp))
     else:
         log.error("param gen failed")
         self.response.status = 500
예제 #46
0
    def get(self, game_id, type, num, ext):
        game = Game.query(Game.id == game_id).get()

        try:
            num = int(num)
        except:
            self.response.write('Invalid ' + type + ' number.')
            self.error(404)
            return

        if type == 'screenshot':
            # Check that the requested image exists for the game.
            if (not game.screenshots) or (len(game.screenshots) <= num):
                self.response.write('Screenshot ' + ` num ` +
                                    ' not found for game ' + game_id + '.')
                self.error(404)
                return

            # Output the screenshot.
            self.response.headers['Content-Type'] = get_content_type(
                game.screenshots[num], ext)
            self.response.write(game.screenshots[num])

        elif type == 'thumbnail':
            # Check that the requested image exists for the game.
            if (not game.thumbnails) or int(num) >= (len(game.thumbnails)):
                self.response.write('Thumbnail ' + ` num ` +
                                    ' not found for game ' + game_id + '.')
                self.error(404)
                return

            # Output the thumbnail.
            self.response.headers['Content-Type'] = get_content_type(
                game.thumbnails[num], ext)
            self.response.write(game.thumbnails[num])

        else:
            self.error(404)
예제 #47
0
    def get(self):

        app_id = app_identity.get_application_id()
        open_games = Game.query(Game.status.IN(['p1 move','p2 move'])).fetch()

        emails_to_send = []
        for g in open_games:
            if g.status == 'p1 move':
                user_email = g.p1.get().email
            elif g.status == 'p2 move':
                user_email = g.p2.get().email
            if user_email:
                emails_to_send.append((user_email, g.key.urlsafe()))

        for e in emails_to_send:
            subject = 'Your turn!'
            body = 'Just a reminder: It\'s your turn in the Battleship game with id {}!'.format(e[1])

            # from, to, subject, body
            mail.send_mail('noreply@{}.appspotmail.com'.format(app_id),
                           e[0],
                           subject,
                           body)
예제 #48
0
    def get(self):
        """Send a reminder email to each User with an email about games.
        Called every hour using a cron job"""
        app_id = app_identity.get_application_id()
        games = Game.query(Game.game_over == False)
        users = User.query()

        user_keys = []
        for game in games:
            if game.user_one not in user_keys:
                user_keys.append(game.user_one)
            if game.user_two not in user_keys:
                user_keys.append(game.user_two)

        for user in users:
            if user.key in user_keys:
                subject = 'This is a reminder!'
                body = ('Hello {}, you still have an'
                        ' active Crazy Eights Game!').format(user.name)
                # This will send test emails, the arguments to send_mail are:
                # from, to, subject, body
                mail.send_mail('noreply@{}.appspotmail.com'.format(app_id),
                               user.email, subject, body)
예제 #49
0
 def add_game():
     try:
         current_user = get_current_member_object()
         game_id = request.form.get('game')
         title = request.form.get('title')
         link = request.form.get('link')
         if game_id is not '0':
             game = Game.query.filter_by(id=game_id).one_or_none()
             if game not in current_user.ownership:
                 current_user.ownership.append(game)
                 db.session.commit()
         else:
             new_game = Game(title=title, link=link)
             db.session.add(new_game)
             current_user.ownership.append(new_game)
             db.session.commit()
     except Exception as e:
         db.session.rollback()
         return jsonify({'success': False}), e.status_code
     finally:
         current_user_id = current_user.id
         db.session.close()
         return redirect(f'/members/{current_user_id}')
예제 #50
0
    def get_user_rankings(self, request):
        """Returns user rankings"""
        users = User.query()
        for user in users:
            total_rankings = 0
            ranking = 0
            games = Game.query(ancestor=user.key)
            for count, game in enumerate(games):
                # calculate ranking
                correct_guesses = (len(game.correct_guesses) -
                                   game.correct_guesses.count('_'))
                total_guesses = correct_guesses + len(game.incorrect_guesses)
                score = Score.query(ancestor=game.key).get()
                if score.points > 0 and total_guesses > 0:
                    ranking = score.points / total_guesses + score.points
                    total_rankings += ranking

            if total_rankings > 0:
                user.ranking = total_rankings / count
                user.put()

        users = User.query().order(-User.ranking)
        return UserForms(users=[user.to_form() for user in users])
예제 #51
0
def getCards(payload):
    username = payload['username']
    gameId = payload['gameId']
    games = Game.objects(gameID=gameId)

    dataA = [game.playerADataField for game in games]
    binDataA = dataA[0]

    dataB = [game.playerBDataField for game in games]
    binDataB = dataB[0]

    playerA = pickle.loads(binDataA)
    playerB = pickle.loads(binDataB)
    recipient_session_id = clients[username]

    if username == playerA.name:
        playerACards = playerA.cards
        playerACardsList = []
        for card in playerACards:
            jsonStrA = json.dumps(card.__dict__)
            playerACardsList.append(jsonStrA)
        emit('assign cards', playerACardsList, room=recipient_session_id)
        print('playerA emitted')
    elif username == playerB.name:
        playerBCards = playerB.cards
        playerBCardsList = []
        for card in playerBCards:
            jsonStrB = json.dumps(card.__dict__)
            playerBCardsList.append(jsonStrB)
        emit('assign cards', playerBCardsList, room=recipient_session_id)
        print('playerB emitted')
    else:
        print('Something is up.')

    print('it ran')
    print('username: '******'playerA: ' + playerA.name + 'playerB: ' +
          playerB.name)
예제 #52
0
def addGame(platform_id):
    checkIfUserLoggedIn()
    platform = session.query(Platform).filter_by(id=platform_id).one()
    if request.method == 'POST':
        input_date = request.form['release_date'].split('-')
        year = int(input_date[0])
        month = int(input_date[1])
        day = int(input_date[2])
        release_date = datetime.date(year, month, day)
        newGame = Game(title=request.form['title'],
                       developer=request.form['developer'],
                       publisher=request.form['publisher'],
                       release_date=release_date,
                       platform_id=platform.id,
                       user_id=platform.user_id,
                       multiplayer=request.form['multiplayer'],
                       multiplatform=request.form['multiplatform'],
                       online_multiplayer=request.form['online_multiplayer'])
        session.add(newGame)
        session.commit()
        flash('New Game - %s Successfully Created' % (newGame.title))
        return redirect(url_for('showPlatforms', platform_id=platform_id))
    else:
        return render_template('addgame.html', platform_id=platform_id)
예제 #53
0
    def new_game(self, request):
        """Creates new game"""
        user = User.query(User.name == request.user_name).get()
        if not user:
            raise endpoints.NotFoundException(
                'A User with that name does not exist!')
        url = 'http://www.setgetgo.com/randomword/get.php'
        try:
            result = urlfetch.fetch(url)
            if result.status_code == 200:
                target = result.content
                target_list = {}
                for i in target:
                    target_list[i] = False
                game = Game.new_game(user.key, request.attempts,
                                     target, target_list)
        except urlfetch.Error:
            logging.exception('Caught exception fetching url')

        # Use a task queue to update the average attempts remaining.
        # This operation is not needed to complete the creation of a new game
        # so it is performed out of sequence.
        taskqueue.add(url='/tasks/cache_average_attempts')
        return game.to_form('Good luck playing Hangman!')
예제 #54
0
    def checkGameState(self, request):
        game_id = request.game_id
        game = Game.query(Game.game_id == game_id).get()

        if game == None:
            print("\n\n Game doesnt exist for ID: {0} \n\n".format(game_id))
            return StringMessage(
                message="Game doesnt exist for ID: {0} ".format(game_id))

        state = GuessANumberApi._check_game_state(game_id)

        if state == "no_more_moves":
            print("\n\n Game Ended, No Winners: {0} \n\n".format(game_id))
            return StringMessage(
                message="Game Ended, No Winners: {0} ".format(game_id))

        if state == "no_winners_yet":
            print("\n\n No Winners Yet, Game Continues: {0} \n\n".format(
                game_id))
            return StringMessage(
                message="No Winners Yet, Game Continues: {0} ".format(game_id))

        print("\n\n Game Won By: {0} \n\n".format(state))
        return StringMessage(message="Game Won By: {0} ".format(state))
예제 #55
0
    def new_game(self, request):
        """Creates new game"""
        if 1 > request.attempts or request.attempts > 14:
            raise endpoints.BadRequestException(
                'Attempts should not be less than 1 or '
                'greater than 14!')
        user = User.query(User.name == request.user_name).get()
        if not user:
            raise endpoints.NotFoundException(
                'A User with that name does not exist!')
        try:
            target = self.pickaWord()
            game = Game.new_game(user.key, request.attempts, target[0],
                                 target[1], [
                                     '{} created a new game'.format(user.name),
                                 ])
        except:
            print 'mark 1: something wrong with creating a new game'

        # Use a task queue to update the average attempts remaining.
        # This operation is not needed to complete the creation of a new game
        # so it is performed out of sequence.
        taskqueue.add(url='/tasks/cache_average_attempts')
        return game.to_form('Good luck playing Hangman!')
예제 #56
0
def new_game(request):

    opponent = None
    if 'opponent' in request.GET:
        try:
            opponent = Player.objects.get(
                user__username=request.GET.get('opponent'))
        except:
            pass
    if opponent is None:
        opponent = random.choice(
            list(
                Player.objects.filter(logged_in=True).exclude(
                    pk=request.player.pk)))
    if opponent is None:
        # no one is available to play, wait a while
        return HttpResponse(json.dumps({'status':
                                        'Waiting for other players'}))
    sides = [request.player, opponent]
    #random.shuffle(sides)
    g = Game.start_new_game(*sides)
    for p in sides:
        p.update_play_time()
    return HttpResponseRedirect('/game/{}/'.format(g.id))
예제 #57
0
파일: tests.py 프로젝트: jsphyin/idb
    def test_add_Game3(self):

        with app.test_request_context():
            game3 = Game(id=1000000,
                         is_expansion=False,
                         primary_name="game3",
                         alt_names="alt_game3",
                         image="www.test_image3.com",
                         desc="This is a test game 3.",
                         raw_desc="Test game 3",
                         year=1980,
                         min_players=10,
                         max_players=15,
                         rating=2.5)
            db.session.add(game3)
            db.session.commit()

            gamequery = db.session.query(Game).filter_by(id="1000000").first()
            self.assertEqual(gamequery.min_players, 10)
            self.assertEqual(gamequery.max_players, 15)
            self.assertEqual(gamequery.rating, 2.5)

            db.session.delete(game3)
            db.session.commit()
예제 #58
0
    def get():
        """Send a reminder email to the user who's turn it is for
        each game that is active. Called every hour using a cron job"""
        app_id = app_identity.get_application_id()

        # Get all in progress games
        games = Game.query(Game.game_over == False)
        for game in games:

            # Get first player or second player based on whos turn
            if game.whos_turn == 1:
                user = game.player_one.get()
            else:
                user = game.player_two.get()

            # If the user has an email send them a little reminder
            if user.email is not None:
                subject = 'Freaky TicTacToe Reminder'
                body = 'Hello {}, it is currently your turn in the game [ {} ]. Please return to the game.'\
                    .format(user.name, game.key.urlsafe())
                mail.send_mail('noreply@{}.appspotmail.com'.format(app_id),
                               user.email,
                               subject,
                               body)
예제 #59
0
class SendReminderEmail(webapp2.RequestHandler):
    """Send a reminder email to each User with an email who has
        games in progress. Email body includes a count of active games and their
        urlsafe keys
        Called every hour using a cron job"""
    users = User.query(User.email is not None)

    for user in users:
        games = Game.query(Game.user == user.key).\
            filter(Game.game_over is False)
        if games.count() > 0:
            subject = 'This is a reminder!'
            body = 'Hello {}, you have {} games in progress. Their' \
                   ' keys are: {}'.\
                format(user.name,
                       games.count(),
                       ', '.join(game.key.urlsafe() for game in games))
            logging.debug(body)
            # This will send test emails, the arguments to send_mail are:
            # from, to, subject, body
            mail.send_mail(
                'noreply@{}.appspotmail.com'.format(
                    app_identity.get_application_id()), user.email, subject,
                body)
예제 #60
0
def create_game():
    json_data = request.get_json()

    # Validate Input
    if not json_data:
        return jsonify({'message': 'No input data provided'}), 400

    if 'game_id' in json_data and 'players' in json_data:
        game_id = json_data['game_id']
        players = json_data['players']

        if game_id in games:
            return jsonify({'message': 'Game with game id already exists.'},
                           400)

        game = Game(game_id, players)
        games[game_id] = game
        result = game_schema.dump(game)
        return jsonify({'message': 'Created new game.', 'game': result})
    else:
        return jsonify({
            'message':
            'A game id and a list of player names must be provided to create a game.'
        }), 400