George Kruger Home Projects CV Contact
Project Details
Project Type Personal Project
Duriation 1 Month
Tools Used

Unity

Trello

GitKraken

Visual Studio

Jett is a high-octane, anti-gravity racer inspired by games reminiscent of Wipeout, F-Zero, Pacer and BallisticNG. Jett is a personal project developed during the summer break whilst attending university, used as a platform to learn and experiment with systems and features normally found within racing games. The project concluded in a playable graybox prototype that included an array of core features. With a potential to restart the project again from scratch in the future, equipped with a better understanding of developing a project like this would allow for higher quality and efficient implementations.

Main Features
Racer Tracking System

The tracking system utilizes a spline following along the course of a track, enabling positional tracking of racers along the track – an essential component for many other features needed in this project. These features include:

  • Accurately ranking racers allowing for players to see where they position in real-time.
  • A checkpoint system defined during development, serving multiple purposes:
    • Tracking time splits between racers or from a player’s personal best record.
    • Preventing players from exploiting unintentionally skipping parts of the track by ensuring that they pass each checkpoint in succession.
    • Return players back on the track should they fall out of bounds, storing a position on the spline should they become ungrounded.

This would only require mapping a spline along a track and defining checkpoints along it, ensuring straightforward implementation will allow for efficient horizontal development.

Ship Leveller System

The ship leveller is responsible for smoothly aligning the racer with the surface angle of the track, ensuring seamless transitions between different surface rotations. This is achieved by utilizing an array of raycasts that returns the surface rotation value and create an average value used for setting the ship's rotation. The density of the array, it's size and offset can be easily adjusted to fit the footprint of a ship.

Code Snippet
  1. public float Width;
  2. public float Length;
  4. public int WidthAmount;
  5. public int LengthAmount;
  6. public float LengthOffset;
  1. private void PlayerLeveler()
  2. {
  3. Vector3 Medium = RaycastCalc();
  4. float RotateRate;
  6. if (Medium == new Vector3(0, 0, 0)) //Non-Grounded
  7. {
  8. Medium = new Vector3(0, 1, 0);
  9. RotateRate = 2f;
  10. }
  11. else //Grounded
  12. {
  13. RotateRate = 7f;
  14. }
  16. //Rot Setter
  17. Quaternion SetRotation = Quaternion.FromToRotation(transform.up, Medium) * transform.rotation;
  18. transform.rotation = Quaternion.Lerp(transform.rotation, SetRotation, RotateRate * Time.deltaTime);
  19. }
  1. private Vector3 RaycastCalc()
  2. {
  3. float WidthGap = (Width * 2 / WidthAmount);
  4. float LengthGap = (Length * 2 / LengthAmount);
  6. float Xpos = Width;
  7. float Ypos = Length + LengthOffset;
  8. int XposReset = 0;
  10. Vector3 MedRotation = new Vector3(0, 0, 0);
  12. for (int i = 0; i < (WidthAmount * LengthAmount) + LengthAmount + WidthAmount + 1;)
  13. {
  14. if (XposReset > WidthAmount)
  15. {
  16. Xpos = Width;
  18. XposReset = 0;
  19. Ypos -= LengthGap;
  20. }
  21. else
  22. {
  23. MedRotation += LevelerRaycast(Xpos, Ypos);
  25. Xpos -= WidthGap;
  26. XposReset++;
  27. i++;
  28. }
  29. }
  31. int devide = (WidthAmount * LengthAmount) + (LengthAmount + WidthAmount) + 1;
  32. Vector3 Final = new Vector3(MedRotation.x / devide, MedRotation.y / devide, MedRotation.z / devide);
  33. return Final;
  34. }
  1. private Vector3 LevelerRaycast(float Xpos, float Ypos)
  2. {
  3. Vector3 RayOrigin = transform.position + (transform.forward * Ypos) + (transform.right * Xpos);
  5. Color RaycastColor;
  6. Vector3 HitNormal;
  7. int MaxDistance = 12;
  8. float DebugDrawDistance;
  10. RaycastHit hit;
  11. if (Physics.Raycast(RayOrigin, transform.TransformVector(Vector3.down), out hit, MaxDistance, ~IgnoreRaycastLayer)) //Ray hits a surface
  12. {
  13. DebugDrawDistance = hit.distance;
  14. RaycastColor = Color.green;
  15. HitNormal = hit.normal;
  16. }
  17. else //Ray out of range
  18. {
  19. DebugDrawDistance = MaxDistance;
  20. RaycastColor = Color.red;
  21. HitNormal = new Vector3(0, 0, 0);
  22. }
  24. if (DrawDebugRays)
  25. {
  26. Debug.DrawRay(RayOrigin, transform.TransformVector(Vector3.down) * DebugDrawDistance, RaycastColor);
  27. }
  29. return HitNormal;
  30. }
Track Intro

After a scene has finished loading, a camera cinematic will play on loop until the player proceeds. This is achieved by utilizing Unity's keyframe animation and animation tree systems. Taking advantage of these built-in systems allow for simple implementation and flexible revision of each animation, as well as being able to attach functions in the animation timeline for effects and flexibility of each animation's order.

Main Menu

A main menu wasn't essential for the playable prototype, but it was an element I wanted to include to experiment and learn from, with the goal to create a simple menu system and design that accommodates with both controller and mouse/keyboard inputs.

3D Modeling

I wanted to integrate some 3D modelling work into the project, as I enjoy the process of 3D art, and integrating it into an active project seemed fitting. While the model remains incomplete, I am satisfied with how it is taking shape, and should I return to this project later and opt to recreate from the project from the ground-up, this model will likely carry over to a future iteration.

The basic greyboxing for the test level was also done within blender, as it was easier to create a smooth yet irregular set of surfaces to test as a track environment.