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 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 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 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 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 get_queryset(self):
return Meal.objects.filter(eater__game=Game.nearest_game(),
time__isnull=False)
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(started=True, finished=False).exists():
raise NoActiveGame("There is no game in progress!")
return view_func(*args, **kwargs)
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 get_queryset(self):
game = Game.nearest_game()
return Player.objects.filter(game=game)
def wrapper(*args, **kwargs):
if not Game.games(finished=False).exists():
raise NoUnfinishedGames
return view_func(*args, **kwargs)
def wrapper(*args, **kwargs):
if not Game.games(started=True, finished=False).exists():
raise NoActiveGame
return view_func(*args, **kwargs)
