Dev Log

Here's what the heart containers look like when taking damage. Working on collision detection at the moment.

The code is far over my head; I can't believe I listened to the whole thing. Seeing the graphic has me thinking about how we're going to display armour and such as well. HUD in general is something I'll keep in the back of my mind this week. Keep up the good work!

So I've been working on locking and found it to be a bit trickier than I expected. The issue is how Unity handles colliders. In Unity, you can put a game object in its own collision layer then designate which layers can collide with one another. For example, I've setup 3 layers: player, ally, and enemy. Player can walk through allies but cannot walk through enemies. The problem is that when you tell Unity to ignore a layer it also turns off collision triggers. A trigger is an invisible volume that detects other colliders. When collider enters its space, an event is raised so that you can react to it. Think of how doors work in FP. There is a trigger on the door that checks whether the player is an ally or enemy. Depending on which, the open door animation plays. Triggers are essential because they tell me when an ally or enemy comes within range.

So instead of turning off the collision at the layer level, I'm telling Unity to ignore collision at the object level. For some reason, ignoring collision this way does not turn off triggers. The problem with this approach is that I have to tell Unity to ignore every ally object individually. If there's a respawn, then I have to account for that as well because Unity treats it as a new object.

What I plan to do is to check at the time of collision if an object is an ally. I'll turn off collision for that object, but triggers will still work. Not sure what happens memory-wise after an ally object is destroyed but I'm pretty sure Unity handles the clean up. I could also have a script that keeps track of respawns and turn it off as soon as an ally object is created.

Not sure yet how this will work during multiplayer games. From player A's point of view, player B is an ally. From player B's point of view, player A is an ally. I don't know if Unity can change the layers of each player depending on which point of view the game is being played. I'm pretty sure there's a way otherwise you'd never be able to make a multiplayer game.

The other tricky part is switching between ally and enemy locks. Since is character driven, I can't write a generic targeting script. I'll probably have to have 2 versions of the targeting script: one for allies and one for enemies. Oh, there'll probably a third one for scene objects (mask machines, ores, trees, etc.). Crap, I have to figure out a way to generalize this. Perhaps a generic script with a some sort of property telling it what it can lock on to (allies, enemies, objects)...

Yes, I was curious about it so I did do a quick search on multiplayer games in Unity. In brief, there are 2 ways of handling multiplayer games: authoritative server and non-authoritative server. In an authoritative server, all objects are created and maintained in a central server. Clients (players) only send and receive updates. In a non-authoritative server, clients own the objects. Updates are sent to the central server and all other clients are updated accordingly. There are pro's and con's for each method. In the end, we'll probably have to do a hybrid approach. Some things the server will handle, others things the clients will handle it.

This is something we need not worry about at the moment since we will be focusing on the single player campaign. It was just a thought that entered my head while I was writing.

I don't know for sure but if I had to make an educated guess I'd say that it uses a combination of the two. However, the way FP handles matchmaking is different from the way we will be doing it. FP designates a player as the host. We will most likely use a central server (Kongregate, Photon, etc.) as the host. It's just a matter of deciding which parts of the game should be handled at the server vs. client.

On another note, I'm close to finishing locking. Probably another night or 2 of coding, though I might leave it for the weekend.

Basic targeting pretty much done. I need to tweak a couple of things but the code works in general. Here's the code:

using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class Targeting : MonoBehaviour {
private GameObject currentTarget;
private PlatformInputController inputController;

public float range = 10f;
public LayerMask layer;

// Use this for initialization
void Start ()
       {
inputController = GetComponent<PlatformInputController>();
}

// Update is called once per frame
void Update()
{
//Lock button pressed.
if (Input.GetButtonDown("Lock"))
{
//Find the closest target.
currentTarget = GetClosestTarget(range, layer);
if (currentTarget != null)
{
Debug.Log(currentTarget.name);
}
}

//Lock button released.
if (Input.GetButtonUp("Lock"))
{
currentTarget.renderer.material.color = Color.white;
currentTarget = null;
inputController.autoRotate = true;
}

//Lock button held.
if (Input.GetButton("Lock"))
{
if (currentTarget != null)
{
currentTarget.renderer.material.color = Color.red;
inputController.autoRotate = false; //Turn off auto-rotation while locking.
transform.LookAt(currentTarget.transform); //Rotate player towards target.
}
}
}

GameObject GetClosestTarget(float radius, int layer)
{
GameObject closestTarget = null;
float distance = radius;
float currentDistance = 0f;
//TODO: Need to optimize search as there could be thousands of gameobjects in a scene.
GameObject[] targets = GameObject.FindObjectsOfType(typeof(GameObject)) as GameObject[];

foreach (GameObject target in targets)
{
if ((layer & (1 << (target.layer))) != 0)
{
Vector3 forward = transform.TransformDirection(Vector3.forward);
Vector3 toOther = target.transform.position - transform.position;
//The priority variable gives more weight to targets in front of player.
float priority = Mathf.Clamp(Vector3.Dot(forward.normalized, toOther.normalized), 0f, 1f);
currentDistance = Vector3.Distance(target.transform.position, this.transform.position) - priority;
if (currentDistance < distance)
{
closestTarget = target;
distance = currentDistance;
}
}
}
return closestTarget;
}
}