Make a Ninja Survival game for mobile in Unity® and Blender!

Explore the Unity editor interface, learn to navigate the scene, and manipulate 3D models like cubes and spheres, while applying color, transparency, and lighting.

Create a new Unity project, set its name and location, then explore core editor windows and components like Transform and Camera to build game objects.

Move and rotate objects in Unity using the transform component to adjust position on the x, y, and z axes and explore scale with a 3D cube.

Create and apply materials in Unity to change a cube’s color, then adjust rendering mode and alpha to make transparent glass walls and shadows.

Explore how directional, spotlight, and point lights shape scenes, shadows, and ambient intensity in Unity, and learn to adjust rotation, range, intensity, and color.

Create and position a Unity particle system, emitting from a cube, and adjust duration, start delay, lifetime, speed, gravity, color, rotation, shape, and simulation space (local or world) for effects.

Add a rigid body to the cube in Unity to apply gravity and collisions, producing a physics simulation. Tweak rotation and positions, duplicate objects, and observe tumbling and particle effects.

Discover the Unity asset store to extend your game by swapping simple assets for ready-made 3D models, animations, complete projects, scripts, and shaders, then import into your project.

Explore basic coding concepts in C#, including variables, methods, conditionals, and loops, to start building a ninja survival game for mobile in Unity.

Create a simple Unity scene with a cube, attach a C# script, and expose public variables like size modifier, new name, and is rotated to drive behavior and debugging.

Learn to use methods in Unity to perform operations, pass parameters, and return values, including start and update lifecycle methods, transform manipulation, and creating custom string-returning functions.

Explore how if blocks enforce conditions in Unity using C#. Learn to compare numbers and strings, use else, and apply booleans like is rotated to rotate a cube.

Learn to spawn multiple cubes in Unity by creating a cube prefab, a game controller script, and using for and while loops to instantiate cubes at random positions.

Explore basic input systems in Unity to listen for key presses, move left, right, forward, and jump with space, and switch between camera viewpoints, including a chasing camera.

Create a Unity project, implement a game controller script, and learn input handling with get key and get key down to move left/right and jump, printing Hello world.

Create a player cube in Unity, assign a script with a public speed, and move the player left and right using Time.deltaTime and keyboard input for frame-rate independent movement.

Apply a vertical force to the player's Rigidbody on space press using Unity's physics, and enable jumping only after collision with the floor, with jump force adjustable at runtime.

Move and rotate a player in Unity using transform.forward for forward motion and rotate around the Y axis with delta time, while using left and right inputs.

Cycle through four cameras in Unity using a game controller by enabling one camera at a time, while a chase camera follows and looks at the player.

Discover how to use Unity prefabs to reuse objects like bullets, enemies, coins, and explosions, and replicate them across scenes, guided by practical particle effects.

Learn to build a simple scene with floor and wall, create a bullet prefab with rigidbody, and shoot it by instantiating from a player script on click.

Learn to control bullet direction in Unity by exposing a shoot direction, instantiating the prefab, normalizing vectors, adding random spread, and implementing a 3‑second lifetime with automatic destruction.

Learn to create a simple explosion in Unity by spawning colored explosion particles as prefabs, applying random rigidbody forces, and destroying particles after a short lifetime.

Learn to add explosion effects in a Unity mobile game by detecting bullet-wall collisions, using colliders and OnCollisionEnter, checking collision tags for trigger explosion, and instantiating explosion prefabs.

Set up a new Unity project for a ninja survival mobile game in 3D mode with a 2D feel, name it ninja, and organize assets into scripts, scenes, and triodes.

Create a simple Unity scene by adding a floor from a scaled cube, color it with a matte material, and place a player object with a box collider.

Enable gravity with a rigidbody, freeze rotation, and move a mobile-friendly 2d-style player in a 3d scene by dragging on the screen, using screen percentage coordinates to handle different resolutions.

Compute movement variation by converting mouse or touch input to viewport coordinates, tracking click origin, and calculating variation as viewport minus origin, with debug logs and reset for Unity testing.

Explore implementing smooth 3d movement in Unity for a ninja survival game, using an original position anchor, target position, and lerp to move along x and z while locking y.

Switch the main camera from perspective to orthographic to render a 2d, isometric-like view with parallel rays, and adjust size and rotation for mobile aspect ratios 3:4 to 9:16.

Create a jumping enemy in Unity by modeling a red sphere, adding a rigidbody and collider, and scripting collision-triggered jumps with a configurable jumping force and random horizontal movement.

Define a public horizontal range to bound the jumping enemy, clamp its y position, then use velocity to switch from up to down and lerp to a random target x.

Implement collision detection in Unity to destroy the player when an enemy touches it, using a get component check for the player and a kill method to destroy the object.

Build a Unity canvas UI to show a survival timer, anchor the text at the top-left, and configure the canvas scaler for scale with screen size in portrait mode.

Create a Unity game controller to manage end game messages and a countdown timer, updating the user interface with you win or you lose, and grant invincibility after victory.

Learn to make a reusable game controller in Unity, turn the jumping enemy into a prefab, and design multiple levels with scalable difficulty for a ninja survival game.

Expose a jumping enemy prefab in the game controller, instantiate the enemy at runtime, and parent it to the game controller for dynamic, switchable enemy creation in Unity.

Define a game mode enum in Unity to switch between jumpers, rollers, and shooters, using if-else or switch blocks and debug warnings for unimplemented modes.

Create a rolling enemy in Unity by building a rolling enemy object, assigning a rolling enemy script from the jumping enemy, and using a rigidbody with a sphere collider.

Configure the rolling enemy to move left and right within a horizontal range, rolling along the x-axis and adjusting depth on the z-axis, with a wait duration between turns.

Define an array of integer depth values for the roding enemy and pick a random depth at start with Random.Range, then position it with a vector3 and randomize its side.

Expose a public lock property controlled by the game controller to switch between jumping and rolling modes, and implement collision logic to kill the player with rolling enemies in Unity.

Learn to implement a depth range in Unity to constrain player and enemies along the z-axis, using a depth range property, clamping positions, and applying percentage-based calculations for rolling enemies.

Apply horizontal range calculations to keep the player and enemies within screen bounds across aspect ratios, using an orthographic camera and dynamic aspect variation to adjust bounds.

Learn to create a bouncing enemy prefab in Unity, build its red spike model, add colliders and rigidbody, and wire it into the game controller for balancer mode.

Extend the rolling enemy into a bouncing enemy in Unity, using speed, depth range, and horizontal range, with a random start position and rigidbody velocity for dual-axis motion.

Convert a 0–360 degree angle to radians and apply cos and sin to derive horizontal and z axis velocity, then use speed in Unity's update loop to move enemy diagonally.

Flip the bouncing enemy's movement when it hits bounds by adjusting target velocity with vector3, using horizontal and depth limits, and updating rigidbody velocity in unity.

Define two public variables, base angle and angle, to set a random initial trajectory for the bouncing enemy. Use a 50/50 random to decide up-down and left-right.

Control enemy spawn counts with the game controller, using a for loop to spawn multiple bouncers, and prevent enemy collisions by assigning a dedicated enemy layer in Unity’s collision matrix.

Coordinate the bouncing enemies with the game controller by spawning one on the left and one on the right using an even/odd check, and manage initialization with awake and start.

Balance enemies in the ninja survival game by adjusting bouncing enemy angles and collision, including rolling enemies and player death on contact. Add depth walls to define bounds.

Design and implement crawling enemies in a Unity mobile survival game by creating three models, a crawling enemy script, and spawning randomized prefabs with horizontal offset.

Implement crawling enemy movement in Unity by adding speed and lifetime, using delta time for countdown, moving with rigidbody velocity, destroying enemy after lifetime, and killing the player on collision.

Explains implementing player rotation and jump logic in Unity, using canJump to control jumping, detecting mouse release or touch, and smoothly rotating the player model with quaternions and lerp.

Define a jumping angle and force, compute x and y from cos and sin of the angle in radians, and apply force using the rigidbody, with z zero.

Learn to implement a jumping state in Unity, gating input while jumping, detecting floor collisions to reset jumps, and tuning jump force and angle for responsive movement.

Implement crawler spawning in a Unity mobile game with a spawn timer and interval in the game controller, conditioned on game mode. Use prefabs and layer settings to prevent collisions.

Design and implement a turret enemy in Unity by building a cylinder model, applying a material, turning it into a non-collider prefab, and configuring its spawn and aiming behavior.

Define three turret states—waiting, moving, aiming—with duration controls for each, and cache the turret component to avoid repeated GetComponent calls.

this lesson builds a simple turret state machine in Unity, cycling through waiting, moving, and aiming using a target position and rotation with timers and linear interpolation for smooth motion.

The lesson demonstrates smooth aiming in unity by using the look at method and target rotation, then applies lerp to interpolate toward the target with an aiming speed.

Learn to implement enemy aiming and shooting in a Unity game: set horizontal targeting, instantiate and move bullets, handle collisions with triggers, bullet lifetime, and basic rotation for visual effect.