CreateNew
(NetworkedPlayerController controller)
{
MyContract.RequireArgumentNotNull(
controller,
"NetworkedPlayerController"
);
PlayerIdentifier ExtantId
= controller
.gameObject
.GetComponent <PlayerIdentifier>();
PlayerIdentifier NewId = ExtantId;
if (ExtantId == null)
{
NewId = controller
.gameObject
.AddComponent <PlayerIdentifier>();
NewId.SetBackingController(controller);
Debug.Log(
"No existing PlayerIdentifier for "
+ NewId.ToString()
+ "\nCreating new PlayerIdentifier with net id "
+ NewId.netId
);
}
return(NewId);
}
LocalShipDestroyedAction
(PlayerIdentifier killer, Vector3 deathLocation)
{
Debug.Log("Our player is dead!");
this.transform.position = deathLocation;
LocalPlayerShipDestroyed(killer);
StartCoroutine(RequestRespawn());
}
/// <summary>
/// I would expand this to include a new parameter
/// of enum HitType with value of PHASER_BOLT etc.
/// </summary>
public void OnProjectileHit(PlayerIdentifier shooter)
{
// Stops useless messages propagating
// Easier to reason about with one path
if (isServer)
{
TakeDamage(1.0, shooter);
}
}
public void OnServerDisconnect(NetworkConnection conn)
{
PlayerDisconnectedHandler handler = PlayerDisconnected;
if (oem.shouldTriggerEvent(handler))
{
handler(PlayerIdentifier.CreateNew(conn));
}
}
OnKillEvent
(PlayerIdentifier hunter,
PlayerIdentifier hunted)
{
Debug.Log(PrintPlayerScore());
MyContract.RequireField(PlayerScore.ContainsKey(hunter.PlayerID),
"contains an entry for netid " + hunter.ToString(),
"PlayerScore");
PlayerScore[hunter.PlayerID] += 1;
ScoreUpdate(hunter, PlayerScore[hunter.PlayerID]);
}
ShipDestroyedClientAction
(PlayerIdentifier killer,
Vector3 deathLocation,
Vector3 deathEulerRotation)
{
AnyShipDestroyedAction(deathLocation, deathEulerRotation);
if (hasAuthority)
{
LocalShipDestroyedAction(killer, deathLocation);
}
}
GetScoreList()
{
return(PlayerScore
.Select(
kvp =>
new KeyValuePair <PlayerIdentifier, int>
(PlayerIdentifier.CreateNew(kvp.Key),
kvp.Value)
)
.ToList());
}
public void OnLocalPlayerShipDestroyed(PlayerIdentifier killer, float respawnDelay)
{
Debug.Log("UIManager: received player kill message - swapping to respawn UI");
TransitionToUIElements(UiElementTransitionType.Subtractive, UIElements.GameplayUI);
TransitionToUIElements(UiElementTransitionType.Additive, UIElements.Respawn);
RespawnUIManager RespawnUI =
ComponentRegistry
.RetrieveManager <RespawnUIManager>(UIElements.Respawn);
RespawnUI.SetKiller(killer);
RespawnUI.StartTimer(respawnDelay);
}
ShipDestroyedServerAction
(PlayerIdentifier killer,
Vector3 deathLocation,
Vector3 deathEulerRotation)
{
Debug.Log("Ship destroyed - taking server action");
ShipSpawned = false;
ShipDestroyed.Invoke(killer);
Vector3 respawn_location = chooseSpawnLocation();
StartCoroutine(destroyShipWithDelayCoroutine());
StartCoroutine(EnableRespawnAfterDelayCoroutine());
}
public void AddNewPlayer(PlayerIdentifier player, int score)
{
MyContract.RequireArgumentNotNull(player, "player");
MyContract.RequireField(
!ScoreElement.ContainsKey(player.PlayerID),
"does not already contain an entry for player "
+ player.ToString(),
"ScoreElement"
);
Debug.Log(
"ScoreboardUIManager: Adding new element ["
+ player.ToString()
+ " -> "
+ score + "]"
);
GameObject NewScoreUiElement;
string DisplayName = "[Uninitialised]";
if (player.PlayerID == LocalPlayerId)
{
NewScoreUiElement
= Instantiate(LocalPlayerScoreUiElementPrefab);
DisplayName = player.ToString() + " (Me)";
}
else
{
NewScoreUiElement
= Instantiate(ScoreUiElementPrefab);
DisplayName = player.ToString();
}
NewScoreUiElement.transform.SetParent(UiElementListParent, false);
ScoreUiElementManager ElementManager
= NewScoreUiElement.GetComponent <ScoreUiElementManager>();
// This is programmer/compile-time error if it occurs
// as in, this shouldn't be needed in production code
MyContract.RequireFieldNotNull(ElementManager, "ScoreUiElementManager");
ElementManager.Initialise(DisplayName, score);
NewScoreUiElement.SetActive(true);
ScoreUiElements.Add(ElementManager);
SortScoreElements();
ScoreElement.Add(player.PlayerID, ElementManager);
}
public void OnPlayerRemovedFromScoreboard(PlayerIdentifier playerId)
{
MyContract.RequireField(
ComponentRegistry.Contains(UIElements.Scoreboard),
"contains a scoreboard",
"ComponentRegistry"
);
ComponentRegistry
.RetrieveManager <ScoreboardUiManager>(UIElements.Scoreboard)
.RemovePlayer(playerId);
// Debug
Debug.Log("Player "
+ playerId.PlayerID
+ " was removed");
}
public void RemovePlayer(PlayerIdentifier playerId)
{
MyContract.RequireArgumentNotNull(playerId, "newPlayerId");
MyContract.RequireField(
PlayerScore.ContainsKey(playerId.PlayerID),
"PlayerScore contains the player ID "
+ playerId.ToString(),
"playerId " + playerId.ToString()
);
PlayerScore.Remove(playerId.PlayerID);
Debug.Log("Scoreboard: Removed player id "
+ playerId.ToString()
+ " from the scoreboard.");
Debug.Log(PrintPlayerScore());
if (oem.shouldTriggerEvent(PlayerRemoved))
{
PlayerRemoved(playerId);
}
}
public void RegisterNewPlayer(PlayerIdentifier newPlayerId)
{
MyContract.RequireArgumentNotNull(newPlayerId, "newPlayerId");
MyContract.RequireField(
!PlayerScore.ContainsKey(newPlayerId.PlayerID),
"PlayerScore does not contain the new player ID "
+ newPlayerId.ToString(),
"newPlayerId " + newPlayerId.ToString()
);
PlayerScore.Add(newPlayerId.PlayerID, InitialScore);
Debug.Log("Scoreboard: Added player id "
+ newPlayerId.ToString()
+ " to the scoreboard.");
Debug.Log(PrintPlayerScore());
if (oem.shouldTriggerEvent(ScoreUpdate))
{
ScoreUpdate(newPlayerId, InitialScore);
}
}
private void TakeDamage(double amount, PlayerIdentifier shooter)
{
Debug.Log("Taking Damage");
if (amount >= Health)
{
Health = 0;
KillThisUnit(shooter);
}
else
{
Health -= amount;
HealthChangeHandler handler = EventHealthChanged;
if (oem.shouldTriggerEvent(handler))
{
Debug.Log("Triggering Health change event");
handler(Health);
}
}
}
public void OnPlayerJoin(NetworkedPlayerController playerController)
{
MyContract.RequireArgumentNotNull(playerController, "playerController");
PlayerIdentifier NewPlayerId = PlayerIdentifier.CreateNew(playerController);
playerController.ShipDestroyed
+= delegate(PlayerIdentifier hunter)
{
Scoreboard.OnKillEvent(hunter, NewPlayerId);
};
Scoreboard.ScoreUpdate += playerController.OnScoreUpdate;
Scoreboard.PlayerRemoved
+= playerController.OnPlayerRemovedFromScoreboardPassthrough;
Scoreboard.RegisterNewPlayer(NewPlayerId);
//Debug.Log("Game State Manager: Checking if we have a spaceship class manager");
MyContract.RequireFieldNotNull(SSClassManager, "Spaceship Class Manager");
//Debug.Log("Game State Manager: Initialising given NPC with our SSCManager");
playerController.initialiseShipClassManager(SSClassManager);
}
OnScoreUpdate
(PlayerIdentifier playerId,
int newScore)
{
MyContract.RequireField(
ComponentRegistry.Contains(UIElements.Scoreboard),
"contains a scoreboard",
"ComponentRegistry"
);
ComponentRegistry
.RetrieveManager <ScoreboardUiManager>(UIElements.Scoreboard)
.ChangePlayerScore(playerId, newScore);
// Debug
Debug.Log("Score was updated for player "
+ playerId.PlayerID
+ " to new score "
+ newScore);
}
public void ChangePlayerScore(PlayerIdentifier player, int score)
{
MyContract.RequireArgumentNotNull(player, "player");
if (ScoreElement.ContainsKey(player.PlayerID))
{
ScoreElement[player.PlayerID].UpdateScore(score);
SortScoreElements();
}
else
{
Debug.Log(
"ScoreboardUIManager: Received a ChangePlayerScore "
+ "request for an unregistered player ("
+ player.ToString()
+ ")"
);
AddNewPlayer(player, score);
}
}
private void KillThisUnit(PlayerIdentifier killer)
{
// This lock was put in as a result of bugs,
// it's not just experimental!
lock (DeathLock)
{
if (!IsDead) // If we're the first responder
{
Debug.Log("Player is dead!");
IsDead = true;
DeathHandler handler = EventDeath;
if (oem.shouldTriggerEvent(handler))
{
handler(
killer,
transform.position,
transform.eulerAngles
);
}
}
}
}
public void RemovePlayer(PlayerIdentifier player)
{
MyContract.RequireArgumentNotNull(player, "player");
MyContract.RequireField(
ScoreElement.ContainsKey(player.PlayerID),
"Contains an entry for player "
+ player.ToString(),
"ScoreElement"
);
ScoreUiElementManager ElementManager = ScoreElement[player.PlayerID];
ScoreElement.Remove(player.PlayerID);
ScoreUiElements.Remove(ElementManager);
// If needed this can be optimised by pooling the
// score ui elements,
// so when a player is removed they are deactivated,
// then when a new player is added they try to reactivate
// an old slot before instantiating a new one.
Destroy(ElementManager.gameObject);
//SortScoreElements(); should remain sorted
}
public void OnPlayerRemovedFromScoreboardPassthrough (PlayerIdentifier playerId)
{
EventPlayerRemovedFromScoreboard(playerId);
}
public void OnPlayerDisconnect(PlayerIdentifier player)
{
Scoreboard.RemovePlayer(player);
}
public void OnScoreUpdate(PlayerIdentifier playerId, int newScore)
{
EventScoreUpdated(playerId, newScore);
}
private void SpawnSpaceShip(SpaceShipClass spaceShipType)
{
lock (SpaceshipSpawnLock)
{
if (ShipSpawned)
{
Debug.LogWarning(ShipAlreadySpawnedWarning);
return;
}
MyContract.RequireArgument(
spaceShipType != SpaceShipClass.NONE,
"is not NONE",
"spaceShipType"
);
MyContract.RequireFieldNotNull(
SpaceshipClassManager,
"Spaceship Class Manager"
);
GameObject SpaceshipPrefab
= SpaceshipClassManager.getSpaceShipPrefab(spaceShipType);
MyContract.RequireFieldNotNull(SpaceshipPrefab, "Spaceship Prefab");
// Should not remain null unless Unity.Instantiate can return null
GameObject ServerSpaceship = null;
if (CurrentSpaceship != null
&& ShipController.getSpaceshipClass() == spaceShipType)
{
// current_spaceship was just despawned, not destroyed,
// so it simply needs to be respawned
ServerSpaceship = CurrentSpaceship;
ServerSpaceship.SetActive(true);
MyContract.RequireFieldNotNull(
ShipController,
"ShipController"
);
ShipController.Respawn();
}
else
{
// Create the ship locally (local to the server)
// NB: the ship will be moved to an appropriate NetworkStartPosition
// by the server so the location specified here is irrelevant
ServerSpaceship = (GameObject)Instantiate(
SpaceshipPrefab,
transform.TransformPoint(chooseSpawnLocation()),
transform.rotation);
ShipController = ServerSpaceship.GetComponent<PlayerShipController>();
ShipController.SetSpaceshipClass(spaceShipType);
ShipController.owner = PlayerIdentifier.CreateNew(this);
ShipController.EventDeath += ShipDestroyedServerAction;
}
MyContract.RequireFieldNotNull(
ServerSpaceship,
"Server Spaceship"
);
CanRespawn = false;
ShipSpawned = true;
// Spawn the ship on the clients
NetworkServer.SpawnWithClientAuthority(
ServerSpaceship,
connectionToClient
);
CurrentSpaceship = ServerSpaceship; // Update [SyncVar]
RpcPlayerShipSpawned(CurrentSpaceship);
}
}
public void SetKiller(PlayerIdentifier killer)
{
KillerIdentifierDisplay.text = killer.ToString();
}