Prompt #1: “Describe step by step how to create a 3d character controller for a basic platformer game using Unity”
Muse
To create a 3D character controller for a basic platformer game in Unity, follow these steps:
- Create a new Unity project and import any necessary assets.
- Create a new scene and add a ground plane.
- Create a new GameObject and name it “Player”.
- Add a Rigidbody component to the Player GameObject :citation[1].
- Add a Capsule Collider component to the Player GameObject :citation[2].
- Add a script to the Player GameObject to handle movement and input :citation[3].
- In the script, add variables for movement speed, jump force, and gravity.
- In the script, add code to handle horizontal movement using the Input.GetAxis() function
–boundary-37a8dc0f854147438b52921ae1eebccf
{“source”: “Unity - Manual: Unity XR Input”, “reason”: “Input.GetAxis() function usage.”}
boundary-37a8dc0f854147438b52921ae1eebccf
. For example:
float horizontalInput = Input.GetAxis("Horizontal");
Vector3 movement = new Vector3(horizontalInput, 0, 0);
transform.position += movement * speed * Time.deltaTime;
- In the script, add code to handle jumping using the Input.GetKeyDown() function and the Rigidbody.AddForce() function :citation[4]. For example:
if (Input.GetKeyDown(KeyCode.Space) && isGrounded)
{
playerRigidbody.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
}
- In the script, add code to handle gravity using the Rigidbody.AddForce() function :citation[1]. For example:
playerRigidbody.AddForce(Vector3.down * gravity * Time.deltaTime);
- Test the character controller in the scene and adjust variables as necessary.
Remember to define and initialize variables like speed, jumpForce, gravity, playerRigidbody, and isGrounded in your script. You may also need to implement a method to check if the player is grounded before allowing them to jump.
Claude
Here is a step-by-step guide to creating a 3D character controller for a basic platformer game in Unity:
- Create a new 3D Unity project. When prompted, select the 3D template.
- Create a plane to act as the ground by going to GameObject > 3D Object > Plane. Name it “Ground” and scale it up to an appropriate size.
- Create the character controller by going to Assets > Import Package > Character Controller. Import all the files.
- Create a capsule game object (GameObject > 3D Object > Capsule). Name it “Player”.
- Add the Character Controller component to the Player object (Components > Physics > Character Controller).
- Create a new C# script called “PlayerController” and attach it to the Player object.
- In the PlayerController script, declare variables for the CharacterController, Transform, and movement speed. Get references to the CharacterController and Transform components in the Start() method.
- In Update(), check for player input and move the character by calling CharacterController’s Move() method, passing in the movement vector * speed * Time.deltaTime.
- To handle jumping, check if the player presses jump and the character is grounded. If so, set a vertical velocity on the character’s movement.
- Handle gravity by applying a downward force to the vertical velocity over time in Update(). Clamp the velocity to a terminal velocity so the character doesn’t accelerate infinitely.
- Adjust the movement calculations and variables until the character’s movement feels right - things like max speed, acceleration, jump height, gravity, etc.
- Set up basic collision detection/response on the controller to handle landing on surfaces and not falling through terrain.
That covers the basics of setting up a controllable 3D character with Unity’s built-in character controller! Expand on it by adding animations, particle effects, etc.
LLama-2
Sure! Here’s a step-by-step guide on how to create a 3D character controller for a basic platformer game using Unity:
Step 1: Create a new project in Unity
First, open Unity and create a new project. Choose a project name, select a location to save the project, and then click “Create Project.”
Step 2: Create a new scene
In the Unity editor, go to File > New Scene, and then click “Create.” Name the scene (e.g., “Platformer”) and click “Create.”
Step 3: Create a new character model
Right-click in the Hierarchy panel and select “3D Object” > “Mesh” > “Cube.” Drag the cube into the Scene panel. This will be our character model. You can modify the cube’s shape and size by selecting it in the Hierarchy panel and adjusting its dimensions in the Inspector panel.
Step 4: Add a Rigidbody component
Select the character model in the Hierarchy panel and click on the “Add Component” button in the Inspector panel. Search for “Rigidbody” and add the Rigidbody component to the character model. This will allow the character to interact with the game world and other objects.
Step 5: Create a new script
Right-click in the Assets folder and select “Create” > “C# Script.” Name the script “CharacterController.” Double-click on the script to open it in your preferred code editor.
Step 6: Write the Character Controller script
Here’s an example of a basic Character Controller script:
using UnityEngine;
public class CharacterController : MonoBehaviour
{
public float speed = 10f;
public float jumpForce = 10f;
private Rigidbody rb;
void Start()
{
rb = GetComponent<Rigidbody>();
}
void Update()
{
float horizontalInput = Input.GetAxis("Horizontal");
float verticalInput = Input.GetAxis("Vertical");
Vector3 movement = new Vector3(horizontalInput, 0f, verticalInput);
rb.velocity = movement * speed;
if (Input.GetKeyDown(KeyCode.Space) && IsGrounded())
{
rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
}
}
bool IsGrounded()
{
return Physics.Raycast(transform.position, Vector3.down, 0.1f);
}
}
This script uses the Input system to get input from the player and moves the character left and right based on the horizontal input. It also allows the character to jump when the space bar is pressed and checks if the character is grounded before applying the jump force.
Step 7: Attach the script to the character model
Drag and drop the CharacterController script onto the character model in the Hierarchy panel. The script should now be attached to the character model.
Step 8: Test the character controller
Press Play in the Unity editor to enter Play mode. Use the arrow keys to move the character left and right, and press the space bar to jump. The character should now be able to move around the scene and jump off platforms.
That’s it! You have now created a basic 3D character controller for a platformer game using Unity. Of course, this is just the beginning - there are many more features you could add to the character controller, such as strafing, looking around, and collision detection. But this should give you a good starting point for creating your own 3D platformer game.
GPT-4
Creating a 3D character controller for a basic platformer game involves creating a 3D model, importing it into Unity, and writing scripts to control the character’s actions. Here’s a step-by-step guide:
- **Create Your 3D Character:**First, you’ll need a 3D character model. You can create this using software like Blender or Maya, or find a pre-made model. The model should be rigged and animated for basic movements like running, jumping, and idle.
- **Import Your 3D Character Into Unity:**Unity supports most popular 3D formats. Use the ‘Import New Asset’ option from the ‘Assets’ menu to import your 3D model. Once imported, place it into your scene.
- **Create a Character Controller Script:**You’ll need a script to control your character’s movements. This will be written in C#. Go to ‘Assets’ > ‘Create’ > ‘C# Script’, and name it something like ‘CharacterController’.Here is a very basic structure of how such a script may look:
csharpCopy code
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class CharacterController : MonoBehaviour
{
public float speed = 10.0f;
public float rotationSpeed = 100.0f;
public float jumpHeight = 2.0f;
private bool isJumping = false;
private Rigidbody rb;
void Start()
{
rb = GetComponent<Rigidbody>();
}
void Update()
{
float moveHorizontal = Input.GetAxis("Horizontal");
float moveVertical = Input.GetAxis("Vertical");
Vector3 movement = new Vector3(moveHorizontal, 0.0f, moveVertical);
rb.AddForce(movement * speed);
if(Input.GetButtonDown("Jump") && !isJumping)
{
rb.AddForce(new Vector3(0, jumpHeight, 0), ForceMode.Impulse);
isJumping = true;
}
}
void OnCollisionEnter(Collision collision)
{
if (collision.gameObject.tag == "Ground")
{
isJumping = false;
}
}
}
This script applies a force in the direction of input to the character’s Rigidbody, allowing it to move. When the Jump button is pressed and the character is not already jumping, an upward force is applied to simulate a jump. When the character hits the ground (any GameObject tagged “Ground”), it’s marked as not jumping and can jump again.
4. **Attach the Script to Your Character:**In the Unity editor, select your character model, then drag the CharacterController script from your project files onto the Inspector pane with your character selected. This attaches the script to your character.
5. **Set Up the Input Manager:**For the character to receive input, you’ll need to set up the Input Manager. Go to ‘Edit’ > ‘Project Settings’ > ‘Input Manager’. Here you can define various inputs. Make sure “Horizontal”, “Vertical”, and “Jump” inputs are defined and mapped to the correct keys or buttons.
6. **Test Your Game:**Now you should be able to press the ‘Play’ button in Unity and control your character. It should move based on your Horizontal and Vertical inputs, and jump when you press the Jump button.
Remember, this is a very basic character controller. There are many more features you might want to add, like animations, more complex movement, interactions with other objects, etc. However, this will provide you with a solid starting point.
Conclusion
Both GPT-4 and Llama-2 give thorough answers with specific instructions and a full script to get started. Claude gives specific instructions but doesn’t include any code. Muse provides less specific instructions than the other models and includes a few lines of example code.
Prompt 2: “Write the code for a basic 3d player character controller for a game in Unity. The player character should be able to use WASD to move and Space to jump. The player character should also be able to double jump after collecting a powerup, and should slide down when standing on surfaces that are too steep.”
Muse
Here’s a basic 3D player character controller script for Unity that includes WASD movement, jumping, double jumping after collecting a power-up, and sliding on steep surfaces:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PlayerController : MonoBehaviour
{
public float speed = 5f;
public float jumpForce = 10f;
public float slideForce = 5f;
public float maxSlopeAngle = 45f;
public bool canDoubleJump = false;
private Rigidbody rb;
private bool isGrounded;
private bool hasDoubleJumped;
private Vector3 groundNormal;
void Start()
{
rb = GetComponent();
}
void Update()
{
// Movement
float horizontalInput = Input.GetAxis("Horizontal");
float verticalInput = Input.GetAxis("Vertical");
Vector3 movement = new Vector3(horizontalInput, 0, verticalInput);
transform.position += movement * speed * Time.deltaTime;
// Jumping
if (Input.GetKeyDown(KeyCode.Space) && (isGrounded || (canDoubleJump && !hasDoubleJumped)))
{
rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
if (!isGrounded)
{
hasDoubleJumped = true;
}
}
// Sliding on steep surfaces
if (!isGrounded && Vector3.Angle(groundNormal, Vector3.up) > maxSlopeAngle)
{
rb.AddForce(Vector3.down * slideForce, ForceMode.Acceleration);
}
}
private void OnCollisionEnter(Collision collision)
{
if (collision.gameObject.CompareTag("PowerUp"))
{
canDoubleJump = true;
Destroy(collision.gameObject);
}
}
private void OnCollisionStay(Collision collision)
{
foreach (ContactPoint contact in collision.contacts)
{
if (Vector3.Angle(contact.normal, Vector3.up) < maxSlopeAngle)
{
isGrounded = true;
groundNormal = contact.normal;
hasDoubleJumped = false;
return;
}
}
isGrounded = false;
}
private void OnCollisionExit(Collision collision)
{
isGrounded = false;
}
}
Attach this script to your player GameObject, and make sure it has a Rigidbody and a Collider component. For the power-up, create a GameObject with a Collider component set to be a trigger and add a tag named “PowerUp” to it. Adjust the speed, jumpForce, slideForce, and maxSlopeAngle variables as needed.
Claude
Here is some example code for a basic 3D player character controller in Unity with movement, jumping, double jumping, and sliding functionality:
csharp
Copy code
using UnityEngine;
public class PlayerController : MonoBehaviour {
public float moveSpeed = 10f;
public float jumpForce = 10f;
public float slideSpeed = 5f;
public float maxSlideAngle = 45f;
private CharacterController controller;
private Vector3 moveDirection;
private bool canDoubleJump;
void Start() {
controller = GetComponent<CharacterController>();
}
void Update() {
// Get input for movement
float xInput = Input.GetAxis("Horizontal");
float zInput = Input.GetAxis("Vertical");
// Calculate movement vector
Vector3 move = transform.right * xInput + transform.forward * zInput;
// Apply gravity
moveDirection.y += Physics.gravity.y * Time.deltaTime;
// Move the controller
controller.Move(move * moveSpeed * Time.deltaTime);
// Jump
if (Input.GetButton("Jump") && controller.isGrounded) {
moveDirection.y = jumpForce;
}
// Double jump
if (Input.GetButton("Jump") && !controller.isGrounded && canDoubleJump) {
moveDirection.y = jumpForce;
canDoubleJump = false;
}
// Slide down steep slopes
if (controller.isGrounded && Vector3.Angle(Vector3.up, Vector3.ProjectOnPlane(moveDirection, Vector3.up)) > maxSlideAngle) {
moveDirection.x = -slideSpeed * Vector3.ProjectOnPlane(moveDirection, Vector3.up).x;
moveDirection.z = -slideSpeed * Vector3.ProjectOnPlane(moveDirection, Vector3.up).z;
}
}
void OnTriggerEnter(Collider other) {
// Pick up double jump powerup
if (other.gameObject.CompareTag("DoubleJump")) {
canDoubleJump = true;
Destroy(other.gameObject);
}
}
}
This implements basic movement and jumping, along with sliding down steep slopes and picking up a double jump powerup. Additional gameplay mechanics, animations, UI, etc. would be added on top of this foundation.
Llama-2
Here is some sample code for a basic 3D player character controller in Unity:
using UnityEngine;
public class PlayerController : MonoBehaviour
{
public float speed = 10.0f;
public float jumpForce = 10.0f;
public float doubleJumpForce = 15.0f;
public float slideSpeed = 5.0f;
private Rigidbody rb;
private bool grounded = true;
private bool doubleJump = false;
void Start()
{
rb = GetComponent<Rigidbody>();
}
void FixedUpdate()
{
// Movement
float horizontalInput = Input.GetAxis("Horizontal");
float verticalInput = Input.GetAxis("Vertical");
Vector3 movement = new Vector3(horizontalInput, 0f, verticalInput);
rb.velocity = movement * speed;
// Jumping
if (Input.GetKeyDown(KeyCode.Space) && grounded)
{
rb.AddForce(Vector3.up * jumpForce, ForceMode.Impulse);
grounded = false;
}
else if (doubleJump && grounded)
{
rb.AddForce(Vector3.up * doubleJumpForce, ForceMode.Impulse);
doubleJump = false;
}
// Sliding
if (!grounded && !doubleJump)
{
float slope = Mathf.Abs(transform.localPosition.x / transform.localPosition.z);
if (slope > 0.5f)
{
rb.velocity = Vector3.zero;
rb.angularVelocity = Vector3.zero;
transform.rotation = Quaternion.Euler(new Vector3(-90f, 0f, 0f));
rb.AddTorque(Vector3.back * slideSpeed, ForceMode.Impulse);
}
}
}
void OnCollisionStay(Collision collision)
{
if (collision.gameObject.CompareTag("Ground"))
{
grounded = true;
}
}
void OnTriggerEnter(Collider collider)
{
if (collider.gameObject.CompareTag("PowerUp"))
{
doubleJump = true;
}
}
}
This script assumes that your player object has a Rigidbody component attached, and that you have already set up the gameobject hierarchy and tags for the game.
The Start() method is called once at the beginning of the game, and sets up the reference to the Rigidbody component.
The FixedUpdate() method is called every frame, and handles the player movement and jumping. It gets input from the player using the Input.GetAxis() function, and applies forces to the Rigidbody using the Rigidbody.AddForce() function.
The OnCollisionStay() method is called whenever the player collides with a ground object, and sets the grounded flag to true.
The OnTriggerEnter() method is called whenever the player touches a power-up object, and sets the doubleJump flag to true.
Note that this is just one way to implement a 3D player character controller in Unity, and you may need to customize it depending on your specific game requirements. For example, you might want to add additional features like strafing, looking around, or collision detection.
GPT-4
Below is a very basic example of a Unity script that should accomplish these tasks. The code assumes that you have a Rigidbody and a Collider attached to your player GameObject, and your power-up object is tagged “PowerUp” in Unity.
When a power-up is collected, it enables the player to double jump until they use it. It’s also set up to make the player slide when the ground is steeper than a certain angle. This code doesn’t deal with animations - you’ll need to handle those separately if you want the character to animate while performing these actions.
csharpCopy code
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class PlayerController : MonoBehaviour
{
public float speed = 10.0f;
public float rotationSpeed = 100.0f;
public float jumpHeight = 2.0f;
public float maxGroundAngle = 45.0f;
private bool isJumping = false;
private bool canDoubleJump = false;
private Rigidbody rb;
private Vector3 groundNormal;
void Start()
{
rb = GetComponent<Rigidbody>();
}
void Update()
{
float moveHorizontal = Input.GetAxis("Horizontal");
float moveVertical = Input.GetAxis("Vertical");
Vector3 movement = new Vector3(moveHorizontal, 0.0f, moveVertical);
rb.AddForce(movement * speed);
if (Input.GetButtonDown("Jump"))
{
if (!isJumping)
{
rb.AddForce(new Vector3(0, jumpHeight, 0), ForceMode.Impulse);
isJumping = true;
}
else if (canDoubleJump)
{
rb.AddForce(new Vector3(0, jumpHeight, 0), ForceMode.Impulse);
canDoubleJump = false;
}
}
// Handle steep slopes
if (Vector3.Angle(Vector3.up, groundNormal) > maxGroundAngle)
{
Vector3 slideDirection = Vector3.ProjectOnPlane(Vector3.down, groundNormal);
rb.AddForce(slideDirection, ForceMode.Acceleration);
}
}
void OnCollisionEnter(Collision collision)
{
if (collision.gameObject.tag == "Ground")
{
isJumping = false;
groundNormal = collision.GetContact(0).normal;
}
if (collision.gameObject.tag == "PowerUp")
{
canDoubleJump = true;
Destroy(collision.gameObject);
}
}
void OnCollisionExit(Collision collision)
{
if (collision.gameObject.tag == "Ground")
{
groundNormal = Vector3.up; // Reset to prevent sliding when not on ground
}
}
}
Here’s how the code works:
- It adds forces to the Rigidbody to move and jump.
- If the player isn’t jumping, it allows them to jump.
- If they are jumping and have a double jump available (from a power-up), it allows them to jump again.
- When the player collides with the ground, it sets
isJumpingto false so they can jump again, and records the angle of the ground they landed on. - When they leave the ground, it resets the ground angle to prevent sliding when not on the ground.
- When they collide with a power-up, it enables double jumping and destroys the power-up.
- If the ground angle is too steep, it makes the player slide down.
Note that this is a basic script and there’s a lot more you could add to it. You could implement animations, wall jumps, different types of power-ups, etc.
Conclusion
All these models do ok at writing basic code. GPT-4 performed the best, meeting all the requirements and only suffering from some poorly tuned default numeric values, and provided a thorough code explanation. Llama-2 and Claude performed the weakest with Llama-2 writing a really strange implementation of jump and sliding and no ability to collect the powerup along with a fairly weak code explanation. Claude was able to collect the powerup as a trigger but completely missed on gravity and only provided a minimal code expalnation in comments. Muse did ok, getting everything right except collecting the powerup due to giving instructions to set the Is Trigger flag on the powerup but using OnCollisionEnter in the code, but also didn’t explain its code very well.
Prompt #3: "Write a compelling narrative setting for a puzzle platformer game, including a backstory for the main character with some powers that will make for interesting gameplay.
Muse
In the mystical realm of Ethea, an ancient civilization once thrived, harnessing the power of elemental crystals to create marvels of technology and magic. Over time, their hubris led to their downfall, and the once-great cities now lay in ruins, reclaimed by nature and shrouded in mystery.
You play as Lyra, a young and curious adventurer, who discovers an ancient artifact while exploring the remnants of Ethea. The artifact, known as the “Aegis of Elements,” unexpectedly bonds with her, granting her the ability to manipulate the four elements: earth, water, fire, and air.
As Lyra, you must traverse the treacherous landscapes and solve intricate puzzles to uncover the forgotten secrets of the ancient civilization and restore balance to Ethea. Each element offers unique gameplay mechanics and abilities:
- Earth: Lyra can create temporary platforms, move large objects, or reshape the environment to overcome obstacles.
- Water: Lyra can control water flow, freeze it to create icy surfaces, or generate steam to power ancient machinery.
- Fire: Lyra can ignite flammable objects, create explosions to clear paths, or use fire to provide light in dark environments.
- Air: Lyra can create gusts of wind to move objects, glide across large gaps, or manipulate air pressure to activate mechanisms.
Throughout the game, Lyra encounters various elemental guardians who challenge her mastery of each element. As she progresses, she learns more about the tragic history of Ethea and her own connection to the ancient civilization. Ultimately, Lyra must confront the source of the imbalance threatening Ethea and decide the fate of the realm.
The game’s narrative unfolds through environmental storytelling, ancient texts, and interactions with ethereal beings who guide Lyra on her journey. The evocative setting, combined with Lyra’s elemental powers, creates a rich and engaging puzzle platformer experience.
Claude
Here’s a potential narrative setup for a puzzle platformer:
The main character is a young girl named Stella who lives in a sleepy seaside village. She’s always been fascinated by the old lighthouse on the cliff overlooking the village. Legend says it was built long ago by a mystical order of monks to guide ships safely to harbor.
One night during a fierce storm, Stella sees a strange glow coming from the abandoned lighthouse. Sneaking up to investigate, she discovers the ghostly forms of the old monks still dutifully keeping the light.
The apparitions greet Stella, explaining that a vengeful sea witch had cursed their brotherhood ages ago. The monks are trapped between the living world and the spirit realm, unable to move on until the witch’s curse is broken. They tell Stella she’s the first person able to see them in centuries. She could be the one to finally free them!
Stella agrees to help. The monks grant her magical abilities to aid in her quest - she can conjure ghostly platforms to reach new heights, charm spectral crabs and seagulls to ride and carry her, and summon guiding beams of moonlight.
With her new powers, Stella must traverse haunted seaside ruins, navigate lost underwater caverns, and ultimately make her way to the sea witch’s lair to break the curse once and for all. Along the way she pieces together the tale of the monks’ ancient tragedy and learns life lessons about bravery, compassion, and sacrifice.
The puzzle platforming challenges will stem from Stella mastering her new abilities to explore the atmospheric, magical environments while unlocking the story of the cursed monks and how Stella may be the key to finally setting their spirits free after all these years.
LLama-2
In the small village of Willowdale, nestled deep within the Whispering Woods, there lived a young girl named Lily. She was an ordinary child, with a love for exploration and adventure, until the day she stumbled upon a mysterious artifact hidden away in the forest. As soon as she touched it, she felt a strange energy coursing through her body, and suddenly, she found herself imbued with incredible powers.
Lily discovered that she could control the elements, summoning powerful gusts of wind, conjuring flames from thin air, and manipulating the earth itself. She could also communicate with animals, understanding their thoughts and emotions as if they were her own. But these powers came at a great cost, for they were tied to the balance of nature, and the more Lily used them, the more unstable the world became.
As the villagers began to notice the strange occurrences in the surrounding woods, they grew wary of Lily’s abilities. They saw her as a threat, a potential source of chaos and destruction. Fearing for her safety, Lily’s parents, who had always been supportive of her unique gift, sent her away to a secluded monastery, where she could learn to control her powers and understand their true extent.
Under the guidance of the wise monks, Lily spent many years honing her abilities, studying ancient texts, and meditating to connect with the natural world. She learned how to harness her powers without disrupting the delicate balance of nature. However, as she grew stronger, Lily realized that her abilities were not only a blessing but also a curse. She had become a conduit for the raw force of the universe, and the weight of that responsibility weighed heavily on her shoulders.
One fateful night, Lily received a vision from the spirits of the land, warning her of an impending catastrophe threatening the entire realm. A dark entity, born from human greed and neglect, had begun to spread its influence across the land, corrupting everything in its path. The spirits implored Lily to embark on a perilous journey to stop this evil force before it consumed all life.
Now, armed with her elemental powers and a deep connection to the natural world, Lily must navigate treacherous landscapes, solve enigmatic puzzles, and confront fearsome creatures to save the world from destruction. Her quest will take her to forgotten ruins, mystical groves, and towering mountains, each filled with ancient secrets and challenges that will test her strength, courage, and wisdom.
As she journeys forth, Lily will encounter unlikely allies, such as a wise old owl who serves as a guide, a mischievous Puck who offers his assistance in exchange for favors, and a group of rebels fighting against the dark entity. Together, they will brave the unknown, facing trials that will push Lily’s powers to their limits and beyond.
In this epic tale of magic, friendship, and sacrifice, Lily’s destiny hangs in the balance. Can she overcome the darkness that threatens to engulf the world? Will she find the strength to wield her powers for the greater good, or will she succumb to the temptation of their limitless potential? Embark on Lily’s odyssey and discover the fate that awaits her in this sprawling puzzle platformer game set amidst a fantastical world teeming with wonder and danger.
GPT-4
Game Title: “The Shattered Realms”
Game Description:
“The Shattered Realms” is a mesmerizing puzzle platformer set in the surreal, fragmented world of Eldoria. Eldoria was once a beautiful, thriving realm, a celestial artwork painted by cosmic deities. It was a perfect blend of vivid dreams and crystalline realities until an ominous cataclysm tore the world apart, leaving it fragmented and its inhabitants trapped in disparate reality shards.
Main Character Backstory:
You play as Eris, a young woman with a distinct gift inherited from her lineage. Eris was born into the Starweavers, an ancient tribe tasked with safeguarding the sacred Harmony Crystals. These crystals were the life source of Eldoria, maintaining its balance and vitality.
Eris was a lively and spirited child, always curious about the world around her. Growing up, her grandmother narrated stories of the Starweavers and the importance of the Harmony Crystals. This instilled in Eris a sense of responsibility and love for her land. Her life took an unfortunate turn when the cataclysm struck, shattering Eldoria and the Harmony Crystals. The realms broke apart into countless shards, each becoming a pocket universe with its unique laws of physics and reality.
Eris survived but found herself in an alienated world, far from her family and friends. The surviving Starweaver’s spirit, sensing Eris’s presence, bestows her with the power of the Harmony Crystals. The once playful child was now the lone hope for Eldoria.
Character Powers and Gameplay:
Eris’s powers, gifted by the Harmony Crystals, make for fascinating gameplay mechanics:
-
Reality Manipulation: Eris can manipulate the very fabric of her fragmented reality. This allows her to alter the environment to create platforms, bridges, or even defy the laws of gravity, offering a diverse range of puzzle-solving opportunities.
-
Time Control: Eris has the power to control time within the reality shards. She can slow it down to avoid fast-moving obstacles or speed it up to make platforms move faster.
-
Elemental Manipulation: With her connection to the Harmony Crystals, Eris can harness the elemental energy of fire, water, earth, and air. Each element has its unique uses and advantages, making for varied and compelling gameplay.
-
Astral Projection: Eris can project her astral form to reach otherwise inaccessible areas. This ability becomes vital in solving complex puzzles that require her to be in two places simultaneously.
-
Harmony Pulse: An ultimate ability that can restore a shard to its original state, but it needs to be used sparingly as it drains Eris’s energy.
As Eris navigates through the mind-bending puzzles and challenging platforms of the shattered reality shards, she must harness her abilities wisely. Her goal is to restore the Harmony Crystals, piece together her fractured world, and hopefully reunite with her lost family and friends. Each shard presents a unique challenge that tests the player’s wit, dexterity, and mastery of Eris’s powers. Each victory brings Eris one step closer to restoring Eldoria to its former glory.
“The Shattered Realms” is a tale of resilience, determination, and hope. It’s a journey through a world that’s as beautiful as it is challenging, and at the end of it all, a home that’s worth fighting for.
Conclusion
Narrative is somewhat subjective, but overall Muse provided a brief response and a story that was quite generic, although it did give some gameplay examples. Claude provided the most unique story but didn’t focus too much on gameplay. Llama-2 went even further toward the narrative side of things, with a story that might be better suited for a non-interactive medium. GPT-4 was the most deliberate, formatting sections to address each part of the prompt and providing an interesting mix of backstory and mechanics.
Overall
GPT-4 still performs the best for me in my use cases. The differences in response quality become more apparent the more extensive and technical your prompts become. GPT-4 can much more easily find bugs or help refactor code that other models struggle with. Muse so far is doing a fair job of keeping up with the other models. It excels in Unity specific tasks (as should be expected), but struggles in the same areas as other models with more complex logic and general knowledge. If you’d like to see more of these kinds of comparisons let me know.