Chains-Of-Eternity

Main World
Dungeon
Enemy Fights
Dungeon Map
Weapons GUI
Spells GUI
Lobby Screen
Multiplayer
Transaction

About the Project

Inspiration

The idea for ARCANE: The On-Chain Spellcraft Arena was inspired by our experience with Web3 games where data was not verifiable or truly on-chain. In most blockchain-based RPGs, the gameplay logic and states exist off-chain while only the NFTs are stored on-chain. In essence, the equation many projects follow is:

$$ \text{GAME} = \text{NFT} $$

We wanted to challenge this notion. Our goal was to build a system where all game states, actions, and interactions — including player movement, spells, and combat — are stored and verifiable on the blockchain. We wanted a world where the blockchain is not just a record of ownership but the actual engine of gameplay itself.

What We Learned

During the hackathon, we learned how to integrate Dojo with Unity to create a scalable, modular, and verifiable game system. This included:

Understanding the Dojo ECS architecture — models, entities, systems, and events.
Learning how to design and synchronize on-chain PvP combat in real time.
Building sustainable game design patterns for large, scalable worlds.
Maintaining consistency and collaborative workflow across months of development.

We also gained hands-on experience with Starknet’s infrastructure, managing smart contract state transitions, and developing modular systems that scale.

How We Built It

We built ARCANE using Unity 6.2 LTS for the game client and Dojo ECS on Starknet for the on-chain logic.
The project includes the following components:

Game World Design
- Created a home map and player system with core movement and actions.
- Designed a small enemy system and basic NPC interactions.
- Expanded the world with dungeon maps, new enemies, and additional spells.
Core Mechanics
- Implemented a custom modular spell system using the factory pattern.
- Added PvP functionality with verifiable on-chain combat resolution.
- Developed an inventory and marketplace system for future expansion.
- Introduced shaders and visual effects for improved immersion.
On-Chain Architecture
- Defined all gameplay entities (player, spell, enemy, session) as on-chain models in Cairo.
- Designed the physics and combat parameters to execute deterministically on Starknet.
- Integrated Unity with Dojo’s SDK for real-time state synchronization and event handling.

A simplified version of our on-chain system can be expressed as:

$$ S_{t+1} = f(S_t, a_t) $$

where (S_t) is the current game state and (a_t) represents the player’s on-chain action, processed and verified through Dojo’s ECS on Starknet.

Challenges

Latency and Nonce Errors
Encountered network latency and nonce synchronization issues when submitting frequent on-chain transactions for player state updates.
Complex Parameter Handling
Managing numerous gameplay variables for spells and physics behaviors in Cairo required careful structuring and optimization.
Resource Constraints
Free and high-quality design assets were difficult to find, which limited the visual scope of early builds.

Summary

Through this project, we demonstrated how a fully on-chain game can exist beyond static NFTs. We built ARCANE as a living, scalable, verifiable world powered entirely by Dojo and Starknet. The process taught us not only advanced technical concepts like deterministic state management and on-chain PvP design but also sustainable teamwork and long-term development discipline.

ARCANE represents our belief that the next generation of Web3 games will not just use the blockchain — they will live on it.