def handle(self, *args, **options): try: self.game = Game.imminent_game() except Game.DoesNotExist: self.stderr.write("No currently-running game found.") call_command('newgame', stdout=self.stdout, stderr=self.stderr) self.game = Game.imminent_game() self.schools = list(School.objects.all()) self.dorms = list(Building.dorms().all()) if len(self.schools) == 0 or len(self.dorms) == 0: call_command( 'loaddata', os.path.join('HVZ', 'main', 'fixtures', 'production.json'), stdout=self.stdout, stderr=self.stderr, ) self.schools = list(School.objects.all()) self.dorms = list(Building.dorms().all()) num_players = options.get('players') or NUM_PLAYERS num_ozs = options.get('ozs') or NUM_OZS self.password = options.get('password') or PASSWORD self.year = settings.NOW().year players = self.make_players(num_players) Player.objects.bulk_create(players) self.pick_ozs(num_ozs)
def raw_serialization(self, context): game = Game.nearest_game() t0, tf = time_endpoints(game) meals_vs_hours = meals_per_hour(Game.nearest_game(), self.get_queryset()) histogram = [] for hour in xrange(len(meals_vs_hours)): t = t0 + timedelta(hours=hour) # Stop at the current time if t > settings.NOW(): break histogram.append([json_format_time(t), meals_vs_hours[hour]]) # Pre-game case if not histogram: histogram = [[json_format_time(t0), 0]] return [{ "data": histogram, "color": "rgb(0, 128, 0)", }]
def save(self, commit=True): """Save the player, creating or updating the user if necessary.""" player = super(RegisterForm, self).save(commit=False) def grab(s): return self.cleaned_data.get(s) email = grab('email') password = grab('password1') try: user = User.objects.get(email=email) user.set_password(password) except User.DoesNotExist: user = User.objects.create_user( email=email, username=email, password=password, ) finally: user.first_name = grab("first_name") user.last_name = grab("last_name") user.full_clean() user.save() player.user = user player.game = Game.imminent_game() if commit == True: player.save() return player
def make_meals(self, num_meals): humans = list(Player.current_players().filter(team='H')) zombies = list(Player.current_players().filter(team='Z')) g = Game.imminent_game() days = (g.end_date - g.start_date).days day = g.start_date while day < g.end_date: meals_per_hour = [0 for i in xrange(24)] for i in xrange(int(num_meals / days)): meals_per_hour[int(random.gauss(13, 4)) % 24] += 1 for hour in xrange(24): for meal in xrange(meals_per_hour[hour]): z = int(random.random() * len(zombies)) h = int(random.random() * len(humans)) Meal( eater=zombies[z], eaten=humans[h], time=datetime.combine(day, time(hour=hour)), location=random.choice(Building.objects.all()), ).save() # Instead of retrieving the entire zombie and human lists # again, why don't we just add the human to the zombie # horde ourselves? zombies.append(humans.pop(h)) day += timedelta(days=1)
def spitList(request, clan): if request.user.is_staff: clan = clan.replace("_", " ") context = {'clan': clan, 'players':Player.objects.all().filter(game=Game.nearest_game(), clan=clan)} else: context = {'clan': 'No Permission', 'players':[]} return render(request, 'main/spitList.html', context)
def clean(self, *args, **kwargs): cleaned_data = super(MealForm, self).clean(*args, **kwargs) g = Game.imminent_game() # Check that day and time exist if not 'day' in cleaned_data: raise forms.ValidationError("Somehow you didn't specify the day.") if not 'time' in cleaned_data: raise forms.ValidationError("Somehow you didn't select a time.") feed_date = g.start_date + datetime.timedelta(days=int(cleaned_data['day'])) if feed_date < g.start_date: raise forms.ValidationError("Can't have eaten before the game!") if feed_date > g.end_date: raise forms.ValidationError("Can't have eaten after the game ended!") feed_time = datetime.datetime.combine(feed_date, cleaned_data['time']) if feed_time > settings.NOW(): raise forms.ValidationError("You can't eat in the future, bro.") cleaned_data['time'] = feed_time return cleaned_data
def clean(self, *args, **kwargs): cleaned_data = super(MealForm, self).clean(*args, **kwargs) g = Game.imminent_game() # Check that day and time exist if not 'day' in cleaned_data: raise forms.ValidationError("Somehow you didn't specify the day.") if not 'time' in cleaned_data: raise forms.ValidationError("Somehow you didn't select a time.") feed_date = g.start_date + datetime.timedelta( days=int(cleaned_data['day'])) if feed_date < g.start_date: raise forms.ValidationError("Can't have eaten before the game!") if feed_date > g.end_date: raise forms.ValidationError( "Can't have eaten after the game ended!") feed_time = datetime.datetime.combine(feed_date, cleaned_data['time']) if feed_time > settings.NOW(): raise forms.ValidationError("You can't eat in the future, bro.") cleaned_data['time'] = feed_time return cleaned_data
def get_offset(): """Return the number of days since game start.""" try: g = Game.imminent_game() except Game.DoesNotExist: return 0 return (settings.NOW().date() - g.start_date).days
def save(self, commit=False): def grab(s): return self.cleaned_data[s] game = Game.nearest_game() player = Player.user_to_player(self.user, game) self.thread = Thread( game=game, team=grab('team'), title=grab('title'), slug=slugify(grab('title')), ) self.thread.save() post = Post( author=player, thread=self.thread, body=grab('post_body'), created=settings.NOW(), ) if commit: post.save() return self.thread
def get_queryset(self, *args, **kwargs): return (Meal.objects.filter( eater__game=Game.nearest_game()).select_related( 'eater__user__first_name', 'eater__user__last_name', 'eaten__user__first_name', 'eaten__user__last_name', ).order_by('time'))
def game(self): if self._game: return self._game try: self._game = Game.nearest_game() except Game.DoesNotExist: raise PermissionDenied("You need to create a game!") return self._game
def spitList(request, clan): if request.user.is_staff: clan = clan.replace("_", " ") context = { 'clan': clan, 'players': Player.objects.all().filter(game=Game.nearest_game(), clan=clan) } else: context = {'clan': 'No Permission', 'players': []} return render(request, 'main/spitList.html', context)
def handle(self, *args, **options): now = settings.NOW() start_date = now.date() # The game starts or started on a Tuesday of this week if start_date.weekday() in (SUNDAY, MONDAY, TUESDAY): start_date -= datetime.timedelta((TUESDAY - start_date.weekday()) % 7) else: start_date += datetime.timedelta((start_date.weekday() - TUESDAY) % 7) end_date = start_date + datetime.timedelta(SATURDAY - TUESDAY) if Game.objects.filter(start_date=start_date, end_date=end_date).exists(): self.stderr.write("You don't need to create a game!") return game = Game(start_date=start_date, end_date=end_date) game.full_clean() game.save() self.stderr.write( "Game created from {:%A %d} to {:%A %d}, {:%B %Y}".format( start_date, end_date, start_date, ) )
def handle(self, *args, **options): try: self.game = Game.imminent_game() except Game.DoesNotExist: # Create game and players call_command( 'randomplayers', players=options.get('players'), ozs=options.get('ozs'), password=options.get('password'), stdout=self.stdout, stderr=self.stderr, ) self.game = Game.imminent_game() humans = Player.current_players().filter(team='H') zombies = Player.current_players().filter(team='Z') if not len(humans) or not len(zombies): self.stderr.write( '\n'.join(["There are no players in the current game.", "To generate a batch of random players, run", " ./manage.py randomplayers"])) return num_meals = options.get('meals') or len(humans) / 2 self.stdout.write("Creating {} meals".format(num_meals)) if not num_meals: return if len(humans) < num_meals: self.stderr.write( "There are only {} humans in the current game.".format(len(humans)) ) num_meals = len(humans) meals = self.make_meals(num_meals) Meal.objects.bulk_create(meals)
def get_context_data(self, **kwargs): context = super(PlayerListView, self).get_context_data(**kwargs) context['game_season'] = Game.nearest_game().season() context['schools'] = School.objects.all().annotate( num_players=Count('player_set')).order_by('-num_players') context['years'] = map( str, sorted(set([p.grad_year for p in Player.current_players()]))) context['school'] = self.kwargs.get('school', '') context['gradyear'] = self.kwargs.get('gradyear', '') return context
def get_context_data(self, **kwargs): context = super(PlayerListView, self).get_context_data(**kwargs) context['game_season'] = Game.nearest_game().season() context['schools'] = School.objects.all().annotate( num_players=Count('player_set') ).order_by('-num_players') context['years'] = map(str, sorted(set([p.grad_year for p in Player.current_players()]))) context['school'] = self.kwargs.get('school', '') context['gradyear'] = self.kwargs.get('gradyear', '') return context
def weekday_choices(): """Returns a list of offsets from the start of the current game.""" try: g = Game.imminent_game() except Game.DoesNotExist: return [(i, CAL.formatweekday(i, 3)) for i in xrange(7)] # Bounds on when the meal can have occurred start = g.start_date end = min(settings.NOW().date(), g.end_date) return ((i, CAL.formatweekday((start + datetime.timedelta(days=i)).weekday(), 3)) for i in range((end - start).days + 1))
def raw_serialization(self, context): game = Game.nearest_game() t0, tf = time_endpoints(game) players = Player.current_players().all() meals = Meal.objects.select_related('eaten').all() eaten_zombies = set([m.eaten for m in meals]) ozs = [p for p in players if p.team == 'Z' and p not in eaten_zombies] num_zombies = len(ozs) num_humans = len(players) - num_zombies human_tally = [] zombie_tally = [] meals_vs_hours = meals_per_hour(game, self.get_queryset()) for hour in xrange(len(meals_vs_hours)): t = t0 + timedelta(hours=hour) # Stop the graph at the current time if t > settings.NOW(): break meal_count = meals_vs_hours[hour] num_humans -= meal_count num_zombies += meal_count human_tally.append([json_format_time(t), num_humans]) zombie_tally.append([json_format_time(t), num_zombies]) if not human_tally: human_tally = [[json_format_time(t0), num_humans]] if not zombie_tally: zombie_tally = [[json_format_time(t0), num_zombies]] return [ { 'label': 'humans', 'data': human_tally, 'color': 'rgb(128, 0, 0)' }, { 'label': 'zombies', 'data': zombie_tally, 'color': 'rgb(0, 128, 0)' }, ]
def weekday_choices(): """Returns a list of offsets from the start of the current game.""" try: g = Game.imminent_game() except Game.DoesNotExist: return xrange(7) # Bounds on when the meal can have occurred start = g.start_date end = min(settings.NOW().date(), g.end_date) return ( (i, CAL.formatweekday((start+datetime.timedelta(days=i)).weekday(), 3)) for i in range((end-start).days+1) )
def test_invalid_time(self): """Ensure that eating times only occur within the game's timeline.""" g = Game.imminent_game() num_z = Player.objects.filter(team="Z").count() self.assertEqual(Meal.objects.count(), 0) m = MEAL.copy() m["day"] = -1 c = Client() c.post(reverse("login"), ROB_ZOMBIE) c.post(reverse("feed_eat"), m) # Ensure that no meal was created, and no new zombies have spawned. self.assertEqual(Meal.objects.count(), 0) self.assertEqual(Player.objects.filter(team="Z").count(), num_z)
def get_context_data(self, *args, **kwargs): context = super(LandingPage, self).get_context_data(*args, **kwargs) if not self.request.user.is_authenticated(): form = PrettyAuthForm() else: form = None context['login_form'] = form context['is_landing_page'] = True try: context['latest_meals'] = (Meal.objects.filter( eater__game=Game.games( started=True).latest(), ).order_by('-time')[:20]) except Game.DoesNotExist: context['latest_meals'] = [] return context
def inject_outbreak_percentage(request): try: latest_game = Game.games(started=True).latest() except Game.DoesNotExist: # Just return an arbitrary sane value return {'outbreak_percent': 96} players = Player.objects.filter(game=latest_game) humans = players.filter(team='H') nPlayers = players.count() if nPlayers > 0: percent = humans.count() * 100. / nPlayers else: percent = 100 return {'outbreak_percent': min(96, percent)}
def inject_outbreak_percentage(request): try: newest_game = Game.nearest_game() except Game.DoesNotExist: # Just return an arbitrary sane value return {'outbreak_percent': 96} players = Player.objects.filter(game=newest_game) humans = players.filter(team='H') nPlayers = players.count() if nPlayers > 0: percent = humans.count() * 100. / nPlayers else: percent = 100 return {'outbreak_percent': min(96, percent)}
def handle(self, *args, **options): try: self.game = Game.imminent_game() except Game.DoesNotExist: self.stderr.write("No currently-running game found.") return num_players = options.get('players') num_ozs = options.get('ozs') or NUM_OZS self.password = options.get('password') or PASSWORD self.year = settings.NOW().year players = self.make_players(num_players) Player.objects.bulk_create(players) self.pick_ozs(num_ozs)
def get_context_data(self, *args, **kwargs): context = super(LandingPage, self).get_context_data(*args, **kwargs) if not self.request.user.is_authenticated(): form = PrettyAuthForm() else: form = None context['login_form'] = form context['is_landing_page'] = True try: context['latest_meals'] = ( Meal.objects.filter( eater__game=Game.games(started=True).latest(), ).order_by('-time')[:20]) except Game.DoesNotExist: context['latest_meals'] = [] return context
def raw_serialization(self, context): game = Game.nearest_game() t0, tf = time_endpoints(game) players = Player.current_players().all() meals = Meal.objects.select_related('eaten').all() eaten_zombies = set([m.eaten for m in meals]) ozs = [p for p in players if p.team == 'Z' and p not in eaten_zombies] num_zombies = len(ozs) num_humans = len(players) - num_zombies human_tally = [] zombie_tally = [] meals_vs_hours = meals_per_hour(game, self.get_queryset()) for hour in xrange(len(meals_vs_hours)): t = t0 + timedelta(hours=hour) # Stop the graph at the current time if t > settings.NOW(): break meal_count = meals_vs_hours[hour] num_humans -= meal_count num_zombies += meal_count human_tally.append([json_format_time(t), num_humans]) zombie_tally.append([json_format_time(t), num_zombies]) if not human_tally: human_tally = [[json_format_time(t0), num_humans]] if not zombie_tally: zombie_tally = [[json_format_time(t0), num_zombies]] return [ {'label': 'humans', 'data': human_tally, 'color': 'rgb(128, 0, 0)'}, {'label': 'zombies', 'data': zombie_tally, 'color': 'rgb(0, 128, 0)'}, ]
def raw_serialization(self, context): self.players = Player.current_players().filter(team='Z').select_related('user') self.names = {p: p.user.get_full_name() for p in self.players} self.meals = (Meal.objects.filter(eater__game=Game.nearest_game()) .select_related('eater', 'eaten')) self.possible_ozs = set(self.players) self.children = defaultdict(list) for m in self.meals: if m.eaten not in self.players: continue self.children[m.eater].append(m.eaten) self.possible_ozs.remove(m.eaten) ozs = [p for p in self.players if p in self.possible_ozs] return { "name": "Subject Zero", "children": map(self.traverse, ozs), }
def raw_serialization(self, context): self.players = Player.current_players().filter( team='Z').select_related('user') self.names = {p: p.user.get_full_name() for p in self.players} self.meals = (Meal.objects.filter( eater__game=Game.nearest_game()).select_related('eater', 'eaten')) self.possible_ozs = set(self.players) self.children = defaultdict(list) for m in self.meals: if m.eaten not in self.players: continue self.children[m.eater].append(m.eaten) self.possible_ozs.remove(m.eaten) ozs = [p for p in self.players if p in self.possible_ozs] return { "name": "Subject Zero", "children": map(self.traverse, ozs), }
def save(self, commit=True): """Save the player, creating or updating the user if necessary.""" player = super(RegisterForm, self).save(commit=False) def grab(s): return self.cleaned_data.get(s) email = grab('email') password = grab('password1') try: user = User.objects.select_for_update().get(email=email) user.set_password(password) except User.DoesNotExist: # Slice is there because of a 30 character limit on # usernames... we need a custom user model in the future. # FIXED: the longerusernameandemail app makes usernames and # emails the same length and that length is 255 characters user = User.objects.create_user( email=email, username=email, password=password, ) user.first_name = grab("first_name") user.last_name = grab("last_name") user.full_clean() user.save() player.user = user player.game = Game.imminent_game() if commit == True: player.save() return player
def get_queryset(self): game = Game.nearest_game() return Player.objects.filter(game=game)
def _bounded_grad_year(grad_year): return abs(Game.nearest_game().start_date.year - grad_year) < 5
def get_queryset(self): return Meal.objects.filter(eater__game=Game.nearest_game(), time__isnull=False)
def get_queryset(self): game = Game.nearest_game() team = self.player.team return Plot.get_visible(game, team).select_related('mission')
def get_queryset(self, *args, **kwargs): return Meal.objects.filter(eater__game=Game.nearest_game()).select_related( 'eater__user__first_name', 'eater__user__last_name', 'eaten__user__first_name', 'eaten__user__last_name').order_by('time')
def get_queryset(self): return Player.objects.all().filter(game=Game.nearest_game())
def wrapper(*args, **kwargs): if not Game.games(started=True, finished=False).exists(): raise NoActiveGame("There is no game in progress!") return view_func(*args, **kwargs)
def get_queryset(self): game = Game.nearest_game() return Player.objects.filter(game=game).select_related("user").annotate(meal_count=Count("meal_set"))
def wrapper(*args, **kwargs): if not Game.games(finished=False).exists(): raise NoUnfinishedGames return view_func(*args, **kwargs)
def get_queryset(self): game = Game.imminent_game() return (Player.objects.filter(game=game). select_related('user'). annotate(meal_count=Count('meal_set')))
def wrapper(*args, **kwargs): if not Game.games(started=True, finished=False).exists(): raise NoActiveGame return view_func(*args, **kwargs)