Esempio n. 1
0
    def test_TH_reports_completion(self):
        loc_order = utils.csv_to_list(self.game.ordered_locations)

        # when the player visits the first location, 'complete' flag should be false
        self.player.highest_visited = None
        self.player.save()
        self.response = self.client.get(self.url)
        self.assertEqual(self.response.status_code, 200)
        self.assertEqual(self.response.context["game_data"]["complete"], False)

        # player visits next location - 'complete' still false
        self.location = self.game.location_set.all()[1]
        self.url = reverse(self.view, args=(self.location.uuid,))
        self.response = self.client.get(self.url)
        self.assertEqual(self.response.status_code, 200)
        self.assertEqual(self.response.context["game_data"]["complete"], False)

        # set the player to have visited the next-to-last location
        self.player.highest_visited = self.game.location_set.filter(pk=loc_order[-2])[0]
        self.player.save()
        # visiting the last location should set 'complete' to true
        last_loc = self.game.location_set.filter(pk=loc_order[-1])[0]
        self.url = reverse(self.view, args=(last_loc.uuid,))
        self.response = self.client.get(self.url)
        self.assertEqual(self.response.status_code, 200)
        self.assertEqual(self.response.context["game_data"]["complete"], True)
Esempio n. 2
0
    def test_point_order_correct(self):
        # only applies for TH game currently; thus, the default
        # should be empty
        self.assertEqual(self.response.context["gmap"].point_order, [])

        # get the page response for a TH game
        hunt = TreasureHuntGame.objects.all()[0]
        self.assertTrue(isinstance(hunt, TreasureHuntGame))
        self.assertEqual(self.user, hunt.created_by)
        self.url = reverse(self.view, args=(hunt.pk,))
        self.response = self.client.get(self.url)

        self.assertEqual(self.response.context["gmap"].point_order, utils.csv_to_list(hunt.ordered_locations))
Esempio n. 3
0
    def test_saving_location_updates_ordered_locations(self):
        # the TH game's location list should be empty
        self.assertEqual(self.hunt.ordered_locations, "")

        # add some locations to the TH game and make
        # sure they get added to ordered_locations
        ids = []
        for i in range(5):
            loc = Location()
            loc.gameID = self.hunt
            loc.save()
            ids.append(loc.id)

        game_locs = utils.csv_to_list(self.hunt.ordered_locations)
        for loc_id in ids:
            self.assertTrue(loc_id in game_locs)
Esempio n. 4
0
def qrcode(game, location):
    try:
        loc_order = utils.csv_to_list(game.ordered_locations)
        loc_index = loc_order.index(location.id)
    except ValueError:
        return ''
    
    next_index = loc_index + 1
    clue = ''
    if next_index >= len(loc_order):
        clue = 'You have reaced the final location! Congratulations!'
    else:
        next_loc = Location.objects.filter(id=loc_order[next_index])[0]
        clue = 'Clue to next location: %s' % next_loc.clue
    
    return '%s\nURL for this location:\n' % clue
Esempio n. 5
0
def location_save(sender, **kwargs):
    ''' Called after a location gets saved.
        Check if the location is for a TreasureHuntGame,
        and if so then make sure the game's ordered_locations
        includes the location.
    '''
    # only need to update when a new location is added
    # (assuming locations are never moved to a new game
    # after they are created)
    if kwargs['created']:
        loc = kwargs['instance']
        game = loc.gameID
        if isinstance(game, TreasureHuntGame):
            game_locs = utils.csv_to_list(game.ordered_locations)
            if loc.id not in game_locs:
                game.ordered_locations += str(loc.id) + ','
                game.save()
Esempio n. 6
0
    def test_TH_game_reports_completion(self):
        # join the TH game
        form_data = {"mode": "join"}
        self.response = self.client.post(self.url, form_data)
        self.assertEqual(self.response.status_code, 200)

        # the returned page should state the game is not complete
        self.assertEqual(self.response.context["game_data"]["complete"], False)

        # move the player to a middle location, game should not be complete
        player = self.game.player_set.all()[0]
        player.highest_visited = self.game.location_set.all()[0]

        # move the player to the last location in the game
        last_id = utils.csv_to_list(self.game.ordered_locations)[-1]
        player.highest_visited = self.game.location_set.filter(pk=last_id)[0]
        player.save()
        self.response = self.client.get(self.url)
        self.assertEqual(self.response.status_code, 200)
        self.assertEqual(self.response.context["game_data"]["complete"], True)
Esempio n. 7
0
def details(game, player):
    # if the player isn't given, they are not a player in this game;
    # thus return nothing
    if player is None:
        return {}
    
    game_data = {'clue':'', 'complete':False}
    loc_order = utils.csv_to_list(game.ordered_locations)
    
    # if player hasn't visited any locations, give the first clue
    next_index = 0
    if player.highest_visited is not None:
        next_index = 1 + loc_order.index(player.highest_visited.id)
    
    # if player has visited the last location
    if next_index >= len(loc_order):
        game_data['complete'] = True
    else:
        next_location = get_object_or_404(Location, id=loc_order[next_index])
        game_data['clue'] = next_location.clue
    
    return game_data
Esempio n. 8
0
def process(player, location):
    game_data = {'clue':'', 'complete':False}
    loc_order = utils.csv_to_list(player.game.ordered_locations)
    
    # if the player hasn't visited any locations
    # yet, the next location should be the first one
    next_loc_id = loc_order[0]
    
    if player.highest_visited is not None:
        # if the player has already visited the last location, do nothing
        if player.highest_visited == loc_order[-1]:
            game_data['complete'] = True
            return game_data
        else:
            # otherwise, find the next location the player should be visiting
            next_index = 1 + loc_order.index(player.highest_visited.id)
            next_loc_id = loc_order[next_index]
    
    # if the given location is the one the player should be at next,
    # then advance the player
    if location.id == next_loc_id:
        player.highest_visited = location
        player.save()
    else:
        # the player shouldn't be at this location yet
        raise PermissionDenied('not next location')
    
    # give the player the clue for the location after
    # the one they just told us they visited
    # (unless they're done the game already)
    next_index = 1 + loc_order.index(location.id)
    if next_index >= len(loc_order):
        game_data['complete'] = True
    else:
        next_location = get_object_or_404(Location, id=loc_order[next_index])
        game_data['clue'] = next_location.clue
    
    return game_data
Esempio n. 9
0
def game_edit(request, game_id):
    
    # get the game
    game = get_object_or_404(Game, pk=game_id)
    
    # only the game's creator can edit the locations
    if request.user != game.created_by:
        return HttpResponseForbidden('Cannot access: not game creator')
    
    locations = game.location_set.all().order_by('id')
    
    error_msgs = []
    if request.method == 'POST':
        # save locations, if they were given
        if request.POST['mode'] == 'update_locations':
            new_locations = simplejson.loads(request.POST['locations'])
            
            for loc in new_locations:
                # make sure this location ID exists & is
                # linked with the current game_id
                try:
                    existing_loc = locations.get(pk=loc['id'])
                except ObjectDoesNotExist:
                    error_msgs.append(
                        'location[%d] not linked to game[%d]'
                        % (int(loc['id']), int(game_id)))
                
                # set the new lat/lon
                existing_loc.latitude = str(loc['lat'])
                existing_loc.longitude = str(loc['lon'])
                
                # save any game-specific data (from the edit_XX.html templates)
                if isinstance(game, TreasureHuntGame):
                    existing_loc.clue = request.POST['clue_%d' % (existing_loc.id,)]
                
                existing_loc.save()

        # add a new point
        elif request.POST['mode'] == 'add_point':
            new_loc = Location(latitude=game.center_latitude,
                               longitude=game.center_longitude,
                               created=datetime.now(),
                               visible=datetime.now(),
                               expires=datetime.now(),
                               gameID=game)
            new_loc.save()
            
            # re-load the locations to grab the new point
            locations = game.location_set.all().order_by('id')
    
    # if this is a game with an ordering to the points,
    # grab that order for the map to connect the points
    point_order = []
    if isinstance(game, TreasureHuntGame):
        point_order = utils.csv_to_list(game.ordered_locations)
    
    points = utils.locations_to_points(locations)
    gmap = Map('gmap', points, point_order)
    gmap.center = (game.center_latitude, game.center_longitude)
    gmap.zoom = '15'
    
    context = RequestContext(request)
    context['gmap'] = gmap
    context['error_msgs'] = error_msgs
    context['game'] = game
    context['locations'] = locations
    a = ActivityStreamItem(actor=request.user,verb="has modified ",target=game,occurred=datetime.now())
    a.save()   
    context = page_info(context)
    return render_to_response('games/edit.html', context)