public void PlayerIdentityId_should_be_preserved()
{
var calculator = new BowlingFiguresCalculator(Mock.Of <IOversHelper>());
var bowler1 = new PlayerIdentity {
PlayerIdentityId = Guid.NewGuid(), PlayerIdentityName = "Bowler 1"
};
var bowler2 = new PlayerIdentity {
PlayerIdentityId = Guid.NewGuid(), PlayerIdentityName = "Bowler 2"
};
var innings = new MatchInnings
{
PlayerInnings = new List <PlayerInnings> {
new PlayerInnings {
DismissalType = DismissalType.Bowled,
Bowler = bowler2
}
},
OversBowled = new List <Over> {
new Over {
Bowler = bowler1
},
}
};
var result = calculator.CalculateBowlingFigures(innings);
Assert.Equal(bowler1.PlayerIdentityId, result[0].Bowler.PlayerIdentityId);
Assert.Equal(bowler2.PlayerIdentityId, result[1].Bowler.PlayerIdentityId);
}
public void TeamId_should_be_preserved()
{
var calculator = new BowlingFiguresCalculator(Mock.Of <IOversHelper>());
var teamId1 = Guid.NewGuid();
var teamId2 = Guid.NewGuid();
var bowler1 = new PlayerIdentity {
PlayerIdentityName = "Bowler 1", Team = new Team {
TeamId = teamId1
}
};
var bowler2 = new PlayerIdentity {
PlayerIdentityName = "Bowler 2", Team = new Team {
TeamId = teamId2
}
};
var innings = new MatchInnings
{
PlayerInnings = new List <PlayerInnings> {
new PlayerInnings {
DismissalType = DismissalType.Bowled,
Bowler = bowler2
}
},
OversBowled = new List <Over> {
new Over {
Bowler = bowler1
},
}
};
var result = calculator.CalculateBowlingFigures(innings);
Assert.Equal(teamId1.ToString(), result[0].Bowler.Team.TeamId.ToString());
Assert.Equal(teamId2.ToString(), result[1].Bowler.Team.TeamId.ToString());
}
public void Affected_bowler_PlayerIdentity_is_identified()
{
var playerOne = new PlayerIdentity {
PlayerIdentityName = "Player one"
};
var playerTwo = new PlayerIdentity {
PlayerIdentityName = "Player two"
};
var playerThree = new PlayerIdentity {
PlayerIdentityName = "Player three"
};
var firstInningsBefore = new PlayerInnings {
BattingPosition = 1, Batter = playerOne, Bowler = playerThree, DismissalType = DismissalType.Bowled, RunsScored = 0, BallsFaced = 10
};
var firstInningsAfter = new PlayerInnings {
BattingPosition = 1, Batter = playerOne, Bowler = playerThree, DismissalType = DismissalType.Bowled, RunsScored = 0, BallsFaced = 12
};
var secondInningsBefore = new PlayerInnings {
BattingPosition = 2, Batter = playerTwo, Bowler = playerThree, DismissalType = DismissalType.Bowled, RunsScored = 0, BallsFaced = 10
};
var secondInningsAfter = new PlayerInnings {
BattingPosition = 2, Batter = playerTwo, Bowler = playerThree, DismissalType = DismissalType.Bowled, RunsScored = 0, BallsFaced = 10
};
var comparer = new BattingScorecardComparer();
var result = comparer.CompareScorecards(new List <PlayerInnings> {
firstInningsBefore, secondInningsBefore
}, new List <PlayerInnings> {
firstInningsAfter, secondInningsAfter
});
Assert.Single(result.BowlingPlayerIdentitiesAffected);
Assert.Contains(playerThree.PlayerIdentityName, result.BowlingPlayerIdentitiesAffected);
}
IEnumerator wipeIdentities()
{
List <PlayerIdentity> newIdentities = new List <PlayerIdentity>();
foreach (PlayerIdentity identity in GameManager.Instance.GetIdentifierMap().Values)
{
while (identity.ConnectedSession != null)
{
GameManager.Instance.KickPlayer(identity.ConnectedSession, "Server Wipe");
ForcePlayerRemoval(identity.ConnectedSession);
yield return(new WaitForSeconds(0.5f));
}
if (!safeInv.Contains(identity.SteamId.m_SteamID))
{
PlayerIdentity newIdentity = new PlayerIdentity()
{
SteamId = new Steamworks.CSteamID(identity.SteamId.m_SteamID),
Name = identity.Name,
PlayerStateByes = null,
PlayerStateString = String.Empty
};
newIdentities.Add(newIdentity);
}
}
newIdentities.ForEach(newIdentity => GameManager.Instance.OverwriteIdentity(newIdentity.SteamId, newIdentity));
PrintWarning("All player wiped. Saving now.");
SaveServer();
}
public void Changed_innings_is_identified_from_changed_BowlerU002EPlayerIdentityName_for_batting_position()
{
var playerOne = new PlayerIdentity {
PlayerIdentityName = "Player one"
};
var playerTwo = new PlayerIdentity {
PlayerIdentityName = "Player two"
};
var firstInningsBefore = new PlayerInnings {
BattingPosition = 1, Batter = playerOne, Bowler = playerTwo, DismissalType = DismissalType.Bowled, RunsScored = 0, BallsFaced = 10
};
var firstInningsAfter = new PlayerInnings {
BattingPosition = 1, Batter = playerOne, Bowler = playerTwo, DismissalType = DismissalType.Bowled, RunsScored = 0, BallsFaced = 10
};
var secondInningsBefore = new PlayerInnings {
BattingPosition = 2, Batter = playerTwo, Bowler = new PlayerIdentity {
PlayerIdentityName = "Before"
}, DismissalType = DismissalType.NotOut, RunsScored = 0, BallsFaced = 10
};
var secondInningsAfter = new PlayerInnings {
BattingPosition = 2, Batter = playerTwo, Bowler = new PlayerIdentity {
PlayerIdentityName = "Changed"
}, DismissalType = DismissalType.NotOut, RunsScored = 0, BallsFaced = 10
};
var comparer = new BattingScorecardComparer();
var result = comparer.CompareScorecards(new List <PlayerInnings> {
firstInningsBefore, secondInningsBefore
}, new List <PlayerInnings> {
firstInningsAfter, secondInningsAfter
});
Assert.Single(result.PlayerInningsChanged);
Assert.Contains((secondInningsBefore, secondInningsAfter), result.PlayerInningsChanged);
}
public void Removed_innings_is_identified_by_batting_position()
{
var playerOne = new PlayerIdentity {
PlayerIdentityName = "Player one"
};
var playerTwo = new PlayerIdentity {
PlayerIdentityName = "Player two"
};
var firstInningsBefore = new PlayerInnings {
BattingPosition = 1, Batter = playerOne, DismissalType = DismissalType.NotOut, RunsScored = 0, BallsFaced = 10
};
var firstInningsAfter = new PlayerInnings {
BattingPosition = 1, Batter = playerOne, DismissalType = DismissalType.NotOut, RunsScored = 0, BallsFaced = 10
};
var secondInningsBefore = new PlayerInnings {
BattingPosition = 2, Batter = playerTwo, DismissalType = DismissalType.NotOut, RunsScored = 0, BallsFaced = 10
};
var comparer = new BattingScorecardComparer();
var result = comparer.CompareScorecards(new List <PlayerInnings> {
firstInningsBefore, secondInningsBefore
}, new List <PlayerInnings> {
firstInningsAfter
});
Assert.Single(result.PlayerInningsRemoved);
Assert.Contains(secondInningsBefore, result.PlayerInningsRemoved);
}
void OnGUI()
{
Scene scene = SceneManager.GetActiveScene();
if (scene.name == "hunterVictory" || scene.name == "seekerVictory")
{
return;
}
// Player manager doesn't have the players on start
if (!id)
{
if (PlayerManager.instance.thisPlayer)
{
thisPlayer = PlayerManager.instance.thisPlayer;
id = thisPlayer.GetComponent <PlayerIdentity>();
movement = thisPlayer.GetComponent <PlayerMovement3D>();
}
}
// if (id && id.IsSeeker()) {
// DrawSeekerUI();
// }
if (id && id.IsHunter())
{
DrawHunterUI();
}
// DrawMinimap();
}
void OnGUI() {
Scene scene = SceneManager.GetActiveScene();
if (scene.name == "hunterVictory" || scene.name == "seekerVictory" ) {
return;
}
// Player manager doesn't have the players on start
if (!id) {
if (PlayerManager.instance.thisPlayer) {
thisPlayer = PlayerManager.instance.thisPlayer;
id = thisPlayer.GetComponent<PlayerIdentity>();
movement = thisPlayer.GetComponent<PlayerMovement3D>();
}
}
// if (id && id.IsSeeker()) {
// DrawSeekerUI();
// }
if (id && id.IsHunter()) {
DrawHunterUI();
}
// DrawMinimap();
}
private bool isValidKill(PlayerIdentity victim, PlayerIdentity killer)
{
bool sameStake = GetConfig(false, "Settings", "KillCount_Exclusion", "SameStake");
bool sameClan = GetConfig(false, "Settings", "KillCount_Exclusion", "SameClan");
if (sameStake)
{
List <OwnershipStakeServer> victim_stakes = GetStakesFromPlayer(victim.ConnectedSession);
List <OwnershipStakeServer> killer_stakes = GetStakesFromPlayer(killer.ConnectedSession);
foreach (OwnershipStakeServer killer_stake in killer_stakes)
{
if (victim_stakes.Contains(killer_stake))
{
return(false);
}
}
}
if (sameClan && HWClans != null)
{
ulong victim_clanID = (ulong)HWClans.Call("getClanId", victim.ConnectedSession);
ulong killer_clanID = (ulong)HWClans.Call("getClanId", killer.ConnectedSession);
if (victim_clanID == killer_clanID)
{
if (victim_clanID != 0)
{
return(false);
}
}
}
return(true);
}
private HashSet <int> BuildConnectedOwnedCellCluster(PlayerIdentity identity, int cell)
{
if (!IsCellOwnedByPlayer(identity, cell))
{
return(new HashSet <int>());
}
var queue = new Queue <int>();
var result = new HashSet <int>();
queue.Enqueue(cell);
result.Add(cell);
while (queue.Count > 0)
{
var p = queue.Dequeue();
var surroundedCells = GetSurroundingCells(p).Where(c => IsCellOwnedByPlayer(identity, c));
foreach (var newCell in surroundedCells)
{
if (!result.Contains(newCell))
{
queue.Enqueue(newCell);
result.Add(newCell);
}
}
}
return(result);
}
public override void OnServerAddPlayer(NetworkConnection conn, short playerControllerId)
{
Debug.Log("NetManager OnServerAddPlayer");
Vector3 position = Vector3.zero;
Quaternion rotation = Quaternion.identity;
PlayerSpawnPoint spawnPoint = PlayerSpawnPoint.Next();
if (spawnPoint != null)
{
position = spawnPoint.position;
rotation = spawnPoint.rotation;
}
//add player object
GameObject player = (GameObject)GameObject.Instantiate(playerPrefab, position, rotation);
PlayerIdentity identity = player.GetComponent <PlayerIdentity>();
if (identity != null)
{
//TODO: player name and team id values are temporary - maybe grab from settings?
string playerName = player.name + conn.connectionId.ToString();
byte teamId = 1;
identity.Initialize(conn.connectionId, playerControllerId, playerName, teamId);
}
else
{
Debug.LogWarning("NetManager: Player prefab does not have a PlayerIdentity assigned.");
}
m_playerTracker.Add(player);
NetworkServer.AddPlayerForConnection(conn, player, playerControllerId);
}
void Update()
{
// The other player may not be available at Start, so do it on update until we can find them
if (!otherPlayer || !thisPlayer)
{
GameObject[] gos;
gos = GameObject.FindGameObjectsWithTag("Player");
foreach (GameObject go in gos)
{
PlayerIdentity id = go.GetComponent <PlayerIdentity>();
if (id)
{
if (!id.IsThisPlayer())
{
otherPlayer = go;
}
else
{
thisPlayer = go;
}
if (id.IsHunter())
{
hunter = go;
}
else
{
seeker = go;
}
}
}
}
}
void Start()
{
id = GetComponent <PlayerIdentity>();
movement = GetComponent <PlayerMovement3D>();
ui = GetComponentInChildren <InWorldUI>();
sfxManager = GetComponentInChildren <NetworkedSFXManager>();
}
protected virtual void OnTriggerExit(Collider collider)
{
if (collider.GetComponentInParent<Transform>().tag == "Player") {
isTouch = false;
colliderId = null;
}
}
public void RpcUpdateLogText(string logString, PlayerIdentity playeridentity)
{
if ((localPlayerGameObject.GetComponent <Player>().playerIdentity == playeridentity) || (playeridentity == PlayerIdentity.IsNotAllocated))
{
logText.text += logString;
}
}
//------------- Time Travel Related Functions: Echos --------------//
public void setupEcho(Transform inputEchoParent, Queue <TBInput> inputEchoRecording)
{
playerIdentity = PlayerIdentity.Echo;
echoParent = inputEchoParent;
echoRecording = inputEchoRecording;
playerPercent = 200;
// *** Set the material to the special one ****//
GameObject echoModel = transform.GetChild(2).gameObject;// get CharacterModel gameobject
Renderer echoRenderer = echoModel.transform.GetChild(1).gameObject.GetComponent <Renderer>();
Material[] newMats = new Material[echoRenderer.materials.Length];
for (int i = 0; i < newMats.Length; i++)
{
newMats[i] = echoMat;
}
echoRenderer.materials = newMats;
// Enable the Halo effect from the prefab
Behaviour halo = (Behaviour)echoModel.GetComponent("Halo");
halo.enabled = true;
gameObject.tag = "Clone";
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/// Record Names
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void RecordName(NetworkPlayer netPlayer, PlayerIdentity player)
{
string playername = player.Name;
var NameList = new Dictionary <string, object>();
var success = PlayerDatabase.Call("GetPlayerData", player.SteamId.m_SteamID.ToString(), "Names");
if (success is Dictionary <string, object> )
{
NameList = (Dictionary <string, object>)success;
}
if (NameList.ContainsValue(playername))
{
return;
}
if (NameList.Count >= NAMESmaxLogs)
{
var tempList = new Dictionary <string, object>();
foreach (KeyValuePair <string, object> pair in NameList)
{
tempList.Add(pair.Key, pair.Value);
}
NameList.Clear();
for (int i = tempList.Count - NAMESmaxLogs + 1; i < tempList.Count; i++)
{
NameList.Add(NameList.Count.ToString(), tempList[i.ToString()]);
}
}
NameList.Add(NameList.Count.ToString(), playername);
PlayerDatabase.Call("SetPlayerData", player.SteamId.m_SteamID.ToString(), "Names", NameList);
}
void MotdCommand(PlayerIdentity identity, NetworkMessageInfo info, string command, string[] args)
{
string MOTDColor = Config["MOTDSettings", "MOTDColor"].ToString();
string MOTDTitle = Config["MOTDSettings", "MOTDTitle"].ToString();
ChatManager.Instance?.AppendChatboxServerSingle("<color=" + MOTDColor + ">" + MOTDTitle + "</color> " + Config["MOTDmessages", "1"], info.sender);
}
void Start()
{
if (!GameObject.Find("Hunter Sprite"))
{
return;
}
id = GetComponent <PlayerIdentity>();
if (id)
{
if (id.IsHunter())
{
spriteRenderer = GameObject.Find("Hunter Sprite").GetComponent <Renderer>();
}
else
{
spriteRenderer = GameObject.Find("Seeker Sprite").GetComponent <Renderer>();
}
}
else
{
spriteRenderer = GetComponent <Renderer>();
}
}
public AddTicTacToeStepCommandHandler(PlayerIdentity playerIdentity, IGameRepository gameRepository, ITicTacToeRepository ticTacToeRepository, IGameHubSender gameHub)
{
_playerIdentity = playerIdentity;
_gameRepository = gameRepository;
_ticTacToeRepository = ticTacToeRepository;
_gameHub = gameHub;
}
public int getPlayerIdByConnection(NetworkConnection connection)
{
GameObject go = connection.playerControllers [0].gameObject;
PlayerIdentity pi = go.GetComponent <PlayerIdentity> ();
return(pi.PlayerNumber);
}
void OnPlayerIdentityChanged(PlayerIdentity value)
{
playerIdentity = value;
if (hasAuthority)
{
if (value == PlayerIdentity.Werewolves)
{
playerIdentityDropdown.value = 1;
}
else if (value == PlayerIdentity.OrdinaryTownsfolk)
{
playerIdentityDropdown.value = 2;
}
else if (value == PlayerIdentity.FortuneTeller)
{
playerIdentityDropdown.value = 3;
}
else if (value == PlayerIdentity.Witch)
{
playerIdentityDropdown.value = 4;
savePotionNum = 1;
eliminatePotionNum = 1;
}
else if (value == PlayerIdentity.IsNotAllocated)
{
playerIdentityDropdown.value = 0;
}
}
else
{
playerIdentityDropdown.value = 0;
}
}
public void Removed_PlayerIdentity_is_identified()
{
var playerOne = new PlayerIdentity {
PlayerIdentityName = "Player one"
};
var playerTwo = new PlayerIdentity {
PlayerIdentityName = "Player two"
};
var playerThree = new PlayerIdentity {
PlayerIdentityName = "Player three"
};
var firstOverBefore = new Over {
OverNumber = 1, Bowler = playerOne, BallsBowled = 8, NoBalls = 0, Wides = 0, RunsConceded = 10
};
var firstOverAfter = new Over {
OverNumber = 1, Bowler = playerOne, BallsBowled = 8, NoBalls = 0, Wides = 0, RunsConceded = 10
};
var secondOverBefore = new Over {
OverNumber = 2, Bowler = playerTwo, BallsBowled = 8, NoBalls = 0, Wides = 0, RunsConceded = 10
};
var secondOverAfter = new Over {
OverNumber = 2, Bowler = playerThree, BallsBowled = 8, NoBalls = 0, Wides = 0, RunsConceded = 10
};
var comparer = new BowlingScorecardComparer();
var result = comparer.CompareScorecards(new List <Over> {
firstOverBefore, secondOverBefore
}, new List <Over> {
firstOverAfter, secondOverAfter
});
Assert.Single(result.PlayerIdentitiesRemoved);
Assert.Contains(playerTwo.PlayerIdentityName, result.PlayerIdentitiesRemoved);
}
private object OnPlayerChat(PlayerIdentity identity, NetworkMessageInfo info, string message)
{
if (message.Trim().Length <= 1) return true;
var str = message.Substring(0, 1);
// Is it a chat command?
if (str.Equals("/") || str.Equals("!"))
{
// Get the arg string
var argstr = message.Substring(1);
// Parse it
string chatcmd;
string[] args;
ParseChatCommand(argstr, out chatcmd, out args);
if (chatcmd == null) return null;
// Handle it
if (!cmdlib.HandleChatCommand(identity, info, chatcmd, args))
{
ChatManager.Instance.AppendChatboxServerSingle($"<color=#b8d7a3>Unknown command: {chatcmd}</color>", info.sender);
return true;
}
return true;
}
return null;
}
public void Changed_over_is_identified_from_changed_RunsConceded_for_over_number()
{
var playerOne = new PlayerIdentity {
PlayerIdentityName = "Player one"
};
var playerTwo = new PlayerIdentity {
PlayerIdentityName = "Player two"
};
var firstOverBefore = new Over {
OverNumber = 1, Bowler = playerOne, BallsBowled = 8, NoBalls = 0, Wides = 0, RunsConceded = 10
};
var firstOverAfter = new Over {
OverNumber = 1, Bowler = playerOne, BallsBowled = 8, NoBalls = 0, Wides = 0, RunsConceded = 10
};
var secondOverBefore = new Over {
OverNumber = 2, Bowler = playerTwo, BallsBowled = 8, NoBalls = 0, Wides = 0, RunsConceded = 10
};
var secondOverAfter = new Over {
OverNumber = 2, Bowler = playerTwo, BallsBowled = 8, NoBalls = 0, Wides = 0, RunsConceded = 12
};
var comparer = new BowlingScorecardComparer();
var result = comparer.CompareScorecards(new List <Over> {
firstOverBefore, secondOverBefore
}, new List <Over> {
firstOverAfter, secondOverAfter
});
Assert.Single(result.OversChanged);
Assert.Contains((secondOverBefore, secondOverAfter), result.OversChanged);
}
public async Task Matched_PlayerIdentity_is_returned()
{
using (var connection = _databaseFixture.ConnectionFactory.CreateDatabaseConnection())
{
connection.Open();
using (var transaction = connection.BeginTransaction())
{
var dataForAnyPlayerIdentity = await connection.QuerySingleAsync <(Guid playerIdentityId, Guid playerId, string comparableName, Guid teamId)>(
$"SELECT TOP 1 PlayerIdentityId, PlayerId, ComparableName, TeamId FROM {Tables.PlayerIdentity}"
).ConfigureAwait(false);
var playerIdentity = new PlayerIdentity {
PlayerIdentityName = dataForAnyPlayerIdentity.comparableName, Team = new Team {
TeamId = dataForAnyPlayerIdentity.teamId
}
};
var repo = new SqlServerPlayerRepository(Mock.Of <IAuditRepository>(), Mock.Of <ILogger>(), Mock.Of <IRouteGenerator>(), Mock.Of <IStoolballEntityCopier>(), Mock.Of <IPlayerNameFormatter>());
var result = await repo.CreateOrMatchPlayerIdentity(playerIdentity, Guid.NewGuid(), "Member name", transaction).ConfigureAwait(false);
Assert.NotNull(result);
Assert.Equal(dataForAnyPlayerIdentity.playerIdentityId, result.PlayerIdentityId);
Assert.Equal(dataForAnyPlayerIdentity.playerId, result.Player.PlayerId);
Assert.Equal(dataForAnyPlayerIdentity.teamId, result.Team.TeamId);
Assert.Equal(dataForAnyPlayerIdentity.comparableName, result.ComparableName());
transaction.Rollback();
}
}
}
// Use this for initialization
void Start () {
hidingPlaceLayerMask = 1 << layerIndex;
id = GetComponent<PlayerIdentity>();
echoParticleEmitter = GetComponentInChildren<ParticleEmitter>();
ui = GetComponentInChildren<InWorldUI>();
sfxManager = GetComponentInChildren<NetworkedSFXManager>();
}
void EndRecordTime(PlayerIdentity player)
{
if (!recordPlayTime.ContainsKey(player))
{
return;
}
var TimePlayed = new Dictionary <string, object>();
var success = PlayerDatabase.Call("GetPlayerData", player.SteamId.m_SteamID.ToString(), "Time Played");
if (success is Dictionary <string, object> )
{
TimePlayed = (Dictionary <string, object>)success;
}
double totaltime = LogTime() - recordPlayTime[player];
if (TimePlayed.ContainsKey("0"))
{
totaltime += double.Parse((string)TimePlayed["0"]);
}
TimePlayed.Clear();
TimePlayed.Add("0", totaltime.ToString());
PlayerDatabase.Call("SetPlayerData", player.SteamId.m_SteamID.ToString(), "Time Played", TimePlayed);
}
public void LoadId()
{
if (isClient)
{
GameObject go = NetworkManager.singleton.client.connection.playerControllers [0].gameObject;
id = go.GetComponent <PlayerIdentity> () as PlayerIdentity;
}
}
protected virtual void OnTriggerExit(Collider collider)
{
if (collider.GetComponentInParent <Transform>().tag == "Player")
{
isTouch = false;
colliderId = null;
}
}
public void Write(GamePacketWriter writer)
{
writer.Write(RealmId, 14u);
writer.Write(GuildId);
PlayerIdentity.Write(writer);
writer.Write(Unknown0);
writer.Write(Unknown1);
}
public GameService(PlayerIdentity playerIdentity, IGameRepository repository,
IGameHubSender gameHub, IUniqueRandomRangeCreator uniqueRandomRangeCreator)
{
_playerIdentity = playerIdentity;
_repository = repository;
_gameHub = gameHub;
_uniqueRandomRangeCreator = uniqueRandomRangeCreator;
}
// Use this for initialization
void Start()
{
hidingPlaceLayerMask = 1 << layerIndex;
id = GetComponent <PlayerIdentity>();
echoParticleEmitter = GetComponentInChildren <ParticleEmitter>();
ui = GetComponentInChildren <InWorldUI>();
sfxManager = GetComponentInChildren <NetworkedSFXManager>();
}
void StartRecordTime(PlayerIdentity player)
{
if (recordPlayTime.ContainsKey(player))
{
recordPlayTime.Remove(player);
}
recordPlayTime.Add(player, LogTime());
}
public void LoadId()
{
if (isClient) {
GameObject go = NetworkManager.singleton.client.connection.playerControllers [0].gameObject;
id = go.GetComponent<PlayerIdentity> () as PlayerIdentity;
}
}
//Call Caught command when player collides
protected virtual void OnTriggerEnter(Collider collider)
{
if (collider.GetComponentInParent<Transform>().tag == "Player") {
isTouch = true;
colliderId = collider.GetComponentInParent<PlayerIdentity>();
//Let's test this badboy out
/*Application.LoadLevel (Application.loadedLevel);
Debug.Log("Reloaded");*/
}
}
void Start() {
id = GetComponent<PlayerIdentity>();
hunterSprite = GameObject.Find("Hunter Sprite");
seekerSprite = GameObject.Find("Seeker Sprite");
if (!hunterSprite) {
return;
}
hunterRenderer = hunterSprite.GetComponent<Renderer>();
seekerRenderer = seekerSprite.GetComponent<Renderer>();
hunterOffset = hunterRenderer.bounds.size.y / 2;
seekerOffset = seekerRenderer.bounds.size.y / 2;
}
void Start() {
if (!GameObject.Find("Hunter Sprite")) {
return;
}
id = GetComponent<PlayerIdentity>();
if (id) {
if (id.IsHunter()) {
spriteRenderer = GameObject.Find("Hunter Sprite").GetComponent<Renderer>();
} else {
spriteRenderer = GameObject.Find("Seeker Sprite").GetComponent<Renderer>();
}
} else {
spriteRenderer = GetComponent<Renderer>();
}
}
void Start() {
if (!isLocalPlayer) {
return;
}
navAgent = GetComponent<NavMeshAgent>();
hidingManager = GetComponent<HidingManager>();
hunterEchoAbility = GetComponent<HunterEcho>();
id = GetComponent<PlayerIdentity>();
spriteManager = GetComponent<SpriteFollowPlayer>();
if (!Camera.main.GetComponent<followTarget3D>()) {
return;
}
Camera.main.GetComponent<followTarget3D>().target = transform;
GameObject.Find("Minimap Camera").GetComponent<followTarget3D>().target = transform;
}
private void OnPlayerChat(PlayerIdentity player, uLink.NetworkMessageInfo info, string message)
{
HookCalled("OnPlayerChat");
}
/// <summary>
/// Handles the specified chat command
/// </summary>
/// <param name="sender"></param>
/// <param name="name"></param>
/// <param name="args"></param>
internal bool HandleChatCommand(PlayerIdentity identity, uLink.NetworkMessageInfo info, string command, string[] args)
{
ChatCommand cmd;
if (!chatCommands.TryGetValue(command.ToLowerInvariant(), out cmd)) return false;
cmd.Plugin.CallHook(cmd.CallbackName, identity, info, command, args);
return true;
}
internal HurtworldLivePlayer(PlayerIdentity player)
{
this.player = player;
guid = player.PlayerGuid; // TODO: Switch to steamid once implemented
Object = player;
}
internal HurtworldLivePlayer(PlayerIdentity player)
{
this.player = player;
steamid = (ulong)player.SteamId;
Object = player;
}
void Start () {
id = GetComponent<PlayerIdentity>();
movement = GetComponent<PlayerMovement3D>();
ui = GetComponentInChildren<InWorldUI>();
sfxManager = GetComponentInChildren<NetworkedSFXManager>();
}
internal void NotifyPlayerConnect(PlayerIdentity ply)
{
NotifyPlayerJoin((ulong)ply.SteamId, ply.Name);
livePlayers[ply.SteamId.ToString()] = new HurtworldLivePlayer(ply);
}