patsonluk/airline

This system is a complex airline management simulation game, comprising a backend simulation engine, a REST API, and a web frontend. It models detailed economic and operational aspects of running an airline, including fleet lifecycle management, fuel procurement, airport asset development, and alliance missions. The platform supports real-time interaction through WebSocket updates, features event-driven gameplay mechanics like the Olympics and seasonal campaigns, and includes social features such as real-time chat and user account management.

24 changes.

The project established a modular architecture by splitting functionality into distinct airline-web, airline-data, and airline-rest modules, underpinned by a comprehensive rewrite of the simulation engine and data models. Significant effort was directed toward building the web interface with modern UI themes, account management features, and a robust WebSocket system for real-time cycle updates. The period also involved setting up the backend infrastructure, including remote actor communication, database persistence layers, and extensive unit testing for the new economic and operational logic.

15 changes.

This period focused on expanding the airline simulation with complex new mechanics, including oil fuel procurement, caching layers, and seasonal events like the Olympics and Santa Claus. The backend was strengthened with database schema migrations and data patching to support these features, while the frontend received enhancements such as real-time websocket chat, emoji support, and image lazy loading.

7 changes.

This period focused on implementing comprehensive new features for version 2.2, including a structured tutorial system, user notifications, and alliance mission simulations. The underlying data models were significantly expanded to support these features, introducing new entities for tutorials, animations, and alliance stats. Concurrently, the database schema was restructured to improve financial tracking accuracy and introduce new tables for airport champion bonuses.

The airline-web application now includes the FusionCharts JavaScript library files (fusioncharts-jquery-plugin.js and fusioncharts.charts.js) in the public/fusioncharts directory. These files provide the underlying charting engine and jQuery integration required to render various chart types (such as column, bar, area, line, pie, and doughnut charts) within the application's user interface.

airline-web/public/fusioncharts · high confidence

The airline-web application now includes the 'Treviso' UI template, adding a new visual layer for the user interface. This change introduces a complete set of static assets including the main stylesheet (style.css), a custom icon font (dripicons), and the base HTML structure (index.html) along with its associated JavaScript (custom.js). For the user, this provides the foundational styling and layout components for the web interface, utilizing the Open Sans font family and a specific icon set for navigation and UI elements.

airline-web/public/css-templates · high confidence

A new Tutorial case class has been introduced in the airline-data module to represent tutorial entities, storing a category and an ID.

airline-data/src/main/scala/com/patson/model/tutorial · high confidence

Introduced the AirportAnimation case class to represent animated airport assets, linking an Airport entity with a specific animation type and URL. Added the AirportAnimationType enumeration to categorize animations as AIRPORT, CITY, or SCENERY, enabling the system to distinguish between different visual representations of airport data.

airline-data/src/main/scala/com/patson/model/animation · high confidence

A new tooltip file has been added to display explanations for capital gains and losses related to airplane transactions, covering scenarios such as buying used aircraft at discounted or elevated values, selling aircraft, and the lack of gain/loss for new purchases.

airline-web/public/html/tooltip · high confidence

The airline-web application now includes the emojify library (emojify.js and emojify.min.css) to automatically convert text-based emoticons (such as :) or :heart:) into corresponding emoji images. This change introduces a new JavaScript module that parses text content and replaces recognized emoticon patterns with image tags, along with the necessary CSS styles to display the emoji graphics inline.

airline-web/public/javascripts/emojify · high confidence

The application now includes a firework animation system, introducing new frontend assets (firework.js, firework.css, fscreen.js, my-math.js, stage.js) that provide visual effects for events. Additionally, a new admin.js module has been added to the public JavaScript bundle, enabling administrative actions such as invalidating images and viewing user IP/UUID histories directly from the rival details interface.

airline-web/public/javascripts · high confidence

Integrated the jEmoji jQuery plugin into the airline-web frontend, providing users with a visual emoji picker that appears in input fields when typing a colon. The update includes the plugin's JavaScript logic, CSS styling with multiple color themes (blue, red, green, black), and a comprehensive library of emoji assets, enabling richer communication in text inputs.

airline-web/public/javascripts/jemoji · high confidence

The application now includes the lazysizes library (v5.2.0) to enable lazy loading of images. This change improves page load performance and reduces initial bandwidth usage by deferring the loading of images until they are needed.

airline-web/public/javascripts/lazysizes · high confidence

The airline data model now includes the core logic for Alliance Missions, introducing new Scala classes to define mission types (such as Total Pax, Revenue, and Rankings) and their specific progress calculation rules (Accumulative, Discrete, Duration-based, and Hit Count). This change adds the \AllianceStats\ structure to aggregate and track key performance indicators like passenger counts, lounge visits, and revenue, enabling the simulation to evaluate mission completion and reward eligibility based on these metrics.

airline-data/src/main/scala/com/patson/model/alliance · high confidence

The airline-data module has been initialized with core geographic and environmental datasets required for the simulation. This includes \additional-cities.csv\ and \additional-airports.csv\ to expand the available network with specific locations (such as Cancún, Bermuda, and various US/Indian cities), and \airport-weather.csv\ providing detailed seasonal weather forecasts for major hubs like HND and LHR. The directory also includes standard project scaffolding files (\.gitignore\, \LICENSE\, \README.md\).

airline-data · high confidence

This change introduces the \airline-rest\ component, a Play Framework-based REST API for managing airline simulation data. It provides endpoints for managing airports (including slot assignments and appeal metrics), airlines (including bases and headquarters), and aircraft (including models, purchasing, and selling). The API also exposes flight link management (routes, capacity, quality, and consumption) and supports cross-origin requests. The service is built using Play 2.3.7 and sbt 0.13.8.

airline-rest · high confidence

The airline-web module is initialized with its core Play Framework dependencies (version 2.4.3) and build configuration. This change adds support for Google services by introducing OAuth credential handling for Gmail and Google Photos, requiring users to provide local JSON credentials and API keys in the application configuration. It also updates the README with instructions for setting up these Google integrations, configuring map keys, and sourcing city/airport data, while adding a .gitignore to exclude sensitive credential files and build artifacts.

airline-web · high confidence

This change adds the backend actors for a new chat feature, enabling users to send and receive messages in real-time via websocket. The system supports a general chat room and private alliance rooms, with message history limited to the latest 100 messages per room for new sessions. It includes logic to handle chat bans by segregating banned users into a 'penalty box' room while allowing them to view general messages, and restricts alliance room access based on user roles. The implementation also tracks unread message counts and supports pagination for older messages.

airline-web/app/websocket/chat · high confidence

A new ChatMessage case class has been added to the airline-data module, defining the structure for chat interactions. This model includes fields for the associated airline, user, room ID, message text, timestamp, and a unique identifier, establishing the data foundation for the chat feature within the airline context.

airline-data/src/main/scala/com/patson/model/chat · high confidence

A new \GoogleResource\ case class has been added to the \com.patson.model.google\ package to represent external resources fetched from Google, including fields for resource ID, type, URL, and a maximum age deadline. This change also introduces a \ResourceType\ enumeration defining \CITY\_IMAGE\ and \AIRPORT\_IMAGE\ as the supported resource categories, enabling the application to distinguish between different types of Google-hosted assets.

airline-data/src/main/scala/com/patson/model/google · high confidence

This change introduces the core data models for the airline simulation, including \Airline\, \AirlineBase\, \AirlineCountryRelationship\, \Airport\, \AirportAsset\, and \AirportFeature\. It defines the structure for airline bases, specializations (such as Negotiation Expert, Delegate Recruiter, and Branding), country relationships, and airport features (like International Hub, Vacation Hub, and Financial Hub). The code also includes asset types (e.g., Ski Resort, Convention Center) and their associated boosts, as well as the logic for calculating income, population, and demand adjustments based on these features and relationships.

airline-data/src/main/scala/com/patson/model · high confidence

The application now includes a structured notification system to inform users about key airline lifecycle events. This change introduces models for level-up achievements, loyalist status updates (calculated based on flight volume), and game-over scenarios triggered by bankruptcy when an airline's balance falls below a specific cash threshold. These notifications provide clear, descriptive feedback to the user regarding their airline's progress and status changes.

airline-data/src/main/scala/com/patson/model/notice · high confidence

This change introduces a new caching infrastructure in the \com.patson.util\ package to improve data retrieval performance for core entities. New cache implementations have been added for Airlines, Airports, Alliances, Countries, Users, Airplane Models, Airplane Model Discounts, and Airplane Ownership, utilizing Google Guava's \LoadingCache\ with configurable sizes and expiration policies. Additionally, a \LogoGenerator\ utility has been added to programmatically generate airline logos from templates and color inputs, and an \AllianceRankingUtil\ has been introduced to manage cached alliance rankings based on cycle changes.

airline-data/src/main/scala/com/patson/util · high confidence

This change introduces the core data models and logic for managing airline oil fuel procurement, including contract management, inventory policies, and consumption tracking. Users can now define oil contracts with specific prices, volumes, and durations, subject to a maximum duration of 200 weeks and a limit of 5 active contracts. The system supports three inventory policy options—Conservative, Balanced, and Aggressive—which determine how much of the market price fluctuation is shielded (90%, 50%, and 20% respectively), with Conservative being the default. Additionally, a consumption history model tracks fuel sources (Contract, Market, Inventory, Excess) and associated costs, enabling detailed analysis of fuel spending over time.

airline-data/src/main/scala/com/patson/model/oil · high confidence

This change introduces a new 'Olympics' event type to the airline simulation, allowing airlines to participate in a multi-year cycle involving voting for host cities and earning rewards. The implementation includes logic for tracking event status (Voting, Host City Selected, Preparation, In Progress, Concluded), calculating airline vote weights based on reputation (threshold of 30) and national airline status, and managing unclaimed cash or loyalty rewards for passengers and airlines. It also defines demand multipliers that increase significantly as the games approach, affecting airline goals and performance metrics during the event.

airline-data/src/main/scala/com/patson/model/event · high confidence

The application now includes dedicated views for user account lifecycle events. A new 'About' page explains the game's simulation features and community. Users can now sign up via a new signup form, and recover access through 'Forgot User Name' and 'Forgot Password' pages that send instructions via email. A 'Password Reset' view allows users to set a new password using a secure token, and a 'Check Email' confirmation page guides users to verify their inbox. These changes replace the previous generic main layout with a more structured, multi-page authentication flow.

airline-web/app/views · high confidence

This change introduces the core data structures for the airline's fleet, including the Airplane, Model, and AirplaneConfiguration classes. It defines airplane types (Light through Jumbo and Supersonic) based on speed and capacity, establishes runway requirements and manufacturer details for each model, and implements a configuration system that allows airlines to customize seat layouts (Economy, Business, First) with a limit of five templates per model. Additionally, it adds logic for maintenance factors based on fleet diversity, link assignment tracking for flight minutes, and a discount system that applies price or construction-time reductions for favorite models or preferred suppliers.

airline-data/src/main/scala/com/patson/model/airplane · high confidence

A new database table, \airport\_champion\_bonus\, has been introduced to store additional details regarding airport champion bonuses. This table links specific airports and airlines to a description field, enforcing referential integrity with the existing \airport\_champion\ table via a composite foreign key that cascades on delete and update.

_airline-data/db\scripts/v2.2 · high confidence

Added a suite of initialization and patching scripts in the airline-data module to manage airport and airline data. This includes AirportGeoPatcher for regenerating airport data from CSV sources, AirportFeaturePatcher for applying specific airport features (like hubs and vacation spots), AirportAnimationPatcher for associating video content with airports, and AirlineGenerator for creating simulated AI airlines. These tools allow for more granular control over the game's world data and simulation entities.

airline-data/src/main/scala/com/patson/init · high confidence

This change introduces a new set of Scala source files in the airline-data module that provide the database persistence layer for core game systems. Specifically, it adds \AdminSource\ to log administrative actions, \AirlineSource\ to manage airline profiles and balances, \AirlineViolationSource\ to track compliance infractions, and \BankSource\ to handle loan records. These files establish the backend data operations required for the airline management and administrative features.

airline-data/src/main/scala/com/patson/data · high confidence

The application introduces a suite of new data models to support expanded functionality. Account management is supported by new models for user registration (NewUser), password recovery (ForgotId, ForgotPassword, PasswordReset), and user profiles (Profile). Facility management includes a new AirportFacility model with validation for lounge names and types, as well as a Consideration model for evaluating facility additions. Operational workflows are enhanced with PendingAction models to track Olympic voting/rewards and alliance applications, while AirportWithChampion and LinkHistory models support airport champion tracking and link history visualization.

airline-web/app/models · high confidence

Added a new \SimulationEventStream\ component that introduces a dedicated \BridgeActor\ to relay simulation cycle data to the web application. This actor maintains a single connection to the web app, tracking cycle durations using the last 10 samples to calculate an average, and broadcasts \CycleInfo\ (including cycle number, elapsed fraction, and estimated duration) to subscribed clients upon cycle completion. The implementation includes supporting case classes for simulation events (\CycleCompleted\, \CycleStart\, \CycleInfo\) and configuration constants for the actor system.

airline-data/src/main/scala/com/patson/stream · high confidence

The game now includes a comprehensive tutorial framework and new notification modals to guide players. The public HTML now features a structured tutorial system covering initial setup, airport selection, flight planning, negotiations, and oil management, with an option to disable these guides. Additionally, new modal popups have been added to display level-up milestones, loyalist achievements, and bankruptcy warnings, while a dedicated announcement page displays the V2.2 release notes and updated game rules.

airline-web/public/html · high confidence

The airline simulation now includes a Santa Claus event where players can select from six distinct reward types: Cash (up to 20M), Service Quality, HQ Loyalty, Airport Loyalty, Reputation, or Delegate boosts. The impact of these rewards scales based on a difficulty system (Normal vs. Hard), which is determined by the player's remaining attempts and guesses, effectively doubling the reward values in Hard mode.

airline-data/src/main/scala/com/patson/model/christmas · high confidence

The database schema for airport financials has been updated to replace the generic 'power' metric with specific income tracking. The 'power' column was removed from the 'airport' table and replaced with an 'income' column, which is automatically populated from the associated country's income data. Additionally, the 'others\_income' table now tracks asset-specific financials via new 'asset\_expense' and 'asset\_revenue' columns, replacing the previous 'shuttle\_cost' and 'maintenance\_investment' fields, while the 'cash\_flow' table now includes an 'asset\_transactions' column to record related financial movements. The 'airport\_asset\_property\_history' table also had its 'value' column type adjusted to VARCHAR(256).

_airline-data/db\scripts/v2.1 · high confidence

The system now calculates airline bonuses for campaigns based on population coverage and delegate task levels, with a maximum loyalty bonus of 10 per delegate. The bonus calculation applies a diminishing factor (halving) for each additional delegate task, and only applies if the target airport is within the campaign's defined area.

airline-data/src/main/scala/com/patson/model/campaign · high confidence

A new application.conf file is introduced for the airline-data service to configure a remote actor system using Pekko. This configuration sets up TCP-based remote communication (Artery transport) with the actor provider set to 'remote'. It specifies binding to all interfaces (0.0.0.0) on port 2552 and sets the canonical hostname to 127.0.0.1 on the same port. Java serialization is explicitly enabled, and the dev flag is set to false. This change supports the remote communication needs of the data simulation component, allowing it to receive messages from the web application.

airline-data/src/main/resources · high confidence

This release includes a suite of database patcher scripts to migrate existing airline data to support new features and fix calculation errors. The v1.1 migration (Version1\_1Patcher, Issue218\_patcher, Issue227Patcher) introduces per-airplane flight minute tracking, assigns default configurations to unassigned airplanes, and adjusts link frequencies based on new capacity models. The v2.1 migration (Version2\_1Patcher, Issue264OlympicsPatcher, Issue271Patcher) adds database schemas for airport assets, alliance missions, and airplane model favorites/discounts, while also generating asset blueprints. The v2.2 migration (Version2\_2Patcher, Version2\_2AssetIncomePatcher) corrects income boost calculations for airport assets by converting boost values from income levels to actual income gains and updating historical records. Additional patches handle specific issues: Issue485 compensates shuttle services and generates generic transit links, Issue581 fixes missing country delegates, Issue498 purges invalid airport base specializations, LoanPatcher converts legacy loan data to the new model, and LinkCountryPatcher populates country codes for flight links.

airline-data/src/main/scala/com/patson/patch · high confidence

This change introduces a collection of SQL migration scripts within the airline-data/db\_scripts directory to evolve the database schema. Key updates include adding columns for airplane purchase cycles, versions, and families; enhancing the link\_consumption table with duration, flight type, and satisfaction metrics; and introducing new tables for tracking notices and airline violations. The scripts also modify passenger history to include destination airports and cost, adjust user and airline modifier structures, and fix data integrity issues such as orphaned alerts and typos in airplane model names.

_airline-data/db\scripts · high confidence

The application now includes a new 'modern' visual theme that replaces the previous styling, featuring CSS custom properties for consistent theming, backdrop blur effects on panels and tooltips, and a comprehensive dark mode. This change introduces a new set of stylesheet files (including modern.css, main.css, chat.css, and mobile.css) that define the look and feel of the interface, ensuring that components like the live chat, search results, and data tables adapt correctly to both light and dark user preferences.

airline-web/public/stylesheets · high confidence

The airline-web configuration has been significantly expanded to support a much larger application surface area. The routes file now defines over 150 new endpoints covering extensive new features including alliance management, oil contracts, loans, airline branding (logos/livery), used airplane markets, and detailed link history/rival tracking. The application.conf has been updated to configure Pekko remote actors with Artery TCP transport for both the main and websocket actor systems, enabling distributed communication. Additionally, the Play framework configuration now explicitly sets the HTTP secret key, enables Gzip filtering for text and JSON content, disables CSRF protection, allows all hosts, and sets long-term immutable caching for public images and music. Logging has been adjusted to include controller-level INFO logs and suppress JWT codec errors, while the logback converter class has been updated to the Play library version.

airline-web/conf · high confidence

The controller classes in the airline-web application have been updated to extend AbstractController and use constructor injection via the @Inject annotation, replacing the deprecated Controller trait. This change aligns the codebase with modern Play Framework standards for dependency injection and controller composition.

airline-web/app/controllers · high confidence

The airplane data repository has been replaced with a new implementation in \AirplaneSource\ and \ModelSource\. This change introduces support for loading airplane link assignments (including flight minutes), managing airplane configurations, and handling airplane models with manufacturer details, family, and image URLs. It also adds functionality to save and load favorite models for airlines, replacing the previous data access logic.

airline-data/src/main/scala/com/patson/data/airplane · high confidence

The simulation backend has been rewritten to introduce dedicated simulation modules for airline financials, airplane lifecycle management, airport assets, and alliance missions. AirlineSimulation now calculates detailed profit and loss statements including fuel, crew, maintenance, lounge costs, and loan interest. AirplaneSimulation handles aircraft decay, depreciation, auto-renewal logic, and second-hand market adjustments. AirportAssetSimulation computes passenger statistics and revenue for airport upgrades, while AllianceMissionSimulation introduces a mission system with selection and active phases. These changes replace the previous monolithic simulation logic with a more modular and detailed economic model.

airline-data/src/main/scala/com/patson · high confidence

The WebSocket subsystem has been restructured to maintain a single persistent connection between the web application and the simulation server, rather than creating a new connection per user login. This change introduces an \ActorCenter\ that manages a \LocalMainActor\ to handle cycle completion events, cache invalidation, and keep-alive pings, while individual \LocalActor\ instances relay specific user notifications (such as notices, prompts, and pending actions) to their respective WebSocket clients. The new architecture also includes a \ReconnectActor\ to automatically detect disconnections and attempt to re-establish the link with the simulation server, ensuring more robust real-time updates for cycle progress and airline-specific events.

airline-web/app/websocket · high confidence

Added comprehensive test coverage for airline simulation models; Added unit tests for airline simulation model components; Removed default Play Framework test templates.

The project's build configuration has been updated to use Scala 2.13.14 and upgraded core libraries, including Apache Pekko 1.0.3 (replacing older Akka versions) and Google Guice 5.1.0. New dependencies have been added to support external services and data handling: Google API clients for Gmail and Photos, JavaMail, and the Elasticsearch REST high-level client 7.17.2. Additionally, the MySQL JDBC driver 5.1.49 and c3p0 connection pool 0.9.5.5 are explicitly defined in the data module, and a new \airline-rest\ module was introduced with its own dependency set.

(dependencies) · high confidence

The Highcharts JavaScript library in the public libs directory has been updated to version 4.1.9. This change provides the underlying charting engine used by the airline web interface, ensuring the application uses the latest features and bug fixes available in this release.

airline-web/public/javascripts/libs · high confidence

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

• First survey — no prior run to compare against. CAI 25.

• Code Health 40
• Architecture 79
• Maturity 39
• Readiness 8
• Security 70
• Accessibility 30

• 300 commits — 226 feature/other, 74 fixes

• airline-data/src — 83 commits
• airline-web/public — 74 commits
• airline-web/app — 68 commits
• (repo) — 58 commits
• airline-web/conf — 8 commits
• (root) — 6 commits
• airline-data/build.sbt — 2 commits
• airline-web/build.sbt — 1 commit

• fix: Added pending action for alliance pending apps Dynamically update pending action bubble due to certain actions (voting olympics. remove/accept alliance member etc) Fixed alliance apply - alliance id udpate
• fix: Better display for tooltip with $ value Also fixed modern layout. Boosted value should have green
• fix: Fix actor issue from web -> sim
• fix: Fix airplane retiring issue
• fix: Fix dropdown colors
• fix: Fix getYearMonthText incorrect months (#627)
• fix: Fix it when both from and to airport are nearby
• fix: Fix missing rival history in event view by querying airport pair directly
• fix: Fix multiple campaigns issue
• fix: Fix multiple campaigns issue
• fix: Fix startup issue from IDE
• fix: Fixed #651
• fix: Fixed Aviation hub not going away for very small airports
• fix: Fixed actor web -> sim
• fix: Fixed airline name and code validations
• fix: Fixed airport link map capacity
• fix: Fixed airport link map capacity
• fix: Fixed airport link map capacity
• fix: Fixed airport link map capacity
• fix: Fixed airport markers no longer hide/show links after pax map/alliance map
• …and 280 more

• 0 containers · 3 bounded contexts · 3 dependency edges (baseline)

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

patsonluk/airline 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.