Spring Break: March 29 – April 27 – METAL MADNESS by Sam Cox

Prototype Feedback

On March 29th, I provided to Guy what I had done so far in response to the feedback we had gotten on last week’s playtest session on Thursday.

Guy provided some clarification on the last part, although I was still unsure by what he meant.

I also asked about putting in a tutorial for the game:

Resetting Interactables

To reset interactable objects whenever the player fell through the world and respawned, I made a new function in GameManager.cs

    void ResetInteractables()
    {
        foreach (var interactable in _interactables)
        {
            interactable.ResetPosition();
        }
    }

And then in Interactables.cs:


public class Interactables : MonoBehaviour
{
    Vector3 _originalPosition;
    Quaternion _originalRotation;
    // Start is called before the first frame update
    void Start()
    {
        _originalPosition = transform.position;
        _originalRotation = transform.rotation;
    }

    public void ResetPosition()
    {
        transform.position = _originalPosition;
        transform.rotation = _originalRotation;
    }
}

Player Cooldown

As suggested previously, I added a cooldown to the game, so in PlayerAbility.cs, after the player casts an ability, I call this IEnumerator:

    IEnumerator CoolDownAbility()
    {
        _abilityIsCoolingDown = true;
        yield return new WaitForSeconds(cooldownTime);
        _abilityIsCoolingDown = false;
    }

And then I added this line whenever the player tries to get up the ability menu:

(_abilityIsCoolingDown) return;

Graphics Settings

I also started work on the game’s graphics settings. Parker, in his GDD, said that “The minimum requirements should be kept low due to the very large target demographic of family players.” Therefore, having graphics options was crucial for allowing the game to be run on those lower end platforms, as well as maximizing the game’s graphics for those players with machines that can handle it.

There are 5 graphics options, Potato, Performant, Balanced, High Fidelity, and Max. I added the Potato and Max quality options.

I implemented this by going into File, then Build Settings, selecting Player Settings, then on the left hand menu, selecting Quality. This then allowed me to add quality options to the game, as well as set presets for each platform. For desktop, I selected Max to be the default option, and Potato for WebGL.

This was what is shown in the Quality screen. The main thing to note is that the way I affected the quality of the game was mostly through the Render Pipeline Asset. Each URP Asset also contains a corresponding Renderer file, and it is the Asset I modified which determined the game’s image quality, so I made 4 new files, 2 for the Potato quality and another 2 for the Max quality.

Below is an overview of those graphics features.

Basketball Fix

There was an issue I noticed with the basketball, where if I used the gravity ability to get the player up to the basketball and try to go through the hoop, they would get stuck within the loop. The fix I found was to turn off the convex option for the Mesh Collider on the GameObject. I also added a sister GameObject with a Box Trigger that, when the player passes through, plays a sound.

Portals

I was inspired by the Portal series of games to add exactly that, portals! To facilitate this, I created a new GameObject and a script called Portal.cs.

using UnityEngine;

public class Portal : MonoBehaviour
{
    [SerializeField] Transform cameraTransform;
    private void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            other.transform.position = cameraTransform.position;
        }
    }
}

The object was a plane that contained a Render Texture that was connected to a camera where the new destination would be. There’s also a Mesh Collider with a trigger so that when the player jumped onto the box, they would be teleported to the location of the camera.

HDR Issues on Mac

There was one issue that I noticed on my Mac, and not anywhere else where the screen would be mushy and Eta would have a black dot. It didn’t affect gameplay but it was annoying to look at, and it wouldn’t go away when I built the lighting.

I later discovered that the fix was to disable HDR in the Player Build Settings.

Possession Ability

I also worked on the possession ability such that I would have a workable version in the end. I had it mostly working on the code side, at least, allowing the player to switch to the ability and to apply it, but not the actual ability.

In the PlayerAbility script, when the player hits the E key and activates the MoveObject coroutine, it will look for each GameObject with an Interactables script, and set a bool in that script to true, and then wait a bit and set it to false.

IEnumerator MoveObjects(Interactables objects)
{
    objects.canMove = true;
    yield return new WaitForSecondsRealtime(forceMovementEnd);
    objects.canMove = false;
}

And this is the code in the Interactables script:

    private void FixedUpdate()
    {
        MoveObject();
    }

    void MoveObject()
    {
        if (_rb == null) return;
        if (!canMove)
        {
            _rb.isKinematic = false;
            return;
        }
        _rb.isKinematic = true;
        Vector3 movement = _camera.transform.right * _movementDirection.x + _camera.transform.forward * _movementDirection.y;
        movement.y = 0f;
        _rb.MovePosition(_rb.position + movement * (_movementSpeed * Time.fixedDeltaTime));
    }

HubWorld

There was also an issue with the HubWorld, with was highlighted by Esi.

I was also able to fix it by going into the scene, and hooking up the objects that was need to be hooked together in the inspector.

WebGL testing

I also tried to make as WebGL build of the game, however, it produced subpar results with the FPS, even at Potato quality.

Font Experimentation

For the font of the game, I messaged Parker about what he used for his GDD.

I found a free version of this font on the internet and I imported it into Unity. I made it into a FontAsset using Unity’s Text Mesh Pro tools and added it to the existing UI elements, however, it looked like this.