big shot

Implement instant websocket room updates

.ai/rules/index.md

@@ -0,0 +1,7 @@
+# Project Rules Index
+
+Before planning or editing, find the row whose globs match the file's path and read that rule file.
+
+| Applies to | Rule file |
+| --- | --- |
+| {app/Events/**,app/Services/Rooms/**,resources/js/composables/**} | .ai/rules/js-composables.md |

.ai/rules/js-composables.md

@@ -0,0 +1,9 @@
+---
+paths:
+  - '{app/Events/**,app/Services/Rooms/**,resources/js/composables/**}'
+---
+
+# Js Composables
+
+## Never broadcast hidden room votes
+Room table updates are delivered as synchronous WebSocket state payloads without polling or Inertia reloads. Before a round is revealed, broadcast only has_voted and keep every player's vote null; actual vote values may enter the shared payload only after reveal. State-changing commands remain server-authorized HTTP requests.

app/Events/PaperBallThrown.php

@@ -17,6 +17,7 @@ class PaperBallThrown implements ShouldBroadcastNow
         public readonly string $roomId,
         public readonly int $fromPlayerId,
         public readonly int $targetPlayerId,
+        public readonly int $chargeLevel,
     ) {}
 
     public function broadcastOn(): Channel
@@ -30,7 +31,7 @@ class PaperBallThrown implements ShouldBroadcastNow
     }
 
     /**
-     * @return array{id: string, from_player_id: int, target_player_id: int}
+     * @return array{id: string, from_player_id: int, target_player_id: int, charge_level: int}
      */
     public function broadcastWith(): array
     {
@@ -38,6 +39,7 @@ class PaperBallThrown implements ShouldBroadcastNow
             'id' => $this->id,
             'from_player_id' => $this->fromPlayerId,
             'target_player_id' => $this->targetPlayerId,
+            'charge_level' => $this->chargeLevel,
         ];
     }
 }

app/Events/RoomStateChanged.php

@@ -5,18 +5,22 @@ namespace App\Events;
 use App\Enums\RoomStateChange;
 use Illuminate\Broadcasting\Channel;
 use Illuminate\Broadcasting\InteractsWithSockets;
-use Illuminate\Contracts\Broadcasting\ShouldBroadcast;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;
 use Illuminate\Foundation\Events\Dispatchable;
 use Illuminate\Queue\SerializesModels;
 
-class RoomStateChanged implements ShouldBroadcast
+class RoomStateChanged implements ShouldBroadcastNow
 {
     use Dispatchable, InteractsWithSockets, SerializesModels;
 
+    /**
+     * @param  array<string, mixed>|null  $state
+     */
     public function __construct(
         public readonly string $roomId,
         public readonly int $version,
         public readonly RoomStateChange $change,
+        public readonly ?array $state = null,
     ) {}
 
     public function broadcastOn(): Channel
@@ -30,13 +34,14 @@ class RoomStateChanged implements ShouldBroadcast
     }
 
     /**
-     * @return array{version: int, change: string}
+     * @return array{version: int, change: string, state: array<string, mixed>|null}
      */
     public function broadcastWith(): array
     {
         return [
             'version' => $this->version,
             'change' => $this->change->value,
+            'state' => $this->state,
         ];
     }
 }

app/Http/Controllers/RoomEmoteController.php

@@ -27,6 +27,7 @@ class RoomEmoteController extends Controller
             $room,
             $player,
             (int) $request->validated('target_player_id'),
+            (int) ($request->validated('charge_percentage') ?? 0),
         );
 
         return response()->noContent();

app/Http/Controllers/RoundController.php

@@ -5,8 +5,8 @@ namespace App\Http\Controllers;
 use App\Models\Player;
 use App\Models\Room;
 use App\Services\Rooms\RoundService;
-use Illuminate\Http\RedirectResponse;
 use Illuminate\Http\Request;
+use Illuminate\Http\Response;
 
 class RoundController extends Controller
 {
@@ -14,28 +14,28 @@ class RoundController extends Controller
         private readonly RoundService $rounds,
     ) {}
 
-    public function reset(Request $request, Room $room): RedirectResponse
+    public function reset(Request $request, Room $room): Response
     {
         $this->ensureModerator($request, $room);
         $this->rounds->reset($room);
 
-        return back();
+        return response()->noContent();
     }
 
-    public function reveal(Request $request, Room $room): RedirectResponse
+    public function reveal(Request $request, Room $room): Response
     {
         $this->ensureModerator($request, $room);
         $this->rounds->reveal($room);
 
-        return back();
+        return response()->noContent();
     }
 
-    public function nextRound(Request $request, Room $room): RedirectResponse
+    public function nextRound(Request $request, Room $room): Response
     {
         $this->ensureModerator($request, $room);
         $this->rounds->startNext($room);
 
-        return back();
+        return response()->noContent();
     }
 
     private function ensureModerator(Request $request, Room $room): void

app/Http/Controllers/VoteController.php

@@ -6,7 +6,7 @@ use App\Http\Requests\SubmitVoteRequest;
 use App\Models\Player;
 use App\Models\Room;
 use App\Services\Rooms\VoteService;
-use Illuminate\Http\RedirectResponse;
+use Illuminate\Http\Response;
 
 class VoteController extends Controller
 {
@@ -17,7 +17,7 @@ class VoteController extends Controller
     public function store(
         SubmitVoteRequest $request,
         Room $room,
-    ): RedirectResponse {
+    ): Response {
         $player = $request->attributes->get('currentPlayer');
 
         abort_unless(
@@ -32,6 +32,6 @@ class VoteController extends Controller
             $request->validated('value'),
         );
 
-        return back();
+        return response()->noContent();
     }
 }

app/Http/Requests/ThrowPaperBallRequest.php

@@ -19,6 +19,7 @@ class ThrowPaperBallRequest extends FormRequest
     {
         return [
             'target_player_id' => ['required', 'integer'],
+            'charge_percentage' => ['sometimes', 'integer', 'between:0,300'],
         ];
     }
 }

app/Services/Rooms/RoomEmoteService.php

@@ -11,8 +11,12 @@ use Illuminate\Validation\ValidationException;
 
 class RoomEmoteService
 {
-    public function throwPaperBall(Room $room, Player $player, int $targetPlayerId): void
-    {
+    public function throwPaperBall(
+        Room $room,
+        Player $player,
+        int $targetPlayerId,
+        int $chargePercentage,
+    ): void {
         if ($targetPlayerId === $player->id) {
             throw ValidationException::withMessages([
                 'target_player_id' => 'Du kannst dich nicht selbst abwerfen.',
@@ -39,11 +43,19 @@ class RoomEmoteService
 
         RateLimiter::hit($rateLimitKey, 10);
 
+        $chargeLevel = match (true) {
+            $chargePercentage >= 300 => 3,
+            $chargePercentage >= 200 => 2,
+            $chargePercentage >= 100 => 1,
+            default => 0,
+        };
+
         PaperBallThrown::dispatch(
             Str::uuid()->toString(),
             $room->id,
             $player->id,
             $targetPlayerId,
+            $chargeLevel,
         );
     }
 }

app/Services/Rooms/RoomLifecycleService.php

@@ -11,6 +11,10 @@ use Illuminate\Support\Facades\DB;
 
 class RoomLifecycleService
 {
+    public function __construct(
+        private readonly RoomRealtimeStateService $realtimeState,
+    ) {}
+
     /**
      * @return array{player: Player, was_reopened: bool}
      */
@@ -49,6 +53,7 @@ class RoomLifecycleService
                 $room->id,
                 $stateVersion,
                 RoomStateChange::RoomReopened,
+                $this->realtimeState->for($room),
             );
         }
 

app/Services/Rooms/RoomParticipationService.php

@@ -12,6 +12,10 @@ use Illuminate\Validation\ValidationException;
 
 class RoomParticipationService
 {
+    public function __construct(
+        private readonly RoomRealtimeStateService $realtimeState,
+    ) {}
+
     public function findByJoinCode(string $joinCode): ?Room
     {
         if ($joinCode === '') {
@@ -92,6 +96,7 @@ class RoomParticipationService
             $room->id,
             $room->state_version,
             RoomStateChange::PlayerJoined,
+            $this->realtimeState->for($room),
         );
 
         return [$room, $player];

app/Services/Rooms/RoomRealtimeStateService.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace App\Services\Rooms;
+
+use App\Models\Room;
+
+class RoomRealtimeStateService
+{
+    public function __construct(
+        private readonly RoomStatisticsService $statistics,
+    ) {}
+
+    /**
+     * @return array{
+     *     current_round: int,
+     *     revealed: bool,
+     *     state_version: int,
+     *     statistics: array{average: string|null, median: string|null}|null,
+     *     players: array<int, array{
+     *         id: int,
+     *         name: string,
+     *         is_moderator: bool,
+     *         is_owner: bool,
+     *         has_voted: bool,
+     *         vote: string|null
+     *     }>
+     * }
+     */
+    public function for(Room $room): array
+    {
+        $room->refresh();
+        $room->load([
+            'players' => fn ($query) => $query
+                ->active()
+                ->select(['id', 'room_id', 'user_id', 'name', 'is_moderator', 'created_at'])
+                ->orderByDesc('is_moderator')
+                ->orderBy('created_at'),
+            'players.votes' => fn ($query) => $query
+                ->where('room_id', $room->id)
+                ->where('round', $room->current_round),
+        ]);
+
+        return [
+            'current_round' => $room->current_round,
+            'revealed' => $room->revealed_at !== null,
+            'state_version' => $room->state_version,
+            'statistics' => $this->statistics->currentRound($room),
+            'players' => $room->players
+                ->map(function ($player) use ($room): array {
+                    $vote = $player->votes->first();
+
+                    return [
+                        'id' => $player->id,
+                        'name' => $player->name,
+                        'is_moderator' => $player->is_moderator,
+                        'is_owner' => $player->user_id === $room->owner_id,
+                        'has_voted' => $vote !== null,
+                        'vote' => $room->revealed_at !== null ? $vote?->value : null,
+                    ];
+                })
+                ->all(),
+        ];
+    }
+}

app/Services/Rooms/RoundService.php

@@ -11,6 +11,10 @@ use Illuminate\Validation\ValidationException;
 
 class RoundService
 {
+    public function __construct(
+        private readonly RoomRealtimeStateService $realtimeState,
+    ) {}
+
     public function reset(Room $room): void
     {
         $stateVersion = DB::transaction(function () use ($room): int {
@@ -38,6 +42,7 @@ class RoundService
             $room->id,
             $stateVersion,
             RoomStateChange::VotesReset,
+            $this->realtimeState->for($room),
         );
     }
 
@@ -69,6 +74,7 @@ class RoundService
             $room->id,
             $stateVersion,
             RoomStateChange::CardsRevealed,
+            $this->realtimeState->for($room),
         );
     }
 
@@ -101,6 +107,7 @@ class RoundService
             $room->id,
             $stateVersion,
             RoomStateChange::NextRound,
+            $this->realtimeState->for($room),
         );
     }
 

app/Services/Rooms/VoteService.php

@@ -12,6 +12,10 @@ use Illuminate\Validation\ValidationException;
 
 class VoteService
 {
+    public function __construct(
+        private readonly RoomRealtimeStateService $realtimeState,
+    ) {}
+
     public function submit(Room $room, Player $player, string $value): void
     {
         $stateVersion = DB::transaction(function () use ($room, $player, $value): int {
@@ -52,6 +56,7 @@ class VoteService
             $room->id,
             $stateVersion,
             RoomStateChange::VoteChanged,
+            $this->realtimeState->for($room),
         );
     }
 }

resources/js/components/rooms/RoomModeratorControls.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { useForm } from '@inertiajs/vue3';
+import { useHttp } from '@inertiajs/vue3';
 import { Eye, RotateCcw, Trash2 } from '@lucide/vue';
 
 import { nextRound, reset as resetRound, reveal } from '@/routes/room';
@@ -7,26 +7,29 @@ import type { RoomModeratorControlsProps } from '@/types/room';
 
 const props = defineProps<RoomModeratorControlsProps>();
 
-const revealForm = useForm<{ room?: string }>({});
-const nextRoundForm = useForm<{ room?: string }>({});
-const resetForm = useForm<{ room?: string }>({});
+const revealRequest = useHttp<{ room?: string }>(
+    () => reveal(props.roomId),
+    {},
+);
+const nextRoundRequest = useHttp<{ room?: string }>(
+    () => nextRound(props.roomId),
+    {},
+);
+const resetRequest = useHttp<{ room?: string }>(
+    () => resetRound(props.roomId),
+    {},
+);
 
 function revealCards(): void {
-    revealForm.submit(reveal(props.roomId), {
-        preserveScroll: true,
-    });
+    void revealRequest.submit();
 }
 
 function startNextRound(): void {
-    nextRoundForm.submit(nextRound(props.roomId), {
-        preserveScroll: true,
-    });
+    void nextRoundRequest.submit();
 }
 
 function resetVotes(): void {
-    resetForm.submit(resetRound(props.roomId), {
-        preserveScroll: true,
-    });
+    void resetRequest.submit();
 }
 </script>
 
@@ -35,7 +38,7 @@ function resetVotes(): void {
         <button
             type="button"
             class="inline-flex items-center gap-2 rounded-xl border border-slate-600 bg-slate-800 px-4 py-2.5 font-semibold text-slate-200 transition hover:bg-slate-700 disabled:cursor-not-allowed disabled:opacity-40"
-            :disabled="resetForm.processing || !hasVotes"
+            :disabled="resetRequest.processing || !hasVotes"
             @click="resetVotes"
         >
             <Trash2 class="size-4" />
@@ -45,18 +48,18 @@ function resetVotes(): void {
 
     <div class="moderator-controls">
         <p
-            v-if="revealForm.errors.room || nextRoundForm.errors.room"
+            v-if="revealRequest.errors.room || nextRoundRequest.errors.room"
             class="max-w-64 rounded-lg bg-rose-950/90 px-3 py-2 text-right text-sm text-rose-200 shadow-lg"
             role="alert"
         >
-            {{ revealForm.errors.room ?? nextRoundForm.errors.room }}
+            {{ revealRequest.errors.room ?? nextRoundRequest.errors.room }}
         </p>
 
         <button
             v-if="!revealed"
             type="button"
             class="inline-flex items-center gap-2 rounded-xl border border-slate-300 bg-slate-100 px-5 py-2.5 font-semibold text-slate-900 transition hover:bg-white disabled:opacity-50"
-            :disabled="revealForm.processing"
+            :disabled="revealRequest.processing"
             @click="revealCards"
         >
             <Eye class="size-4" />
@@ -67,7 +70,7 @@ function resetVotes(): void {
             v-else
             type="button"
             class="inline-flex items-center gap-2 rounded-xl border border-slate-300 bg-slate-100 px-5 py-2.5 font-semibold text-slate-900 transition hover:bg-white disabled:opacity-50"
-            :disabled="nextRoundForm.processing"
+            :disabled="nextRoundRequest.processing"
             @click="startNextRound"
         >
             <RotateCcw class="size-4" />

resources/js/components/rooms/RoomSeat.vue

@@ -1,14 +1,181 @@
 <script setup lang="ts">
 import { CircleUserRound, Crown } from '@lucide/vue';
+import { computed, onBeforeUnmount, ref } from 'vue';
+import type { CSSProperties } from 'vue';
 
 import type { RoomSeatProps } from '@/types/room';
 
 const props = defineProps<RoomSeatProps>();
 
 const emit = defineEmits<{
-    throwPaperBall: [playerId: number];
+    throwPaperBall: [playerId: number, chargePercentage: number];
 }>();
 
+const MAX_CHARGE_PERCENTAGE = 300;
+const CHARGE_DURATION = 3_000;
+const chargePercentage = ref(0);
+const chargeStartedAt = ref<number | null>(null);
+let chargeAnimationFrame: number | null = null;
+let ignoreClickTimer: number | null = null;
+let ignoreNextClick = false;
+
+const isCharging = computed(() => chargeStartedAt.value !== null);
+const seatStyle = computed<CSSProperties>(() => ({
+    ...props.player.seatStyle,
+    '--paper-ball-knockback-x': `${props.paperBallKnockback.x}px`,
+    '--paper-ball-knockback-y': `${props.paperBallKnockback.y}px`,
+}));
+
+function updateCharge(timestamp: number): void {
+    if (chargeStartedAt.value === null) {
+        return;
+    }
+
+    chargePercentage.value = Math.min(
+        MAX_CHARGE_PERCENTAGE,
+        ((timestamp - chargeStartedAt.value) / CHARGE_DURATION) *
+            MAX_CHARGE_PERCENTAGE,
+    );
+
+    if (chargePercentage.value < MAX_CHARGE_PERCENTAGE) {
+        chargeAnimationFrame = window.requestAnimationFrame(updateCharge);
+    } else {
+        chargeAnimationFrame = null;
+    }
+}
+
+function startCharging(): void {
+    if (props.throwDisabled || chargeStartedAt.value !== null) {
+        return;
+    }
+
+    chargePercentage.value = 0;
+    chargeStartedAt.value = performance.now();
+    chargeAnimationFrame = window.requestAnimationFrame(updateCharge);
+}
+
+function stopChargeAnimation(): void {
+    if (chargeAnimationFrame !== null) {
+        window.cancelAnimationFrame(chargeAnimationFrame);
+        chargeAnimationFrame = null;
+    }
+}
+
+function resetCharge(): void {
+    stopChargeAnimation();
+    chargeStartedAt.value = null;
+    chargePercentage.value = 0;
+}
+
+function finishCharging(): void {
+    if (chargeStartedAt.value === null) {
+        return;
+    }
+
+    updateCharge(performance.now());
+
+    const releasedChargePercentage = Math.min(
+        MAX_CHARGE_PERCENTAGE,
+        Math.floor(chargePercentage.value),
+    );
+
+    resetCharge();
+    emit('throwPaperBall', props.player.id, releasedChargePercentage);
+
+    ignoreNextClick = true;
+
+    if (ignoreClickTimer !== null) {
+        window.clearTimeout(ignoreClickTimer);
+    }
+
+    ignoreClickTimer = window.setTimeout(() => {
+        ignoreNextClick = false;
+        ignoreClickTimer = null;
+    });
+}
+
+function startPointerCharge(event: PointerEvent): void {
+    if (event.button !== 0) {
+        return;
+    }
+
+    (event.currentTarget as HTMLButtonElement).setPointerCapture(
+        event.pointerId,
+    );
+    startCharging();
+}
+
+function finishPointerCharge(event: PointerEvent): void {
+    const button = event.currentTarget as HTMLButtonElement;
+
+    if (button.hasPointerCapture(event.pointerId)) {
+        button.releasePointerCapture(event.pointerId);
+    }
+
+    finishCharging();
+}
+
+function cancelPointerCharge(): void {
+    resetCharge();
+}
+
+function handleKeyDown(event: KeyboardEvent): void {
+    if (!['Enter', ' '].includes(event.key)) {
+        return;
+    }
+
+    event.preventDefault();
+    event.stopPropagation();
+
+    if (!event.repeat) {
+        startCharging();
+    }
+}
+
+function handleKeyUp(event: KeyboardEvent): void {
+    if (!['Enter', ' '].includes(event.key)) {
+        return;
+    }
+
+    event.preventDefault();
+    event.stopPropagation();
+    finishCharging();
+}
+
+function handleClick(): void {
+    if (ignoreNextClick) {
+        ignoreNextClick = false;
+
+        return;
+    }
+
+    emit('throwPaperBall', props.player.id, 0);
+}
+
+function chargeSegmentProgress(segment: number): number {
+    return Math.min(100, Math.max(0, chargePercentage.value - segment * 100));
+}
+
+function chargeColor(): string {
+    if (chargePercentage.value > 200) {
+        return '#ef4444';
+    }
+
+    if (chargePercentage.value > 100) {
+        return '#f97316';
+    }
+
+    return '#22c55e';
+}
+
+onBeforeUnmount(() => {
+    stopChargeAnimation();
+
+    if (ignoreClickTimer !== null) {
+        window.clearTimeout(ignoreClickTimer);
+    }
+});
+
 function cardLabel(value: string | null): string {
     if (value === null) {
         return '–';
@@ -30,7 +197,7 @@ function playerVote(): string | null {
     <article
         class="player-seat"
         :class="{ 'is-paper-ball-hit': isPaperBallHit }"
-        :style="player.seatStyle"
+        :style="seatStyle"
         :data-player-id="player.id"
     >
         <div
@@ -98,12 +265,52 @@ function playerVote(): string | null {
             v-if="!isCurrentPlayer()"
             type="button"
             class="throw-paper-ball"
+            :class="{ 'is-charging': isCharging }"
             :disabled="throwDisabled"
-            :aria-label="`Papierknäuel auf ${player.name} werfen`"
-            :title="`Papierknäuel auf ${player.name} werfen`"
-            @click.stop="emit('throwPaperBall', player.id)"
+            :aria-label="`Papierknäuel auf ${player.name} werfen – gedrückt halten zum Aufladen${isCharging ? `, ${Math.floor(chargePercentage)} Prozent geladen` : ''}`"
+            :aria-pressed="isCharging"
+            :title="`Papierknäuel auf ${player.name} werfen – gedrückt halten zum Aufladen`"
+            @pointerdown.stop.prevent="startPointerCharge"
+            @pointerup.stop.prevent="finishPointerCharge"
+            @pointercancel="cancelPointerCharge"
+            @keydown="handleKeyDown"
+            @keyup="handleKeyUp"
+            @blur="cancelPointerCharge"
+            @click.stop.prevent="handleClick"
         >
-            <span class="paper-ball-mini" aria-hidden="true"></span>
+            <svg
+                v-if="isCharging"
+                class="charge-rings"
+                viewBox="0 0 48 48"
+                aria-hidden="true"
+            >
+                <g
+                    v-for="segment in 3"
+                    v-show="chargePercentage > (segment - 1) * 100"
+                    :key="segment"
+                >
+                    <circle
+                        class="charge-ring-track"
+                        cx="24"
+                        cy="24"
+                        :r="8 + segment * 4"
+                    />
+                    <circle
+                        class="charge-ring"
+                        cx="24"
+                        cy="24"
+                        :r="8 + segment * 4"
+                        pathLength="100"
+                        :stroke="chargeColor()"
+                        :stroke-dashoffset="
+                            100 - chargeSegmentProgress(segment - 1)
+                        "
+                    />
+                </g>
+            </svg>
+            <span class="throw-paper-ball-surface" aria-hidden="true">
+                <span class="paper-ball-mini"></span>
+            </span>
         </button>
     </article>
 </template>
@@ -113,7 +320,11 @@ function playerVote(): string | null {
     position: absolute;
     z-index: 2;
     width: 8rem;
-    transform: translate(-50%, -50%);
+    transform: translate(-50%, -50%)
+        translate(
+            var(--paper-ball-knockback-x, 0),
+            var(--paper-ball-knockback-y, 0)
+        );
     text-align: center;
 }
 
@@ -127,23 +338,22 @@ function playerVote(): string | null {
 
 .throw-paper-ball {
     position: absolute;
-    top: 0.65rem;
-    right: 0.35rem;
+    top: 0.15rem;
+    right: -0.15rem;
     z-index: 8;
     display: grid;
-    width: 2rem;
-    height: 2rem;
+    width: 3rem;
+    height: 3rem;
     place-items: center;
-    border: 1px solid #64748b;
-    border-radius: 0.5rem;
-    background: #334155;
+    border: 0;
+    background: transparent;
     opacity: 0;
     transform: translateY(0.25rem) rotate(-8deg);
     pointer-events: none;
+    touch-action: none;
     transition:
         opacity 140ms ease,
-        transform 140ms ease,
-        background-color 140ms ease;
+        transform 140ms ease;
 }
 
 .player-seat:hover .throw-paper-ball,
@@ -153,9 +363,14 @@ function playerVote(): string | null {
     pointer-events: auto;
 }
 
+.throw-paper-ball:hover:not(:disabled) .throw-paper-ball-surface,
+.throw-paper-ball:focus-visible .throw-paper-ball-surface,
+.throw-paper-ball.is-charging .throw-paper-ball-surface {
+    background: #475569;
+}
+
 .throw-paper-ball:hover:not(:disabled),
 .throw-paper-ball:focus-visible {
-    background: #475569;
     transform: translateY(-0.1rem) rotate(4deg);
 }
 
@@ -170,6 +385,46 @@ function playerVote(): string | null {
     pointer-events: none;
 }
 
+.throw-paper-ball-surface {
+    position: relative;
+    z-index: 1;
+    display: grid;
+    width: 2rem;
+    height: 2rem;
+    place-items: center;
+    border: 1px solid #64748b;
+    border-radius: 0.5rem;
+    background: #334155;
+    transition: background-color 140ms ease;
+}
+
+.charge-rings {
+    position: absolute;
+    inset: 0;
+    width: 100%;
+    height: 100%;
+    overflow: visible;
+    filter: drop-shadow(0 0 0.2rem rgb(15 23 42 / 75%));
+}
+
+.charge-ring-track,
+.charge-ring {
+    fill: none;
+    stroke-width: 2.25;
+}
+
+.charge-ring-track {
+    stroke: rgb(148 163 184 / 32%);
+}
+
+.charge-ring {
+    transform: rotate(-90deg);
+    transform-origin: 24px 24px;
+    stroke-linecap: round;
+    stroke-dasharray: 100;
+    transition: stroke 100ms linear;
+}
+
 .paper-ball-mini {
     display: block;
     width: 0.95rem;

resources/js/components/rooms/RoomTable.vue

@@ -17,12 +17,17 @@ const hasCompactHeight = useMediaQuery(
 );
 
 const gameBoard = ref<HTMLElement | null>(null);
-const { activePaperBalls, hitPlayerIds, throwingAtPlayerId, throwPaperBall } =
-    usePaperBallToss({
+const {
+    activePaperBalls,
+    hitPlayerIds,
+    paperBallKnockbacks,
+    throwingAtPlayerId,
+    throwPaperBall,
+} = usePaperBallToss({
     roomId: () => props.room.id,
     currentPlayerId: () => props.currentPlayer.id,
     board: gameBoard,
-    });
+});
 
 const positionedPlayers = computed<PositionedRoomPlayer[]>(() => {
     const currentPlayerIndex = props.room.players.findIndex(
@@ -99,6 +104,7 @@ const voteCount = computed(
                 v-for="paperBall in activePaperBalls"
                 :key="paperBall.id"
                 class="paper-ball-flight"
+                :class="`paper-ball-level-${paperBall.chargeLevel}`"
                 :style="paperBall.style"
                 aria-hidden="true"
             >
@@ -115,6 +121,9 @@ const voteCount = computed(
                 :revealed="room.revealed"
                 :presenter-mode="presenterMode"
                 :is-paper-ball-hit="hitPlayerIds.includes(player.id)"
+                :paper-ball-knockback="
+                    paperBallKnockbacks[player.id] ?? { x: 0, y: 0 }
+                "
                 :throw-disabled="throwingAtPlayerId !== null"
                 @throw-paper-ball="throwPaperBall"
             />
@@ -189,6 +198,21 @@ const voteCount = computed(
     animation: paper-ball-flight 780ms linear forwards;
 }
 
+.paper-ball-flight.paper-ball-level-1 {
+    width: 2.05rem;
+    height: 2.05rem;
+}
+
+.paper-ball-flight.paper-ball-level-2 {
+    width: 2.5rem;
+    height: 2.5rem;
+}
+
+.paper-ball-flight.paper-ball-level-3 {
+    width: 3rem;
+    height: 3rem;
+}
+
 .paper-ball {
     display: block;
     width: 100%;

resources/js/components/rooms/RoomVoteDeck.vue

@@ -1,13 +1,14 @@
 <script setup lang="ts">
-import { useForm } from '@inertiajs/vue3';
+import { useHttp } from '@inertiajs/vue3';
 import { Keyboard } from '@lucide/vue';
 import { useEventListener } from '@vueuse/core';
 import { watch } from 'vue';
 
 import { store as storeVote } from '@/routes/room/vote';
-import type { RoomVoteDeckProps } from '@/types/room';
+import type { RoomVoteDeckEmits, RoomVoteDeckProps } from '@/types/room';
 
 const props = defineProps<RoomVoteDeckProps>();
+const emit = defineEmits<RoomVoteDeckEmits>();
 
 const cardShortcuts = [
     '1',
@@ -25,29 +26,32 @@ const cardShortcuts = [
     ),
 ];
 
-const voteForm = useForm({
+const voteRequest = useHttp(() => storeVote(props.roomId), {
     value: props.currentVote ?? '',
 });
 
 watch(
     () => props.currentVote,
     (value) => {
-        if (!voteForm.processing) {
-            voteForm.value = value ?? '';
+        if (!voteRequest.processing) {
+            voteRequest.value = value ?? '';
         }
     },
 );
 
 function submitVote(value: string): void {
-    if (props.revealed || voteForm.processing) {
+    if (props.revealed || voteRequest.processing) {
         return;
     }
 
-    voteForm.value = value;
-    voteForm.submit(storeVote(props.roomId), {
-        preserveScroll: true,
+    const previousVote = props.currentVote;
+
+    voteRequest.value = value;
+    emit('vote-changed', value);
+    void voteRequest.submit({
         onError: () => {
-            voteForm.value = props.currentVote ?? '';
+            voteRequest.value = previousVote ?? '';
+            emit('vote-changed', previousVote);
         },
     });
 }
@@ -71,7 +75,7 @@ function handleKeyboardVote(event: KeyboardEvent): void {
     if (
         !props.presenterMode ||
         props.revealed ||
-        voteForm.processing ||
+        voteRequest.processing ||
         event.repeat ||
         event.altKey ||
         event.ctrlKey ||
@@ -118,10 +122,10 @@ useEventListener('keydown', handleKeyboardVote);
                 class="deck-card"
                 :class="{
                     'is-selected':
-                        !presenterMode && voteForm.value === card.key,
+                        !presenterMode && voteRequest.value === card.key,
                 }"
-                :disabled="voteForm.processing"
-                :aria-pressed="voteForm.value === card.key"
+                :disabled="voteRequest.processing"
+                :aria-pressed="voteRequest.value === card.key"
                 :aria-label="`Karte ${card.label} wählen`"
                 @click="submitVote(card.key)"
             >
@@ -138,11 +142,11 @@ useEventListener('keydown', handleKeyboardVote);
         </div>
 
         <p
-            v-if="voteForm.errors.value"
+            v-if="voteRequest.errors.value"
             class="mt-3 text-sm text-rose-300"
             role="alert"
         >
-            {{ voteForm.errors.value }}
+            {{ voteRequest.errors.value }}
         </p>
     </section>
 </template>

resources/js/composables/usePaperBallToss.ts

@@ -4,7 +4,9 @@ import { toast } from 'vue-sonner';
 import { useRoomEmotes } from '@/composables/useRoomEmotes';
 import { store as throwPaperBallRoute } from '@/routes/room/emote/paper-ball';
 import type {
+    PaperBallChargeLevel,
     PaperBallFlight,
+    PaperBallKnockback,
     PaperBallThrowError,
     PaperBallThrownPayload,
     PaperBallTossOptions,
@@ -13,6 +15,14 @@ import type {
 const PAPER_BALL_FLIGHT_DURATION = 780;
 const SEEN_EVENT_RETENTION = 5_000;
 const THROW_BUTTON_COOLDOWN = 550;
+const MAX_KNOCKBACK_DISTANCE = 72;
+const KNOCKBACK_RETURN_SPEED = 58;
+const KNOCKBACK_FORCE: Record<PaperBallChargeLevel, number> = {
+    0: 0,
+    1: 18,
+    2: 32,
+    3: 48,
+};
 
 export function usePaperBallToss({
     roomId,
@@ -21,9 +31,12 @@ export function usePaperBallToss({
 }: PaperBallTossOptions) {
     const activePaperBalls = ref<PaperBallFlight[]>([]);
     const hitPlayerIds = ref<number[]>([]);
+    const paperBallKnockbacks = ref<Record<number, PaperBallKnockback>>({});
     const throwingAtPlayerId = ref<number | null>(null);
     const seenPaperBallIds = new Set<string>();
     const timers = new Set<number>();
+    let knockbackAnimationFrame: number | null = null;
+    let previousKnockbackFrameTime: number | null = null;
 
     function schedule(callback: () => void, delay: number): void {
         const timer = window.setTimeout(() => {
@@ -34,7 +47,87 @@ export function usePaperBallToss({
         timers.add(timer);
     }
 
-    async function throwPaperBall(targetPlayerId: number): Promise<void> {
+    function animateKnockbacks(timestamp: number): void {
+        const elapsed = Math.min(
+            timestamp - (previousKnockbackFrameTime ?? timestamp),
+            32,
+        );
+        const returnDistance = (KNOCKBACK_RETURN_SPEED * elapsed) / 1_000;
+        const nextKnockbacks: Record<number, PaperBallKnockback> = {};
+
+        Object.entries(paperBallKnockbacks.value).forEach(
+            ([playerId, knockback]) => {
+                const distance = Math.hypot(knockback.x, knockback.y);
+                const nextDistance = Math.max(0, distance - returnDistance);
+
+                if (nextDistance > 0.1) {
+                    const scale = nextDistance / distance;
+
+                    nextKnockbacks[Number(playerId)] = {
+                        x: knockback.x * scale,
+                        y: knockback.y * scale,
+                    };
+                }
+            },
+        );
+
+        paperBallKnockbacks.value = nextKnockbacks;
+        previousKnockbackFrameTime = timestamp;
+
+        if (Object.keys(nextKnockbacks).length > 0) {
+            knockbackAnimationFrame =
+                window.requestAnimationFrame(animateKnockbacks);
+
+            return;
+        }
+
+        knockbackAnimationFrame = null;
+        previousKnockbackFrameTime = null;
+    }
+
+    function applyKnockback(
+        playerId: number,
+        directionX: number,
+        directionY: number,
+        chargeLevel: PaperBallChargeLevel,
+    ): void {
+        const force = KNOCKBACK_FORCE[chargeLevel];
+
+        if (force === 0) {
+            return;
+        }
+
+        const currentKnockback = paperBallKnockbacks.value[playerId] ?? {
+            x: 0,
+            y: 0,
+        };
+        let nextX = currentKnockback.x + directionX * force;
+        let nextY = currentKnockback.y + directionY * force;
+        const nextDistance = Math.hypot(nextX, nextY);
+
+        if (nextDistance > MAX_KNOCKBACK_DISTANCE) {
+            const scale = MAX_KNOCKBACK_DISTANCE / nextDistance;
+
+            nextX *= scale;
+            nextY *= scale;
+        }
+
+        paperBallKnockbacks.value = {
+            ...paperBallKnockbacks.value,
+            [playerId]: { x: nextX, y: nextY },
+        };
+
+        if (knockbackAnimationFrame === null) {
+            previousKnockbackFrameTime = null;
+            knockbackAnimationFrame =
+                window.requestAnimationFrame(animateKnockbacks);
+        }
+    }
+
+    async function throwPaperBall(
+        targetPlayerId: number,
+        chargePercentage = 0,
+    ): Promise<void> {
         if (
             targetPlayerId === currentPlayerId() ||
             throwingAtPlayerId.value !== null
@@ -66,6 +159,7 @@ export function usePaperBallToss({
                 },
                 body: JSON.stringify({
                     target_player_id: targetPlayerId,
+                    charge_percentage: chargePercentage,
                 }),
             });
 
@@ -106,6 +200,9 @@ export function usePaperBallToss({
             typeof payload.id !== 'string' ||
             !Number.isInteger(payload.from_player_id) ||
             !Number.isInteger(payload.target_player_id) ||
+            !Number.isInteger(payload.charge_level) ||
+            payload.charge_level < 0 ||
+            payload.charge_level > 3 ||
             seenPaperBallIds.has(payload.id)
         ) {
             return;
@@ -142,9 +239,12 @@ export function usePaperBallToss({
             targetRect.top + targetRect.height / 2 - boardRect.top - startY;
         const distance = Math.hypot(travelX, travelY);
         const arcHeight = Math.min(130, Math.max(55, distance * 0.22));
+        const knockbackDirectionX = distance === 0 ? 1 : travelX / distance;
+        const knockbackDirectionY = distance === 0 ? 0 : travelY / distance;
 
         activePaperBalls.value.push({
             id: payload.id,
+            chargeLevel: payload.charge_level,
             style: {
                 left: `${startX}px`,
                 top: `${startY}px`,
@@ -163,6 +263,13 @@ export function usePaperBallToss({
             if (!hitPlayerIds.value.includes(payload.target_player_id)) {
                 hitPlayerIds.value.push(payload.target_player_id);
             }
+
+            applyKnockback(
+                payload.target_player_id,
+                knockbackDirectionX,
+                knockbackDirectionY,
+                payload.charge_level,
+            );
         }, PAPER_BALL_FLIGHT_DURATION - 80);
 
         schedule(() => {
@@ -183,11 +290,16 @@ export function usePaperBallToss({
     onScopeDispose(() => {
         timers.forEach((timer) => window.clearTimeout(timer));
         timers.clear();
+
+        if (knockbackAnimationFrame !== null) {
+            window.cancelAnimationFrame(knockbackAnimationFrame);
+        }
     });
 
     return {
         activePaperBalls,
         hitPlayerIds,
+        paperBallKnockbacks,
         throwingAtPlayerId,
         throwPaperBall,
     };

resources/js/composables/useRoomRealtime.ts

@@ -1,72 +1,73 @@
 import { router } from '@inertiajs/vue3';
-import { onScopeDispose, watch } from 'vue';
+import { onScopeDispose, ref, shallowReadonly, watch } from 'vue';
 
 import { getEcho } from '@/lib/echo';
-import type { RoomStateChangedPayload } from '@/types/room';
+import { home } from '@/routes';
+import { join } from '@/routes/room';
+import type {
+    CurrentRoomPlayer,
+    PokerRoom,
+    RoomStateChangedPayload,
+} from '@/types/room';
 
 const ROOM_EVENT = '.room.state.changed';
 
 export function useRoomRealtime(
-    roomId: () => string,
-    stateVersion: () => number,
-): void {
-    let reloadInProgress = false;
-    let pendingVersion = 0;
-    let disposed = false;
-
-    function reloadRoom(): void {
-        if (reloadInProgress || disposed) {
-            return;
-        }
-
-        reloadInProgress = true;
-
-        router.reload({
-            only: ['room', 'currentPlayer'],
-            onFinish: () => {
-                reloadInProgress = false;
-
-                if (disposed) {
-                    return;
-                }
-
-                if (pendingVersion > stateVersion()) {
-                    reloadRoom();
-
-                    return;
-                }
-
-                pendingVersion = stateVersion();
-            },
-        });
-    }
+    initialRoom: () => PokerRoom,
+    initialCurrentPlayer: () => CurrentRoomPlayer,
+) {
+    const room = ref<PokerRoom>({ ...initialRoom() });
+    const currentPlayer = ref<CurrentRoomPlayer>({ ...initialCurrentPlayer() });
 
     function handleRoomChange(payload: RoomStateChangedPayload): void {
         if (
             typeof payload.version !== 'number' ||
-            payload.version <= Math.max(stateVersion(), pendingVersion)
+            payload.version <= room.value.state_version
         ) {
             return;
         }
 
-        pendingVersion = payload.version;
-
         if (payload.change === 'room_deleted') {
-            router.visit('/', { replace: true });
+            router.visit(home().url, { replace: true });
 
             return;
         }
 
-        reloadRoom();
+        if (payload.change === 'room_closed') {
+            router.visit(
+                join({ query: { join_code: room.value.join_code } }).url,
+                { replace: true },
+            );
+
+            return;
+        }
+
+        if (payload.state === null || payload.state === undefined) {
+            return;
+        }
+
+        room.value = {
+            ...room.value,
+            ...payload.state,
+        };
+
+        if (
+            payload.change === 'votes_reset' ||
+            payload.change === 'next_round'
+        ) {
+            currentPlayer.value = {
+                ...currentPlayer.value,
+                current_vote: null,
+            };
+        }
     }
 
     const stopWatchingRoom = watch(
-        roomId,
+        () => initialRoom().id,
         (nextRoomId, _previousRoomId, onCleanup) => {
             const echo = getEcho();
             const channelName = `rooms.${nextRoomId}`;
 
-            pendingVersion = stateVersion();
             echo.channel(channelName).listen(ROOM_EVENT, handleRoomChange);
 
             onCleanup(() => {
@@ -76,19 +77,30 @@ export function useRoomRealtime(
         { immediate: true },
     );
 
-    const stopWatchingVersion = watch(
-        stateVersion,
-        (version) => {
-            if (!reloadInProgress) {
-                pendingVersion = Math.max(pendingVersion, version);
-            }
+    const stopWatchingInitialState = watch(
+        [initialRoom, initialCurrentPlayer],
+        ([nextRoom, nextCurrentPlayer]) => {
+            room.value = { ...nextRoom };
+            currentPlayer.value = { ...nextCurrentPlayer };
         },
-        { flush: 'sync' },
+        { deep: true },
     );
 
     onScopeDispose(() => {
-        disposed = true;
         stopWatchingRoom();
-        stopWatchingVersion();
+        stopWatchingInitialState();
     });
+
+    function setCurrentVote(value: string | null): void {
+        currentPlayer.value = {
+            ...currentPlayer.value,
+            current_vote: value,
+        };
+    }
+
+    return {
+        room: shallowReadonly(room),
+        currentPlayer: shallowReadonly(currentPlayer),
+        setCurrentVote,
+    };
 }

resources/js/pages/rooms/Show.vue

@@ -1,5 +1,5 @@
 <script setup lang="ts">
-import { Head, usePage, usePoll } from '@inertiajs/vue3';
+import { Head, usePage } from '@inertiajs/vue3';
 import { computed, ref } from 'vue';
 
 import RoomHeader from '@/components/rooms/RoomHeader.vue';
@@ -18,18 +18,18 @@ const canFavorite = computed(
     () => page.props.auth.user?.id != props.room.owner_id,
 );
 
-useRoomRealtime(
-    () => props.room.id,
-    () => props.room.state_version,
+const {
+    room: realtimeRoom,
+    currentPlayer: realtimeCurrentPlayer,
+    setCurrentVote,
+} = useRoomRealtime(
+    () => props.room,
+    () => props.currentPlayer,
 );
-
-usePoll(30_000, {
-    only: ['room', 'currentPlayer'],
-});
 </script>
 
 <template>
-    <Head :title="room.title ?? 'Scrum Poker'" />
+    <Head :title="realtimeRoom.title ?? 'Scrum Poker'" />
 
     <main
         class="-m-6 min-h-[calc(100svh-4rem)] bg-slate-900 px-3 py-6 text-white sm:px-6 md:flex md:h-[calc(100dvh-4rem-1px)] md:min-h-0 md:flex-col md:overflow-hidden lg:px-10"
@@ -37,26 +37,27 @@ usePoll(30_000, {
         <RoomRetentionNotice v-if="roomNotice" :notice="roomNotice" />
 
         <RoomHeader
-            :id="room.id"
-            :title="room.title"
-            :join_code="room.join_code"
-            :is_favorite="room.is_favorite"
+            :id="realtimeRoom.id"
+            :title="realtimeRoom.title"
+            :join_code="realtimeRoom.join_code"
+            :is_favorite="realtimeRoom.is_favorite"
             :can-favorite="canFavorite"
             v-model:presenter-mode="presenterMode"
         />
 
         <RoomTable
-            :room="room"
-            :current-player="currentPlayer"
+            :room="realtimeRoom"
+            :current-player="realtimeCurrentPlayer"
             :presenter-mode="presenterMode"
         />
 
         <RoomVoteDeck
-            :room-id="room.id"
-            :revealed="room.revealed"
-            :cards="room.deck.cards"
-            :current-vote="currentPlayer.current_vote"
+            :room-id="realtimeRoom.id"
+            :revealed="realtimeRoom.revealed"
+            :cards="realtimeRoom.deck.cards"
+            :current-vote="realtimeCurrentPlayer.current_vote"
             :presenter-mode="presenterMode"
+            @vote-changed="setCurrentVote"
         />
     </main>
 </template>

resources/js/types/emote.ts

@@ -1,9 +1,12 @@
 import type { Ref, CSSProperties } from 'vue';
 
+export type PaperBallChargeLevel = 0 | 1 | 2 | 3;
+
 export type PaperBallThrownPayload = {
     id: string;
     from_player_id: number;
     target_player_id: number;
+    charge_level: PaperBallChargeLevel;
 };
 
 export type PaperBallFlightStyle = CSSProperties & {
@@ -19,9 +22,15 @@ export type PaperBallFlightStyle = CSSProperties & {
 
 export type PaperBallFlight = {
     id: string;
+    chargeLevel: PaperBallChargeLevel;
     style: PaperBallFlightStyle;
 };
 
+export type PaperBallKnockback = {
+    x: number;
+    y: number;
+};
+
 export type PaperBallTossOptions = {
     roomId: () => string;
     currentPlayerId: () => number;

resources/js/types/room.ts

@@ -1,5 +1,7 @@
 import type { CSSProperties } from 'vue';
 
+import type { PaperBallKnockback } from '@/types/emote';
+
 export type PokerCard = {
     key: string;
     label: string;
@@ -115,6 +117,7 @@ export type RoomSeatProps = {
     revealed: boolean;
     presenterMode: boolean;
     isPaperBallHit: boolean;
+    paperBallKnockback: PaperBallKnockback;
     throwDisabled: boolean;
 };
 
@@ -132,6 +135,10 @@ export type RoomVoteDeckProps = {
     presenterMode: boolean;
 };
 
+export type RoomVoteDeckEmits = {
+    'vote-changed': [value: string | null];
+};
+
 export type RoomStateChange =
     | 'player_joined'
     | 'vote_changed'
@@ -145,4 +152,10 @@ export type RoomStateChange =
 export type RoomStateChangedPayload = {
     version: number;
     change: RoomStateChange;
+    state: RoomRealtimeState | null;
 };
+
+export type RoomRealtimeState = Pick<
+    PokerRoom,
+    'current_round' | 'revealed' | 'state_version' | 'statistics' | 'players'
+>;

tests/Feature/RoomBroadcastingTest.php

@@ -5,6 +5,7 @@ use App\Events\RoomStateChanged;
 use App\Jobs\CloseInactiveRooms;
 use App\Models\Room;
 use App\Models\User;
+use Illuminate\Contracts\Broadcasting\ShouldBroadcastNow;
 use Illuminate\Support\Carbon;
 use Illuminate\Support\Facades\Event;
 
@@ -23,18 +24,20 @@ function createBroadcastRoom(array $attributes = []): Room
     ]);
 }
 
-test('room state broadcasts expose only invalidation metadata', function () {
+test('room state broadcasts synchronously expose sanitized state', function () {
     $event = new RoomStateChanged(
         '019b8f80-37c4-71a3-b415-5f2697332c16',
         7,
         RoomStateChange::VoteChanged,
     );
 
-    expect($event->broadcastAs())->toBe('room.state.changed')
+    expect($event)->toBeInstanceOf(ShouldBroadcastNow::class)
+        ->and($event->broadcastAs())->toBe('room.state.changed')
         ->and($event->broadcastOn()->name)->toBe('rooms.019b8f80-37c4-71a3-b415-5f2697332c16')
         ->and($event->broadcastWith())->toBe([
             'version' => 7,
             'change' => 'vote_changed',
+            'state' => null,
         ])
         ->and($event->broadcastWith())->not->toHaveKeys([
             'player_name',
@@ -68,23 +71,23 @@ test('voting and round actions broadcast their state changes', function () {
 
     $this->withSession($session)
         ->post(route('room.vote.store', $room), ['value' => '5'])
-        ->assertRedirect();
+        ->assertNoContent();
 
     $this->withSession($session)
         ->post(route('room.reveal', $room))
-        ->assertRedirect();
+        ->assertNoContent();
 
     $this->withSession($session)
         ->post(route('room.next-round', $room))
-        ->assertRedirect();
+        ->assertNoContent();
 
     $this->withSession($session)
         ->post(route('room.vote.store', $room), ['value' => '3'])
-        ->assertRedirect();
+        ->assertNoContent();
 
     $this->withSession($session)
         ->post(route('room.reset', $room))
-        ->assertRedirect();
+        ->assertNoContent();
 
     foreach ([
         RoomStateChange::VoteChanged,
@@ -98,6 +101,35 @@ test('voting and round actions broadcast their state changes', function () {
         );
     }
 
+    Event::assertDispatched(
+        RoomStateChanged::class,
+        function (RoomStateChanged $event) use ($moderator): bool {
+            if ($event->change !== RoomStateChange::VoteChanged || $event->state === null) {
+                return false;
+            }
+
+            $player = collect($event->state['players'])->firstWhere('id', $moderator->id);
+
+            return $event->state['revealed'] === false
+                && $player['has_voted'] === true
+                && $player['vote'] === null;
+        },
+    );
+
+    Event::assertDispatched(
+        RoomStateChanged::class,
+        function (RoomStateChanged $event) use ($moderator): bool {
+            if ($event->change !== RoomStateChange::CardsRevealed || $event->state === null) {
+                return false;
+            }
+
+            $player = collect($event->state['players'])->firstWhere('id', $moderator->id);
+
+            return $event->state['revealed'] === true
+                && $player['vote'] === '5';
+        },
+    );
+
     Event::assertDispatchedTimes(RoomStateChanged::class, 5);
 });
 

tests/Feature/RoomEmoteTest.php

@@ -20,7 +20,6 @@ function createEmoteRoom(array $attributes = []): Room
 }
 
 test('a participant can throw a realtime paper ball at another player', function () {
-    Event::fake([PaperBallThrown::class]);
     $room = createEmoteRoom(['last_activity_at' => now()->subDay()]);
     $sender = $room->players()->create([
         'name' => 'Eric',
@@ -33,6 +32,7 @@ test('a participant can throw a realtime paper ball at another player', function
     $room->refresh();
     $activity = $room->last_activity_at;
     $stateVersion = $room->state_version;
+    Event::fake([PaperBallThrown::class]);
 
     $this->withSession(["room_players.{$room->id}" => $sender->id])
         ->postJson(route('room.emote.paper-ball.store', $room), [
@@ -44,12 +44,14 @@ test('a participant can throw a realtime paper ball at another player', function
         return $event->roomId === $room->id
             && $event->fromPlayerId === $sender->id
             && $event->targetPlayerId === $target->id
+            && $event->chargeLevel === 0
             && $event->broadcastOn()->name === "rooms.{$room->id}"
             && $event->broadcastAs() === 'room.emote.thrown'
             && array_keys($event->broadcastWith()) === [
                 'id',
                 'from_player_id',
                 'target_player_id',
+                'charge_level',
             ];
     });
 
@@ -59,6 +61,65 @@ test('a participant can throw a realtime paper ball at another player', function
         ->and($room->state_version)->toBe($stateVersion);
 });
 
+test('paper ball charge percentages map to the expected level', function (int $chargePercentage, int $expectedLevel) {
+    $room = createEmoteRoom();
+    $sender = $room->players()->create([
+        'name' => 'Eric',
+        'is_moderator' => true,
+    ]);
+    $target = $room->players()->create([
+        'name' => 'Anna',
+        'is_moderator' => false,
+    ]);
+    Event::fake([PaperBallThrown::class]);
+
+    $this->withSession(["room_players.{$room->id}" => $sender->id])
+        ->postJson(route('room.emote.paper-ball.store', $room), [
+            'target_player_id' => $target->id,
+            'charge_percentage' => $chargePercentage,
+        ])
+        ->assertNoContent();
+
+    Event::assertDispatched(
+        PaperBallThrown::class,
+        fn (PaperBallThrown $event): bool => $event->chargeLevel === $expectedLevel,
+    );
+})->with([
+    'uncharged' => [0, 0],
+    'just below level one' => [99, 0],
+    'level one threshold' => [100, 1],
+    'top of level one' => [199, 1],
+    'level two threshold' => [200, 2],
+    'top of level two' => [299, 2],
+    'level three threshold and cap' => [300, 3],
+]);
+
+test('paper ball charge percentages outside the supported range are rejected', function (int $chargePercentage) {
+    $room = createEmoteRoom();
+    $sender = $room->players()->create([
+        'name' => 'Eric',
+        'is_moderator' => true,
+    ]);
+    $target = $room->players()->create([
+        'name' => 'Anna',
+        'is_moderator' => false,
+    ]);
+    Event::fake([PaperBallThrown::class]);
+
+    $this->withSession(["room_players.{$room->id}" => $sender->id])
+        ->postJson(route('room.emote.paper-ball.store', $room), [
+            'target_player_id' => $target->id,
+            'charge_percentage' => $chargePercentage,
+        ])
+        ->assertUnprocessable()
+        ->assertJsonValidationErrors('charge_percentage');
+
+    Event::assertNotDispatched(PaperBallThrown::class);
+})->with([
+    'below zero' => -1,
+    'above the cap' => 301,
+]);
+
 test('a participant cannot throw a paper ball at themselves', function () {
     Event::fake([PaperBallThrown::class]);
     $room = createEmoteRoom();

tests/Feature/RoomLifecycleTest.php

@@ -238,7 +238,7 @@ test('meaningful game actions update the explicit activity timestamp', function
 
     $this->withSession(["room_players.{$room->id}" => $moderator->id])
         ->post(route('room.vote.store', $room), ['value' => '5'])
-        ->assertRedirect();
+        ->assertNoContent();
 
     expect($room->fresh()->last_activity_at->equalTo(now()))->toBeTrue();
 });

tests/Feature/RoomVotingTest.php

@@ -40,7 +40,7 @@ test('a participant can vote and change their vote in the current round', functi
 
     $this->withSession($session)
         ->post(route('room.vote.store', $room), ['value' => '5'])
-        ->assertRedirect();
+        ->assertNoContent();
 
     $this->assertDatabaseHas('votes', [
         'room_id' => $room->id,
@@ -51,7 +51,7 @@ test('a participant can vote and change their vote in the current round', functi
 
     $this->withSession($session)
         ->post(route('room.vote.store', $room), ['value' => '8'])
-        ->assertRedirect();
+        ->assertNoContent();
 
     expect(Vote::query()->count())->toBe(1);
     expect(Vote::query()->value('value'))->toBe('8')
@@ -91,7 +91,7 @@ test('other votes stay hidden until the moderator reveals the round', function (
 
     $this->withSession($session)
         ->post(route('room.reveal', $room))
-        ->assertRedirect();
+        ->assertNoContent();
 
     expect($room->fresh()->last_activity_at->greaterThan($previousActivity))->toBeTrue();
 
@@ -123,7 +123,7 @@ test('starting the next round clears the revealed state', function () {
 
     $this->withSession(["room_players.{$room->id}" => $moderator->id])
         ->post(route('room.next-round', $room))
-        ->assertRedirect();
+        ->assertNoContent();
 
     $room->refresh();
 
@@ -156,7 +156,7 @@ test('the moderator can reset only the votes from the current round', function (
 
     $this->withSession(["room_players.{$room->id}" => $moderator->id])
         ->post(route('room.reset', $room))
-        ->assertRedirect();
+        ->assertNoContent();
 
     $this->assertDatabaseHas('votes', [
         'room_id' => $room->id,