Canonical: https://www.brettsanders.com/blog/towers-of-hanoi-3d
Author: [Brett Sanders](https://www.brettsanders.com/)
Published: 2024-11-10

Field Note

# Building a Modern 3D Towers of Hanoi Game with Three.js and GSAP

Create an interactive 3D Towers of Hanoi game using Three.js, React, and TypeScript with smooth animations and user interactions.

Published November 10, 2024 4 min read

Three.js React TypeScript 3D Graphics Game Development

# Building a Modern 3D Towers of Hanoi Game with Three.js and GSAP

The Towers of Hanoi is a classic mathematical puzzle that has fascinated minds for generations. While it has been reimagined countless times, creating a polished 3D version presents unique challenges in terms of user interaction, performance, and visual appeal. I took on this challenge by building an interactive 3D version using modern web technologies.

👉 **[Play the game here](https://towersofhanoi-alpha.vercel.app/)** or explore the [source code on GitHub](https://github.com/DontFretBrett/towersofhanoi-3d).

## Technical Stack Overview

I built this project using a modern JavaScript stack:

- Three.js for 3D rendering and scene management
- GSAP (GreenSock Animation Platform) for smooth animations
- Vite as the build tool and development server
- Vanilla JavaScript with ES6+ features
- Vercel for deployment

## Architecture and Design Patterns

The application follows a component-based architecture with clear separation of concerns. The core structure is organized into several key managers:

1. **App Class**: The main orchestrator that initializes and connects all components
2. **Scene Manager**: Handles the 3D scene setup and rendering
3. **Game Manager**: Controls game logic and state
4. **Event Manager**: Manages user interactions
5. **UI Manager**: Handles the game's interface elements
6. **Audio Manager**: Controls sound effects and audio feedback

## Game Components

The 3D elements are carefully modeled as distinct components:

- **Rods**: Represented as cylindrical meshes with custom positioning
- **Disks**: Implemented with varying radii and colors
- **Table**: Provides the game surface with a wood-grain texture

## Core Game Logic

The game's core mechanics are handled by the GameManager class, which implements several key features:

### Disk Management

- Dynamic disk creation based on difficulty level (3-10 disks)
- Automatic radius calculation for visual consistency
- Color assignment from a predefined palette

### Move Validation

- Real-time checking of move legality
- Prevention of larger disks being placed on smaller ones
- Destination rod highlighting for better user guidance

### State Management

- Track selected disks and valid moves
- Maintain move counter and timer
- Calculate optimal moves for the current configuration

## User Interaction

The game supports multiple input methods:

- Mouse/touch interaction for disk selection and movement
- Keyboard controls (numbers 1-3) for rod selection
- Responsive design adapting to different screen sizes

## Performance Optimizations

Several optimizations ensure smooth gameplay:

### Object Pooling

- Reuse of 3D objects to minimize garbage collection
- Efficient management of disk creation and destruction

### Render Optimization

- Selective rendering of changed elements
- Optimized animation frames

### Resource Management

- Preloading of textures and audio
- Efficient memory usage through proper object disposal

## Advanced Features

### 1. Randomization

The game includes a sophisticated randomization feature that:

- Creates valid random configurations
- Ensures puzzles are solvable
- Maintains game rules during randomization

### 2. Win Detection

Victory conditions are checked by:

- Verifying all disks are on the destination rod
- Confirming correct disk ordering
- Comparing against optimal move count

### 3. Debug Tools

During development, a debug panel provides:

- Real-time state inspection
- Performance monitoring
- Move validation checking

## Challenges and Solutions

### Physics Simulation

Instead of using a full physics engine, I implemented simplified movement constraints and animations, reducing computational overhead while maintaining visual appeal.

### Cross-browser Compatibility

The implementation uses standard Web APIs and includes fallbacks for broader browser support.

### Mobile Optimization

Touch events are carefully handled to provide a smooth mobile experience, with appropriate hit areas and gesture recognition.

## Future Enhancements

The codebase is structured to allow for several potential enhancements:

- Multiplayer support
- Additional difficulty modes
- Custom disk themes
- Achievement system
- Move replay functionality
- Mobile touch support improvements
- Automated solution visualization
- Additional visual themes

## Conclusion

This implementation of Towers of Hanoi demonstrates how modern web technologies can be used to create an engaging 3D game while maintaining good performance and code maintainability. The component-based architecture and careful consideration of performance optimizations result in a smooth and responsive user experience.

The project serves as an excellent example of combining 3D graphics, user interaction, and game logic in a web application, while maintaining clean code structure and following software engineering best practices.
