You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
308 lines
10 KiB
308 lines
10 KiB
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using Networking.Server;
|
|
using TMPro;
|
|
using UnityEngine.UI;
|
|
using System.Linq;
|
|
|
|
[CreateAssetMenu(menuName = "Major Project/GameModes/Racetrack", order = 201)]
|
|
public class RacetrackGameMode : GameMode
|
|
{
|
|
public MapManager mapManager;
|
|
public GameObject spawn;
|
|
|
|
public int MaxRound = 999;
|
|
public string nextScene = "ServerTestScene";
|
|
List<ClientData> ConnectedClients;
|
|
public Material OverlayMaterial;
|
|
public float scrollSpeed = 1.0f; //The rate at which the level will scroll past
|
|
|
|
|
|
public int RoundCount { get; private set; }
|
|
private Dictionary<ClientData, List<Block>> BlocksOwned;
|
|
int currentBoulderCount;
|
|
|
|
/// <summary>
|
|
/// Called once before any players have spawned
|
|
/// </summary>
|
|
protected override void OnPreGameStart()
|
|
{
|
|
mapManager.init();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Called once all players have finished their moves but before the Objective is checked
|
|
/// </summary>
|
|
protected override void OnRoundEnd(PlayerData[] allPlayers)
|
|
{
|
|
cameraCheck(allPlayers);
|
|
|
|
//At the end of each round, any stuck players are freed to resume moving next round
|
|
foreach (PlayerData player in allPlayers)
|
|
{
|
|
player.character.stuck = false;
|
|
|
|
if (player.character.inPit && player.client.Lives > 0)
|
|
{
|
|
player.character.respawnCharacter();
|
|
}
|
|
}
|
|
|
|
RoundCount++;
|
|
}
|
|
|
|
void cameraCheck(PlayerData[] allPlayers)
|
|
{
|
|
//Get the average x-position of all players
|
|
float xAvg = 0.0f;
|
|
int livePlayerCount = 0;
|
|
|
|
foreach (PlayerData player in allPlayers)
|
|
{
|
|
if (player.client.Lives > 0)
|
|
{
|
|
xAvg += player.character.transform.position.x;
|
|
livePlayerCount++;
|
|
}
|
|
}
|
|
|
|
xAvg = xAvg / livePlayerCount;
|
|
|
|
//Turn that position into a vector in viewport space
|
|
Vector3 xAvgPos = new Vector3(xAvg, 0.0f, 0.0f);
|
|
Vector3 xAvgVP = Camera.main.WorldToViewportPoint(xAvgPos);
|
|
|
|
//Debug.Log("xAvgPos = " + xAvgPos + ", xAvgVP = " + xAvgVP);
|
|
|
|
//We move the camera forward by at least one increment
|
|
//Keep doing it until the average x-position is roughly centred
|
|
do
|
|
{
|
|
Camera.main.transform.Translate(scrollSpeed, 0, 0, Space.World);
|
|
xAvgVP = Camera.main.WorldToViewportPoint(xAvgPos);
|
|
|
|
//Debug.Log("Camera = " + Camera.main.transform.position + ", xAvgVP = " + xAvgVP);
|
|
} while (xAvgVP.x > 0.5f || xAvgVP.y > 0.5f);
|
|
|
|
//If the foremost player is off the screen, scroll forward to catch up with them
|
|
|
|
//Find who's furthest ahead
|
|
PlayerData playerAhead = allPlayers[0];
|
|
foreach (PlayerData player in allPlayers)
|
|
{
|
|
if (player.client.Lives > 0 && player.character.transform.position.x > playerAhead.character.transform.position.x)
|
|
{
|
|
playerAhead = player;
|
|
}
|
|
}
|
|
|
|
//Turn their position to a viewport vector
|
|
Vector3 playerVP = Camera.main.WorldToViewportPoint(playerAhead.character.transform.position);
|
|
|
|
//If that position is not in view, advance until it is
|
|
while (playerVP.x > 1 || playerVP.y > 1)
|
|
{
|
|
Camera.main.transform.Translate(scrollSpeed, 0, 0, Space.World);
|
|
playerVP = Camera.main.WorldToViewportPoint(playerAhead.character.transform.position);
|
|
}/**/
|
|
|
|
|
|
//We check for track sections we need to add/remove
|
|
mapManager.checkTrack();
|
|
spawn.GetComponent<blockSpawn>().wakeup();
|
|
|
|
//Move the camera forward at a steady rate each round
|
|
/*if (scrollSpeed > 0.0f)
|
|
{
|
|
Camera.main.transform.Translate(scrollSpeed, 0, 0, Space.World);
|
|
mapManager.checkTrack();
|
|
//Debug.Log("New camera position at x = " + Camera.main.transform.position.x);
|
|
|
|
//Plan: get average position of surviving players, centre camera view on it
|
|
//Also, will need to check every time someone moves: are they still on camera?
|
|
//If ahead of camera, advance it until they're visible
|
|
//If behind camera, they lose a life & respawn
|
|
}
|
|
else
|
|
{
|
|
//Debug.Log("Not scrolling");
|
|
}*/
|
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Checks if the Game is finished
|
|
/// </summary>
|
|
/// <returns>returns if game is finished</returns>
|
|
public override bool isGameOver(PlayerData[] allPlayers)
|
|
{
|
|
return (RoundCount >= MaxRound -1);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Called once per player after they have moved onto a block
|
|
/// </summary>
|
|
/// <param name="character">Character which moved</param>
|
|
/// <param name="client">Client of the character</param>
|
|
/// <param name="currentBlock">Block moved onto</param>
|
|
protected override void OnPlayerMoved(Character character, ClientData client, Block currentBlock)
|
|
{
|
|
handleFalling(character, client, currentBlock, character.justMoved);
|
|
|
|
/*Debug.Log("Moved to square at " + currentBlock.transform.position.x + ", "
|
|
+ currentBlock.transform.position.y + ", "
|
|
+ currentBlock.transform.position.z);
|
|
|
|
//If a character has fallen in the water or into a pit, we mark that fact, and they lose the rest of their turn
|
|
character.inWater = currentBlock.isWater;
|
|
character.inPit = currentBlock.isPit;
|
|
|
|
if (character.inWater == true || character.inPit == true)
|
|
{
|
|
character.stuck = true;
|
|
}
|
|
|
|
Debug.Log("inWater = " + character.inWater + ", inPit = " + character.inPit + ", stuck = " + character.stuck);*/
|
|
|
|
//Commented out because we don't do this in the racetrack mode
|
|
|
|
/*ClientData OwnedClient;
|
|
Material overlay = null;
|
|
if (isOwned(currentBlock, out OwnedClient))
|
|
{
|
|
if (OwnedClient == client)
|
|
return;
|
|
|
|
BlocksOwned[OwnedClient].Remove(currentBlock);
|
|
|
|
foreach (Material mat in currentBlock.GetComponent<Renderer>().materials)
|
|
{
|
|
if (mat.name == OverlayMaterial.name + " (Instance)")
|
|
overlay = mat;
|
|
}
|
|
}
|
|
|
|
if (overlay == null)
|
|
{
|
|
overlay = new Material(OverlayMaterial);
|
|
List<Material> mats = new List<Material>(currentBlock.GetComponent<Renderer>().materials);
|
|
mats.Add(overlay);
|
|
currentBlock.GetComponent<Renderer>().materials = mats.ToArray();
|
|
}
|
|
|
|
overlay.SetColor("_NewColor", client.Color);
|
|
|
|
if (!BlocksOwned.ContainsKey(client))
|
|
BlocksOwned.Add(client, new List<Block>());
|
|
|
|
BlocksOwned[client].Add(currentBlock);
|
|
|
|
if (overlay != null)
|
|
currentBlock.StartCoroutine(AnimateBlock(overlay, 0.25f));*/
|
|
}
|
|
|
|
protected override void OnRoundStart(PlayerData[] allPlayers)
|
|
{
|
|
|
|
}
|
|
|
|
protected override void OnAllPlayersMoved(PlayerData[] allPlayers)
|
|
{
|
|
foreach (PlayerData player in allPlayers)
|
|
{
|
|
/* The justMoved variable is used to determine whether a player taking their turn in the water should become stuck
|
|
* (because they moved into/in the water), or not (because they're turning while remaining in the same square)
|
|
* It's not needed from move to move, so we clear it
|
|
*/
|
|
player.character.justMoved = false;
|
|
|
|
/* if (BlocksOwned.ContainsKey(player.client))
|
|
player.client.SceneScore = BlocksOwned[player.client].Count;
|
|
else
|
|
player.client.SceneScore = 0;*/
|
|
}
|
|
}
|
|
|
|
protected override void OnGameOver(PlayerData[] allPlayers)
|
|
{
|
|
throw new System.NotImplementedException();
|
|
}
|
|
|
|
private bool isOwned(Block block, out ClientData client)
|
|
{
|
|
client = null;
|
|
|
|
foreach (KeyValuePair<ClientData, List<Block>> ownedList in BlocksOwned)
|
|
{
|
|
if (ownedList.Value.Contains(block))
|
|
{
|
|
client = ownedList.Key;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private void handleFalling(Character character, ClientData client, Block currentBlock, bool didMove)
|
|
{
|
|
//If a character has fallen in the water or into a pit, we mark that fact, and they lose the rest of their turn
|
|
character.inWater = currentBlock.isWater;
|
|
character.inPit = currentBlock.isPit;
|
|
character.onCrystal = currentBlock.isCrystals;
|
|
character.underRock = currentBlock.isRock;
|
|
|
|
if (didMove && (character.inWater || character.inPit))
|
|
{
|
|
character.stuck = true;
|
|
}
|
|
//Debug.Log("inWater = " + character.inWater + ", inPit = " + character.inPit + ", stuck = " + character.stuck);
|
|
}
|
|
|
|
protected override void OnPlayerKilled(Character character, ClientData client)
|
|
{
|
|
if (character.inPit || character.onCrystal)
|
|
{
|
|
character.lives -= 1;
|
|
character.ClientLink.Lives = character.lives;
|
|
}
|
|
if(character.underRock && currentBoulderCount < 1)
|
|
{
|
|
character.lives -= 1;
|
|
character.ClientLink.Lives = character.lives;
|
|
}
|
|
}
|
|
|
|
private IEnumerator AnimateBlock(Material mat, float time)
|
|
{
|
|
float timeElasped = 0;
|
|
|
|
while (timeElasped < time)
|
|
{
|
|
mat.SetFloat("_Multiplier", (timeElasped / time));
|
|
yield return new WaitForEndOfFrame();
|
|
timeElasped += Time.deltaTime;
|
|
}
|
|
mat.SetFloat("_Multiplier", 1);
|
|
}
|
|
|
|
protected override void OnGameStart(PlayerData[] AllPlayers)
|
|
{
|
|
BlocksOwned = new Dictionary<ClientData, List<Block>>();
|
|
RoundCount = 0;
|
|
AllPlayers = getPlayerOrder(AllPlayers);
|
|
for (int i = 0; i < AllPlayers.Length; i++)
|
|
{
|
|
OnPlayerMoved(AllPlayers[i].character, AllPlayers[i].client, AllPlayers[i].character.CurrentBlock);
|
|
}
|
|
}
|
|
|
|
public override PlayerData[] getPlayerOrder(PlayerData[] AllPlayers)
|
|
{
|
|
AllPlayers = AllPlayers.ToArray().OrderBy(unit => unit.character.CurrentBlock.transform.position.x).ToArray();
|
|
return AllPlayers;
|
|
}
|
|
}
|