def view_game(request, game_id):
game = get_object_or_404(Game, id=game_id)
can_view_scenario = False
my_invitation = None
if request.user.is_authenticated:
my_invitation = get_object_or_none(
request.user.game_invite_set.filter(relevant_game=game_id))
if request.user.has_perm("view_scenario", game.scenario):
can_view_scenario = True
invite_form = None
can_edit = game.player_can_edit(request.user)
if can_edit and game.is_scheduled():
initial_data = {"message": game.hook}
invite_form = CustomInviteForm(initial=initial_data)
nsfw_blocked = game.is_nsfw and (
request.user.is_anonymous
or not request.user.profile.view_adult_content)
reason_cannot_rsvp = game.reason_player_cannot_rsvp(request.user)
can_rsvp = not reason_cannot_rsvp
gametime_url = None if not my_invitation or not game.gametime_url else game.gametime_url
context = {
'game': game,
'can_view_scenario': can_view_scenario,
'my_invitation': my_invitation,
'invite_form': invite_form,
'can_edit': can_edit,
'can_rsvp': can_rsvp,
'reason_cannot_rsvp': reason_cannot_rsvp,
'nsfw_blocked': nsfw_blocked,
'gametime_url': gametime_url,
}
return render(request, 'games/view_game_pages/view_game.html', context)
def player_is_only_leader(self, player):
membership = get_object_or_none(
self.cellmembership_set.filter(member_player=player))
if not membership:
return False
return membership.role == ROLE[0][0] and get_queryset_size(
self.cellmembership_set.filter(role=ROLE[0][0])) == 1
def not_attending(self, player):
invite = get_object_or_none(self.game_invite_set.filter(invited_player=player))
if invite:
attendance = invite.attendance
if attendance:
attendance.delete()
invite.delete()
def get_improvement(self):
return get_object_or_none(
Reward,
rewarded_player=self.game_attendance.get_player(),
relevant_game=self.game_attendance.relevant_game,
is_void=False,
is_journal=True)
def accept_invite(request, game_id):
game = get_object_or_404(Game, id=game_id)
if not game.player_can_rsvp(request.user):
raise PermissionDenied(game.reason_player_cannot_rsvp(request.user))
invite = get_object_or_none(
request.user.game_invite_set.filter(relevant_game=game.id))
if request.method == 'POST':
if not invite:
# player self-invite
invite = Game_Invite(invited_player=request.user,
relevant_game=game)
if game.scenario in request.user.scenario_set.all():
invite.as_ringer = True
form = make_accept_invite_form(invite)(request.POST)
if form.is_valid():
game_attendance = invite.attendance
with transaction.atomic():
invite.save()
if game_attendance:
game_attendance.attending_character = form.cleaned_data[
'attending_character']
game_attendance.save()
else:
game_attendance = Game_Attendance(
attending_character=form.
cleaned_data['attending_character'],
relevant_game=game,
)
game_attendance.save()
invite.is_declined = False
invite.attendance = game_attendance
invite.save()
if invite.as_ringer and not form.cleaned_data[
'attending_character']:
#Reveal scenario to ringer
game.scenario.played_discovery(request.user)
return HttpResponseRedirect(
reverse('games:games_view_game', args=(game.id, )))
else:
print(form.errors)
return None
else:
can_view_scenario = False
if request.user.has_perm("view_scenario", game.scenario):
can_view_scenario = True
# Build a accept form.
if not invite:
# if game is open for self-invites, make a temp invite that we don't save so we can make a form
invite = Game_Invite(invited_player=request.user,
relevant_game=game)
if game.scenario in request.user.scenario_set.all():
invite.as_ringer = True
form = make_accept_invite_form(invite)
context = {
'form': form,
'game': game,
'invite': invite,
'can_view_scenario': can_view_scenario,
}
return render(request, 'games/accept_invite.html', context)
def reason_player_cannot_rsvp(self, player):
if not player.is_authenticated or player.is_anonymous:
return "You must log in to accept this Game invite"
if self.gm == player:
return "GMs cannot RSVP to their own Games"
if player.is_superuser:
return None
if hasattr(self,
"max_rsvp") and self.max_rsvp and self.get_attended_players(
).count() >= self.max_rsvp:
return "This Game is full"
if self.invitation_mode == CLOSED or not self.is_scheduled():
return "This Game is closed for RSVPs."
if self.is_nsfw and not player.profile.view_adult_content:
return "This Game is marked for adults. Your content settings do not allow you to participate."
player_invitation = get_object_or_none(
player.game_invite_set.filter(relevant_game=self.id))
if player_invitation:
return None
if self.invitation_mode == INVITE_ONLY:
return "This Game only allows those with an invitation to RSVP."
if self.invitation_mode == WORLD_MEMBERS:
if not self.cell.get_player_membership(player):
return "This Game only allows those who are a member of its World to RSVP without an invite."
else:
return None
# ANYONE case
return None
def dispatch(self, *args, **kwargs):
self.character = get_object_or_404(Character, id=self.kwargs['character_id'])
self.__check_permissions()
self.cover = get_object_or_none(JournalCover, character=self.character)
if self.cover:
self.initial = {
"title": self.cover.title,
"content": self.cover.content,
}
return super().dispatch(*args, **kwargs)
def invitePlayer(self, player, text):
extant_invite = get_object_or_none(
self.cellinvite_set.filter(invited_player=player))
membership = get_object_or_none(
self.cellmembership_set.filter(member_player=player))
if membership:
membership.delete()
if extant_invite:
if extant_invite.is_declined:
extant_invite.is_declined = False
extant_invite.save()
return extant_invite
else:
invite = CellInvite(
relevant_cell=self,
invited_player=player,
invite_text=text,
)
invite.save()
return invite
def removePlayer(self, player):
membership = get_object_or_none(
self.cellmembership_set.filter(member_player=player))
if not membership:
raise ValueError("player not in cell")
if self.player_is_only_leader(player):
raise ValueError("Cannot remove only leader")
membership = self.cellmembership_set.get(member_player=player)
membership.remove_user_from_all_groups()
membership.remove_characters_from_cell()
membership.delete()
def view_scenario(request, scenario_id, game_id=None):
scenario = get_object_or_404(Scenario, id=scenario_id)
if not scenario.player_can_view(
request.user) and not scenario.player_discovered(request.user):
raise PermissionDenied(
"You don't have permission to view this scenario")
show_spoiler_warning = scenario.is_public() \
and not (request.user.is_authenticated and scenario.player_discovered(request.user)) \
or scenario.is_spoilable_for_player(request.user)
if request.method == 'POST':
form = GameFeedbackForm(request.POST)
if form.is_valid() and game_id:
game = get_object_or_none(Game, id=game_id)
if game and game.gm.id == request.user.id and str(
game.scenario.id) == scenario_id:
with transaction.atomic():
game = get_object_or_404(Game, id=game_id)
if game.gm.id == request.user.id:
game.scenario_notes = form.cleaned_data[
'scenario_notes']
game.save()
else:
raise ValueError("Invalid Game for feedback")
return HttpResponseRedirect(
reverse('games:games_view_scenario', args=(scenario.id, )))
else:
game_feedback = None
games_run = Game.objects.filter(
gm_id=request.user.id,
scenario_id=scenario.id).order_by("end_time").all()
games_run = [
x for x in games_run if not x.is_scheduled() and not x.is_active()
]
games_run_no_feedback = Game.objects.filter(gm_id=request.user.id,
scenario_id=scenario.id,
scenario_notes=None).all()
games_run_no_feedback = [
x for x in games_run_no_feedback
if not x.is_scheduled() and not x.is_active()
]
if games_run_no_feedback:
game_feedback = GameFeedbackForm()
context = {
'show_spoiler_warning': show_spoiler_warning,
'scenario': scenario,
'games_run': games_run,
'games_run_no_feedback': games_run_no_feedback,
'game_feedback_form': game_feedback,
}
return render(request, 'games/view_scenario.html', context)
def ban_player(self, player, reason):
membership = get_object_or_none(
self.cellmembership_set.filter(member_player=player))
if not membership:
raise ValueError("player not in cell")
if self.player_is_only_leader(player):
raise ValueError("Cannot remove only leader")
membership = self.cellmembership_set.get(member_player=player)
membership.remove_user_from_all_groups()
membership.remove_characters_from_cell()
membership.is_banned = True
membership.reason_banned = reason
membership.date_banned = timezone.now()
membership.save()
def addPlayer(self, player, role):
if self.get_player_membership(player):
raise ValueError("player already in cell")
membership = CellMembership(
relevant_cell=self,
member_player=player,
role=role[0],
)
membership.save()
invite = get_object_or_none(
self.cellinvite_set.filter(invited_player=player))
if invite:
invite.membership = membership
invite.save()
return membership
class SelectArtifactForm(forms.Form):
initial_artifact = None
if existing_power and existing_power.crafting_type == CRAFTING_SIGNATURE:
initial_artifact = get_object_or_none(
existing_power.artifactpowerfull_set.filter(
relevant_artifact__is_signature=True))
if existing_character:
queryset = existing_character.artifact_set.filter(
cell__isnull=True,
crafting_character=existing_character,
is_signature=True)
elif existing_power and existing_power.owner:
queryset = existing_power.owner.artifact_set.filter(
cell__isnull=True,
crafting_character__isnull=True,
is_signature=True)
elif user and user.is_authenticated:
queryset = user.artifact_set.filter(
cell__isnull=True,
crafting_character__isnull=True,
is_signature=True)
else:
queryset = Artifact.objects.none()
selected_artifact = forms.ModelChoiceField(
queryset=queryset,
initial=initial_artifact,
required=False,
empty_label="Create New Artifact",
label="Attach to existing Legendary Artifact?",
widget=forms.Select(attrs={
'v-model': 'selectedItem',
"@input": "changeSelectedItem",
}))
item_name = forms.CharField(
required=False,
max_length=450,
help_text="The name of the Legendary Artifact",
widget=forms.TextInput(attrs={
'v-model': 'sigItemName',
}))
item_description = forms.CharField(
required=False,
max_length=5000,
help_text="(Optional) A physical description of the Artifact",
widget=forms.TextInput(attrs={
'v-model': 'sigItemDescription',
}))
def view_cell(request, cell_id):
cell = get_object_or_404(Cell, id=cell_id)
#TODO: View permissions? Private cells?
can_manage_memberships = cell.player_can_manage_memberships(request.user)
can_edit_world = cell.player_can_edit_world(request.user)
user_membership = None
invite = None
if request.user.is_authenticated:
invite = get_object_or_none(
cell.open_invitations().filter(invited_player=request.user))
user_membership = cell.get_player_membership(request.user)
if not request.user.profile.confirmed_agreements:
return HttpResponseRedirect(reverse('profiles:profiles_terms'))
can_edit_characters = cell.player_can_edit_characters(request.user)
can_administer = cell.player_can_admin(request.user)
can_manage_games = cell.player_can_manage_games(request.user)
memberships_and_characters = ()
for role in ROLE:
for membership in cell.cellmembership_set.filter(role=role[0]):
characters = ()
for character in membership.member_player.character_set.filter(
cell=cell, is_deleted=False):
if not character.is_dead():
characters = characters + (character, )
memberships_and_characters = memberships_and_characters + ((
membership,
characters,
), )
upcoming_games = cell.game_set.filter(status=GAME_STATUS[0][0])
completed_games = cell.game_set\
.exclude(Q(status = GAME_STATUS[0][0]) | Q(status = GAME_STATUS[1][0]) | Q(status = GAME_STATUS[4][0]))\
.order_by("end_time").all()
context = {
'cell': cell,
'can_edit_world': can_edit_world,
'can_manage_memberships': can_manage_memberships,
'can_edit_characters': can_edit_characters,
'user_membership': user_membership,
'can_administer': can_administer,
'can_manage_games': can_manage_games,
'memberships_and_characters': memberships_and_characters,
'upcoming_games': upcoming_games,
'completed_games': completed_games,
'invite': invite,
}
return render(request, 'cells/view_cell.html', context)
def decline_invite(request, game_id):
game = get_object_or_404(Game, id=game_id)
if game.is_scheduled():
invite = get_object_or_none(
request.user.game_invite_set.filter(relevant_game=game))
if not invite:
return HttpResponseRedirect(
reverse('games:games_view_game', args=(game.id, )))
if request.user == invite.invited_player:
invite.is_declined = True
if invite.attendance:
invite.attendance.delete()
invite.attendance = None
with transaction.atomic():
invite.save()
return HttpResponseRedirect(
reverse('games:games_view_game', args=(game.id, )))
def invitePlayer(self, player, text):
extant_invite = get_object_or_none(
self.cellinvite_set.filter(invited_player=player))
if extant_invite:
if extant_invite.is_declined:
extant_invite.is_declined = False
extant_invite.save()
return extant_invite
else:
raise ValueError("Cannot invite someone already invited")
else:
invite = CellInvite(
relevant_cell=self,
invited_player=player,
invite_text=text,
)
invite.save()
return invite
def rsvp_invite(request, cell_id, secret_key=None, accept=None):
if not request.user.is_authenticated:
raise PermissionDenied(
"You must be logged in to RSVP to a Cell invitation")
if accept:
is_accepted = accept == 'y'
else:
is_accepted = False
cell = get_object_or_404(Cell, id=cell_id)
if cell.get_player_membership(request.user):
return HttpResponseRedirect(
reverse('cells:cells_view_cell', args=(cell.id, )))
invite = get_object_or_none(
cell.open_invitations().filter(invited_player=request.user))
if not invite:
if not cell.allow_self_invites and (
not secret_key
or not cell.invite_link_secret_key == secret_key):
raise PermissionDenied(
"You have not been invited to this World or your invite link has expired. Ask for a new one."
)
if request.method == 'POST':
form = RsvpForm(request.POST)
if form.is_valid():
with transaction.atomic():
if is_accepted and invite:
invite.accept()
elif is_accepted and not invite:
cell.addPlayer(request.user, ROLE[2])
elif invite:
invite.reject()
return HttpResponseRedirect(
reverse('cells:cells_view_cell', args=(cell.id, )))
else:
print(form.errors)
return None
else:
form = RsvpForm()
context = {
'form': form,
'cell': cell,
'secret_key': secret_key,
}
return render(request, 'cells/rsvp_invite.html', context)
def view_game(request, game_id):
game = get_object_or_404(Game, id=game_id)
can_view_scenario = False
my_invitation = None
if request.user.is_authenticated:
my_invitation = get_object_or_none(
request.user.game_invite_set.filter(relevant_game=game_id))
if request.user.has_perm("view_scenario", game.scenario):
can_view_scenario = True
invite_form = None
if request.user.has_perm('edit_game', game) and game.is_scheduled():
initial_data = {"message": game.hook}
invite_form = CustomInviteForm(initial=initial_data)
context = {
'game': game,
'can_view_scenario': can_view_scenario,
'my_invitation': my_invitation,
'invite_form': invite_form,
}
return render(request, 'games/view_game_pages/view_game.html', context)
def view_character(request, character_id, secret_key=None):
character = get_object_or_404(Character, id=character_id)
if character.player and secret_key:
return HttpResponseRedirect(
reverse('characters:characters_view', args=(character_id, )))
if not character.player_can_view(request.user):
raise PermissionDenied(
"You do not have permission to view this Character")
if request.user.is_authenticated and not request.user.profile.confirmed_agreements:
return HttpResponseRedirect(reverse('profiles:profiles_terms'))
secret_key_valid = False
if secret_key:
secret_key_valid = character.is_editable_with_key(secret_key)
else:
secret_key = ""
user_can_edit = (request.user.is_authenticated
and character.player_can_edit(
request.user)) or secret_key_valid
if not character.stats_snapshot:
context = {"character": character, "user_can_edit": user_can_edit}
return render(request, 'characters/legacy_character.html', context)
completed_games = [(x.relevant_game.end_time, "game", x)
for x in character.completed_games()
] # completed_games() does ordering
character_edit_history = [
(x.created_time, "edit", x)
for x in character.contractstats_set.filter(
is_snapshot=False).order_by("created_time").all()[1:]
]
exp_rewards = [(x.created_time, "exp_reward", x)
for x in character.experiencereward_set.filter(
is_void=False).order_by("created_time").all()]
events_by_date = list(
merge(completed_games, character_edit_history, exp_rewards))
timeline = defaultdict(list)
for event in events_by_date:
if event[1] == "edit":
phrases = event[2].get_change_phrases()
if len(phrases):
timeline[event[0].strftime("%d %b %Y")].append(
(event[1], phrases))
else:
timeline[event[0].strftime("%d %b %Y")].append(
(event[1], event[2]))
char_ability_values = character.stats_snapshot.abilityvalue_set.order_by(
"relevant_ability__name").all()
ability_value_by_id = {}
char_value_ids = [x.relevant_ability.id for x in char_ability_values]
primary_zero_values = [(x.name, x, 0) for x in Ability.objects.filter(
is_primary=True).order_by("name").all() if x.id not in char_value_ids]
all_ability_values = []
for x in char_ability_values:
all_ability_values.append(
(x.relevant_ability.name, x.relevant_ability, x.value))
ability_value_by_id[x.relevant_ability.id] = x.value
ability_value_by_name = list(merge(primary_zero_values,
all_ability_values))
unspent_experience = character.unspent_experience()
exp_earned = character.exp_earned()
exp_cost = character.exp_cost()
equipment_form = EquipmentForm()
bio_form = BioForm()
num_journal_entries = character.num_journals if character.num_journals else 0
latest_journals = []
if num_journal_entries > 0:
journal_query = Journal.objects.filter(
game_attendance__attending_character=character.id).order_by(
'-created_date')
if request.user.is_anonymous or not request.user.profile.view_adult_content:
journal_query = journal_query.exclude(is_nsfw=True)
journals = journal_query.all()
for journal in journals:
if len(latest_journals) > 2:
break
if journal.player_can_view(request.user):
latest_journals.append(journal)
journal_cover = get_object_or_none(JournalCover, character=character.id)
next_entry = get_characters_next_journal_credit(
character) if user_can_edit else None
show_more_home_games_warning = character.number_completed_games() > 3 \
and (character.number_completed_games_in_home_cell() < character.number_completed_games_out_of_home_cell())
available_gift = character.unspent_rewards().count() > 0
circumstance_form = None
condition_form = None
artifact_form = None
world_element_initial_cell = character.world_element_initial_cell()
world_element_cell_choices = None
if user_can_edit:
# We only need these choices if the user can edit, both for forms and for char sheet.
world_element_cell_choices = character.world_element_cell_choices()
circumstance_form = make_world_element_form(
world_element_cell_choices, world_element_initial_cell)
condition_form = make_world_element_form(world_element_cell_choices,
world_element_initial_cell)
artifact_form = make_world_element_form(world_element_cell_choices,
world_element_initial_cell)
artifacts = get_world_element_default_dict(world_element_cell_choices)
for artifact in character.artifact_set.all():
artifacts[artifact.cell].append(artifact)
artifacts = dict(artifacts)
circumstances = get_world_element_default_dict(world_element_cell_choices)
for circumstance in character.circumstance_set.all():
circumstances[circumstance.cell].append(circumstance)
circumstances = dict(circumstances)
conditions = get_world_element_default_dict(world_element_cell_choices)
for condition in character.condition_set.all():
conditions[condition.cell].append(condition)
conditions = dict(conditions)
assets = character.stats_snapshot.assetdetails_set.all()
liabilities = character.stats_snapshot.liabilitydetails_set.all()
physical_attributes = character.get_attributes(is_physical=True)
mental_attributes = character.get_attributes(is_physical=False)
attribute_value_by_id = {}
for attr in physical_attributes:
attribute_value_by_id[
attr.relevant_attribute.id] = attr.val_with_bonuses()
for attr in mental_attributes:
attribute_value_by_id[
attr.relevant_attribute.id] = attr.val_with_bonuses()
context = {
'character': character,
'user_can_edit': user_can_edit,
'health_display': character.get_health_display(),
'ability_value_by_name': ability_value_by_name,
'ability_value_by_id': ability_value_by_id,
'physical_attributes': physical_attributes,
'mental_attributes': mental_attributes,
'attribute_value_by_id': attribute_value_by_id,
'timeline': dict(timeline),
'tutorial': get_object_or_404(CharacterTutorial),
'battle_scar_form': BattleScarForm(),
'trauma_form': TraumaForm(prefix="trauma"),
'injury_form': InjuryForm(request.POST, prefix="injury"),
'exp_cost': exp_cost,
'exp_earned': exp_earned,
'unspent_experience': unspent_experience,
'equipment_form': equipment_form,
'bio_form': bio_form,
'secret_key': secret_key,
'secret_key_valid': secret_key_valid,
'num_journal_entries': num_journal_entries,
'journal_cover': journal_cover,
'next_entry': next_entry,
'latest_journals': latest_journals,
'show_more_home_games_warning': show_more_home_games_warning,
'available_gift': available_gift,
'circumstance_form': circumstance_form,
'condition_form': condition_form,
'artifact_form': artifact_form,
'artifacts_by_cell': artifacts,
'conditions_by_cell': conditions,
'circumstances_by_cell': circumstances,
'initial_cell': world_element_initial_cell,
'assets': assets,
'liabilities': liabilities,
}
return render(request, 'characters/view_pages/view_character.html',
context)
def view_character(request, character_id, secret_key = None):
character = get_object_or_404(Character, id=character_id)
if character.player and secret_key:
return HttpResponseRedirect(reverse('characters:characters_view', args=(character_id,)))
if not character.player_can_view(request.user):
raise PermissionDenied("You do not have permission to view this Character")
if request.user.is_authenticated and not request.user.profile.confirmed_agreements:
return HttpResponseRedirect(reverse('profiles:profiles_terms'))
secret_key_valid = False
if secret_key:
secret_key_valid = character.is_editable_with_key(secret_key)
else:
secret_key = ""
user_can_edit = (request.user.is_authenticated and character.player_can_edit(request.user)) or secret_key_valid
if not character.stats_snapshot:
context={"character": character,
"user_can_edit": user_can_edit}
return render(request, 'characters/legacy_character.html', context)
completed_games = [(x.relevant_game.end_time, "game", x) for x in character.completed_games()] # completed_games() does ordering
character_edit_history = [(x.created_time, "edit", x) for x in
character.contractstats_set.filter(is_snapshot=False).order_by("created_time").all()[1:]]
exp_rewards = [(x.created_time, "exp_reward", x) for x in character.experiencereward_set.filter(is_void=False).order_by("created_time").all()]
events_by_date = list(merge(completed_games, character_edit_history, exp_rewards))
timeline = defaultdict(list)
for event in events_by_date:
timeline[event[0].strftime("%d %b %Y")].append((event[1], event[2]))
char_ability_values = character.stats_snapshot.abilityvalue_set.order_by("relevant_ability__name").all()
char_value_ids = [x.relevant_ability.id for x in char_ability_values]
primary_zero_values = [(x.name, x, 0) for x in Ability.objects.filter(is_primary=True).order_by("name").all()
if x.id not in char_value_ids]
all_ability_values =[(x.relevant_ability.name, x.relevant_ability, x.value) for x in char_ability_values]
ability_value_by_name = list(merge(primary_zero_values, all_ability_values))
unspent_experience = character.unspent_experience()
exp_earned = character.exp_earned()
exp_cost = character.exp_cost()
equipment_form = EquipmentForm()
bio_form = BioForm()
num_journal_entries = Journal.objects.filter(game_attendance__attending_character=character.id).count()
journal_cover = get_object_or_none(JournalCover, character=character.id)
next_entry = get_characters_next_journal_credit(character) if user_can_edit else None
context = {
'character': character,
'user_can_edit': user_can_edit,
'health_display': character.get_health_display(),
'ability_value_by_name': ability_value_by_name,
'physical_attributes': character.get_attributes(is_physical=True),
'mental_attributes': character.get_attributes(is_physical=False),
'timeline': dict(timeline),
'tutorial': get_object_or_404(CharacterTutorial),
'battle_scar_form': BattleScarForm(),
'trauma_form': TraumaForm(prefix="trauma"),
'injury_form': InjuryForm(request.POST, prefix="injury"),
'exp_cost': exp_cost,
'exp_earned': exp_earned,
'unspent_experience': unspent_experience,
'equipment_form': equipment_form,
'bio_form': bio_form,
'secret_key': secret_key,
'secret_key_valid': secret_key_valid,
'num_journal_entries': num_journal_entries,
'journal_cover': journal_cover,
'next_entry': next_entry,
}
return render(request, 'characters/view_pages/view_character.html', context)
def accept_invite(request, game_id):
if not request.user.is_authenticated or request.user.is_anonymous:
raise PermissionDenied("You must log in to accept this Game invite")
game = get_object_or_404(Game, id=game_id)
if not game.is_scheduled(
) or game.creator.id == request.user.id or game.gm.id == request.user.id:
raise PermissionDenied(
"This Game has already started, or you're the GM!")
invite = get_object_or_none(
request.user.game_invite_set.filter(relevant_game=game))
if not invite and not game.open_invitations:
raise PermissionDenied(
"This is awkward. . . You, uh, haven't been invited to this Game")
if request.method == 'POST':
if not invite:
# player self-invite
invite = Game_Invite(invited_player=request.user,
relevant_game=game)
if game.scenario in request.user.scenario_set.all():
invite.as_ringer = True
form = make_accept_invite_form(invite)(request.POST)
if form.is_valid():
game_attendance = invite.attendance
with transaction.atomic():
invite.save()
if game_attendance:
game_attendance.attending_character = form.cleaned_data[
'attending_character']
game_attendance.save()
else:
game_attendance = Game_Attendance(
attending_character=form.
cleaned_data['attending_character'],
relevant_game=game,
)
game_attendance.save()
invite.is_declined = False
invite.attendance = game_attendance
invite.save()
if invite.as_ringer and not form.cleaned_data[
'attending_character']:
#Reveal scenario to ringer
game.scenario.played_discovery(request.user)
return HttpResponseRedirect(
reverse('games:games_view_game', args=(game.id, )))
else:
print(form.errors)
return None
else:
can_view_scenario = False
if request.user.has_perm("view_scenario", game.scenario):
can_view_scenario = True
# Build a accept form.
if not invite:
# if game is open for self-invites, make a temp invite that we don't save so we can make a form
invite = Game_Invite(invited_player=request.user,
relevant_game=game)
if game.scenario in request.user.scenario_set.all():
invite.as_ringer = True
form = make_accept_invite_form(invite)
context = {
'form': form,
'game': game,
'invite': invite,
'can_view_scenario': can_view_scenario,
}
return render(request, 'games/accept_invite.html', context)
def get_player_membership(self, player):
return get_object_or_none(
self.cellmembership_set.filter(member_player=player))
def discovery_for_player(self, player):
return get_object_or_none(Scenario_Discovery,
relevant_scenario=self,
discovering_player=player)
def get_permissions_for_role(self, role):
return get_object_or_none(PermissionsSettings,
relevant_cell=self,
role=role)
def view_cell(request, cell_id):
cell = get_object_or_404(Cell, id=cell_id)
user_membership = None
invite = None
can_manage_memberships = None
can_edit_world = None
can_edit_characters = None
can_administer = None
can_manage_games = None
can_post_world_events = None
can_gm = None
my_cell_contractors = None
if request.user.is_authenticated:
if not request.user.profile.confirmed_agreements:
return HttpResponseRedirect(reverse('profiles:profiles_terms'))
invite = get_object_or_none(
cell.open_invitations().filter(invited_player=request.user))
user_membership = cell.get_player_membership(request.user)
can_manage_memberships = cell.player_can_manage_memberships(
request.user)
can_edit_world = cell.player_can_edit_world(request.user)
can_edit_characters = cell.player_can_edit_characters(request.user)
can_administer = cell.player_can_admin(request.user)
can_manage_games = cell.player_can_manage_games(request.user)
can_post_world_events = cell.player_can_post_world_events(request.user)
can_gm = cell.player_can_run_games(request.user)
my_cell_contractors = request.user.character_set.filter(
cell=cell, is_deleted=False)
memberships_and_characters = ()
for role in ROLE:
for membership in cell.cellmembership_set.filter(role=role[0]):
characters = ()
for character in membership.member_player.character_set.filter(
cell=cell, is_deleted=False):
if not character.is_dead():
characters = characters + (character, )
memberships_and_characters = memberships_and_characters + ((
membership,
characters,
), )
upcoming_games = cell.game_set.filter(status=GAME_STATUS[0][0])
completed_games = cell.completed_games()
world_events = WorldEvent.objects.filter(
parent_cell=cell).order_by("-created_date").all()
can_view_community_link = cell.is_community_link_public or user_membership
community_link = cell.community_link if can_view_community_link else None
journal_query = Journal.objects.filter(game_attendance__attending_character__private=False)\
.filter(game_attendance__relevant_game__cell=cell)
if request.user.is_anonymous:
journal_query.filter(contains_spoilers=False, is_nsfw=False)
elif not request.user.profile.view_adult_content:
journal_query.filter(is_nsfw=False)
public_journals = journal_query.order_by('-created_date').all()[:20]
max_journals_to_display = 20
displayed_journals = []
for journal in public_journals:
if max_journals_to_display <= len(displayed_journals):
break
if journal.player_can_view(request.user):
displayed_journals.append(journal)
context = {
'cell': cell,
'can_edit_world': can_edit_world,
'can_manage_memberships': can_manage_memberships,
'can_edit_characters': can_edit_characters,
'user_membership': user_membership,
'can_administer': can_administer,
'can_manage_games': can_manage_games,
'can_post_world_events': can_post_world_events,
'can_gm': can_gm,
'memberships_and_characters': memberships_and_characters,
'upcoming_games': upcoming_games,
'completed_games': completed_games,
'invite': invite,
'my_cell_contractors': my_cell_contractors,
'world_events': world_events,
'community_link': community_link,
'latest_journals': displayed_journals,
}
return render(request, 'cells/view_cell.html', context)
def get_reward(self):
return get_object_or_none(Reward,
rewarded_player=self.get_player(),
relevant_game=self.relevant_game,
is_void=False)
def __get_context_data(self):
if 'journal_id' in self.kwargs:
journal = get_object_or_404(Journal, id=self.kwargs['journal_id'])
character = journal.game_attendance.attending_character
game_id = journal.game_attendance.relevant_game.id
else:
character = get_object_or_404(Character,
id=self.kwargs['character_id'])
game_id = self.kwargs[
'game_id'] if 'game_id' in self.kwargs else None
viewer_can_write = character.player_can_edit(self.request.user)
completed_attendances = character.completed_games()
cover = get_object_or_none(JournalCover, character=character)
journal_pages = []
cover_id = "journal_page_cover"
journal_page = {
"header": "cover",
"id": cover_id,
"empty": False,
"cover": cover if cover else {
"title": "",
"content": ""
},
}
journal_pages.append(journal_page)
for i, attendance in enumerate(completed_attendances, start=1):
if attendance.is_death():
continue
journal_page = {
"header": roman.toRoman(i),
"game": attendance.relevant_game,
"id": "journal_page_{}".format(attendance.relevant_game.id),
"game_journal": None,
"downtime_journals": [],
"empty": False,
}
journals = attendance.journal_set.filter(is_deleted=False)
if journals.count() == 0:
if viewer_can_write:
journal_page["empty"] = True
journal_pages.append(journal_page)
else:
game_journal = get_object_or_none(Journal,
game_attendance=attendance,
is_deleted=False,
is_downtime=False)
if game_journal:
game_journal.inject_viewable(self.request.user)
journal_page["game_journal"] = game_journal
journal_page["downtime_journals"] = journals.filter(
is_downtime=True).order_by("created_date").all()
for journal in journal_page["downtime_journals"]:
journal.inject_viewable(self.request.user)
journal_pages.append(journal_page)
death = character.real_death()
if death:
journal_page = {
"header":
"death",
"game":
death.game_attendance.relevant_game
if hasattr(death, 'game_attendance') and death.game_attendance
else None,
"id":
"journal_page_death",
"game_journal":
None,
"downtime_journals": [],
"empty":
False,
"death":
death,
}
journal_pages.append(journal_page)
prev_page = None
for journal_page in journal_pages:
if prev_page:
prev_page['next_id'] = journal_page['id']
journal_page['prev_id'] = prev_page['id']
prev_page = journal_page
num_journals_until_improvement = Journal.get_num_journals_until_improvement(
character) if viewer_can_write else 0
next_reward_is_improvement = num_journals_until_improvement <= 1
context = {
'view_game_id':
"journal_page_{}".format(game_id) if game_id else cover_id,
'character': character,
'viewer_can_write': viewer_can_write,
'journal_pages': journal_pages,
'next_reward_is_improvement': next_reward_is_improvement,
'num_journals_until_improvement': num_journals_until_improvement,
}
return context