mchekin/rpg

This system is a browser-based multiplayer role-playing game engine built on Laravel 8, featuring a domain-driven architecture for managing characters, combat, and inventory. It supports core RPG mechanics including turn-based battles, character progression, and equipment management, alongside player-run store trading and real-time messaging. The application provides a full-stack interface with Vue.js components for inventory and store management, backed by a structured data layer for persistent game state.

22 changes.

The codebase underwent a major framework upgrade to Laravel 8, modernizing the build tooling, middleware, and configuration while removing legacy artifacts. This technical foundation enabled the introduction of new game systems, including character management, battles, and inventory, supported by updated database schemas and controllers.

26 changes.

The project underwent a significant modernization by upgrading to Laravel 8 and refactoring the codebase to use domain-driven design principles, including new repositories, factories, and view composers. This period also introduced comprehensive test coverage and front-end enhancements with Vue.js and SASS, while adding new features for battles, messaging, and character inventory management.

25 changes.

This period focused on implementing a domain-driven architecture for the Character, Equipment, and Trade modules, introducing comprehensive domain models, services, and command patterns. It also established the foundational infrastructure for player-run shops and inventory management, supported by Dockerized development and testing environments.

5 changes.

This period focused on implementing a player-driven economy by adding API endpoints and services for inventory, store management, and trading. The work also included migrating Eloquent models to a standardized namespace and expanding database seeding to support the new game mechanics and the Voyager admin panel.

New Blade templates have been added for the 'own store' and 'store trade' endpoints. These views render Vue components (\\<store-management\>\ and \\<store-trade\>\) that handle the user interface for managing a player's store and trading with vendor NPCs, respectively.

resources/views/trade · medium confidence

A new page has been added to display a paginated list of a character's battles. Each entry shows the date, the attacker and defender characters, and the outcome (victory or loss).

resources/views/character/battle · high confidence

Users can now view a detailed breakdown of a specific battle, including the attacker, defender, and victor, along with a round-by-round battle log that displays misses, hits, critical hits, and damage absorption. Additionally, a new empty state view is displayed when no battles are found.

resources/views/battle · high confidence

The UI layer now includes dedicated command mappers for buying, selling, moving items and money between containers, and changing item prices. These new mappers translate HTTP requests into domain commands, enabling the frontend to interact with the trade system's backend logic.

app/Modules/Trade/UI · high confidence

A new home page (index.blade.php) has been added to the application. It displays the application name and a village image, along with buttons to navigate to the register and login routes.

resources/views/pages · high confidence

The application now includes the Blade templates for the password reset flow. Specifically, \resources/views/auth/passwords/email.blade.php\ and \resources/views/auth/passwords/reset.blade.php\ have been added. These views provide the user interface for requesting a password reset link and for entering a new password, completing the authentication scaffolding.

resources/views/auth/passwords · high confidence

The frontend now supports full client-side management of inventory and character stores. Users can drag and drop items between their inventory and store slots, as well as move money between the two. A new popup modal allows users to view item details, edit the sell price for items in their inventory, and see the store's buy price. The interface also displays the store type (e.g., 'Sell Only') and provides success/error flash messages for trades and store management actions.

resources/js/components · high confidence

The database migrations have been updated to support new game features and structural changes. This includes the creation of tables for locations, races, characters, battles, battle rounds, and battle turns, establishing the data model for the game world and combat system. Additionally, new tables for messages, images, items, inventories, and stores have been added to support player interaction, equipment management, and trading. The users table was also modified to include email verification and role relationships.

database/migrations · high confidence

The PHP container image now includes Node.js, Yarn, and Xdebug for local development. The container automatically runs application initialization scripts, including Composer install, Artisan commands, and Xdebug configuration, to streamline the local development workflow.

docker/php · high confidence

The Battle module now includes a full domain model for managing combat rounds and turns, including the \Battle\, \BattleRound\, \BattleTurn\, and \BattleTurnResult\ classes. These models encapsulate the logic for executing combat rounds, calculating damage, and determining critical hits. A corresponding \BattleRepositoryInterface\ and its \BattleRepository\ implementation have been added to handle persistence of battle data.

app/Modules/Battle · high confidence

Added new services to support a player-run store system. CreateStoreService allows characters to create sell-only stores. ManageStoreService enables players to move items and money between their inventory and their store, and to set item prices. TradeService implements the actual buy and sell logic, including a 75% prototype price cap for NPC vendors (though the cap logic is present in the diff, the primary new feature is the player store interaction).

app/Modules/Trade/Application/Services · high confidence

The system now persists and reconstructs equipment-related domain objects using new infrastructure classes. Specifically, the \InventoryRepository\ and \ItemRepository\ have been implemented to handle the storage and retrieval of \Inventory\ and \Item\ domain entities, utilizing new \ReconstitutionFactory\ classes to map database models to domain objects. This change introduces the underlying data access layer for managing character inventories, item prototypes, and individual items, supporting the broader equipment management feature.

app/Modules/Equipment/Infrastructure · high confidence

A new CharacterService has been added to handle key character actions including creation, attribute increases, movement, and combat. The service integrates with existing repositories and services (LevelService, InventoryService, CreateStoreService) to manage character state, update profiles, and process battle outcomes.

app/Modules/Character/Application/Services · high confidence

Added the Store domain entity and its infrastructure components, including the StoreReconstitutionFactory and StoreRepository. This enables the system to persist and retrieve store data, including associated items and money, supporting the new store functionality.

app/Modules/Trade/Infrastructure · high confidence

A new Store domain model has been added to the Trade module, providing a structured way to manage shop inventories and associated funds. The Store class manages a fixed set of 24 slots for items, allowing players to add, remove, and query items within the shop's inventory. It also tracks the store's monetary balance, supporting operations to deposit and withdraw money. Additionally, the model enforces business rules by preventing non-buying (sell-only) stores from processing buy-back transactions, throwing a StoreDoesNotBuyItems exception in such cases.

app/Modules/Trade/Domain · high confidence

The Equipment module's domain layer now includes a comprehensive set of domain classes to manage player inventories and items. The new \Inventory\ class handles the storage of items and associated money, enforcing a 24-slot capacity and ensuring only valid \InventoryItem\ instances are stored. \InventoryItem\ wraps base \Item\ objects with a status (equipped or in backpack), while \Item\ itself now carries a price and effects. The \Money\ class manages currency operations, and supporting types like \ItemStatus\, \ItemType\, and \ItemEffect\ define the structure of items and their attributes. This refactoring centralizes inventory logic, allowing for features like drag-and-drop management and price adjustments within the equipment module.

app/Modules/Equipment/Domain · high confidence

The application now supports a new messaging feature, allowing users to view and interact with messages. The update adds a main inbox view that lists messages, displaying them in a conversation format that distinguishes between the user's own messages and those from others. It also includes partials for rendering individual message cards and content, as well as a state for when no messages are present. Additionally, the diff introduces several new pagination view templates (Bootstrap 4, default, Semantic UI, and simple variants) to handle navigation across message pages.

resources/views/message · high confidence

Added new application services to handle equipment and item operations. InventoryService now manages inventory creation, equipping, and unequipping of items. ItemService handles the creation of new items, including database transactions and repository interactions.

app/Modules/Equipment/Application/Services · medium confidence

Adds new command objects to handle trade-related actions: creating a store, adding items to a store, buying and selling items, changing item prices, and moving items or money between containers. Also introduces the StoreRepositoryInterface to manage store data persistence. These changes support the underlying mechanics for player-run shops and inventory management.

app/Modules/Trade/Application/Commands · high confidence

The Character module's domain layer now includes new value objects and entities: an Attributes class managing stat points, a Statistics class tracking battle outcomes, and a Reputation object. The core Character entity is expanded to include a CharacterType (supporting player, merchant, civilian, and monster roles), alongside identity (CharacterId), name, gender, race, and hit point management. These changes provide a structured, object-oriented foundation for character creation, attribute allocation, and combat calculations.

app/Modules/Character/Domain · high confidence

The application now supports four new character commands: Attack, Create, IncreaseAttribute, and Move. These commands encapsulate the necessary data for initiating combat, creating new characters, increasing character attributes, and moving characters between locations, respectively.

app/Modules/Character/Application/Commands · high confidence

The application now includes a suite of new controllers—BattleController, CharacterBattleController, CharacterController, CharacterMessageController, CharacterStoreController, InventoryController, ItemCreateController, LocationController, MessageController, OwnStoreController, and ProfilePictureController—each handling specific user-facing actions such as viewing or initiating battles, managing character attributes and movement, sending and receiving messages, buying/selling in stores, equipping or unequipping items, creating new items (admin), viewing locations, and uploading or deleting profile pictures. These controllers implement the HTTP layer for these features, delegating to corresponding services and command mappers, and are protected by middleware for authentication, character ownership, and location access.

app/Http/Controllers · high confidence

The Image module now uses a domain-driven structure with dedicated classes for image metadata (Image, ImageFile, ImageId) and application commands (AddImageCommand). The ProfilePictureService orchestrates uploading, resizing, and storing images in three sizes (full, small, icon) via the new ImageRepository, which handles file system operations and database persistence. This replaces previous ad-hoc upload logic with a more robust, modular approach to managing character profile pictures.

app/Modules/Image · high confidence

A new CharacterFactory class has been added to the application layer to handle the creation of Character objects. This factory encapsulates the logic for initializing a character with specific attributes, statistics, hit points, and an inventory, ensuring that new characters are instantiated with consistent default values and structure.

app/Modules/Character/Application/Factories · high confidence

The application now exposes new API controllers to handle player inventory and store management. ManageInventoryController provides endpoints to equip and un-equip items. ManageStoreController allows moving items and money between a player's inventory and a store's inventory. TradeController adds endpoints to buy and sell items from the store.

app/Http/Controllers/Api · high confidence

The application now includes new Blade templates for the login and registration forms, which are styled with Bootstrap 4 grid and card components. Additionally, a new email template for password reset links has been added to support the password recovery workflow.

resources/views/auth · high confidence

Added a new 'increment\_attribute\_button' component that renders a '+1' button for spending free points, and a 'short\_character\_description' component that displays a character's name and race. These components support the new character management and progression features.

resources/views/components · high confidence

The character creation interface now features interactive carousels for selecting race and gender, displaying race statistics and images. The character profile page has been restructured to display character details, equipment, and statistics in a two-column layout.

resources/views/character · high confidence

The character page now features dedicated partials for displaying and managing character state. Users can view and update their attributes (Strength, Agility, etc.) and see their general stats (Race, Level, XP, Reputation, Money). A new profile picture upload and delete form is available for the player's own character. The interface includes a visual representation of the character's health points. Crucially, the UI now supports managing equipment (head, body armor, main hand, off-hand) and a 10-slot inventory system where items can be equipped or unequipped. For other characters, the page displays their profile picture, attributes, and provides action buttons for messaging, attacking, and trading.

resources/views/character/partials · high confidence

Added three new JavaScript files to handle specific user interactions: \character-create.js\ manages the race and gender selection carousels for character creation; \character-update.js\ handles clicking on attribute increments to populate a hidden input; and \vcountdown.js\ provides a reusable component that enforces a character limit on text inputs and displays a remaining character count, highlighting a warning state when the limit is near.

public/js · high confidence

A new Blade template for the location show page has been added, providing a structured view that displays the location's name, description, and image, alongside a list of characters currently present at that location.

resources/views/location · high confidence

Added two new Blade templates to the location view layer: a directional navigator that renders movement buttons for adjacent map locations (north, south, east, west), and a character list partial that displays online/offline status, gender badges, and action buttons (message, trade, attack) for each character in the current location.

resources/views/location/partials · high confidence

A new view for the messaging system has been added, allowing users to send and view conversations with a specific character. The page features a text area for composing messages, a send button, and a paginated list of previous messages that distinguishes between the user's own messages and those from the character using separate partials. A JavaScript countdown is also included to enforce character limits on input.

resources/views/character/message · high confidence

The application now includes dedicated Blade partials for the main navigation bar and flash messages. The navbar provides context-aware links for authenticated users, including navigation to their character profile, location, messages, and battles, with unread counts displayed as badges. It also includes an admin link for users with browse\_admin permissions, a logout form, and login/register links for guests. The flash-messages component renders validation errors and session status messages as JSON for frontend consumption.

resources/views/partials · high confidence

Added three new PHP traits to the application: GeneratesUuid, which provides a method to generate UUIDs using the Ramsey library; UsesStringId, which configures models to use string keys instead of integers; and ThrowsDice, which adds methods for simulating dice rolls (one, two, or three dice).

app/Traits · high confidence

The database seeding process has been significantly expanded to support new game features and the Voyager admin panel. A new CharacterSeeder was added to generate NPC characters and player data, integrating with the new domain models. Additionally, a suite of new seeders (DataTypes, DataRows, Menus, Permissions, Roles, Settings, Translations) were introduced to initialize the Voyager admin panel's configuration, menus, and permissions. The main DatabaseSeeder was updated to call these new seeders, ensuring the application starts with the necessary admin and game data.

database/seeders · high confidence

A new Blade template at resources/views/character/inventory/index.blade.php renders the character inventory interface. The page splits the layout into two columns: the left column renders an \<inventory-management\> Vue component (passing the character and its loaded items), while the right column includes existing partials for general info, attributes, and statistics. This introduces a client-side inventory management view, though the backend integration is not yet complete.

resources/views/character/inventory · medium confidence

The application's Docker setup now includes specific configuration files for the MySQL and Nginx services. For MySQL, a new \my.cnf\ file enables the general query log, directing output to \/var/lib/mysql/general.log\. For Nginx, a new \app.conf\ file defines the server block to listen on port 80, serve PHP files via FastCGI to the \app\ container, and handle static file caching. These changes provide explicit configuration for the database and web server components within the Docker environment.

docker/mysql, docker/nginx · low confidence

The cron service is now containerized with a dedicated Dockerfile that installs PHP 7.4 CLI, required extensions, and the cron daemon. A new cron schedule file is added to /etc/cron.d/scheduler, which runs the Laravel scheduler every minute. The cron process is configured to log to stdout and stderr (file descriptors 1 and 2) rather than writing to a file, facilitating better log aggregation in a Docker environment.

docker/cron · high confidence

A new exception class, SellPriceIsTooHigh, has been introduced in the Trade module's domain layer. This change supports the enforcement of a rule where merchant NPCs will only purchase items for no more than 75% of the prototype price, ensuring that selling prices are validated against this threshold.

app/Modules/Trade/Domain/Exception · medium confidence

The application now provides a more user-friendly error message when a file upload exceeds the configured size limit. The \Handler\ class was updated to catch \PostTooLargeException\ and return a back response with a specific error message indicating the maximum allowed file size in kilobytes. Additionally, a new helper file \app/Support/helpers.php\ was added to provide utility functions for converting between bytes, kilobytes, and megabytes, which are used by the exception handler to calculate the maximum upload size.

app/Exceptions · high confidence

The front-end build process has been updated to use NPM for generating JavaScript and CSS files. A new Vue.js application entry point (app.js) has been introduced, registering several new Vue components including popup-modal, inventory-management, store-management, store-trade, and flash-messages. The bootstrap.js file has been added to configure Axios for HTTP requests and set up CSRF token handling, while also integrating jQuery, Bootstrap, and Popper.js.

resources/js · high confidence

A new CharacterReconstitutionFactory has been added to map Eloquent CharacterModel instances to the domain Character entity. This factory handles the conversion of character attributes, statistics, hit points, and inventory, ensuring that the domain model is correctly populated from the database layer.

app/Modules/Character/Infrastructure/ReconstitutionFactories · medium confidence

A new base layout template (base.blade.php) is introduced, providing a common HTML structure that includes the navbar, flash messages, and application scripts. Existing standalone views, such as the default welcome page and the 503 maintenance mode error page, are removed or refactored to extend this new base template, ensuring consistent styling and script loading across the application.

resources/views · high confidence

Added new command mapper classes for the Equipment module's UI layer, specifically for adding items to inventory, creating items, and equipping items. Each mapper translates HTTP requests into corresponding domain commands, extracting user and item identifiers to facilitate the application's command pattern.

app/Modules/Equipment/UI · medium confidence

New repository interfaces have been added to the application layer to define contracts for data access. CharacterRepositoryInterface defines methods for managing Character entities and their IDs, LocationRepositoryInterface handles LocationId generation, and RaceRepositoryInterface provides a method to retrieve Race entities by ID. These interfaces establish the abstraction layer for data operations within the Character module.

app/Modules/Character/Application/Contracts · high confidence

Added three new repository interfaces—InventoryRepositoryInterface, ItemPrototypeRepositoryInterface, and ItemRepositoryInterface—within the Equipment module's application contracts. These interfaces define the data access layer for managing inventory, item prototypes, and individual items, each providing methods for identity generation, retrieval, addition, and updates.

app/Modules/Equipment/Application/Contracts · high confidence

A new ItemFactory class has been added to the Equipment module's application layer. This factory encapsulates the logic for instantiating Item objects, taking an ItemId, ItemPrototype, and the creator's CharacterId as inputs. This change supports the broader refactoring of the Equipment module by centralizing Item creation.

app/Modules/Equipment/Application/Factories · high confidence

The application now uses specific FormRequest classes to validate incoming data for creating characters, items, and updating character attributes, as well as for uploading images. Each request class defines its own set of validation rules (e.g., name uniqueness, gender/race constraints, attribute values, and image file constraints). The generic base Request class has been removed, indicating a move towards more granular, feature-specific validation logic.

app/Http/Requests · high confidence

The application now uses dedicated repository classes to handle data persistence and retrieval for characters, locations, and races. The CharacterRepository manages character creation, updates, and retrieval using Eloquent models and a reconstitution factory, while the LocationRepository and RaceRepository provide similar infrastructure for their respective domains. This change shifts the data access layer to be more structured around domain concepts, improving separation of concerns and making it easier to manage character-related data operations.

app/Modules/Character/Infrastructure/Repositories · high confidence

Adds a new \BaseId\ class for managing unique identifiers and a \Container\ abstract class to manage collections of items. The update also introduces a \ContainerType\ enum-like class that distinguishes between 'inventory' and 'store' containers, alongside several new exception classes (e.g., \ContainerIsFullException\, \InvalidMoneyValue\) to handle specific container state errors.

app/Modules/Generic · high confidence

The application has been upgraded to Laravel 8, which includes updating the route files to match the new framework conventions. The web routes in routes/web.php have been reorganized to use closures for simple routes and resource controllers for complex ones, including new endpoints for character, inventory, store, and battle management. The API routes in routes/api.php have been moved to a dedicated file and namespaced under 'Api', with middleware applied to protect them. Additionally, the old app/Http/routes.php file was renamed to routes/channels.php to handle broadcast channels, reflecting the separation of concerns in the new structure.

routes · high confidence

All Eloquent models, including Battle, BattleRound, BattleTurn, Character, Image, Inventory, Item, ItemPrototype, Location, Message, Race, Store, and User, have been moved into the App\\Models namespace. This change organizes the codebase by grouping all model classes under a single, consistent directory structure, which simplifies autoloading and improves code discoverability for developers working with the application's data layer.

app/Models · high confidence

The project has been upgraded from Laravel 5 to Laravel 8, which includes replacing the deprecated Gulp/Elixir asset pipeline with Laravel Mix (webpack.mix.js) and updating the PHPUnit configuration to use the modern XML schema and directory structure. Additionally, the development environment has shifted from Vagrant/Homestead to a Docker-based setup, introducing a docker-compose.yml and related configuration files (.env.docker.example, .editorconfig) to standardize cross-platform line endings and containerized services.

(repo-wide) · high confidence

The authentication controllers in app/Http/Controllers/Auth have been refactored to use Laravel's built-in authentication traits (such as AuthenticatesUsers, RegistersUsers, and ResetsPasswords) rather than custom implementations. The RegisterController now accepts UserService and CreateUserCommandMapper dependencies, and validation rules for password length have been updated. This change simplifies the codebase by leveraging framework features instead of maintaining custom logic.

app/Http/Controllers/Auth · high confidence

The application's service providers have been updated to align with Laravel 8+ conventions, including removing unnecessary type-hinted parameters from the boot methods in AuthServiceProvider and EventServiceProvider. The RouteServiceProvider now explicitly defines API and web route groups with modern rate-limiting configuration. Additionally, AppServiceProvider has been expanded to register a comprehensive set of repository interfaces for the new domain-centric architecture, covering modules for battles, characters, equipment, images, messages, and stores.

app/Providers · high confidence

Added new SASS files (\_variables.scss, app.scss, custom.scss) that define color palettes, typography, and custom styles for the application's UI. This includes styling for carousels, character attribute tables, message lists, profile pictures, and online/offline status indicators, ensuring consistent visual presentation across the interface.

resources/sass · high confidence

The application now uses dedicated command mapper classes to translate HTTP requests into domain commands for character operations. New mappers have been introduced for attacking, creating, increasing attributes, and moving characters, each handling the conversion of request data into specific command objects.

app/Modules/Character/UI · high confidence

The application layer for the Equipment module now introduces four new command objects to handle specific equipment actions: creating an inventory for a character, creating a new item from a prototype, adding an item to a character's inventory, and equipping an item. Each command encapsulates the necessary identifiers (CharacterId, ItemId, ItemPrototypeId) to process these distinct equipment-related behaviors.

app/Modules/Equipment/Application/Commands · medium confidence

Added new view composers (BattlesComposer, CharacterGeneralInfoComposer, CharacterMessagesComposer, MessagesComposer) that fetch and pass data to the corresponding views. The battles composer retrieves a character's battles, the character info composer provides level data via a service, and the messaging composers handle message retrieval and read-status updates for both individual and inbox views.

app/Http/ViewComposers · high confidence

The application has removed several legacy files associated with older Laravel versions. Specifically, the manual class autoloading script (bootstrap/autoload.php) and the SASS asset file (resources/assets/sass/app.scss) have been deleted. Additionally, empty placeholder files (.gitkeep) in the Listeners, Policies, and database seeds directories have been removed, indicating a cleanup of unused or deprecated project structure elements.

(repo-wide) · high confidence

The app/User.php file has been deleted, removing the legacy User model that previously handled authentication, authorization, and password reset capabilities via Laravel's built-in traits. This change eliminates the standard user entity from the application's domain model.

app · high confidence

The application's console scheduling has been updated to remove the hourly 'inspire' command and instead run a scheduled task every minute that increments the hit points of wounded characters. This change introduces a new automated behavior where characters regain one hit point per minute, replacing the previous functionality that displayed an inspiring quote.

app/Console · high confidence

The user module has been refactored to adopt a cleaner architecture, introducing a CreateUserCommand to encapsulate user creation data, a UserService to handle the actual creation logic, and a command mapper to transform HTTP requests into commands. This change reorganizes how user data is processed, separating concerns between the UI, application, and domain layers.

app/Modules/User · high confidence

The English language files in resources/lang/en have been updated to align with Laravel 8. This includes adding a new 'password' error message in auth.php, updating the 'passwords' file with a 'throttled' key and revised text, and significantly expanding the validation.php file with new validation rules (such as 'multiple\_of', 'prohibited', 'uploaded', 'uuid') and updated error messages to match the latest framework standards.

resources/lang · high confidence

The application's HTTP kernel has been upgraded to align with newer Laravel versions, replacing deprecated global middleware like CheckForMaintenanceMode with PreventRequestsDuringMaintenance and ValidatePostSize. The global middleware stack now includes TrustProxies and HandleCors, while the route middleware list has been expanded to include standard Laravel guards (cache.headers, can, password.confirm, signed, throttle, verified) and several custom character-related middleware (character.location, has.character, can.move.to.location, can.attack, no.character, owns.character, is.admin).

app/Http · high confidence

The application's HTTP middleware layer has been refactored to align with modern Laravel standards. Several new middleware classes were introduced to enforce game-specific rules: CanAttack and UserOwnsCharacter validate that a user can only interact with their own character or perform attacks under specific conditions; HasCharacter and NoCharacterYet control access based on whether a user has an active character; IsCharacterLocation and CanMoveToLocation ensure users are in the correct location to perform actions; and IsAdmin restricts certain areas to administrators. Additionally, existing middleware was updated: Authenticate now extends the base Laravel class and redirects to the 'login' route; EncryptCookies and TrustProxies were updated to extend their respective base classes; RedirectIfAuthenticated was refactored to use the Auth facade and RouteServiceProvider; and VerifyCsrfToken was updated to catch TokenMismatchException and return a friendly 'Session have expired' error message instead of a generic exception.

app/Http/Middleware · high confidence

The application's configuration files have been updated to reflect changes in the underlying framework. This includes adding new configuration files for CORS, hashing, logging, and image processing, while removing the deprecated \compile.php\ file. The \app.php\ configuration has been updated with new properties like \name\, \env\, and \asset\_url\, and service providers have been adjusted to include notifications and view composers. Authentication is now configured using guards and providers rather than a single driver. Additionally, the \session.php\ file has been enhanced with security improvements such as HTTP-only cookies and same-site attributes, and the \database.php\ file now supports environment-based URLs and stricter MySQL settings.

config · high confidence

The public/index.php entry point was refactored to align with Laravel 8's new structure, including the use of the tap() helper and updated autoloading. Additionally, a new web.config file was added to support URL rewriting on IIS, and the .htaccess file was updated to handle authorization headers and trailing slash redirects.

public · medium confidence

Added Laravel Dusk browser tests; Added database factories for generating test data for Users, Characters, and Items; Added feature tests for character attacks and creation; Added test infrastructure for Laravel Dusk and application bootstrapping; Added unit tests for Level module; Added unit tests for the Inventory domain class; Added unit tests for the ItemService; Updated unit test for Laravel 8 compatibility.

The application has been upgraded to Laravel 8, requiring PHP 7.3+ and introducing modern build tooling with Laravel Mix and Vue.js. This update replaces the older Gulp and Laravel Elixir setup with a more robust asset compilation pipeline, adding dependencies for Vue, Bootstrap, and FontAwesome while updating core framework and package dependencies.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 36 → 37 (+1.2)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 36 → 43 (+7.0)
• Architecture 100 → 86 (-13.8)
• Maturity 42 → 42 (+0.0)
• Readiness 20 → 23 (+2.7)
• Security 74 → 77 (+3.0)
• Accessibility 80 → 58 (-22.4)

• Change coupling: index.blade.php ↔ navbar.blade.php (resources/views/pages/index.blade.php)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (composer.lock)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (composer.lock)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical vulnerability: [GHSA redacted] (package-lock.json)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (12 lines × 2) (database/migrations/2019_08_31_182034_create_items_table.php)
• Duplicated block (13 lines × 2) (app/Modules/Equipment/Domain/Inventory.php)
• Duplicated block (6 lines × 2) (database/migrations/2020_02_29_205957_create_inventory_item.php)
• Duplicated block (7 lines × 2) (database/seeders/TranslationsTableSeeder.php)
• Duplicated block (7 lines × 3) (database/migrations/2017_05_16_144929_create_battles_table.php)
• …and 47 more

• Abandoned package: fruitcake/laravel-cors
• Abandoned package: tcg/voyager
• Change coupling: UserFactory.php ↔ CharacterSeeder.php (database/factories/UserFactory.php)
• Coverage not measured — no coverage collector is wired up
• Critical CVE: [GHSA redacted] (composer.lock)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (composer.lock)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical CVE: [GHSA redacted] (package-lock.json)
• Critical vulnerability: [GHSA redacted] (package-lock.json)
• Duplicated block (10 lines × 2) (database/migrations/2019_08_31_182034_create_items_table.php)
• Duplicated block (13 lines × 2) (app/Modules/Equipment/Domain/Inventory.php)
• Duplicated block (18 lines × 2) (app/Modules/Equipment/Application/Commands/AddItemToInventoryCommand.php)
• Duplicated block (18 lines × 2) (app/Modules/Trade/Application/Commands/BuyItemCommand.php)
• …and 102 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

mchekin/rpg was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.