Antillery Devlog #6
Development Roadmap: 16-Week Sprint Plan
May 28, 2025
A comprehensive development plan using Agile methodology to organize project sprints and establish a clear path to completion
Development Overview
This devlog presents the detailed development roadmap for Antillery. The project follows a 16-week Agile methodology, with each week representing a sprint focused on specific systems, mechanics, or improvements. This structured approach ensures consistent momentum and organized progress toward completion.
Agile Approach
By breaking down the project into weekly sprints, we gain several advantages:
- Clear, achievable goals for each development period
- Regular milestone achievements to maintain motivation
- Opportunity to reassess and adjust as development progresses
- Focused development efforts on one system at a time
- Regular integration points to ensure systems work together
Development Note: While the schedule is carefully planned, I recognize that software development often presents unexpected challenges. The sprint structure provides flexibility to adjust scope within each sprint while maintaining the overall project timeline.
Schedule Context
This activity schedule represents a 16-week period that aligns with a semester timeframe, but actual development is beginning several months ahead (starting in May 2025). This early start may result in significant timeline adjustments as the project progresses. Such flexibility and adaptation to changing circumstances is precisely the strength of the Agile methodology being employed. The roadmap serves as a directional guide rather than a rigid timeline.
Foundation Phase (Weeks 1-4)
The first month focuses on establishing the project foundation and implementing core gameplay mechanics that everything else will build upon.
Week 1: Setup
- Create a Unity project with a versioned folder hierarchy
- Setup GitHub repo and enable Git LFS for Unity assets
- Initialize the Kanban board with sprint columns and core tasks
- Create design document scaffolds: MVP checklist, coding conventions, asset pipeline
Week 2: Core Architecture
- Implement core game-state and turn-state machines
- Integrate event-driven architecture for turn handling
- Define project-wide enums and ScriptableObject data models (weapon/tool definitions)
- Begin technical documentation for the codebase
Week 3: Movement
- Implement player input and per-turn movement limits
- Set up Unity Input System with action maps
- Basic UI feedback: directional arrows and movement readiness indicator
Week 4: Projectiles
- Implement aiming mechanics and trajectory controls (angle, power)
- Basic projectile instantiations and travel arc
- Simulate collisions and test destructible terrain hooks
Core Systems Phase (Weeks 5-8)
The second month is dedicated to implementing the core gameplay systems that define Antillery's unique experience.
Week 5: Terrain
Subject to revision based on integration considerations with Unity's collision system specifics.
- Implement bitmap-based terrain using a black/white mask texture
- Apply real-time alpha-based pixel removal upon impact
- Rebuild mesh collider after terrain mutation
- Integrate terrain change logic with projectile and hazard systems
Week 6: Physics
- Add wind system affecting projectile trajectories
- Finalize physics parameters: gravity, drag, impact force
- Display wind vectors using onscreen HUD indicators
Week 7: War Weapons
- Implement Bazooka, Grenade, and TNT mechanics
- Add distinct audio/visual feedback and impact animations
- Tune explosion radius and test terrain deformation integrity
Week 8: Peace Tools
- Implement Sod Roll, Doom Bloom, and Luster Bomb mechanics
- Ensure Sod Roll mechanics work properly in edge cases
- Ensure visual and audio effects distinguish tone from war tools
Design Note: Peace-based tools offer unique tactical options beyond simple destruction.
Interface & Art Phase (Weeks 9-12)
The third month focuses on user experience, interfaces, and bringing the visual elements together.
Week 9: UI
- Build weapon/tool selection HUD and contextual menus
- Implement the power meter, turn timer, and wind indicators
- Validate real-time feedback for all core turn actions
Week 10: Map Editor
- Build in-game bitmap-based map editor using brush and stamp tools
- Enable saving and loading of custom PNGs from local storage
- Validate file I/O and bitmap handling
Week 11: Art & Animation
- Import 3D ant models and set orthographic 2D camera rig
- Configure idle, walk, aim, and fire animations
- Integrate state transitions using Unity Animator and gameplay triggers
Week 12: Multiplayer
- Implement a round-robin player-switching system
- Track player state across turns and reset between rounds
- Test gameplay for 2-4 players on a shared device
Polish & Launch Phase (Weeks 13-16)
The final month is dedicated to refining the experience, optimizing performance, and preparing for release.
Week 13: Dev Tools
- Build internal Map Generator for rapid test scenario creation
- Create debugging overlays (e.g., collision boxes, terrain debug mask)
- Add shortcut keys for level reset, weapon cycling, and log output
Week 14: Optimize
- Profile memory use and garbage collection during gameplay
- Optimize terrain mutation, physics checks, and render performance
- Refactor redundant scripts and batch costly operations
Week 15: Polish
- Conduct internal playtests and log balance/UX notes
- Address gameplay issues, pacing, terrain abuse, and unclear interactions
- Final pass on audio mix, visual clarity, and turn flow transitions
Week 16: Ship
- Export the final Windows build using Unity's build pipeline
- Package installer and create a release branch with MVP tag
- Assemble README, documentation, and a gameplay demo video
Next Steps
With this roadmap in place, I'm ready to kick off development starting next week. I'll be documenting progress in these devlogs, sharing both successes and challenges.
The first sprint will focus on establishing the project's foundation:
- Setting up a proper Unity project structure
- Configuring version control with Git LFS for Unity assets
- Creating a Kanban board to track sprint progress
- Drafting essential design documents to guide development
Each weekly devlog will cover the previous sprint's accomplishments, challenges faced, and adjustments made to the plan. I'm excited to share this journey and look forward to providing regular updates on Antillery's development progress.
Development Philosophy
Antillery's development approach emphasizes steady progress through structured sprints, allowing for adaptation while maintaining clear forward momentum. By focusing on one system at a time and ensuring thorough integration, we aim to create a cohesive experience where every element works harmoniously with the others. This methodical approach helps prevent the common pitfall of feature creep while ensuring that each component receives the attention it deserves.