2022-11-09 18:53:42 +01:00
|
|
|
from django.contrib import messages
|
2022-10-30 10:12:49 +01:00
|
|
|
from django.contrib.auth.decorators import login_required
|
|
|
|
from django.http import HttpResponse
|
2022-10-31 15:22:36 +01:00
|
|
|
from django.shortcuts import get_object_or_404, redirect, render
|
2022-10-30 23:33:28 +01:00
|
|
|
from django_htmx.http import trigger_client_event
|
2022-10-30 10:12:49 +01:00
|
|
|
|
2023-03-01 16:05:14 +01:00
|
|
|
from character.forms import AddPathForm, CharacterForm, EquipmentForm, PetForm
|
2022-11-02 21:41:06 +01:00
|
|
|
from character.models import Capability, Character, HarmfulState, Path
|
2023-03-01 16:05:14 +01:00
|
|
|
from character.models.pet import Pet
|
2022-11-02 20:39:43 +01:00
|
|
|
from character.templatetags.character_extras import modifier
|
2022-11-06 15:44:55 +01:00
|
|
|
from party.models import Party
|
2022-10-30 10:12:49 +01:00
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
2022-10-31 10:25:26 +01:00
|
|
|
def characters_list(request):
|
2022-10-31 14:47:13 +01:00
|
|
|
context = {
|
2022-11-02 23:10:48 +01:00
|
|
|
"characters": Character.objects.owned_by(request.user).select_related(
|
2023-02-28 12:34:45 +01:00
|
|
|
"race",
|
|
|
|
"profile",
|
2022-11-06 14:42:29 +01:00
|
|
|
),
|
|
|
|
"all_states": HarmfulState.objects.all(),
|
2022-10-31 14:47:13 +01:00
|
|
|
}
|
2022-11-02 23:15:38 +01:00
|
|
|
return render(request, "character/characters_list.html", context)
|
2022-10-31 10:25:26 +01:00
|
|
|
|
|
|
|
|
2022-10-31 15:22:36 +01:00
|
|
|
@login_required
|
|
|
|
def character_create(request):
|
2022-11-09 18:53:42 +01:00
|
|
|
if request.method == "POST":
|
2023-03-01 16:05:14 +01:00
|
|
|
form = CharacterForm(request.POST, request.FILES)
|
2022-11-09 18:53:42 +01:00
|
|
|
if form.is_valid():
|
|
|
|
character = form.save(commit=False)
|
|
|
|
character.player = request.user
|
|
|
|
character.recovery_points_remaining = character.recovery_points_max
|
|
|
|
character.luck_points_remaining = character.luck_points_max
|
|
|
|
character.mana_remaining = character.mana_max
|
|
|
|
character.health_remaining = character.health_max
|
|
|
|
character.save()
|
|
|
|
form.save_m2m()
|
|
|
|
messages.success(request, f"{character.name} a été créé.")
|
|
|
|
return redirect("character:list")
|
|
|
|
else:
|
2023-03-01 16:05:14 +01:00
|
|
|
form = CharacterForm()
|
2022-11-09 18:53:42 +01:00
|
|
|
context = {"form": form}
|
|
|
|
return render(request, "character/character_form.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
def character_change(request, pk: int):
|
|
|
|
character = get_object_or_404(Character.objects.managed_by(request.user), pk=pk)
|
|
|
|
if request.method == "POST":
|
2023-03-01 16:05:14 +01:00
|
|
|
form = CharacterForm(request.POST, request.FILES, instance=character)
|
2022-11-09 18:53:42 +01:00
|
|
|
if form.is_valid():
|
|
|
|
character = form.save()
|
|
|
|
messages.success(request, f"{character.name} a été enregistré.")
|
|
|
|
return redirect(character.get_absolute_url())
|
|
|
|
else:
|
2023-03-01 16:05:14 +01:00
|
|
|
form = CharacterForm(instance=character)
|
2022-11-09 18:53:42 +01:00
|
|
|
context = {"form": form}
|
|
|
|
return render(request, "character/character_form.html", context)
|
2022-10-31 15:22:36 +01:00
|
|
|
|
|
|
|
|
2022-11-15 18:06:55 +01:00
|
|
|
@login_required
|
|
|
|
def character_delete(request, pk: int):
|
|
|
|
character = get_object_or_404(Character.objects.owned_by(request.user), pk=pk)
|
|
|
|
context = {"character": character}
|
|
|
|
if request.method == "POST":
|
|
|
|
name = character.name
|
|
|
|
character.delete()
|
|
|
|
messages.success(request, f"Le personnage {name} a été supprimé.")
|
|
|
|
return redirect("character:list")
|
|
|
|
return render(request, "character/character_delete.html", context)
|
|
|
|
|
|
|
|
|
2022-10-31 10:25:26 +01:00
|
|
|
@login_required
|
|
|
|
def character_view(request, pk: int):
|
2022-10-30 17:56:36 +01:00
|
|
|
character = get_object_or_404(
|
2022-11-11 08:59:18 +01:00
|
|
|
Character.objects.friendly_to(request.user)
|
2022-10-31 17:42:30 +01:00
|
|
|
.select_related("player", "racial_capability", "profile", "race")
|
|
|
|
.prefetch_related("capabilities__path", "weapons"),
|
2022-10-30 17:56:36 +01:00
|
|
|
pk=pk,
|
|
|
|
)
|
2022-10-31 23:23:28 +01:00
|
|
|
add_path_form = AddPathForm(character)
|
2022-11-02 22:02:48 +01:00
|
|
|
context = {
|
|
|
|
"character": character,
|
|
|
|
"add_path_form": add_path_form,
|
|
|
|
"all_states": HarmfulState.objects.all(),
|
|
|
|
}
|
2022-11-06 15:44:55 +01:00
|
|
|
party_pk = request.GET.get("party")
|
|
|
|
if party_pk:
|
|
|
|
context["party"] = get_object_or_404(
|
|
|
|
Party.objects.related_to(request.user).prefetch_related("characters"),
|
|
|
|
pk=party_pk,
|
|
|
|
)
|
2022-11-02 23:15:38 +01:00
|
|
|
return render(request, "character/character_details.html", context)
|
2022-10-30 17:37:09 +01:00
|
|
|
|
|
|
|
|
2022-10-31 23:23:28 +01:00
|
|
|
@login_required
|
|
|
|
def add_path(request, pk: int):
|
2022-11-02 23:10:48 +01:00
|
|
|
character = get_object_or_404(Character.objects.managed_by(request.user), pk=pk)
|
2022-10-31 23:23:28 +01:00
|
|
|
form = AddPathForm(character, request.POST)
|
|
|
|
context = {"character": character}
|
|
|
|
if form.is_valid():
|
2022-11-01 11:20:44 +01:00
|
|
|
path: Path = form.cleaned_data.get("character_path") or form.cleaned_data.get(
|
2023-02-28 12:34:45 +01:00
|
|
|
"other_path",
|
2022-11-01 11:20:44 +01:00
|
|
|
)
|
2023-06-19 17:43:27 +02:00
|
|
|
character.paths.add(path)
|
2022-10-31 23:23:28 +01:00
|
|
|
context["add_path_form"] = AddPathForm(character)
|
|
|
|
else:
|
|
|
|
context["add_path_form"] = form
|
2022-11-02 22:52:36 +01:00
|
|
|
return render(
|
|
|
|
request,
|
|
|
|
"character/snippets/character_details/paths_and_capabilities.html",
|
|
|
|
context,
|
|
|
|
)
|
2022-10-31 23:23:28 +01:00
|
|
|
|
|
|
|
|
2022-10-30 17:37:09 +01:00
|
|
|
@login_required
|
2022-10-31 10:25:26 +01:00
|
|
|
def character_health_change(request, pk: int):
|
2022-10-30 17:56:36 +01:00
|
|
|
character = get_object_or_404(
|
2022-11-02 23:10:48 +01:00
|
|
|
Character.objects.managed_by(request.user).only(
|
2023-02-28 12:34:45 +01:00
|
|
|
"health_max",
|
|
|
|
"health_remaining",
|
2022-10-31 17:42:30 +01:00
|
|
|
),
|
|
|
|
pk=pk,
|
2022-10-30 17:56:36 +01:00
|
|
|
)
|
2024-02-11 12:53:16 +01:00
|
|
|
value = post_updated_value(
|
|
|
|
request,
|
|
|
|
character.health_remaining,
|
|
|
|
character.health_max,
|
|
|
|
)
|
2022-10-30 17:56:36 +01:00
|
|
|
character.health_remaining = value
|
2022-10-30 17:37:09 +01:00
|
|
|
character.save(update_fields=["health_remaining"])
|
2022-11-06 16:22:54 +01:00
|
|
|
response = HttpResponse(value)
|
2022-11-25 15:59:12 +01:00
|
|
|
return trigger_client_event(response, "refresh_health_bar")
|
2022-10-30 17:47:42 +01:00
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
2022-10-31 10:25:26 +01:00
|
|
|
def character_mana_change(request, pk: int):
|
2022-10-30 17:56:36 +01:00
|
|
|
character = get_object_or_404(
|
2022-11-02 23:10:48 +01:00
|
|
|
Character.objects.managed_by(request.user)
|
2022-10-31 17:42:30 +01:00
|
|
|
.only("mana_remaining", "level", "value_intelligence", "profile")
|
|
|
|
.select_related("profile"),
|
2022-10-30 22:44:28 +01:00
|
|
|
pk=pk,
|
2022-10-30 17:56:36 +01:00
|
|
|
)
|
2022-10-30 18:42:55 +01:00
|
|
|
value = get_updated_value(request, character.mana_remaining, character.mana_max)
|
2022-10-30 17:56:36 +01:00
|
|
|
character.mana_remaining = value
|
|
|
|
character.save(update_fields=["mana_remaining"])
|
2022-11-06 16:22:54 +01:00
|
|
|
response = HttpResponse(value)
|
2022-11-25 15:59:12 +01:00
|
|
|
return trigger_client_event(response, "refresh_mana_bar")
|
2022-10-30 17:56:36 +01:00
|
|
|
|
|
|
|
|
2022-10-30 21:55:05 +01:00
|
|
|
@login_required
|
2022-10-31 10:25:26 +01:00
|
|
|
def character_recovery_points_change(request, pk: int):
|
2022-10-30 21:55:05 +01:00
|
|
|
character = get_object_or_404(
|
2022-11-02 23:10:48 +01:00
|
|
|
Character.objects.managed_by(request.user).only("recovery_points_remaining"),
|
2022-10-31 17:42:30 +01:00
|
|
|
pk=pk,
|
2022-10-30 21:55:05 +01:00
|
|
|
)
|
|
|
|
value = get_updated_value(
|
2023-02-28 12:34:45 +01:00
|
|
|
request,
|
|
|
|
character.recovery_points_remaining,
|
|
|
|
character.recovery_points_max,
|
2022-10-30 21:55:05 +01:00
|
|
|
)
|
|
|
|
character.recovery_points_remaining = value
|
|
|
|
character.save(update_fields=["recovery_points_remaining"])
|
|
|
|
return HttpResponse(value)
|
|
|
|
|
|
|
|
|
2022-10-30 23:33:28 +01:00
|
|
|
@login_required
|
2022-10-31 10:25:26 +01:00
|
|
|
def character_defense_misc_change(request, pk: int):
|
2022-10-31 17:42:30 +01:00
|
|
|
character = get_object_or_404(
|
2023-02-28 12:34:45 +01:00
|
|
|
Character.objects.managed_by(request.user).only("defense_misc"),
|
|
|
|
pk=pk,
|
2022-10-31 17:42:30 +01:00
|
|
|
)
|
2022-10-30 23:33:28 +01:00
|
|
|
value = get_updated_value(request, character.defense_misc, float("inf"))
|
|
|
|
character.defense_misc = value
|
|
|
|
character.save(update_fields=["defense_misc"])
|
|
|
|
response = HttpResponse(value)
|
2022-11-25 15:59:12 +01:00
|
|
|
return trigger_client_event(response, "update_defense")
|
2022-10-30 23:33:28 +01:00
|
|
|
|
|
|
|
|
2022-11-02 13:06:21 +01:00
|
|
|
@login_required
|
|
|
|
def character_shield_change(request, pk: int):
|
|
|
|
character = get_object_or_404(
|
2023-02-28 12:34:45 +01:00
|
|
|
Character.objects.managed_by(request.user).only("shield"),
|
|
|
|
pk=pk,
|
2022-11-02 13:06:21 +01:00
|
|
|
)
|
|
|
|
value = get_updated_value(request, character.shield, float("inf"))
|
|
|
|
character.shield = value
|
|
|
|
character.save(update_fields=["shield"])
|
|
|
|
response = HttpResponse(value)
|
2022-11-25 15:59:12 +01:00
|
|
|
return trigger_client_event(response, "update_defense")
|
2022-11-02 13:06:21 +01:00
|
|
|
|
|
|
|
|
2022-11-02 20:46:07 +01:00
|
|
|
@login_required
|
|
|
|
def character_armor_change(request, pk: int):
|
|
|
|
character = get_object_or_404(
|
2023-02-28 12:34:45 +01:00
|
|
|
Character.objects.managed_by(request.user).only("armor"),
|
|
|
|
pk=pk,
|
2022-11-02 20:46:07 +01:00
|
|
|
)
|
|
|
|
value = get_updated_value(request, character.armor, float("inf"))
|
|
|
|
character.armor = value
|
|
|
|
character.save(update_fields=["armor"])
|
|
|
|
response = HttpResponse(value)
|
2022-11-25 15:59:12 +01:00
|
|
|
return trigger_client_event(response, "update_defense")
|
2022-11-02 20:46:07 +01:00
|
|
|
|
|
|
|
|
2022-11-02 13:03:20 +01:00
|
|
|
@login_required
|
|
|
|
def character_initiative_misc_change(request, pk: int):
|
|
|
|
character = get_object_or_404(
|
2023-02-28 12:34:45 +01:00
|
|
|
Character.objects.managed_by(request.user).only("initiative_misc"),
|
|
|
|
pk=pk,
|
2022-11-02 13:03:20 +01:00
|
|
|
)
|
|
|
|
value = get_updated_value(request, character.initiative_misc, float("inf"))
|
|
|
|
character.initiative_misc = value
|
|
|
|
character.save(update_fields=["initiative_misc"])
|
|
|
|
response = HttpResponse(value)
|
2022-11-25 15:59:12 +01:00
|
|
|
return trigger_client_event(response, "update_initiative")
|
2022-11-02 13:03:20 +01:00
|
|
|
|
|
|
|
|
2022-10-30 22:02:21 +01:00
|
|
|
@login_required
|
2022-10-31 10:25:26 +01:00
|
|
|
def character_luck_points_change(request, pk: int):
|
2022-10-30 22:02:21 +01:00
|
|
|
character = get_object_or_404(
|
2022-11-02 23:10:48 +01:00
|
|
|
Character.objects.managed_by(request.user).only(
|
2023-02-28 12:34:45 +01:00
|
|
|
"luck_points_remaining",
|
|
|
|
"value_charisma",
|
2022-10-31 17:42:30 +01:00
|
|
|
),
|
|
|
|
pk=pk,
|
2022-10-30 22:02:21 +01:00
|
|
|
)
|
|
|
|
value = get_updated_value(
|
2023-02-28 12:34:45 +01:00
|
|
|
request,
|
|
|
|
character.luck_points_remaining,
|
|
|
|
character.luck_points_max,
|
2022-10-30 22:02:21 +01:00
|
|
|
)
|
|
|
|
character.luck_points_remaining = value
|
|
|
|
character.save(update_fields=["luck_points_remaining"])
|
|
|
|
return HttpResponse(value)
|
2024-02-11 12:53:16 +01:00
|
|
|
|
|
|
|
|
|
|
|
def post_updated_value(
|
|
|
|
request,
|
|
|
|
remaining_value: float,
|
|
|
|
max_value: float,
|
|
|
|
) -> int:
|
|
|
|
action = request.POST.get("action")
|
|
|
|
if action == "ko":
|
|
|
|
return 0
|
|
|
|
if action == "max":
|
|
|
|
return int(max_value)
|
|
|
|
|
|
|
|
multiplier = 0
|
|
|
|
if action == "positive":
|
|
|
|
multiplier = 1
|
|
|
|
elif action == "negative":
|
|
|
|
multiplier = -1
|
|
|
|
|
|
|
|
form_value = int(request.POST.get("value"))
|
|
|
|
remaining_value += form_value * multiplier
|
|
|
|
remaining_value = min([max_value, remaining_value])
|
|
|
|
remaining_value = max([0, remaining_value])
|
|
|
|
|
|
|
|
return int(remaining_value)
|
2022-10-30 22:02:21 +01:00
|
|
|
|
|
|
|
|
2022-11-18 18:22:05 +01:00
|
|
|
def get_updated_value(
|
2023-02-28 12:34:45 +01:00
|
|
|
request,
|
2023-08-15 18:28:48 +02:00
|
|
|
remaining_value: float,
|
|
|
|
max_value: float,
|
2022-11-18 18:22:05 +01:00
|
|
|
) -> int:
|
2022-10-30 18:42:55 +01:00
|
|
|
form_value = request.GET.get("value")
|
|
|
|
if form_value == "ko":
|
|
|
|
remaining_value = 0
|
|
|
|
elif form_value == "max":
|
|
|
|
remaining_value = max_value
|
2022-10-30 17:47:42 +01:00
|
|
|
else:
|
2022-10-30 18:42:55 +01:00
|
|
|
form_value = int(form_value)
|
|
|
|
remaining_value += form_value
|
|
|
|
remaining_value = min([max_value, remaining_value])
|
|
|
|
remaining_value = max([0, remaining_value])
|
2022-11-18 18:22:05 +01:00
|
|
|
return int(remaining_value)
|
2022-10-30 18:33:30 +01:00
|
|
|
|
|
|
|
|
2022-10-30 23:33:28 +01:00
|
|
|
@login_required
|
2022-10-31 10:25:26 +01:00
|
|
|
def character_get_defense(request, pk: int):
|
2022-10-30 23:33:28 +01:00
|
|
|
character = get_object_or_404(
|
2022-11-02 23:10:48 +01:00
|
|
|
Character.objects.managed_by(request.user).only(
|
2023-02-28 12:34:45 +01:00
|
|
|
"defense_misc",
|
|
|
|
"armor",
|
|
|
|
"shield",
|
|
|
|
"value_dexterity",
|
2022-10-31 17:42:30 +01:00
|
|
|
),
|
2022-10-30 23:33:28 +01:00
|
|
|
pk=pk,
|
|
|
|
)
|
|
|
|
return HttpResponse(character.defense)
|
|
|
|
|
|
|
|
|
2022-11-06 16:22:54 +01:00
|
|
|
@login_required
|
|
|
|
def character_get_health_bar(request, pk: int):
|
|
|
|
character = get_object_or_404(
|
|
|
|
Character.objects.managed_by(request.user).only(
|
2023-02-28 12:34:45 +01:00
|
|
|
"health_max",
|
|
|
|
"health_remaining",
|
2022-11-06 16:22:54 +01:00
|
|
|
),
|
|
|
|
pk=pk,
|
|
|
|
)
|
|
|
|
context = {"character": character}
|
|
|
|
return render(
|
2023-02-28 12:34:45 +01:00
|
|
|
request,
|
|
|
|
"character/snippets/character_details/health_bar.html",
|
|
|
|
context,
|
2022-11-06 16:22:54 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
def character_get_mana_bar(request, pk: int):
|
|
|
|
character = get_object_or_404(
|
|
|
|
Character.objects.managed_by(request.user).select_related("profile"),
|
|
|
|
pk=pk,
|
|
|
|
)
|
|
|
|
context = {"character": character}
|
|
|
|
return render(
|
2023-02-28 12:34:45 +01:00
|
|
|
request,
|
|
|
|
"character/snippets/character_details/mana_bar.html",
|
|
|
|
context,
|
2022-11-06 16:22:54 +01:00
|
|
|
)
|
|
|
|
|
|
|
|
|
2022-11-02 13:03:20 +01:00
|
|
|
@login_required
|
|
|
|
def character_get_initiative(request, pk: int):
|
|
|
|
character = get_object_or_404(
|
2022-11-02 23:10:48 +01:00
|
|
|
Character.objects.managed_by(request.user).only(
|
2023-02-28 12:34:45 +01:00
|
|
|
"initiative_misc",
|
|
|
|
"value_dexterity",
|
2022-11-02 13:03:20 +01:00
|
|
|
),
|
|
|
|
pk=pk,
|
|
|
|
)
|
2022-11-02 20:39:43 +01:00
|
|
|
return HttpResponse(modifier(character.modifier_initiative))
|
2022-11-02 13:03:20 +01:00
|
|
|
|
|
|
|
|
2022-10-30 18:33:30 +01:00
|
|
|
@login_required
|
2022-10-31 10:25:26 +01:00
|
|
|
def character_notes_change(request, pk: int):
|
2022-10-30 18:36:18 +01:00
|
|
|
return update_text_field(request, pk, "notes")
|
2022-10-30 18:33:30 +01:00
|
|
|
|
|
|
|
|
2022-12-28 09:27:27 +01:00
|
|
|
@login_required
|
|
|
|
def character_gm_notes_change(request, pk: int):
|
|
|
|
return update_text_field(request, pk, "gm_notes")
|
|
|
|
|
|
|
|
|
2022-10-30 18:33:30 +01:00
|
|
|
@login_required
|
2022-10-31 10:25:26 +01:00
|
|
|
def character_equipment_change(request, pk: int):
|
2022-10-31 00:06:20 +01:00
|
|
|
field = "equipment"
|
2022-10-31 17:42:30 +01:00
|
|
|
character = get_object_or_404(
|
2023-02-28 12:34:45 +01:00
|
|
|
Character.objects.managed_by(request.user).only(field),
|
|
|
|
pk=pk,
|
2022-10-31 17:42:30 +01:00
|
|
|
)
|
2022-10-31 00:06:20 +01:00
|
|
|
context = {"character": character}
|
|
|
|
if request.method == "GET":
|
2022-11-02 22:52:36 +01:00
|
|
|
return render(
|
|
|
|
request,
|
|
|
|
f"character/snippets/character_details/{field}_update.html",
|
|
|
|
context,
|
|
|
|
)
|
2022-10-31 00:06:20 +01:00
|
|
|
form = EquipmentForm(request.POST, instance=character)
|
|
|
|
if form.is_valid():
|
|
|
|
form.save()
|
2022-11-02 22:52:36 +01:00
|
|
|
return render(
|
|
|
|
request,
|
|
|
|
f"character/snippets/character_details/{field}_display.html",
|
|
|
|
context,
|
|
|
|
)
|
2023-01-29 10:38:41 +01:00
|
|
|
context["errors"] = form.errors
|
|
|
|
return render(
|
|
|
|
request,
|
|
|
|
f"character/snippets/character_details/{field}_update.html",
|
|
|
|
context,
|
|
|
|
)
|
2022-10-30 18:36:18 +01:00
|
|
|
|
|
|
|
|
2022-10-30 23:44:02 +01:00
|
|
|
@login_required
|
2022-10-31 10:25:26 +01:00
|
|
|
def character_damage_reduction_change(request, pk: int):
|
2022-10-30 23:44:02 +01:00
|
|
|
return update_text_field(request, pk, "damage_reduction")
|
|
|
|
|
|
|
|
|
2022-10-30 18:36:18 +01:00
|
|
|
def update_text_field(request, pk, field):
|
2022-10-31 17:42:30 +01:00
|
|
|
character = get_object_or_404(
|
2023-02-28 12:34:45 +01:00
|
|
|
Character.objects.managed_by(request.user).only(field),
|
|
|
|
pk=pk,
|
2022-10-31 17:42:30 +01:00
|
|
|
)
|
2022-10-30 18:33:30 +01:00
|
|
|
context = {"character": character}
|
|
|
|
if request.method == "GET":
|
2022-11-02 22:52:36 +01:00
|
|
|
return render(
|
|
|
|
request,
|
|
|
|
f"character/snippets/character_details/{field}_update.html",
|
|
|
|
context,
|
|
|
|
)
|
2022-10-30 18:36:18 +01:00
|
|
|
setattr(character, field, request.POST.get(field))
|
2022-10-30 18:45:30 +01:00
|
|
|
character.save(update_fields=[field])
|
2022-11-02 22:52:36 +01:00
|
|
|
return render(
|
2023-02-28 12:34:45 +01:00
|
|
|
request,
|
|
|
|
f"character/snippets/character_details/{field}_display.html",
|
|
|
|
context,
|
2022-11-02 22:52:36 +01:00
|
|
|
)
|
2022-10-31 22:32:14 +01:00
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
def add_next_in_path(request, character_pk: int, path_pk: int):
|
|
|
|
character = get_object_or_404(
|
2023-02-28 12:34:45 +01:00
|
|
|
Character.objects.managed_by(request.user),
|
|
|
|
pk=character_pk,
|
2022-10-31 22:32:14 +01:00
|
|
|
)
|
|
|
|
path = get_object_or_404(Path, pk=path_pk)
|
|
|
|
capability = path.get_next_capability(character)
|
|
|
|
character.capabilities.add(capability)
|
2022-10-31 22:50:17 +01:00
|
|
|
context = {
|
|
|
|
"character": character,
|
2022-11-01 10:56:24 +01:00
|
|
|
"add_path_form": AddPathForm(character),
|
2022-10-31 22:50:17 +01:00
|
|
|
}
|
2022-11-02 22:52:36 +01:00
|
|
|
return render(
|
|
|
|
request,
|
|
|
|
"character/snippets/character_details/paths_and_capabilities.html",
|
|
|
|
context,
|
|
|
|
)
|
2022-10-31 22:50:17 +01:00
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
def remove_last_in_path(request, character_pk: int, path_pk: int):
|
|
|
|
character = get_object_or_404(
|
2023-02-28 12:34:45 +01:00
|
|
|
Character.objects.managed_by(request.user),
|
|
|
|
pk=character_pk,
|
2022-10-31 22:50:17 +01:00
|
|
|
)
|
2023-06-19 17:43:27 +02:00
|
|
|
capabilities = character.capabilities.filter(path_id=path_pk).values_list(
|
|
|
|
"rank",
|
|
|
|
flat=True,
|
2022-10-31 22:50:17 +01:00
|
|
|
)
|
2023-06-19 17:43:27 +02:00
|
|
|
if len(capabilities) == 0:
|
|
|
|
character.paths.remove(path_pk)
|
|
|
|
else:
|
|
|
|
last_rank = max(
|
|
|
|
character.capabilities.filter(path_id=path_pk).values_list(
|
|
|
|
"rank",
|
|
|
|
flat=True,
|
|
|
|
),
|
|
|
|
)
|
|
|
|
cap = Capability.objects.get(path_id=path_pk, rank=last_rank)
|
|
|
|
character.capabilities.remove(cap)
|
2022-10-31 22:50:17 +01:00
|
|
|
context = {
|
|
|
|
"character": character,
|
2022-11-01 10:56:24 +01:00
|
|
|
"add_path_form": AddPathForm(character),
|
2022-10-31 22:50:17 +01:00
|
|
|
}
|
2022-11-02 22:52:36 +01:00
|
|
|
return render(
|
|
|
|
request,
|
|
|
|
"character/snippets/character_details/paths_and_capabilities.html",
|
|
|
|
context,
|
|
|
|
)
|
2022-11-02 21:41:06 +01:00
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
def remove_state(request, pk: int, state_pk: int):
|
|
|
|
character: Character = get_object_or_404(
|
2023-02-28 12:34:45 +01:00
|
|
|
Character.objects.managed_by(request.user),
|
|
|
|
pk=pk,
|
2022-11-02 21:41:06 +01:00
|
|
|
)
|
|
|
|
state = get_object_or_404(HarmfulState, pk=state_pk)
|
|
|
|
character.states.remove(state)
|
2022-11-02 22:02:48 +01:00
|
|
|
context = {"character": character, "all_states": HarmfulState.objects.all()}
|
2022-11-02 22:52:36 +01:00
|
|
|
response = render(
|
2023-02-28 12:34:45 +01:00
|
|
|
request,
|
|
|
|
"character/snippets/character_details/states.html",
|
|
|
|
context,
|
2022-11-02 22:52:36 +01:00
|
|
|
)
|
2022-11-25 15:59:12 +01:00
|
|
|
return trigger_client_event(response, "refresh_tooltips", after="swap")
|
2022-11-02 22:02:48 +01:00
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
def add_state(request, pk: int, state_pk: int):
|
|
|
|
character: Character = get_object_or_404(
|
2023-02-28 12:34:45 +01:00
|
|
|
Character.objects.managed_by(request.user),
|
|
|
|
pk=pk,
|
2022-11-02 22:02:48 +01:00
|
|
|
)
|
|
|
|
state = get_object_or_404(HarmfulState, pk=state_pk)
|
|
|
|
character.states.add(state)
|
|
|
|
context = {"character": character, "all_states": HarmfulState.objects.all()}
|
2022-11-02 22:52:36 +01:00
|
|
|
response = render(
|
2023-02-28 12:34:45 +01:00
|
|
|
request,
|
|
|
|
"character/snippets/character_details/states.html",
|
|
|
|
context,
|
2022-11-02 22:52:36 +01:00
|
|
|
)
|
2022-11-25 15:59:12 +01:00
|
|
|
return trigger_client_event(response, "refresh_tooltips", after="swap")
|
2022-11-19 10:00:48 +01:00
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
def reset_stats(request, pk: int):
|
|
|
|
character: Character = get_object_or_404(
|
2023-02-28 12:34:45 +01:00
|
|
|
Character.objects.managed_by(request.user),
|
|
|
|
pk=pk,
|
2022-11-19 10:00:48 +01:00
|
|
|
)
|
|
|
|
context = {"character": character}
|
|
|
|
if request.method == "POST":
|
|
|
|
character.reset_stats()
|
|
|
|
messages.success(request, f"Les stats de {character} ont été réinitialisées.")
|
|
|
|
return redirect(character)
|
|
|
|
return render(request, "character/character_reset_stats.html", context)
|
2023-03-01 16:05:14 +01:00
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
def create_pet(request, pk: int):
|
|
|
|
character = get_object_or_404(Character.objects.managed_by(request.user), pk=pk)
|
|
|
|
if request.method == "POST":
|
|
|
|
form = PetForm(request.POST, request.FILES)
|
|
|
|
if form.is_valid():
|
|
|
|
pet = form.save(commit=False)
|
|
|
|
pet.owner = character
|
|
|
|
pet.save()
|
|
|
|
form.save_m2m()
|
|
|
|
messages.success(request, f"{pet.name} a été créé.")
|
|
|
|
return redirect("character:view", pk=pk)
|
|
|
|
else:
|
|
|
|
form = PetForm()
|
|
|
|
context = {"form": form}
|
|
|
|
return render(request, "character/pet_form.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
def pet_change(request, pk: int):
|
|
|
|
potential_owners = Character.objects.managed_by(request.user)
|
|
|
|
pet = get_object_or_404(Pet.objects.filter(owner__in=potential_owners), pk=pk)
|
|
|
|
if request.method == "POST":
|
|
|
|
form = PetForm(request.POST, request.FILES, instance=pet)
|
|
|
|
if form.is_valid():
|
|
|
|
pet = form.save()
|
|
|
|
messages.success(request, f"{pet.name} a été enregistré.")
|
|
|
|
return redirect(pet.owner.get_absolute_url())
|
|
|
|
else:
|
|
|
|
form = PetForm(instance=pet)
|
|
|
|
context = {"form": form}
|
|
|
|
return render(request, "character/pet_form.html", context)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
def pet_health_change(request, pk: int):
|
|
|
|
potential_owners = Character.objects.managed_by(request.user)
|
|
|
|
pet = get_object_or_404(
|
|
|
|
Pet.objects.filter(owner__in=potential_owners).only(
|
|
|
|
"health_max",
|
|
|
|
"health_remaining",
|
|
|
|
),
|
|
|
|
pk=pk,
|
|
|
|
)
|
|
|
|
value = get_updated_value(request, pet.health_remaining, pet.health_max)
|
|
|
|
pet.health_remaining = value
|
|
|
|
pet.save(update_fields=["health_remaining"])
|
|
|
|
return render(
|
|
|
|
request,
|
|
|
|
"character/snippets/character_details/pet_health_bar.html",
|
|
|
|
{"pet": pet},
|
|
|
|
)
|
|
|
|
|
|
|
|
|
|
|
|
@login_required
|
|
|
|
def pet_delete(request, pk: int):
|
|
|
|
potential_owners = Character.objects.owned_by(request.user)
|
|
|
|
pet = get_object_or_404(Pet.objects.filter(owner__in=potential_owners), pk=pk)
|
|
|
|
context = {"pet": pet}
|
|
|
|
if request.method == "POST":
|
|
|
|
name = pet.name
|
|
|
|
owner = pet.owner
|
|
|
|
pet.delete()
|
|
|
|
messages.success(request, f"Le familier {name} a été supprimé.")
|
|
|
|
return redirect("character:view", pk=owner.pk)
|
|
|
|
return render(request, "character/pet_delete.html", context)
|