big shot

.codex/config.toml

@@ -1,3 +1,7 @@
 [mcp_servers.laravel-boost]
 command = "php"
 args = ["artisan", "boost:mcp"]
+
+[mcp_servers.nightwatch]
+command = "npx"
+args = ["-y", "mcp-remote", "https://nightwatch.laravel.com/mcp"]

app/Enums/RoomStateChange.php

@@ -5,8 +5,6 @@ namespace App\Enums;
 enum RoomStateChange: string
 {
     case PlayerJoined = 'player_joined';
-    case PlayerUpdated = 'player_updated';
-    case PlayerKicked = 'player_kicked';
     case VoteChanged = 'vote_changed';
     case CardsRevealed = 'cards_revealed';
     case VotesReset = 'votes_reset';
@@ -14,5 +12,4 @@ enum RoomStateChange: string
     case RoomReopened = 'room_reopened';
     case RoomClosed = 'room_closed';
     case RoomDeleted = 'room_deleted';
-    case RoomSettingsUpdated = 'room_settings_updated';
 }

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

@@ -21,7 +21,6 @@ class RoomStateChanged implements ShouldBroadcastNow
         public readonly int $version,
         public readonly RoomStateChange $change,
         public readonly ?array $state = null,
-        public readonly ?int $affectedPlayerId = null,
     ) {}
 
     public function broadcastOn(): Channel
@@ -35,20 +34,14 @@ class RoomStateChanged implements ShouldBroadcastNow
     }
 
     /**
-     * @return array{version: int, change: string, state: array<string, mixed>|null, affected_player_id?: int}
+     * @return array{version: int, change: string, state: array<string, mixed>|null}
      */
     public function broadcastWith(): array
     {
-        $payload = [
+        return [
             'version' => $this->version,
             'change' => $this->change->value,
             'state' => $this->state,
         ];
-
-        if ($this->affectedPlayerId !== null) {
-            $payload['affected_player_id'] = $this->affectedPlayerId;
-        }
-
-        return $payload;
     }
 }

app/Http/Controllers/EmbeddedLogoutController.php

@@ -1,28 +0,0 @@
-<?php
-
-namespace App\Http\Controllers;
-
-use Illuminate\Http\RedirectResponse;
-use Illuminate\Http\Request;
-use Illuminate\Support\Facades\Auth;
-
-class EmbeddedLogoutController extends Controller
-{
-    /**
-     * Handle the incoming request.
-     */
-    public function __invoke(Request $request): RedirectResponse
-    {
-        $joinCode = $request->string('join_code')->trim()->upper()->toString();
-        $playerName = $request->string('player_name')->trim()->toString();
-
-        Auth::guard('web')->logout();
-        $request->session()->invalidate();
-        $request->session()->regenerateToken();
-
-        return to_route('embedded.room', [
-            'join_code' => $joinCode,
-            'player_name' => $playerName,
-        ]);
-    }
-}

app/Http/Controllers/EmbeddedRoomController.php

@@ -1,49 +0,0 @@
-<?php
-
-namespace App\Http\Controllers;
-
-use App\Http\Requests\ShowEmbeddedRoomRequest;
-use App\Http\Resources\CurrentPlayerResource;
-use App\Http\Resources\RoomResource;
-use App\Models\Room;
-use App\Models\User;
-use App\Services\Rooms\RoomPageService;
-use App\Services\Rooms\RoomParticipationService;
-use Inertia\Inertia;
-use Inertia\Response;
-
-class EmbeddedRoomController extends Controller
-{
-    public function __construct(
-        private readonly RoomParticipationService $roomParticipation,
-        private readonly RoomPageService $roomPage,
-    ) {}
-
-    public function __invoke(ShowEmbeddedRoomRequest $request): Response
-    {
-        /** @var array{join_code: string, player_name: string} $validated */
-        $validated = $request->validated();
-        $user = $request->user();
-
-        abort_unless($user instanceof User, 403);
-
-        $room = Room::query()
-            ->where('join_code', $validated['join_code'])
-            ->firstOrFail();
-        $player = $this->roomParticipation->joinEmbedded(
-            $room,
-            $user,
-            $validated['player_name'],
-        );
-
-        $request->session()->put("room_players.{$room->id}", $player->id);
-        $request->session()->forget('embedded_login');
-
-        $pageData = $this->roomPage->prepare($room, $player, $user);
-
-        return Inertia::render('embedded/Room', [
-            'room' => (new RoomResource($pageData))->resolve($request),
-            'currentPlayer' => (new CurrentPlayerResource($pageData))->resolve($request),
-        ]);
-    }
-}

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/RoomPlayerKickController.php

@@ -1,34 +0,0 @@
-<?php
-
-namespace App\Http\Controllers;
-
-use App\Http\Requests\KickRoomPlayerRequest;
-use App\Models\Player;
-use App\Models\Room;
-use App\Models\User;
-use App\Services\Rooms\RoomParticipationService;
-use Illuminate\Http\RedirectResponse;
-use Inertia\Inertia;
-
-class RoomPlayerKickController extends Controller
-{
-    public function __construct(
-        private readonly RoomParticipationService $roomParticipation,
-    ) {}
-
-    public function __invoke(KickRoomPlayerRequest $request, Room $room, Player $player): RedirectResponse
-    {
-        $user = $request->user();
-
-        abort_unless($user instanceof User, 403);
-
-        $this->roomParticipation->kick($room, $player, $user);
-
-        Inertia::flash('toast', [
-            'type' => 'success',
-            'message' => "{$player->name} wurde aus dem Raum entfernt.",
-        ]);
-
-        return back();
-    }
-}

app/Http/Controllers/RoomSettingsController.php

@@ -1,52 +0,0 @@
-<?php
-
-namespace App\Http\Controllers;
-
-use App\Http\Requests\UpdateRoomSettingsRequest;
-use App\Models\Room;
-use App\Models\User;
-use App\Services\Rooms\RoomSettingsService;
-use Illuminate\Http\RedirectResponse;
-use Illuminate\Http\Request;
-use Inertia\Inertia;
-use Inertia\Response;
-
-class RoomSettingsController extends Controller
-{
-    public function __construct(
-        private readonly RoomSettingsService $roomSettings,
-    ) {}
-
-    public function edit(Room $room, Request $request): Response
-    {
-        abort_unless($request->user()?->id === $room->owner_id, 403);
-
-        return Inertia::render('rooms/Settings', [
-            'room' => [
-                'id' => $room->id,
-                'title' => $room->title,
-                'join_code' => $room->join_code,
-                'allow_participants_to_manage_rounds' => $room->allow_participants_to_manage_rounds,
-                'is_persistent' => $room->is_persistent,
-            ],
-        ]);
-    }
-
-    public function update(UpdateRoomSettingsRequest $request, Room $room): RedirectResponse
-    {
-        $user = $request->user();
-
-        abort_unless($user instanceof User, 403);
-
-        /** @var array{allow_participants_to_manage_rounds: bool, is_persistent: bool} $settings */
-        $settings = $request->validated();
-        $this->roomSettings->update($room, $user, $settings);
-
-        Inertia::flash('toast', [
-            'type' => 'success',
-            'message' => 'Die Raumeinstellungen wurden gespeichert.',
-        ]);
-
-        return back();
-    }
-}

app/Http/Controllers/RoundController.php

@@ -16,7 +16,7 @@ class RoundController extends Controller
 
     public function reset(Request $request, Room $room): Response
     {
-        $this->ensureCanManageRounds($request, $room);
+        $this->ensureModerator($request, $room);
         $this->rounds->reset($room);
 
         return response()->noContent();
@@ -24,7 +24,7 @@ class RoundController extends Controller
 
     public function reveal(Request $request, Room $room): Response
     {
-        $this->ensureCanManageRounds($request, $room);
+        $this->ensureModerator($request, $room);
         $this->rounds->reveal($room);
 
         return response()->noContent();
@@ -32,20 +32,20 @@ class RoundController extends Controller
 
     public function nextRound(Request $request, Room $room): Response
     {
-        $this->ensureCanManageRounds($request, $room);
+        $this->ensureModerator($request, $room);
         $this->rounds->startNext($room);
 
         return response()->noContent();
     }
 
-    private function ensureCanManageRounds(Request $request, Room $room): void
+    private function ensureModerator(Request $request, Room $room): void
     {
         $player = $request->attributes->get('currentPlayer');
 
         abort_unless(
             $player instanceof Player
             && $player->room_id === $room->id
-            && ($player->is_moderator || $room->allow_participants_to_manage_rounds),
+            && $player->is_moderator,
             403,
         );
     }

app/Http/Requests/KickRoomPlayerRequest.php

@@ -1,35 +0,0 @@
-<?php
-
-namespace App\Http\Requests;
-
-use App\Models\Player;
-use App\Models\Room;
-use Illuminate\Foundation\Http\FormRequest;
-
-class KickRoomPlayerRequest extends FormRequest
-{
-    /**
-     * Determine if the user is authorized to make this request.
-     */
-    public function authorize(): bool
-    {
-        $room = $this->route('room');
-        $player = $this->route('player');
-
-        return $room instanceof Room
-            && $player instanceof Player
-            && $this->user()?->id === $room->owner_id
-            && $player->room_id === $room->id
-            && $player->user_id !== $room->owner_id;
-    }
-
-    /**
-     * Get the validation rules that apply to the request.
-     *
-     * @return array<string, array<int, string>>
-     */
-    public function rules(): array
-    {
-        return [];
-    }
-}

app/Http/Requests/ShowEmbeddedRoomRequest.php

@@ -1,110 +0,0 @@
-<?php
-
-namespace App\Http\Requests;
-
-use App\Models\Player;
-use App\Models\Room;
-use Illuminate\Contracts\Validation\ValidationRule;
-use Illuminate\Contracts\Validation\Validator;
-use Illuminate\Foundation\Http\FormRequest;
-use Illuminate\Http\Exceptions\HttpResponseException;
-use Illuminate\Validation\Rule;
-use Inertia\Inertia;
-
-class ShowEmbeddedRoomRequest extends FormRequest
-{
-    /**
-     * Determine if the user is authorized to make this request.
-     */
-    public function authorize(): bool
-    {
-        return $this->user() !== null;
-    }
-
-    protected function prepareForValidation(): void
-    {
-        $this->merge([
-            'join_code' => $this->string('join_code')->trim()->upper()->toString(),
-            'player_name' => $this->string('player_name')->trim()->toString(),
-        ]);
-    }
-
-    /**
-     * Get the validation rules that apply to the request.
-     *
-     * @return array<string, ValidationRule|array<mixed>|string>
-     */
-    public function rules(): array
-    {
-        return [
-            'join_code' => [
-                'bail',
-                'required',
-                'string',
-                'size:6',
-                Rule::exists(Room::class, 'join_code')->whereNull('deleted_at'),
-            ],
-            'player_name' => ['required', 'string', 'max:50'],
-        ];
-    }
-
-    /** @return array<callable(Validator): void> */
-    public function after(): array
-    {
-        return [
-            function (Validator $validator): void {
-                if ($validator->errors()->has('join_code')) {
-                    return;
-                }
-
-                $room = Room::query()
-                    ->where('join_code', $this->input('join_code'))
-                    ->first();
-
-                if ($room?->isClosed()) {
-                    $validator->errors()->add('join_code', 'Dieser Raum ist geschlossen.');
-
-                    return;
-                }
-
-                if ($room === null || $this->user() === null) {
-                    return;
-                }
-
-                $nameIsTaken = Player::query()
-                    ->where('room_id', $room->id)
-                    ->where('name', $this->input('player_name'))
-                    ->where(function ($query): void {
-                        $query->whereNull('user_id')
-                            ->orWhere('user_id', '!=', $this->user()->id);
-                    })
-                    ->exists();
-
-                if ($nameIsTaken) {
-                    $validator->errors()->add(
-                        'player_name',
-                        'Dieser Anzeigename ist in dem Raum bereits vorhanden.',
-                    );
-                }
-            },
-        ];
-    }
-
-    public function messages(): array
-    {
-        return [
-            'join_code.exists' => 'Dieser Raumcode existiert nicht.',
-            'join_code.size' => 'Der Raumcode muss aus sechs Zeichen bestehen.',
-            'player_name.required' => 'Bitte hinterlege in der Hub-App einen Anzeigenamen.',
-        ];
-    }
-
-    protected function failedValidation(Validator $validator): never
-    {
-        throw new HttpResponseException(
-            Inertia::render('embedded/Error', [
-                'message' => $validator->errors()->first(),
-            ])->toResponse($this)->setStatusCode(422),
-        );
-    }
-}

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/Http/Requests/UpdateRoomSettingsRequest.php

@@ -1,33 +0,0 @@
-<?php
-
-namespace App\Http\Requests;
-
-use App\Models\Room;
-use Illuminate\Foundation\Http\FormRequest;
-
-class UpdateRoomSettingsRequest extends FormRequest
-{
-    /**
-     * Determine if the user is authorized to make this request.
-     */
-    public function authorize(): bool
-    {
-        $room = $this->route('room');
-
-        return $room instanceof Room
-            && $this->user()?->id === $room->owner_id;
-    }
-
-    /**
-     * Get the validation rules that apply to the request.
-     *
-     * @return array<string, array<int, string>>
-     */
-    public function rules(): array
-    {
-        return [
-            'allow_participants_to_manage_rounds' => ['required', 'boolean'],
-            'is_persistent' => ['required', 'boolean'],
-        ];
-    }
-}

app/Http/Resources/DashboardRoomResource.php

@@ -19,17 +19,6 @@ class DashboardRoomResource extends JsonResource
             'current_round' => $this->resource->current_round,
             'players_count' => $this->resource->players_count,
             'active_player_count' => $this->resource->active_player_count,
-            'players' => $this->resource->relationLoaded('activePlayers')
-                ? $this->resource->activePlayers
-                    ->map(fn ($player): array => [
-                        'id' => $player->id,
-                        'name' => $player->name,
-                        'is_moderator' => $player->is_moderator,
-                        'is_owner' => $player->user_id === $this->resource->owner_id,
-                    ])
-                    ->values()
-                    ->all()
-                : [],
             'last_activity_at' => $this->resource->last_activity_at?->toIso8601String(),
             'closed_at' => $this->resource->closed_at?->toIso8601String(),
         ];

app/Http/Resources/RoomResource.php

@@ -26,8 +26,6 @@ class RoomResource extends JsonResource
             'current_round' => $room->current_round,
             'revealed' => $room->revealed_at !== null,
             'state_version' => $room->state_version,
-            'allow_participants_to_manage_rounds' => $room->allow_participants_to_manage_rounds,
-            'is_persistent' => $room->is_persistent,
             'statistics' => $pageData->statistics,
             'deck' => (new RoomDeckResource($room->deck_config))->resolve($request),
             'players' => $room->players

app/Jobs/CloseInactiveRooms.php

@@ -21,7 +21,6 @@ class CloseInactiveRooms implements ShouldQueue
 
         Room::query()
             ->whereNull('closed_at')
-            ->where('is_persistent', false)
             ->where(function ($query) use ($guestCutoff, $accountCutoff): void {
                 $query
                     ->where(function ($query) use ($guestCutoff): void {
@@ -41,12 +40,7 @@ class CloseInactiveRooms implements ShouldQueue
                             ->lockForUpdate()
                             ->find((string) $roomId);
 
-                        if (
-                            $room === null
-                            || $room->isClosed()
-                            || $room->is_persistent
-                            || $room->last_activity_at === null
-                        ) {
+                        if ($room === null || $room->isClosed() || $room->last_activity_at === null) {
                             return null;
                         }
 

app/Models/Room.php

@@ -22,8 +22,6 @@ use Illuminate\Database\Eloquent\SoftDeletes;
  * @property CarbonImmutable|null $last_activity_at
  * @property CarbonImmutable|null $closed_at
  * @property CarbonImmutable|null $deleted_at
- * @property bool $allow_participants_to_manage_rounds
- * @property bool $is_persistent
  * @property int $players_count
  */
 class Room extends Model
@@ -39,13 +37,6 @@ class Room extends Model
         'state_version',
         'last_activity_at',
         'closed_at',
-        'allow_participants_to_manage_rounds',
-        'is_persistent',
-    ];
-
-    protected $attributes = [
-        'allow_participants_to_manage_rounds' => false,
-        'is_persistent' => false,
     ];
 
     protected function casts(): array
@@ -57,8 +48,6 @@ class Room extends Model
             'last_activity_at' => 'immutable_datetime',
             'closed_at' => 'immutable_datetime',
             'deck_config' => 'array',
-            'allow_participants_to_manage_rounds' => 'boolean',
-            'is_persistent' => 'boolean',
         ];
     }
 

app/Providers/FortifyServiceProvider.php

@@ -51,7 +51,6 @@ class FortifyServiceProvider extends ServiceProvider
         Fortify::loginView(fn (Request $request) => Inertia::render('auth/Login', [
             'canResetPassword' => Features::enabled(Features::resetPasswords()),
             'status' => $request->session()->get('status'),
-            'rememberByDefault' => $request->session()->get('embedded_login', false),
         ]));
 
         Fortify::resetPasswordView(fn (Request $request) => Inertia::render('auth/ResetPassword', [

app/Services/Rooms/DashboardRoomService.php

@@ -15,12 +15,6 @@ class DashboardRoomService
     {
         $ownedRooms = $user
             ->ownedRooms()
-            ->with([
-                'activePlayers' => fn ($query) => $query
-                    ->select(['id', 'room_id', 'user_id', 'name', 'is_moderator', 'created_at'])
-                    ->orderByDesc('is_moderator')
-                    ->orderBy('created_at'),
-            ])
             ->withCount('players')
             ->withCount(['activePlayers as active_player_count'])
             ->orderByRaw('closed_at IS NOT NULL')

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.',
@@ -29,23 +33,29 @@ class RoomEmoteService
             ]);
         }
 
-        if (! $player->isModerator()) {
-            $rateLimitKey = "room-emote:{$room->id}:{$player->id}";
+        $rateLimitKey = "room-emote:{$room->id}:{$player->id}";
 
-            abort_if(
-                RateLimiter::tooManyAttempts($rateLimitKey, 10),
-                429,
-                'Bitte warte kurz, bevor du erneut wirfst.',
-            );
+        abort_if(
+            RateLimiter::tooManyAttempts($rateLimitKey, 10),
+            429,
+            'Bitte warte kurz, bevor du erneut wirfst.',
+        );
 
-            RateLimiter::hit($rateLimitKey, 10);
-        }
+        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/RoomParticipationService.php

@@ -101,125 +101,4 @@ class RoomParticipationService
 
         return [$room, $player];
     }
-
-    public function joinEmbedded(Room $room, User $user, string $playerName): Player
-    {
-        [$player, $change, $stateVersion] = DB::transaction(function () use ($room, $user, $playerName): array {
-            $lockedRoom = Room::query()
-                ->lockForUpdate()
-                ->findOrFail($room->id);
-
-            if ($lockedRoom->isClosed()) {
-                throw ValidationException::withMessages([
-                    'join_code' => 'Dieser Raum ist geschlossen.',
-                ]);
-            }
-
-            $nameIsTaken = $lockedRoom->players()
-                ->where('name', $playerName)
-                ->where(function ($query) use ($user): void {
-                    $query->whereNull('user_id')
-                        ->orWhere('user_id', '!=', $user->id);
-                })
-                ->exists();
-
-            if ($nameIsTaken) {
-                throw ValidationException::withMessages([
-                    'player_name' => 'Dieser Anzeigename ist in dem Raum bereits vorhanden.',
-                ]);
-            }
-
-            $player = $lockedRoom->players()
-                ->where('user_id', $user->id)
-                ->first();
-            $change = null;
-
-            if ($player === null) {
-                $player = $lockedRoom->players()->create([
-                    'user_id' => $user->id,
-                    'name' => $playerName,
-                    'is_moderator' => false,
-                    'last_seen_at' => now(),
-                ]);
-                $change = RoomStateChange::PlayerJoined;
-            } else {
-                if ($player->inactive_at !== null) {
-                    $change = RoomStateChange::PlayerJoined;
-                } elseif ($player->name !== $playerName) {
-                    $change = RoomStateChange::PlayerUpdated;
-                }
-
-                $player->update([
-                    'name' => $playerName,
-                    'last_seen_at' => now(),
-                    'inactive_at' => null,
-                ]);
-            }
-
-            if ($change === null) {
-                return [$player, null, null];
-            }
-
-            $lockedRoom->update([
-                'last_activity_at' => now(),
-                'state_version' => $lockedRoom->state_version + 1,
-            ]);
-
-            return [$player, $change, $lockedRoom->state_version];
-        });
-
-        if ($change instanceof RoomStateChange && is_int($stateVersion)) {
-            RoomStateChanged::dispatch(
-                $room->id,
-                $stateVersion,
-                $change,
-                $this->realtimeState->for($room),
-            );
-        }
-
-        return $player;
-    }
-
-    public function kick(Room $room, Player $player, User $user): void
-    {
-        $stateVersion = DB::transaction(function () use ($room, $player, $user): ?int {
-            $lockedRoom = Room::query()
-                ->lockForUpdate()
-                ->findOrFail($room->id);
-
-            abort_unless($lockedRoom->owner_id === $user->id, 403);
-
-            $lockedPlayer = $lockedRoom->players()
-                ->lockForUpdate()
-                ->findOrFail($player->id);
-
-            abort_if($lockedPlayer->user_id === $lockedRoom->owner_id, 403);
-
-            if ($lockedPlayer->inactive_at !== null) {
-                return null;
-            }
-
-            $lockedPlayer->update([
-                'inactive_at' => now(),
-            ]);
-            $lockedRoom->update([
-                'last_activity_at' => now(),
-                'state_version' => $lockedRoom->state_version + 1,
-            ]);
-
-            return $lockedRoom->state_version;
-        });
-
-        if ($stateVersion === null) {
-            return;
-        }
-
-        RoomStateChanged::dispatch(
-            $room->id,
-            $stateVersion,
-            RoomStateChange::PlayerKicked,
-            $this->realtimeState->for($room),
-            $player->id,
-        );
-    }
 }

app/Services/Rooms/RoomRealtimeStateService.php

@@ -15,7 +15,6 @@ class RoomRealtimeStateService
      *     current_round: int,
      *     revealed: bool,
      *     state_version: int,
-     *     allow_participants_to_manage_rounds: bool,
      *     statistics: array{average: string|null, median: string|null}|null,
      *     players: array<int, array{
      *         id: int,
@@ -45,7 +44,6 @@ class RoomRealtimeStateService
             'current_round' => $room->current_round,
             'revealed' => $room->revealed_at !== null,
             'state_version' => $room->state_version,
-            'allow_participants_to_manage_rounds' => $room->allow_participants_to_manage_rounds,
             'statistics' => $this->statistics->currentRound($room),
             'players' => $room->players
                 ->map(function ($player) use ($room): array {

app/Services/Rooms/RoomSettingsService.php

@@ -1,50 +0,0 @@
-<?php
-
-namespace App\Services\Rooms;
-
-use App\Enums\RoomStateChange;
-use App\Events\RoomStateChanged;
-use App\Models\Room;
-use App\Models\User;
-use Illuminate\Support\Facades\DB;
-
-class RoomSettingsService
-{
-    public function __construct(
-        private readonly RoomRealtimeStateService $realtimeState,
-    ) {}
-
-    /** @param array{allow_participants_to_manage_rounds: bool, is_persistent: bool} $settings */
-    public function update(Room $room, User $user, array $settings): void
-    {
-        $stateVersion = DB::transaction(function () use ($room, $user, $settings): ?int {
-            $lockedRoom = Room::query()
-                ->lockForUpdate()
-                ->findOrFail($room->id);
-
-            abort_unless($lockedRoom->owner_id === $user->id, 403);
-
-            $lockedRoom->fill($settings);
-
-            if (! $lockedRoom->isDirty()) {
-                return null;
-            }
-
-            $lockedRoom->state_version++;
-            $lockedRoom->save();
-
-            return $lockedRoom->state_version;
-        });
-
-        if ($stateVersion === null) {
-            return;
-        }
-
-        RoomStateChanged::dispatch(
-            $room->id,
-            $stateVersion,
-            RoomStateChange::RoomSettingsUpdated,
-            $this->realtimeState->for($room),
-        );
-    }
-}

bootstrap/app.php

@@ -18,13 +18,6 @@ return Application::configure(basePath: dirname(__DIR__))
     )
     ->withMiddleware(function (Middleware $middleware): void {
         $middleware->trustProxies(at: '*');
-        $middleware->redirectGuestsTo(function (Request $request): string {
-            if ($request->isMethod('GET') && $request->is('embedded/scrum-poker')) {
-                $request->session()->put('embedded_login', true);
-            }
-
-            return route('login');
-        });
         $middleware->encryptCookies(except: ['appearance', 'sidebar_state']);
         $middleware->alias([
             'room.player' => EnsureRoomParticipant::class,

database/migrations/2026_09_01_134545_add_embedded_settings_to_rooms_table.php

@@ -1,32 +0,0 @@
-<?php
-
-use Illuminate\Database\Migrations\Migration;
-use Illuminate\Database\Schema\Blueprint;
-use Illuminate\Support\Facades\Schema;
-
-return new class extends Migration
-{
-    /**
-     * Run the migrations.
-     */
-    public function up(): void
-    {
-        Schema::table('rooms', function (Blueprint $table) {
-            $table->boolean('allow_participants_to_manage_rounds')->default(false);
-            $table->boolean('is_persistent')->default(false);
-        });
-    }
-
-    /**
-     * Reverse the migrations.
-     */
-    public function down(): void
-    {
-        Schema::table('rooms', function (Blueprint $table) {
-            $table->dropColumn([
-                'allow_participants_to_manage_rounds',
-                'is_persistent',
-            ]);
-        });
-    }
-};

resources/js/app.ts

@@ -9,8 +9,8 @@ const appName = import.meta.env.VITE_APP_NAME || 'Laravel';
 createInertiaApp({
     title: (title) => (title ? `${title} - ${appName}` : appName),
 
-    layout: (name) => {
-        return name.startsWith('embedded/') ? null : PublicLayout;
+    layout: () => {
+        return PublicLayout;
     },
 
     progress: {

resources/js/components/MyRooms.vue

@@ -1,12 +1,6 @@
 <script setup lang="ts">
 import { Link, useForm } from '@inertiajs/vue3';
-import {
-    DoorOpen,
-    Plus,
-    Settings as SettingsIcon,
-    Trash2,
-    UserMinus,
-} from '@lucide/vue';
+import { DoorOpen, Plus, Trash2 } from '@lucide/vue';
 import { ref } from 'vue';
 
 import DashboardRoomCard from '@/components/dashboard/DashboardRoomCard.vue';
@@ -19,23 +13,12 @@ import {
     DialogTitle,
 } from '@/components/ui/dialog';
 import { create, destroy, reopen, show } from '@/routes/room';
-import { destroy as kickRoomPlayer } from '@/routes/room/player';
-import { edit as roomSettings } from '@/routes/room/settings';
-import type {
-    DashboardRoom,
-    DashboardRoomPlayer,
-    OwnedRoomListProps,
-} from '@/types/dashboard';
+import type { DashboardRoom, OwnedRoomListProps } from '@/types/dashboard';
 
 defineProps<OwnedRoomListProps>();
 
 const selectedRoom = ref<DashboardRoom | null>(null);
-const selectedPlayer = ref<{
-    room: DashboardRoom;
-    player: DashboardRoomPlayer;
-} | null>(null);
 const deleteForm = useForm({});
-const kickForm = useForm({});
 
 function setDeleteDialogOpen(open: boolean): void {
     if (!open && !deleteForm.processing) {
@@ -43,12 +26,6 @@ function setDeleteDialogOpen(open: boolean): void {
     }
 }
 
-function setKickDialogOpen(open: boolean): void {
-    if (!open && !kickForm.processing) {
-        selectedPlayer.value = null;
-    }
-}
-
 function deleteRoom(): void {
     if (selectedRoom.value === null || deleteForm.processing) {
         return;
@@ -61,25 +38,6 @@ function deleteRoom(): void {
         },
     });
 }
-
-function kickPlayer(): void {
-    if (selectedPlayer.value === null || kickForm.processing) {
-        return;
-    }
-
-    kickForm.delete(
-        kickRoomPlayer({
-            room: selectedPlayer.value.room.id,
-            player: selectedPlayer.value.player.id,
-        }).url,
-        {
-            preserveScroll: true,
-            onSuccess: () => {
-                selectedPlayer.value = null;
-            },
-        },
-    );
-}
 </script>
 
 <template>
@@ -133,14 +91,6 @@ function kickPlayer(): void {
                         Raum öffnen
                     </Link>
 
-                    <Link
-                        :href="roomSettings(room.id)"
-                        class="inline-flex items-center gap-2 rounded-md px-3 py-2 text-sm font-semibold transition hover:bg-slate-700"
-                    >
-                        <SettingsIcon class="size-4" />
-                        Einstellungen
-                    </Link>
-
                     <button
                         type="button"
                         class="inline-flex items-center gap-2 rounded-md px-3 py-2 text-sm font-semibold text-rose-300 transition hover:bg-rose-500/80"
@@ -149,56 +99,6 @@ function kickPlayer(): void {
                         <Trash2 class="size-4" />
                         Raum löschen
                     </button>
-
-                    <div
-                        class="mt-2 w-full rounded-md border border-slate-700 bg-slate-900/40 p-3"
-                    >
-                        <h3 class="text-sm font-semibold">Teilnehmer</h3>
-
-                        <ul
-                            v-if="room.players.length > 0"
-                            class="mt-2 flex flex-col gap-2"
-                        >
-                            <li
-                                v-for="player in room.players"
-                                :key="player.id"
-                                class="flex items-center justify-between gap-3 rounded-md bg-slate-800 px-3 py-2"
-                            >
-                                <span class="min-w-0">
-                                    <span
-                                        class="block truncate text-sm"
-                                        :class="
-                                            player.is_moderator
-                                                ? 'text-amber-300'
-                                                : 'text-slate-100'
-                                        "
-                                    >
-                                        {{ player.name }}
-                                    </span>
-                                </span>
-
-                                <span
-                                    v-if="player.is_owner"
-                                    class="shrink-0 text-xs text-slate-400"
-                                >
-                                    Du
-                                </span>
-                                <button
-                                    v-else
-                                    type="button"
-                                    class="inline-flex shrink-0 items-center gap-1.5 rounded-md px-2.5 py-1.5 text-xs font-semibold text-rose-300 transition hover:bg-rose-500/20 hover:text-rose-200"
-                                    @click="selectedPlayer = { room, player }"
-                                >
-                                    <UserMinus class="size-3.5" />
-                                    Kicken
-                                </button>
-                            </li>
-                        </ul>
-
-                        <p v-else class="mt-2 text-sm text-slate-400">
-                            Aktuell sind keine Teilnehmer im Raum.
-                        </p>
-                    </div>
                 </template>
             </DashboardRoomCard>
         </div>
@@ -264,42 +164,5 @@ function kickPlayer(): void {
                 </DialogFooter>
             </DialogContent>
         </Dialog>
-
-        <Dialog
-            :open="selectedPlayer !== null"
-            @update:open="setKickDialogOpen"
-        >
-            <DialogContent
-                class="border-slate-700 bg-slate-800 text-slate-100 sm:max-w-md"
-            >
-                <DialogHeader>
-                    <DialogTitle>Teilnehmer wirklich kicken?</DialogTitle>
-                    <DialogDescription class="text-slate-300">
-                        {{ selectedPlayer?.player.name }} wird aus „{{
-                            selectedPlayer?.room.title ?? 'Scrum Poker'
-                        }}“ entfernt und zur Startseite weitergeleitet.
-                    </DialogDescription>
-                </DialogHeader>
-
-                <DialogFooter class="gap-6 space-x-4 sm:gap-0">
-                    <button
-                        type="button"
-                        class="rounded-md border border-slate-600 px-4 py-2 text-sm font-semibold text-slate-200 transition hover:bg-slate-700"
-                        :disabled="kickForm.processing"
-                        @click="selectedPlayer = null"
-                    >
-                        Abbrechen
-                    </button>
-                    <button
-                        type="button"
-                        class="rounded-md bg-rose-600 px-4 py-2 text-sm font-semibold text-white transition hover:bg-rose-500 disabled:opacity-50"
-                        :disabled="kickForm.processing"
-                        @click="kickPlayer"
-                    >
-                        {{ kickForm.processing ? 'Wird entfernt …' : 'Kicken' }}
-                    </button>
-                </DialogFooter>
-            </DialogContent>
-        </Dialog>
     </section>
 </template>

resources/js/components/rooms/RoomExperience.vue

@@ -1,91 +0,0 @@
-<script setup lang="ts">
-import { Head, usePage } from '@inertiajs/vue3';
-import { computed, ref } from 'vue';
-
-import RoomHeader from '@/components/rooms/RoomHeader.vue';
-import RoomRetentionNotice from '@/components/rooms/RoomRetentionNotice.vue';
-import RoomTable from '@/components/rooms/RoomTable.vue';
-import RoomVoteDeck from '@/components/rooms/RoomVoteDeck.vue';
-import { useRoomRealtime } from '@/composables/useRoomRealtime';
-import type { RoomExperienceProps } from '@/types/room';
-
-const props = withDefaults(defineProps<RoomExperienceProps>(), {
-    embedded: false,
-});
-
-const page = usePage();
-const presenterMode = ref(false);
-const roomNotice = computed(() => page.props.roomNotice);
-const embeddedBackgroundColor = computed(() => {
-    if (!props.embedded) {
-        return undefined;
-    }
-
-    const backgroundColor = new URL(
-        page.url,
-        'https://embedded.invalid',
-    ).searchParams.get('background_color');
-
-    return backgroundColor && /^#[0-9a-f]{6}$/i.test(backgroundColor)
-        ? backgroundColor
-        : undefined;
-});
-const canFavorite = computed(
-    () => !props.embedded && page.props.auth.user?.id != props.room.owner_id,
-);
-
-const {
-    room: realtimeRoom,
-    currentPlayer: realtimeCurrentPlayer,
-    setCurrentVote,
-} = useRoomRealtime(
-    () => props.room,
-    () => props.currentPlayer,
-);
-</script>
-
-<template>
-    <Head :title="realtimeRoom.title ?? 'Scrum Poker'" />
-
-    <main
-        class="min-h-svh bg-slate-900 px-3 py-6 text-white sm:px-6 md:flex md:min-h-0 md:flex-col md:overflow-hidden lg:px-10"
-        :style="
-            embeddedBackgroundColor
-                ? { backgroundColor: embeddedBackgroundColor }
-                : undefined
-        "
-        :class="
-            embedded
-                ? 'md:h-dvh'
-                : '-m-6 min-h-[calc(100svh-4rem)] md:h-[calc(100dvh-4rem-1px)]'
-        "
-    >
-        <RoomRetentionNotice v-if="roomNotice" :notice="roomNotice" />
-
-        <RoomHeader
-            :id="realtimeRoom.id"
-            :title="realtimeRoom.title"
-            :join_code="realtimeRoom.join_code"
-            :is_favorite="realtimeRoom.is_favorite"
-            :can-favorite="canFavorite"
-            :embedded="embedded"
-            :player-name="realtimeCurrentPlayer.name"
-            v-model:presenter-mode="presenterMode"
-        />
-
-        <RoomTable
-            :room="realtimeRoom"
-            :current-player="realtimeCurrentPlayer"
-            :presenter-mode="presenterMode"
-        />
-
-        <RoomVoteDeck
-            :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/components/rooms/RoomHeader.vue

@@ -1,10 +1,9 @@
 <script setup lang="ts">
 import { Link } from '@inertiajs/vue3';
-import { Check, Copy, LogOut } from '@lucide/vue';
+import { Check, Copy } from '@lucide/vue';
 import { ref } from 'vue';
 
 import { Checkbox } from '@/components/ui/checkbox';
-import { logout as embeddedLogout } from '@/routes/embedded';
 import { favorite } from '@/routes/room';
 import type { RoomHeaderEmits, RoomHeaderProps } from '@/types/room';
 
@@ -49,24 +48,6 @@ async function copyInviteLink(): Promise<void> {
         </div>
 
         <div class="flex flex-col items-end gap-2">
-            <Link
-                v-if="embedded"
-                :href="
-                    embeddedLogout({
-                        query: {
-                            join_code,
-                            player_name: playerName,
-                        },
-                    })
-                "
-                method="post"
-                as="button"
-                class="inline-flex items-center gap-2 text-sm text-slate-300 transition hover:text-white"
-            >
-                <LogOut class="size-4" />
-                Abmelden
-            </Link>
-
             <button
                 type="button"
                 class="flex w-fit items-center gap-3 rounded-xl border border-slate-700 bg-slate-800 px-4 py-2.5 text-left transition hover:bg-slate-700 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-cyan-300"

resources/js/components/rooms/RoomSeat.vue

@@ -1,14 +1,181 @@
 <script setup lang="ts">
-import { CircleUserRound } from '@lucide/vue';
+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
@@ -75,18 +242,22 @@ function playerVote(): string | null {
             :class="{ 'player-details-above': player.isTopSeat }"
         >
             <p
-                class="player-name max-w-32 text-center text-sm leading-tight font-semibold"
-                :class="
-                    player.is_moderator ? 'text-amber-300' : 'text-slate-100'
-                "
+                class="player-name max-w-32 text-center text-sm leading-tight font-semibold text-slate-100"
             >
                 {{ player.name }}
             </p>
             <div
-                v-if="isCurrentPlayer()"
+                v-if="player.is_moderator || isCurrentPlayer()"
                 class="flex flex-wrap items-center justify-center gap-x-2 gap-y-0.5 text-[11px]"
             >
-                <span class="text-cyan-300">Du</span>
+                <span
+                    v-if="player.is_moderator"
+                    class="inline-flex items-center gap-1 text-amber-300"
+                >
+                    <Crown class="size-3 fill-amber-300" aria-hidden="true" />
+                    Moderator
+                </span>
+                <span v-if="isCurrentPlayer()" class="text-cyan-300">Du</span>
             </div>
         </div>
 
@@ -94,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>
@@ -109,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;
 }
 
@@ -123,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,
@@ -149,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);
 }
 
@@ -166,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,13 +17,17 @@ const hasCompactHeight = useMediaQuery(
 );
 
 const gameBoard = ref<HTMLElement | null>(null);
-const { activePaperBalls, hitPlayerIds, throwingAtPlayerId, throwPaperBall } =
-    usePaperBallToss({
-        roomId: () => props.room.id,
-        currentPlayerId: () => props.currentPlayer.id,
-        currentPlayerIsModerator: () => props.currentPlayer.is_moderator,
-        board: gameBoard,
-    });
+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(
@@ -100,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"
             >
@@ -116,17 +121,15 @@ const voteCount = computed(
                 :revealed="room.revealed"
                 :presenter-mode="presenterMode"
                 :is-paper-ball-hit="hitPlayerIds.includes(player.id)"
-                :throw-disabled="
-                    !currentPlayer.is_moderator && throwingAtPlayerId !== null
+                :paper-ball-knockback="
+                    paperBallKnockbacks[player.id] ?? { x: 0, y: 0 }
                 "
+                :throw-disabled="throwingAtPlayerId !== null"
                 @throw-paper-ball="throwPaperBall"
             />
 
             <RoomModeratorControls
-                v-if="
-                    currentPlayer.is_moderator ||
-                    room.allow_participants_to_manage_rounds
-                "
+                v-if="currentPlayer.is_moderator"
                 :room-id="room.id"
                 :revealed="room.revealed"
                 :has-votes="voteCount > 0"
@@ -195,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/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,18 +15,28 @@ 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,
     currentPlayerId,
-    currentPlayerIsModerator,
     board,
 }: 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(() => {
@@ -35,12 +47,90 @@ export function usePaperBallToss({
         timers.add(timer);
     }
 
-    async function throwPaperBall(targetPlayerId: number): Promise<void> {
-        const shouldApplyCooldown = !currentPlayerIsModerator();
+    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() ||
-            (shouldApplyCooldown && throwingAtPlayerId.value !== null)
+            throwingAtPlayerId.value !== null
         ) {
             return;
         }
@@ -55,9 +145,7 @@ export function usePaperBallToss({
             return;
         }
 
-        if (shouldApplyCooldown) {
-            throwingAtPlayerId.value = targetPlayerId;
-        }
+        throwingAtPlayerId.value = targetPlayerId;
 
         try {
             const response = await fetch(throwPaperBallRoute(roomId()).url, {
@@ -71,6 +159,7 @@ export function usePaperBallToss({
                 },
                 body: JSON.stringify({
                     target_player_id: targetPlayerId,
+                    charge_percentage: chargePercentage,
                 }),
             });
 
@@ -96,13 +185,11 @@ export function usePaperBallToss({
         } catch {
             toast.error('Der Papierknäuel konnte nicht geworfen werden.');
         } finally {
-            if (shouldApplyCooldown) {
-                schedule(() => {
-                    if (throwingAtPlayerId.value === targetPlayerId) {
-                        throwingAtPlayerId.value = null;
-                    }
-                }, THROW_BUTTON_COOLDOWN);
-            }
+            schedule(() => {
+                if (throwingAtPlayerId.value === targetPlayerId) {
+                    throwingAtPlayerId.value = null;
+                }
+            }, THROW_BUTTON_COOLDOWN);
         }
     }
 
@@ -113,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;
@@ -149,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`,
@@ -170,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(() => {
@@ -190,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

@@ -33,15 +33,6 @@ export function useRoomRealtime(
             return;
         }
 
-        if (
-            payload.change === 'player_kicked' &&
-            payload.affected_player_id === currentPlayer.value.id
-        ) {
-            router.visit(home().url, { replace: true });
-
-            return;
-        }
-
         if (payload.change === 'room_closed') {
             router.visit(
                 join({ query: { join_code: room.value.join_code } }).url,

resources/js/pages/auth/Login.vue

@@ -23,7 +23,6 @@ defineOptions({
 defineProps<{
     status?: string;
     canResetPassword: boolean;
-    rememberByDefault: boolean;
 }>();
 </script>
 
@@ -86,12 +85,7 @@ defineProps<{
 
             <div class="flex items-center justify-between">
                 <Label for="remember" class="flex items-center space-x-3">
-                    <Checkbox
-                        id="remember"
-                        name="remember"
-                        :default-value="rememberByDefault"
-                        :tabindex="3"
-                    />
+                    <Checkbox id="remember" name="remember" :tabindex="3" />
                     <span>Remember me</span>
                 </Label>
             </div>

resources/js/pages/embedded/Error.vue

@@ -1,28 +0,0 @@
-<script setup lang="ts">
-import { Head } from '@inertiajs/vue3';
-import { CircleAlert } from '@lucide/vue';
-
-defineProps<{
-    message: string;
-}>();
-</script>
-
-<template>
-    <Head title="Scrum Poker nicht verfügbar" />
-
-    <main
-        class="grid min-h-svh place-items-center bg-slate-900 p-8 text-slate-100"
-    >
-        <section
-            class="flex max-w-lg flex-col items-center gap-4 rounded-2xl border border-slate-700 bg-slate-800 p-8 text-center shadow-xl"
-        >
-            <CircleAlert class="size-10 text-amber-300" />
-            <h1 class="text-2xl font-bold">Raum kann nicht geöffnet werden</h1>
-            <p class="text-slate-300">{{ message }}</p>
-            <p class="text-sm text-slate-400">
-                Bitte ändere Raumcode oder Anzeigename auf der Home-Seite der
-                Fillibri Hub App und öffne Scrum Poker erneut.
-            </p>
-        </section>
-    </main>
-</template>

resources/js/pages/embedded/Room.vue

@@ -1,14 +0,0 @@
-<script setup lang="ts">
-import RoomExperience from '@/components/rooms/RoomExperience.vue';
-import type { RoomPageProps } from '@/types/room';
-
-const props = defineProps<RoomPageProps>();
-</script>
-
-<template>
-    <RoomExperience
-        :room="props.room"
-        :current-player="props.currentPlayer"
-        embedded
-    />
-</template>

resources/js/pages/rooms/Settings.vue

@@ -1,103 +0,0 @@
-<script setup lang="ts">
-import { Head, Link, useForm } from '@inertiajs/vue3';
-import { ArrowLeft } from '@lucide/vue';
-
-import InputError from '@/components/InputError.vue';
-import { Checkbox } from '@/components/ui/checkbox';
-import { dashboard } from '@/routes';
-import { update as updateSettings } from '@/routes/room/settings';
-import type { RoomSettingsPageProps } from '@/types/room';
-
-const props = defineProps<RoomSettingsPageProps>();
-const form = useForm({
-    allow_participants_to_manage_rounds:
-        props.room.allow_participants_to_manage_rounds,
-    is_persistent: props.room.is_persistent,
-});
-
-function submit(): void {
-    form.patch(updateSettings(props.room.id).url, {
-        preserveScroll: true,
-    });
-}
-</script>
-
-<template>
-    <Head title="Raumeinstellungen" />
-
-    <main
-        class="flex min-h-[calc(100svh-4rem)] justify-center bg-slate-900 p-4 text-slate-100 sm:p-8"
-    >
-        <section class="flex w-full max-w-2xl flex-col gap-6">
-            <Link
-                :href="dashboard()"
-                class="inline-flex w-fit items-center gap-2 text-sm text-slate-300 transition hover:text-white"
-            >
-                <ArrowLeft class="size-4" />
-                Zurück zu meinen Räumen
-            </Link>
-
-            <div>
-                <h1 class="text-2xl font-bold">Raumeinstellungen</h1>
-                <p class="mt-1 text-sm text-slate-400">
-                    {{ room.title ?? 'Scrum Poker' }} · {{ room.join_code }}
-                </p>
-            </div>
-
-            <form
-                class="flex flex-col gap-6 rounded-xl border border-slate-700 bg-slate-800 p-6"
-                @submit.prevent="submit"
-            >
-                <label class="flex cursor-pointer items-start gap-4">
-                    <Checkbox
-                        :model-value="form.allow_participants_to_manage_rounds"
-                        @update:model-value="
-                            form.allow_participants_to_manage_rounds =
-                                $event === true
-                        "
-                    />
-                    <span>
-                        <strong class="block"
-                            >Alle dürfen Runden steuern</strong
-                        >
-                        <span class="mt-1 block text-sm text-slate-400">
-                            Alle aktiven Teilnehmer, auch Gäste, dürfen Karten
-                            aufdecken, Votes zurücksetzen und die nächste Runde
-                            starten.
-                        </span>
-                    </span>
-                </label>
-                <InputError
-                    :message="form.errors.allow_participants_to_manage_rounds"
-                />
-
-                <label class="flex cursor-pointer items-start gap-4">
-                    <Checkbox
-                        :model-value="form.is_persistent"
-                        @update:model-value="
-                            form.is_persistent = $event === true
-                        "
-                    />
-                    <span>
-                        <strong class="block"
-                            >Raum dauerhaft offen halten</strong
-                        >
-                        <span class="mt-1 block text-sm text-slate-400">
-                            Der Raum wird auch nach längerer Inaktivität nicht
-                            automatisch geschlossen.
-                        </span>
-                    </span>
-                </label>
-                <InputError :message="form.errors.is_persistent" />
-
-                <button
-                    type="submit"
-                    class="inline-flex w-fit rounded-md bg-primary px-4 py-2 text-sm font-semibold text-primary-foreground transition hover:bg-primary/90 disabled:opacity-50"
-                    :disabled="form.processing"
-                >
-                    {{ form.processing ? 'Wird gespeichert …' : 'Speichern' }}
-                </button>
-            </form>
-        </section>
-    </main>
-</template>

resources/js/pages/rooms/Show.vue

@@ -1,10 +1,63 @@
 <script setup lang="ts">
-import RoomExperience from '@/components/rooms/RoomExperience.vue';
+import { Head, usePage } from '@inertiajs/vue3';
+import { computed, ref } from 'vue';
+
+import RoomHeader from '@/components/rooms/RoomHeader.vue';
+import RoomRetentionNotice from '@/components/rooms/RoomRetentionNotice.vue';
+import RoomTable from '@/components/rooms/RoomTable.vue';
+import RoomVoteDeck from '@/components/rooms/RoomVoteDeck.vue';
+import { useRoomRealtime } from '@/composables/useRoomRealtime';
 import type { RoomPageProps } from '@/types/room';
 
 const props = defineProps<RoomPageProps>();
+
+const page = usePage();
+const presenterMode = ref(false);
+const roomNotice = computed(() => page.props.roomNotice);
+const canFavorite = computed(
+    () => page.props.auth.user?.id != props.room.owner_id,
+);
+
+const {
+    room: realtimeRoom,
+    currentPlayer: realtimeCurrentPlayer,
+    setCurrentVote,
+} = useRoomRealtime(
+    () => props.room,
+    () => props.currentPlayer,
+);
 </script>
 
 <template>
-    <RoomExperience :room="props.room" :current-player="props.currentPlayer" />
+    <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"
+    >
+        <RoomRetentionNotice v-if="roomNotice" :notice="roomNotice" />
+
+        <RoomHeader
+            :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="realtimeRoom"
+            :current-player="realtimeCurrentPlayer"
+            :presenter-mode="presenterMode"
+        />
+
+        <RoomVoteDeck
+            :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/dashboard.ts

@@ -1,10 +1,3 @@
-export type DashboardRoomPlayer = {
-    id: number;
-    name: string;
-    is_moderator: boolean;
-    is_owner: boolean;
-};
-
 export type DashboardRoom = {
     id: string;
     title: string | null;
@@ -12,7 +5,6 @@ export type DashboardRoom = {
     current_round: number;
     players_count: number;
     active_player_count: number;
-    players: DashboardRoomPlayer[];
     last_activity_at: string | null;
     closed_at: string | null;
 };

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,13 +22,18 @@ 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;
-    currentPlayerIsModerator: () => boolean;
     board: Ref<HTMLElement | null>;
 };
 

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;
@@ -44,8 +46,6 @@ export type PokerRoom = {
     current_round: number;
     revealed: boolean;
     state_version: number;
-    allow_participants_to_manage_rounds: boolean;
-    is_persistent: boolean;
     statistics: RoomStatistics | null;
     deck: RoomDeck;
     players: RoomPlayer[];
@@ -66,23 +66,6 @@ export type RoomPageProps = {
     currentPlayer: CurrentRoomPlayer;
 };
 
-export type RoomExperienceProps = RoomPageProps & {
-    embedded?: boolean;
-};
-
-export type RoomSettings = Pick<
-    PokerRoom,
-    | 'id'
-    | 'title'
-    | 'join_code'
-    | 'allow_participants_to_manage_rounds'
-    | 'is_persistent'
->;
-
-export type RoomSettingsPageProps = {
-    room: RoomSettings;
-};
-
 export type CreateRoomPageProps = {
     decks: SelectableDeck[];
     defaultPlayerName: string | null;
@@ -114,8 +97,6 @@ export type RoomHeaderProps = Pick<
 > & {
     canFavorite: boolean;
     presenterMode: boolean;
-    embedded: boolean;
-    playerName: string;
 };
 
 export type RoomHeaderEmits = {
@@ -136,6 +117,7 @@ export type RoomSeatProps = {
     revealed: boolean;
     presenterMode: boolean;
     isPaperBallHit: boolean;
+    paperBallKnockback: PaperBallKnockback;
     throwDisabled: boolean;
 };
 
@@ -159,30 +141,21 @@ export type RoomVoteDeckEmits = {
 
 export type RoomStateChange =
     | 'player_joined'
-    | 'player_updated'
-    | 'player_kicked'
     | 'vote_changed'
     | 'cards_revealed'
     | 'votes_reset'
     | 'next_round'
     | 'room_reopened'
     | 'room_closed'
-    | 'room_deleted'
-    | 'room_settings_updated';
+    | 'room_deleted';
 
 export type RoomStateChangedPayload = {
     version: number;
     change: RoomStateChange;
     state: RoomRealtimeState | null;
-    affected_player_id?: number;
 };
 
 export type RoomRealtimeState = Pick<
     PokerRoom,
-    | 'current_round'
-    | 'revealed'
-    | 'state_version'
-    | 'allow_participants_to_manage_rounds'
-    | 'statistics'
-    | 'players'
+    'current_round' | 'revealed' | 'state_version' | 'statistics' | 'players'
 >;

routes/room.php

@@ -1,15 +1,11 @@
 <?php
 
-use App\Http\Controllers\EmbeddedLogoutController;
-use App\Http\Controllers\EmbeddedRoomController;
 use App\Http\Controllers\FavoriteRoomController;
 use App\Http\Controllers\RoomController;
 use App\Http\Controllers\RoomEmoteController;
 use App\Http\Controllers\RoomJoinController;
 use App\Http\Controllers\RoomLifecycleController;
 use App\Http\Controllers\RoomPlayerController;
-use App\Http\Controllers\RoomPlayerKickController;
-use App\Http\Controllers\RoomSettingsController;
 use App\Http\Controllers\RoundController;
 use App\Http\Controllers\VoteController;
 use App\Models\Room;
@@ -26,27 +22,12 @@ Route::post('room/join', [RoomPlayerController::class, 'join'])->name('room.code
 Route::post('/room', [RoomController::class, 'store'])->name('room.store');
 
 Route::middleware(['auth', 'verified'])->group(function () {
-    Route::get('/embedded/scrum-poker', EmbeddedRoomController::class)
-        ->name('embedded.room');
-});
-
-Route::post('/embedded/scrum-poker/logout', EmbeddedLogoutController::class)
-    ->middleware('auth')
-    ->name('embedded.logout');
-
-Route::middleware(['auth', 'verified'])->group(function () {
-    Route::get('/rooms/{room}/settings', [RoomSettingsController::class, 'edit'])
-        ->name('room.settings.edit');
-    Route::patch('/rooms/{room}/settings', [RoomSettingsController::class, 'update'])
-        ->name('room.settings.update');
     Route::post('/rooms/{room}/reopen', [RoomLifecycleController::class, 'reopen'])
         ->name('room.reopen');
     Route::delete('/rooms/{room}', [RoomLifecycleController::class, 'destroy'])
         ->name('room.destroy');
     Route::post('/rooms/{room}/favorite', FavoriteRoomController::class)
         ->name('room.favorite');
-    Route::delete('/rooms/{room}/players/{player}', RoomPlayerKickController::class)
-        ->name('room.player.destroy');
 });
 
 Route::middleware('room.player')->group(function () {

tests/Feature/EmbeddedRoomTest.php

@@ -1,129 +0,0 @@
-<?php
-
-use App\Models\Room;
-use App\Models\User;
-use Inertia\Testing\AssertableInertia as Assert;
-
-function createEmbeddedRoom(array $attributes = []): Room
-{
-    return Room::create([
-        'title' => 'Fillibri Planning',
-        'deck_config' => [
-            'name' => 'Fibonacci',
-            'cards' => [
-                ['key' => '3', 'label' => '3'],
-                ['key' => '5', 'label' => '5'],
-            ],
-        ],
-        ...$attributes,
-    ]);
-}
-
-test('embedded room access sends guests through login and remembers the intended room', function () {
-    $room = createEmbeddedRoom();
-    $url = route('embedded.room', [
-        'join_code' => $room->join_code,
-        'player_name' => 'Nico',
-    ]);
-
-    $this->get($url)
-        ->assertRedirect(route('login'))
-        ->assertSessionHas('embedded_login', true)
-        ->assertSessionHas('url.intended', $url);
-
-    $this->get(route('login'))
-        ->assertInertia(fn (Assert $page) => $page
-            ->component('auth/Login')
-            ->where('rememberByDefault', true));
-});
-
-test('an authenticated user automatically joins the embedded room', function () {
-    $user = User::factory()->create();
-    $room = createEmbeddedRoom(['allow_participants_to_manage_rounds' => true]);
-
-    $this->actingAs($user)
-        ->get(route('embedded.room', [
-            'join_code' => strtolower($room->join_code),
-            'player_name' => ' Nico ',
-        ]))
-        ->assertOk()
-        ->assertInertia(fn (Assert $page) => $page
-            ->component('embedded/Room')
-            ->where('room.id', $room->id)
-            ->where('room.allow_participants_to_manage_rounds', true)
-            ->where('currentPlayer.name', 'Nico'))
-        ->assertSessionHas("room_players.{$room->id}");
-
-    $this->assertDatabaseHas('players', [
-        'room_id' => $room->id,
-        'user_id' => $user->id,
-        'name' => 'Nico',
-        'is_moderator' => false,
-    ]);
-});
-
-test('embedded access reuses the user player and applies a changed display name', function () {
-    $user = User::factory()->create();
-    $room = createEmbeddedRoom();
-    $player = $room->players()->create([
-        'user_id' => $user->id,
-        'name' => 'Old name',
-        'inactive_at' => now(),
-    ]);
-
-    $this->actingAs($user)
-        ->get(route('embedded.room', [
-            'join_code' => $room->join_code,
-            'player_name' => 'New name',
-        ]))
-        ->assertOk();
-
-    expect($room->players()->count())->toBe(1)
-        ->and($player->fresh()->name)->toBe('New name')
-        ->and($player->fresh()->inactive_at)->toBeNull();
-});
-
-test('embedded access shows a dedicated error when the display name is taken', function () {
-    $user = User::factory()->create();
-    $room = createEmbeddedRoom();
-    $room->players()->create(['name' => 'Nico']);
-
-    $this->actingAs($user)
-        ->get(route('embedded.room', [
-            'join_code' => $room->join_code,
-            'player_name' => 'Nico',
-        ]))
-        ->assertUnprocessable()
-        ->assertInertia(fn (Assert $page) => $page
-            ->component('embedded/Error')
-            ->where('message', 'Dieser Anzeigename ist in dem Raum bereits vorhanden.'));
-});
-
-test('embedded access shows a dedicated error for an unknown room code', function () {
-    $this->actingAs(User::factory()->create())
-        ->get(route('embedded.room', [
-            'join_code' => 'ABC234',
-            'player_name' => 'Nico',
-        ]))
-        ->assertUnprocessable()
-        ->assertInertia(fn (Assert $page) => $page
-            ->component('embedded/Error')
-            ->where('message', 'Dieser Raumcode existiert nicht.'));
-});
-
-test('embedded logout returns to the same configured room and signs the user out', function () {
-    $user = User::factory()->create();
-    $room = createEmbeddedRoom();
-
-    $this->actingAs($user)
-        ->post(route('embedded.logout', [
-            'join_code' => $room->join_code,
-            'player_name' => 'Nico',
-        ]))
-        ->assertRedirect(route('embedded.room', [
-            'join_code' => $room->join_code,
-            'player_name' => 'Nico',
-        ]));
-
-    $this->assertGuest();
-});

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,10 +61,9 @@ test('a participant can throw a realtime paper ball at another player', function
         ->and($room->state_version)->toBe($stateVersion);
 });
 
-test('moderator paper ball throws are not rate limited', function () {
-    Event::fake([PaperBallThrown::class]);
+test('paper ball charge percentages map to the expected level', function (int $chargePercentage, int $expectedLevel) {
     $room = createEmoteRoom();
-    $moderator = $room->players()->create([
+    $sender = $room->players()->create([
         'name' => 'Eric',
         'is_moderator' => true,
     ]);
@@ -70,46 +71,54 @@ test('moderator paper ball throws are not rate limited', function () {
         'name' => 'Anna',
         'is_moderator' => false,
     ]);
-
-    for ($throwCount = 0; $throwCount < 11; $throwCount++) {
-        $this->withSession(["room_players.{$room->id}" => $moderator->id])
-            ->postJson(route('room.emote.paper-ball.store', $room), [
-                'target_player_id' => $target->id,
-            ])
-            ->assertNoContent();
-    }
-
-    Event::assertDispatchedTimes(PaperBallThrown::class, 11);
-});
-
-test('participant paper ball throws remain rate limited', function () {
     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();
-    $moderator = $room->players()->create([
+    $sender = $room->players()->create([
         'name' => 'Eric',
         'is_moderator' => true,
     ]);
-    $participant = $room->players()->create([
+    $target = $room->players()->create([
         'name' => 'Anna',
         'is_moderator' => false,
     ]);
+    Event::fake([PaperBallThrown::class]);
 
-    for ($throwCount = 0; $throwCount < 10; $throwCount++) {
-        $this->withSession(["room_players.{$room->id}" => $participant->id])
-            ->postJson(route('room.emote.paper-ball.store', $room), [
-                'target_player_id' => $moderator->id,
-            ])
-            ->assertNoContent();
-    }
-
-    $this->withSession(["room_players.{$room->id}" => $participant->id])
+    $this->withSession(["room_players.{$room->id}" => $sender->id])
         ->postJson(route('room.emote.paper-ball.store', $room), [
-            'target_player_id' => $moderator->id,
+            'target_player_id' => $target->id,
+            'charge_percentage' => $chargePercentage,
         ])
-        ->assertTooManyRequests();
+        ->assertUnprocessable()
+        ->assertJsonValidationErrors('charge_percentage');
 
-    Event::assertDispatchedTimes(PaperBallThrown::class, 10);
-});
+    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]);

tests/Feature/RoomPlayerKickTest.php

@@ -1,155 +0,0 @@
-<?php
-
-use App\Enums\RoomStateChange;
-use App\Events\RoomStateChanged;
-use App\Models\Player;
-use App\Models\Room;
-use App\Models\User;
-use Illuminate\Support\Facades\Event;
-use Inertia\Testing\AssertableInertia as Assert;
-
-function createRoomForPlayerKick(User $owner, array $attributes = []): Room
-{
-    return Room::create([
-        'owner_id' => $owner->id,
-        'title' => 'Team Planning',
-        'current_round' => 1,
-        'deck_config' => [
-            'name' => 'Fibonacci',
-            'cards' => [
-                ['key' => '3', 'label' => '3'],
-                ['key' => '5', 'label' => '5'],
-            ],
-        ],
-        ...$attributes,
-    ]);
-}
-
-function addPlayerToKickRoom(
-    Room $room,
-    string $name,
-    ?User $user = null,
-    bool $isModerator = false,
-): Player {
-    return $room->players()->create([
-        'user_id' => $user?->id,
-        'name' => $name,
-        'is_moderator' => $isModerator,
-        'last_seen_at' => now(),
-    ]);
-}
-
-test('the room owner sees active room players on the dashboard', function () {
-    $owner = User::factory()->create();
-    $room = createRoomForPlayerKick($owner);
-    $moderator = addPlayerToKickRoom($room, 'Moderator', $owner, true);
-    $participant = addPlayerToKickRoom($room, 'Anna');
-    addPlayerToKickRoom($room, 'Inactive')->update(['inactive_at' => now()]);
-
-    $this->actingAs($owner)
-        ->get(route('dashboard'))
-        ->assertInertia(fn (Assert $page) => $page
-            ->has('rooms.0.players', 2)
-            ->where('rooms.0.players.0.id', $moderator->id)
-            ->where('rooms.0.players.0.is_moderator', true)
-            ->where('rooms.0.players.0.is_owner', true)
-            ->where('rooms.0.players.1.id', $participant->id)
-            ->where('rooms.0.players.1.is_moderator', false)
-            ->where('rooms.0.players.1.is_owner', false));
-});
-
-test('the room owner can kick an active participant', function () {
-    $owner = User::factory()->create();
-    $room = createRoomForPlayerKick($owner);
-    addPlayerToKickRoom($room, 'Moderator', $owner, true);
-    $participant = addPlayerToKickRoom($room, 'Anna');
-    $remainingPlayer = addPlayerToKickRoom($room, 'Ben');
-    $remainingPlayer->votes()->create([
-        'room_id' => $room->id,
-        'round' => $room->current_round,
-        'value' => '5',
-    ]);
-    $previousVersion = $room->fresh()->state_version;
-
-    Event::fake([RoomStateChanged::class]);
-
-    $this->actingAs($owner)
-        ->delete(route('room.player.destroy', [$room, $participant]))
-        ->assertRedirect();
-
-    expect($participant->fresh()->inactive_at)->not->toBeNull()
-        ->and($room->fresh()->state_version)->toBe($previousVersion + 1);
-
-    Event::assertDispatched(
-        RoomStateChanged::class,
-        function (RoomStateChanged $event) use ($participant, $remainingPlayer, $room): bool {
-            if (
-                $event->roomId !== $room->id
-                || $event->change !== RoomStateChange::PlayerKicked
-                || $event->affectedPlayerId !== $participant->id
-                || $event->state === null
-            ) {
-                return false;
-            }
-
-            $remainingPlayerState = collect($event->state['players'])
-                ->firstWhere('id', $remainingPlayer->id);
-
-            return collect($event->state['players'])->doesntContain('id', $participant->id)
-                && $remainingPlayerState['has_voted'] === true
-                && $remainingPlayerState['vote'] === null
-                && $event->broadcastWith()['affected_player_id'] === $participant->id;
-        },
-    );
-    Event::assertDispatchedTimes(RoomStateChanged::class, 1);
-});
-
-test('a participant cannot kick another player', function () {
-    $owner = User::factory()->create();
-    $participantUser = User::factory()->create();
-    $room = createRoomForPlayerKick($owner);
-    addPlayerToKickRoom($room, 'Moderator', $owner, true);
-    addPlayerToKickRoom($room, 'Anna', $participantUser);
-    $target = addPlayerToKickRoom($room, 'Ben');
-
-    Event::fake([RoomStateChanged::class]);
-
-    $this->actingAs($participantUser)
-        ->delete(route('room.player.destroy', [$room, $target]))
-        ->assertForbidden();
-
-    expect($target->fresh()->inactive_at)->toBeNull();
-    Event::assertNotDispatched(RoomStateChanged::class);
-});
-
-test('the room owner cannot kick their own player', function () {
-    $owner = User::factory()->create();
-    $room = createRoomForPlayerKick($owner);
-    $moderator = addPlayerToKickRoom($room, 'Moderator', $owner, true);
-
-    Event::fake([RoomStateChanged::class]);
-
-    $this->actingAs($owner)
-        ->delete(route('room.player.destroy', [$room, $moderator]))
-        ->assertForbidden();
-
-    expect($moderator->fresh()->inactive_at)->toBeNull();
-    Event::assertNotDispatched(RoomStateChanged::class);
-});
-
-test('the room owner cannot kick a player from another room', function () {
-    $owner = User::factory()->create();
-    $otherOwner = User::factory()->create();
-    $room = createRoomForPlayerKick($owner);
-    $otherRoom = createRoomForPlayerKick($otherOwner, ['title' => 'Other room']);
-    $target = addPlayerToKickRoom($otherRoom, 'Anna');
-
-    Event::fake([RoomStateChanged::class]);
-
-    $this->actingAs($owner)
-        ->delete(route('room.player.destroy', [$room, $target]))
-        ->assertForbidden();
-
-    expect($target->fresh()->inactive_at)->toBeNull();
-    Event::assertNotDispatched(RoomStateChanged::class);
-});

tests/Feature/RoomSettingsTest.php

@@ -1,158 +0,0 @@
-<?php
-
-use App\Enums\RoomStateChange;
-use App\Events\RoomStateChanged;
-use App\Jobs\CloseInactiveRooms;
-use App\Models\Room;
-use App\Models\User;
-use Illuminate\Support\Facades\Event;
-use Inertia\Testing\AssertableInertia as Assert;
-
-function createSettingsRoom(array $attributes = []): Room
-{
-    return Room::create([
-        'title' => 'Teamraum',
-        'deck_config' => [
-            'name' => 'Fibonacci',
-            'cards' => [
-                ['key' => '3', 'label' => '3'],
-                ['key' => '5', 'label' => '5'],
-            ],
-        ],
-        ...$attributes,
-    ]);
-}
-
-test('room settings default to moderator control and normal retention', function () {
-    $room = createSettingsRoom();
-
-    expect($room->allow_participants_to_manage_rounds)->toBeFalse()
-        ->and($room->is_persistent)->toBeFalse();
-});
-
-test('the owner can view and update room settings', function () {
-    $owner = User::factory()->create();
-    $room = createSettingsRoom(['owner_id' => $owner->id]);
-
-    $this->actingAs($owner)
-        ->get(route('room.settings.edit', $room))
-        ->assertInertia(fn (Assert $page) => $page
-            ->component('rooms/Settings')
-            ->where('room.id', $room->id)
-            ->where('room.allow_participants_to_manage_rounds', false)
-            ->where('room.is_persistent', false));
-
-    Event::fake();
-
-    $this->actingAs($owner)
-        ->patch(route('room.settings.update', $room), [
-            'allow_participants_to_manage_rounds' => true,
-            'is_persistent' => true,
-        ])
-        ->assertRedirect();
-
-    $room->refresh();
-
-    expect($room->allow_participants_to_manage_rounds)->toBeTrue()
-        ->and($room->is_persistent)->toBeTrue()
-        ->and($room->state_version)->toBe(2);
-
-    Event::assertDispatched(
-        RoomStateChanged::class,
-        fn (RoomStateChanged $event): bool => $event->change === RoomStateChange::RoomSettingsUpdated
-            && $event->state['allow_participants_to_manage_rounds'] === true,
-    );
-});
-
-test('a user who does not own a room cannot manage its settings', function () {
-    $owner = User::factory()->create();
-    $otherUser = User::factory()->create();
-    $room = createSettingsRoom(['owner_id' => $owner->id]);
-
-    $this->actingAs($otherUser)
-        ->get(route('room.settings.edit', $room))
-        ->assertForbidden();
-
-    $this->actingAs($otherUser)
-        ->patch(route('room.settings.update', $room), [
-            'allow_participants_to_manage_rounds' => true,
-            'is_persistent' => true,
-        ])
-        ->assertForbidden();
-
-    expect($room->fresh()->allow_participants_to_manage_rounds)->toBeFalse();
-});
-
-test('all active participants can manage rounds when the room setting is enabled', function () {
-    $room = createSettingsRoom(['allow_participants_to_manage_rounds' => true]);
-    $player = $room->players()->create([
-        'name' => 'Anna',
-        'is_moderator' => false,
-    ]);
-
-    $this->withSession(["room_players.{$room->id}" => $player->id])
-        ->post(route('room.reveal', $room))
-        ->assertNoContent();
-
-    expect($room->fresh()->revealed_at)->not->toBeNull();
-});
-
-test('normal participants remain unable to manage rounds when the setting is disabled', function () {
-    $room = createSettingsRoom();
-    $player = $room->players()->create([
-        'name' => 'Anna',
-        'is_moderator' => false,
-    ]);
-
-    $this->withSession(["room_players.{$room->id}" => $player->id])
-        ->post(route('room.reveal', $room))
-        ->assertForbidden();
-});
-
-test('persistent rooms are excluded from automatic closing', function () {
-    $persistentRoom = createSettingsRoom([
-        'owner_id' => User::factory()->create()->id,
-        'is_persistent' => true,
-        'last_activity_at' => now()->subDays(60),
-    ]);
-    $expiringRoom = createSettingsRoom([
-        'owner_id' => User::factory()->create()->id,
-        'last_activity_at' => now()->subDays(60),
-    ]);
-
-    (new CloseInactiveRooms)->handle();
-
-    expect($persistentRoom->fresh()->closed_at)->toBeNull()
-        ->and($expiringRoom->fresh()->closed_at)->not->toBeNull();
-});
-
-test('room settings broadcasts never expose hidden vote values', function () {
-    $owner = User::factory()->create();
-    $room = createSettingsRoom(['owner_id' => $owner->id]);
-    $player = $room->players()->create([
-        'name' => 'Anna',
-        'is_moderator' => false,
-    ]);
-    $player->votes()->create([
-        'room_id' => $room->id,
-        'round' => 1,
-        'value' => '5',
-    ]);
-
-    Event::fake();
-
-    $this->actingAs($owner)->patch(route('room.settings.update', $room), [
-        'allow_participants_to_manage_rounds' => true,
-        'is_persistent' => false,
-    ]);
-
-    Event::assertDispatched(
-        RoomStateChanged::class,
-        function (RoomStateChanged $event) use ($player): bool {
-            $broadcastPlayer = collect($event->state['players'])->firstWhere('id', $player->id);
-
-            return $broadcastPlayer['has_voted'] === true
-                && $broadcastPlayer['vote'] === null;
-        },
-    );
-});