@Acidicts

Project Summary: Admin & Infrastructure Progress

Key Milestones & Features Built

• 🛠️ Admin Product Management UI: Added a full admin interface for product management, including preview capabilities, environment variable integration, and updated order flow logic. This enables admins to efficiently manage product listings and track orders.
• 🆓 Privacy Enhancements: Implemented a “hide PII” controller to anonymize user data in the UI, ensuring sensitive information is protected in user-facing tables.
• 🧪 Product Cost Handling: Validated GBP pricing logic for products, ensuring accurate cost handling in the British Pounds currency.
• 🛠️ CI/CD & Dependency Updates: Configured PostgreSQL in CI pipelines, updated database URLs, and bumped Ruby gem versions to ensure a stable, up-to-date environment.
• 🎨 Styling Cleanup: Replaced inline styles in admin views with stylesheet_link_tag imports, improving maintainability and separation of concerns.

Current Status
The project now has a functional admin dashboard for product and order management, with privacy features baked into user data displays. Infrastructure is PostgreSQL-ready in CI, and styling practices align with modern Rails conventions. Core e-commerce logic (pricing, currency) is under testing, with environment variables streamlining configuration.

Lessons Learned

• Privacy by Design: Integrating PII protection early simplifies compliance and reduces technical debt.
• Infrastructure as Code: Automating PostgreSQL setup in CI saves manual effort and reduces environment inconsistencies.
• Maintainable Styles: Moving to external stylesheets improves collaboration and long-term code hygiene.

Order Page Started

• Created a functional order page
• Currency Handling: Explicit GBP validation highlights the need for clear financial logic in order systems.

Refactor like/unlike actions, extract button partial, improve flash UISkip ensure_user_setup for like and unlike actions, replace redirect with turbo_stream and fallback HTML, extract the like button into a partial, and rewrite the flash partial with a fixed position, close button and fade‑out animation.

Replace admin view inline styles with stylesheet_link_tag importsRemoved large embedded CSS from multiple admin templates and switched to external stylesheet links for consistency and maintainability.

Add CurrencyConvertible include and cost conversion helpersInclude CurrencyConvertible in ApplicationHelper and Product, add cost_usd and cost_gbp methods, remove obsolete gbp_to_usd, usd_per_gbp and fetch_usd_conversion_rates, rename cost column comment, and adjust product inheritance.

Update README, moved CSS files, fixed issues between pages (styling)Include planning file entry, revise README wording, and remove dashboard and notifications stylesheet files.

feat(database): migrate from SQLite to PostgreSQL and switch to Redis infrastructure- replace sqlite3 with PostgreSQL database adapter in Gemfile and config

• configure Redis for caching, Action Cable, and Active Job instead of Solid adapters
• add guide attribute to User model for onboarding flow control
• implement user existence validation in ApplicationController
• refactor CSS architecture by moving stylesheets to components directory
• create shared designs.css stylesheet for design pages with responsive styling
• update todo partial to check guide flag before displaying onboarding prompts
• add migration for guide column on users table

Key Milestones & Features
The project has introduced a foundational system for managing ship deployments with the implementation of a queue placement for ship requests. This feature ensures organized handling of ship allocation, likely addressing scenarios where players or systems request ships (e.g., resource management, combat, or exploration mechanics). The queue system likely prevents overlaps or conflicts, enabling smoother gameplay and logical progression.

Current Status
The core queue logic is now part of the codebase (commit: 2bc9e46 by Acidicts). While this marks a critical step in structuring backend mechanics, the project remains in early development. No UI or full integration details are visible yet, suggesting future work will tie this system into gameplay loops, player actions, or event triggers.

Things Learnt
This iteration highlights the importance of asynchronous request handling in game systems, especially for resource-heavy actions like deploying ships. Implementing a queue likely involved balancing performance, fairness, and user expectations. The team may have explored patterns for prioritization, delay handling, or concurrency, which will be key as complexity scales.

Key Milestones & Features
The project has made solid strides in building out core admin functionality and refining user interactions:

• Admin Controller Tests: Comprehensive tests for the dashboard, orders, and products controllers were added, ensuring reliability and laying groundwork for future expansions.
• Form Submission Control: A disable button feature was implemented in the design-form component to prevent multiple submissions, improving UX and reducing backend load.
• Dashboard Updates: The dashboard_controller.rb received updates (specifics pending documentation), likely enhancing core admin workflows.

Current Status
The admin interface is shaping up with test-covered controllers and polished frontend interactions. Testing prioritization suggests a focus on stability, while form improvements reflect attention to user-centric details. The project appears in an active development phase, with July 2026 commits indicating recent momentum.

Things Learnt

• Test-Driven Practices: Adding controller tests early highlights the team’s emphasis on maintainable, scalable code.
• Form UX Nuances: Disabling submission buttons during processing is a small but impactful tweak to prevent errors and improve responsiveness.
• Documentation Gaps: The vague “Update dashboard_controller.rb” commit underscores the importance of descriptive commit messages for clarity in collaborative projects.

Added two foundational backend features to the Railbeam - Stardance project. First, we integrated PostgreSQL support to provide a robust, scalable database solution. This replaces earlier stateless approaches, enabling persistent data storage for user sessions, game states, and real-time analytics. The PostgreSQL setup includes optimised schema design and connection pooling for performance.

Introduced a region-aware server model, which dynamically routes user traffic to geographically optimal server instances. This reduces latency for global users and ensures localized compliance for data residency requirements. The model uses IP geolocation and load-balancing logic to adapt to user locations in real time.

Current Status
With these updates, the backend now offers a stable infrastructure for handling complex user interactions and global scalability. The region-aware server is active in staging, and PostgreSQL is fully integrated into the development environment. Next steps include testing cross-region synchronization and refining database query optimizations for high concurrency.

Things Learnt

• Database Integration: Adopting PostgreSQL required careful migration planning and schema validation to avoid data inconsistencies. We learned to prioritize connection resilience and indexing strategies for high-traffic scenarios.
• Geolocation Challenges: Implementing region-aware routing highlighted the trade-offs between latency, cost, and user distribution. We refined the logic to prioritize server proximity without compromising on centralized data management.
• Testing Workflows: Automated testing for database transactions and region routing is critical. We leaned into mock servers and load-testing tools to validate reliability under stress.

The project has seen rapid progress this week, with a focus on foundational backend setup and UI design. Key milestones include:

• Active Storage Configuration: Initial work was done to set up Rails’ Active Storage for S3 integration (July 7), enabling scalable media management.
• Dark Theme Design System: A full dark theme was implemented using CSS variables and modular components (July 8), ensuring consistent styling across the app.
• Landing Page & Home Page Overhaul: A redesigned landing page and updated home page with status group styling were added (July 8), emphasizing clean, responsive layouts.

Current status: The backend is primed for media uploads, and the frontend has a cohesive dark theme and redesigned home/landing pages. Remaining work likely involves finalizing theme toggles and integrating storage with the UI.

Lessons learned:

• Active Storage and S3 setup in Rails requires careful configuration of credentials and bucket policies.
• Modular CSS design systems (like a dark theme) streamline component styling and future maintenance.
• Merging CDN-related changes early improves asset performance and simplifies later deployments.

feat(address): add address management system for physical products- create Address model with country enum and has_many :orders association

• add AddressController with CRUD operations supporting JSON and HTML formats
• add AddressesController with create, update, destroy actions and reload parameter
• add address association to Order model (belongs_to :address, required: false)
• add physical attribute to Product model with physical? helper method
• update User model to use has_many :address association with nested attributes
• add migrations for addresses table and order address reference (address_id)
• add address modal UI with form for creating addresses (HTML/JS)
• add address picker and delete functionality in user edit view
• add address selection dropdown for physical product orders in order forms
• add address display in order details view
• add CSS styles for address modal, form elements, and utility classes
• add JavaScript for modal interactions, address deletion, and form submission
• add trash-bin.svg icon for delete button
• update routes to include destroy action for addresses

refactor(order): improve address handling in order creation

• fix conditional logic for accessory cost calculation (separate if blocks)
• add address assignment for physical products during order creation
• update product form to include physical item checkbox

fix(validation): improve form field warning animations

• add fade-out transition for field validation warnings via fade-out class
• add timer-based warning auto-clear functionality (3s delay, 400ms fade)
• add transition properties for border-color and box-shadow on field-invalid

style(application): add CSS utility classes and address styling

• add transition properties for field-invalid class (border-color, box-shadow)
• add fade-out animation for field-validation-warning (opacity transition)
• add .apf-section-darken, .address-trigger-btn, .del-btn utility classes
• add .inline, .jsb, .w100p, .g2r layout utility classes

fix(auth): update product params to include thread_cost instead of cost_gbp - replace deprecated cost_gbp parameter with thread_cost in product creation/update - adjust database migration to add thread_cost column to products table, added shop, added notification page

Added toggle to disable the address page in the guide/ popup thing, this allows admins to disable collecting addresses immediately and lets people do it later on, eg when ordering a physical prize

Used claude to brainstorm colour schemes and layouts. Created this new dashboard design and transitioned the rest of the site to follow the colour scheme

Added admin changable messages, allows admins to change the rsvp message

Made new mobile UI, and added Addresses, and changed the Comments to be polymorphic to enable easier adding to other things (devlogs, ships, orders) - (allows many different models to have comments)

Add design image gallery with viewer page- Add image route, controller action, and full-size viewer template

• Add gallery grid on show page with hover overlays and timestamps
• Fix partial render syntax (collection with as: :image)

feat: Add death mechanics, signal system, and friendly fire prevention

 - Implement character death with visual         
 feedback                                        
 - Add line-of-sight signal system for squad     
 commands                                        
 - Track bullet shooters to prevent friendly     
 fire                                            
 - Add dead character assets                     
                                                 
 Changes include:                                
                                                 
 - Armed.py: Death state, visual feedback,       
   skip dead enemies                             
 - SquadMember.py: Signal/connection checking    
   through walls                                 
 - Bullet.py: Shooter tracking, team-based       
   targeting                                     
 - Wall.py: Signal blocking property             
 - Level.py: Connection checks for commands      
 - Utils.py & __init__.py: Dead character asset