Winner of the 2025 yWorks Project Days Contest
Every year, we hold "Project Days" to explore new ideas. This year, RobyGraph was chosen as the winner. Our team of two software engineers and a graphic designer spent the week figuring out how to turn complex graph theory into a "gentle" strategy game. Our goal was to make a coding challenge into a game that is technically challenging yet visually cozy and inviting for the player If you want to jump right in, you can Play Now or visit our Game Overview to read the full rules and check the high scores.
The Story of the Starry Skies
Look up at the night sky! Everything is connected—the stars, the moons, even the little happy planets! This special world is called the RobyGraph Nebula. It's a network of cozy little homes (the colored circles, or Nodes) connected by rainbow roads (the Paths). Two teams of super-friendly little Robots live here: the Red Team and the Blue Team. They are having a contest to see which team can color the most Sparkle Gems! The Sparkle Gems are found on the roads. Your job is to tell your little Robot friend—your special AI Agent—how to move! The Goal: Program your Robot to be the smartest on the paths! Help your team grab the most important homes and collect more Sparkle Gems than the other side. It’s a fun race to connect everything and win the stars!
Are you ready to code your way to victory in the RobyGraph?
Bleep-bloop! My code is flawless and my spray bottle is full! Time to turn those lonely stars into our super-cozy planets!RobyGraph
The process
Designing the game rules
On day one, we came together to brainstorm and design the game's rules. Our only ideas so far were: the game should feature graphs, and players should control a robot. The game should fulfill these goals:
- It should be as simple as possible while at the same time offering strategic depth (easy to learn - hard to master).
- We should be able to implement it in the allocated time of about ten person-days, including deployment and this blog article.
- Implementing agents should require using different kinds of graph algorithms.
- There should be a core game logic and optional rule modules ("stretch goals") we could add if time remained at the end.
After a very productive 90-minute session, we had developed most of the game rules and identified several stretch goals.
The game rules
Players program an agent that controls a robot. The robot moves along a graph from node to node via connecting edges. The graph is defined by levels and does not change throughout the game. Players can choose from a fixed set of levels that offer different challenges. Robots can paint nodes in their own color, which takes several rounds depending on a node's paint capacity. Once a node is completely filled with a player's color, that player owns the node, increasing their score, and causing the node to spread the player‘s color. Some nodes belong to checkpoints. When a player owns all nodes of a checkpoint, they own the checkpoint as well. If a player owns more than half of the checkpoints, the game ends and that player wins. If neither player manages to capture enough checkpoints, the game ends after a set number of rounds. The player with the most checkpoints wins. If both players control the same number of checkpoints, the aggregated power of all controlled nodes serves as the tiebreaker.
The game is turn-based. Each turn, an agent chooses one of three actions:
- Move: Move to an adjacent node.
- Spray: Spray paint on the current node. Depending on the node state, this either replenishes the paint of a node you own, removes an opponent's paint,or paints a neutral node, eventually capturing it.
- Refill: Each robot has a paint tank. Spraying gradually depletes this tank. Robots can refill it by removing part of the paint from a node they own.
Nodes a player owns gradually spread their color to adjacent nodes and replenish their own paint if necessary. Nodes have three properties:
- "Power": the amount of paint a node generates per round. It is used to replenish its own color or to paint adjacent nodes.Power is denoted by one to three stars beneath the node.
- "PaintLevel": the amount of paint currently on this node. The paint level is denoted by the colored fraction of the node and the first number.
- "PaintCapacity": the maximum amount of paint a node can hold. This is also the amount needed to capture a node. The paint capacityis denoted by the size of a node and the second number.
Implementation
As the "game board" consists of a graph with individual styling and interaction, yFiles for HTML offers all the necessary tools we needed. Most of the core game logic was implemented on the first day using default styles and a hand-coded graph. We also added a "manual agent" that lets the player control the robot with mouse clicks — great for debugging and learning the game.
On the second day, we added win conditions and checkpoints, a simple level designer, and started refining the UI. The level designer exports the levels to JSON and we customized the yFiles snapping feature and especially the circular snapping to arrange the planets nicely. The AI coding agent Junie helped us to create dynamic styles with CSS animations for the planets which replaced our initial default styles. We also added a weak agent implementation that players can test against. It uses very simple heuristics to capture nodes and mostly moves through the graph at random.
On the third day, we continued making the game look beautiful and implemented a deployment process so the game runs in the yFiles Playground. We also polished the API that players and their agents use.
On the final day, we polished the UI, wrote this blog article, added the optional "paint tank" module, and designed several levels.
We are proud of what we've accomplished in such short time.
Design Philosophy: A Universe of Gentle Strategy
In crafting RobyGraph, our primary goal was to move away from typical combat and warfare tropes, presenting a strategy game that is charming, non-aggressive, and purely competitive. We've meticulously designed a universe where conflict is replaced by playful rivalry and strategic resource collection.
The RobyGraph Nebula
The setting is a vibrant, peaceful corner of the cosmos—the RobyGraph Nebula. This isn't a battlefield; it's a cozy, connected network of celestial bodies:
- Nodes as Planets & Stars: The circular nodes in the graph are central to the game. When neutral (unclaimed), their design evokes the twinkling mystery of distant stars. Once claimed by a team, they transform into brightly colored, hospitable planets.
- Galaxy Color Palette: Our color choices are directly inspired by nebulae and the night sky. We use deep, rich galaxy colors (like cosmic blues, stellar purples, and vibrant nebulae reds) to maintain a visually stunning, space-themed aesthetic that feels otherworldly and non-terrestrial.
Meet the Agent: RobyGraph The Elven-Bot
- Half-Robot, Half-Elf: Our agent combines the precision of a robot with the whimsy and gentle nature of an elf. This design choice immediately signals the game's peaceful tone.
- The Friendly 'Tag': Our Elven-Bot doesn't fight or destroy. Its primary action is to claim paths and nodes for its team, which it does with a cute spray bottle. This action is framed as "tagging" or "decorating" the planets with their team's colors, reinforcing the idea of a peaceful contest rather than a hostile takeover.
The entire design ensures that RobyGraph is not about destroying opponents, but about outsmarting them in a beautiful, non-violent, star-studded arena
It's a sweet race to victory!
Play now!
About the RobyGraph project
RobyGraph was successfully developed within a short timeframe, achieving its goal of creating a simple yet strategically deep graph-based game.The system requires AI agents to apply complex graph algorithms and resource management to secure nodes and capture checkpoints. Critically, the design achieved a balance by framing the competition under a "Gentle Strategy" philosophy, making it an appealing, non-violent contest of wits.
RobyGraph is now fully deployed and ready as an engaging platform for competitive AI testing.
