Make an Assassins GO Board Game in Unity

Set up a new Unity project, import iTween from the asset store, and animate a cube using iTween hash for rotate, move, and timing with ease types.

Apply tween to build a basic board game mechanic in Unity, moving a character one space along connected nodes toward the goal with movement scripts and a core game loop.

Create a dedicated player input script that reads horizontal and vertical axes from the input manager, exposing H and V and an input enabled flag while planning encapsulation with properties.

Replace public fields in the player input script with properties, implementing get and set accessors for input enabled and other variables, illustrating encapsulation, data protection, and inline formatting in C#.

Create a player manager to glue the player mover and player input, populate references with get component in awake, and process input to move in four directions in two-unit steps.

Create and visualize nodes in Unity by importing a dot model, adjusting materials, and applying a silhouette shader. Explore forward and deferred rendering, MSAA options, and post-processing for cleaner edges.

Create a master list called all nodes with public getter, populate it in Awake using Get node list, and add a utility class for vector3 and vector2 rounding for neighbors.

Discover how each node identifies neighbors on a square grid by using rounded coordinates, a board reference, and a find neighbors method to return adjacent nodes two units away.

Develop a chain reaction where each node shows its geometry after a short delay, with the starting node initializing and triggering neighboring nodes while a guard prevents infinite cycles.

Learn to draw link lines between nodes using a three-dimensional plane geometry, offset to prevent z-fighting, and a runtime script that positions, rotates, and scales the line as nodes connect.

Connect the player's movement to the board by caching a board reference and validating destinations with the final node at method, replacing hardcoded spacing with board spacing.

Explore constructing a maze by selectively linking nodes and blocking paths with obstacles in Unity, using gizmos, raycasts, and layer masks to create varied patterns.

Create a Unity board with a player node that moves only along linked nodes. Update and visualize the node using the board and player mover scripts and an obstacle prefab.

Learn to use Unity events in the game manager to broadcast start, play, and end level signals, and link listeners like the screen fader and start button to respond.

Mark a single node as the end of the maze, spin a goal marker at that node, and animate its prefab drawing after the fade to test in play mode.

Implement the is winner method to compare the board player node with the level goal node, trigger end level when true, and disable player input to prevent extra movement.

Create an end screen with a blur effect by using a depth of field post-process, swap post-processing profiles, and wire the behavior through a start screen and end screen script.

Create an end screen UI in Unity by importing Oswald font and sprites, wiring a restart button to game manager, and styling with anchored, scalable elements and a level label.

Create a reusable graphic mover in Unity to animate UI graphics on start and end screens using move to, move from, and scale to with editor setup.

Enhance the start screen by importing a title icon and a custom font, creating a UI image and title text, and applying a staggered screen fade.

Enhance the maze layout in Unity with lighting, a larger floor, and a 5×5 node grid. Adjust the camera for a cinematic view and set the level goal, then test.

block out a level in Unity using primitive cubes and cylinders, snap to a half-unit world grid, and align pivots to form a rough airport/convention center inspired layout.

Learn level blocking in Unity by building blocking geometry, posts, pillars, and shadows, organizing with empty transform containers, and refining snaps and scales for a cohesive layout.

Continue level blocking in Unity by building a back wall, reception desk, and lounge area with cubes and cylinders to block layout and test lighting.

Adjusts environment lighting and reflections using the skybox, prioritizes light maps for visible objects, and explores ambient occlusion, final gathering, and directional lights to shape the scene.

Export Unity primitives to an external 3d package using rbj/obj workflows, via scripts or the scene rbj exporter from the asset store, then import into Maya for higher fidelity modeling.

Break down 3D assets in Maya for Unity by partitioning models for blocking, optimizing light maps, and exporting as FBX with proper pivots, materials, and UV islands for accurate lighting.

Rebuild the level by coordinating high rez models over blocking geometry using grid snapping in Maya, then refine and transfer to Unity for final assembly.

Manage and assign materials across Maya and Unity, then optimize lightmaps and global illumination with static geometry, per-object scale, and color palettes.

Apply finishing touches to the level by adding six vertical supports, glow-lit accents, and a glow material with emission; then bake lighting to refine shadows and complete level extras.

Create a level plaque with a world-space UI label that automatically shows the current level name from the active scene in Unity, using a C# script to assign the text.

Add an enemy guard, place it on the board, and enable four-direction facing with real-time lighting. Refactor movement via a base mover with separate player and enemy movers.

Refactor the mover to track a generic current node for any character, updating it from the board and validating connectivity before moves.

Extends a base mover to create an enemy mover that inherits movement from the mover class, adds face destination, and uses a test routine with delayed moves for maze navigation.

Develop an enemy sensor on the guard that detects the player directly in front by converting a local forward direction to a worldspace node on the board.

Organize turn based gameplay by building a turn manager base class for players and enemies, enabling finished turns and notifying the game manager to update.

Define player and enemy turns in the game manager, expose a current turn property, and implement update turn logic to switch between players and enemies.

Create a turn-based system by wiring turn manager with player and enemy managers using finished movement Unity events. Add wraparound enemy moves and stand routines, updating the board before turns.

Create an enemy sentry that spins to face the player, detects them in front, and can be approached from side or back. Implement a spinner movement type and sensor logic.

Create a player death animation in Unity by tilting the piece from its rear edge with a helper node, keyframes, bounce, and rocking via animation curves.

Configure the player base animator controller as a state machine, with a default state and a transition to the death animation via the is dead trigger.

Trigger enemy attacks to cause player death using public animator controller, player death, and enemy attack scripts; coordinate with the player manager and game manager for timing and transitions.

Create a C# enemy death component in Unity that moves the enemy off screen with a Vector3 offset and drops it into a board capture position via a death event.

Implement a capture enemies mechanic by checking the board for enemies at the player's node after movement, then capture them before finishing the turn.

Fix the enemy turn logic by skipping dead or captured enemies in the game manager, ensuring correct turn order and reliable level completion.

Update the enemy sensor to respect node linkages and only detect the player when the current node is connected to linked nodes, via the enemy mover and manager.