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);
}
private void HandleActionGhostCarLoaded(GameObject obj)
{
Debug.Log("[GhostController] HandleActionGhostCarLoaded");
try{
ghostRacer = obj.GetComponent <RS_DragCarController>();
ghostRacer.gameObject.layer = LayerMask.NameToLayer("Ghost");
PlayerSpawnPoint spawnPoint = GameObject.FindObjectOfType <PlayerSpawnPoint>();
ghostRacer.transform.position = new Vector3(spawnPoint.transform.position.x - 4.8f, spawnPoint.transform.position.y, spawnPoint.transform.position.z);
if (RS_GamePlayController.Mode == RS_GameMode.Multiplayer)
{
UM_TBM_Participant compet = RS_GamePlayController.Instance.Multiplayer.CurrentMatch.Competitor;
if (compet != null)
{
Debug.Log("[Compete With Other Palayer] Name:" + compet.DisplayName);
}
else
{
Debug.Log("[I'm The Creator!!!]");
}
}
else
{
Debug.Log("[Singleplayer Mode activated! Your data will be saved locally]");
}
} catch (Exception ex) {
Debug.LogError("HandleActionGhostBikeLoaded - " + ex.Message);
}
}
private void SpawnPlayer(object sender, EventArgs args)
{
if (!PhotonNetwork.player.IsLocal)
return;
//get the player number from the photon player's custom properties
int playerNumber = (int)PhotonNetwork.player.CustomProperties["PlayerNumber"];
//find a player spawn point who's name is assosiated with the photon player's number
PlayerSpawnPoint[] spawnPositions = FindObjectsOfType<PlayerSpawnPoint>();
PlayerSpawnPoint playerSpawn = null;
foreach (PlayerSpawnPoint spawnPos in spawnPositions)
{
if (spawnPos.SpawnPointNumber == playerNumber)
playerSpawn = spawnPos;
}
if (m_LocalPlayer == null)
{
//get the character that needs to be spawned for this local player
PlayerType = GameManager.Instance.GetLocalPlayer();
GameObject obj = PhotonNetwork.Instantiate("Players/" + PlayerType, playerSpawn.transform.position, playerSpawn.transform.rotation, 0);
Player player = obj.GetComponent<Player>();
player.SetName(PhotonNetwork.player.NickName);
player.photonView.RPC("SyncPlayerNumber", PhotonTargets.All, playerNumber);
m_LocalPlayer = player;
}
else
{
m_LocalPlayer.transform.position = playerSpawn.transform.position;
m_LocalPlayer.transform.rotation = playerSpawn.transform.rotation;
}
}
public static void Initialise()
{
var currentDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var json = File.ReadAllText(Path.Combine(currentDirectory, "PlayerSpawnPoints.json"));
_spawnPositions = NAPI.Util.FromJson <PlayerSpawnPoint>(json);
}
/// <summary>
/// Validates the Player Two spawn point.
/// </summary>
private bool ValidateSpawnPointP2(PlayerSpawnPoint spawnPoint)
{
if (this.spawnPointP2 == null)
{
FetchSpawnPoints();
}
return(this.spawnPointP2 != null);
}
private void OnResetPlayer(Player player)
{
if (player.playerLocation == PlayerLocationEnum.LOCAL)
{
if (PlayerSpawnPoints.Count > 0)
{
PlayerSpawnPoint playerSpawnPoint = PlayerSpawnPoints[Random.Range(0, PlayerSpawnPoints.Count)];
player.transform.position = playerSpawnPoint.transform.position;
player.transform.rotation = Quaternion.LookRotation(playerSpawnPoint.transform.forward);
}
player.Health.Reset();
}
}
void PlayerJoin()
{
PlayerSpawnPoint psp = GameObject.FindObjectOfType <PlayerSpawnPoint>();
Vector3 bornPos = psp.GetSpawnPoint();
bornPos.y = 1.58f;
string data = string.Format(
"{0}|{1}|{2}|{3},{4},{5}|0,0,0|1,1,1",
myPlayerId,
playerNameDefault[Random.Range(0, playerNameDefault.Length - 1)],
playerInitHp,
bornPos.x, bornPos.y, bornPos.z
);
connectionAgent.SendCmd(Cmd.player_join, data);
}
private void Start()
{
// Temp
Vector3 pos;
PlayerSpawnPoint psp = GameObject.FindObjectOfType <PlayerSpawnPoint>();
if (psp != null)
{
pos = psp.transform.position;
}
else
{
pos = Vector3.up;
}
this.playerManager.createPlayer <Player>(pos);
}
IEnumerator JoinTheGame()
{
yield return(new WaitForEndOfFrame());
PlayerSpawnPoint psp = GameObject.FindObjectOfType <PlayerSpawnPoint>();
Vector3 bornPos = psp.GetSpawnPoint();
string data = string.Format(
"{0}|{1}|{2}|{3},{4},{5}|0,0,0|1,1,1",
mySocketId, // 用mySocketId當作playerId
playerNameDefault[Random.Range(0, playerNameDefault.Length - 1)],
playerInitHp,
bornPos.x, bornPos.y, bornPos.z
);
connectionAgent.SendCmd(Cmd.player_join, data);
}
/// <summary>
/// Загрузка уровня.
/// </summary>
private IEnumerator LoadLevel()
{
while (ScenesManager.Instance.Loading)
{
yield return(null);
}
if (PlayerSpawnPoint == null)
{
PlayerSpawnPoint = FindObjectOfType <PlayerSpawnPoint>();
}
Name = UnitPositions.Name;
SceneLoader.LoadScene(UnitPositions);
var player = UnitsCollection.GetUnitPrefabBySid(SettingsManager.Instance.PlayerShipSid);
Instantiate(player, PlayerSpawnPoint.transform.position, PlayerSpawnPoint.transform.rotation);
}
void RS_CarFactory_CarLoadedAction(GameObject car)
{
RS_CarFactory.CarLoadedAction -= RS_CarFactory_CarLoadedAction;
PlayerSpawnPoint spawnPoint = GameObject.FindObjectOfType <PlayerSpawnPoint>();
TrackFinishPoint finishPoint = GameObject.FindObjectOfType <TrackFinishPoint> ();
finishPoint.OnPointTriggered += delegate() {
OnLevelFinishedAction();
Debug.Log("!!!Drag Race Fuinished!!!");
UIController.ButtonGoToMainMenuEvent += UIController_ButtonGoToMainMenuEvent;
if (Mode == RS_GameMode.SinglePlayer)
{
UIController.ShowForSingleplayer(UM_GameServiceManager.Instance.Player,
_ghost.IsNewRecord(),
_ghost.GetCurrentTime(),
_ghost.SavedDataExists(),
_ghost.GetCurrentTime() - _ghost.GetRecordTime());
}
else
{
foreach (UM_TBM_Match match in TBM.Matchmaker.Matches) //Just shitty lines of code. Refactor needed
{
if (match.Id.Equals(ActiveMatch.Id))
{
UIController.ShowForMultiplayer(match, _ghost.GetCurrentTime());
}
}
}
};
_player = car.GetComponent <RS_DragCarController>();
_player.transform.position = spawnPoint.transform.position;
SetupCar();
OnPlayerSpawned();
}
private void SpawnerAPI_OnPlayerSpawningAtPoint(PlayerSpawnPoint playerSpawnPoint)
{
CustomItemSpawner.CustomItemSpawner.CheckRoomItemSpawn(playerSpawnPoint.Room.gameObject);
if (!_initialSpawnsFinished)
{
return;
}
switch (playerSpawnPoint.Room.Zone)
{
case ZoneType.Entrance:
CustomItemSpawner.Spawning.EndlessSpawning.SpawnItemsInEndlessGroup("lczsafe");
break;
case ZoneType.LightContainment:
CustomItemSpawner.Spawning.EndlessSpawning.SpawnItemsInEndlessGroup("entsafe");
break;
}
}
////////////////////////////////////////////////////////////////
void SetPlayerSpawnPoint(PlayerSpawnPoint spawnPoint)
{
if (spawnPoint != null)
{
EventManager.Get().FireEvent(new SpawnPointReachedEvent(spawnPoint));
if (m_CurrentSaveParticleSystem != null && spawnPoint._IsVizualized)
{
AssetDataPlayer assetDataPlayer = AssetManager.GetAssetData <AssetDataPlayer>();
m_CurrentSaveParticleSystem.Clear();
m_CurrentSaveParticleSystem.Play();
m_CurrentSaveParticleSystem.transform.position = spawnPoint.transform.position + assetDataPlayer.SavePointEffectOffset;
if (m_CurrentPlayerSpawnPoint != null)
{
EventManager.Get().FireEvent(new PlaySoundEvent(Sounds.FX_StopFirePlant, m_CurrentPlayerSpawnPoint.gameObject));
}
EventManager.Get().FireEvent(new PlaySoundEvent(Sounds.FX_FirePlant, spawnPoint.gameObject));
GameCore.Get().StartCoroutine(C_FaceInLightForSaveParticleSystem());
}
}
m_CurrentPlayerSpawnPoint = spawnPoint;
}
/// <summary>
/// Finds the player spawn point by name
/// </summary>
/// <remarks>
/// <para>Selects from active PlayerSpawnPoints, then active without PlayerSpawnPoint, then inactive without PlayerSpawnPoint</para>
/// </remarks>
public static GameObject FindPlayerSpawn(string spawnPointName)
{
Transform[] transforms = CoreUtils.GetWorldRoot().GetComponentsInChildren <Transform>(true);
var potentialSpawnPoints = transforms.Select(t => t.gameObject).Where(g => g.name == spawnPointName);
PlayerSpawnPoint spawnPoint = potentialSpawnPoints.Where(g => g.activeInHierarchy).Select(g => g.GetComponent <PlayerSpawnPoint>()).Where(p => p != null).FirstOrDefault();
if (spawnPoint != null)
{
return(spawnPoint.gameObject);
}
GameObject spawnPointObject = potentialSpawnPoints.Where(g => g.activeInHierarchy).FirstOrDefault();
if (spawnPointObject != null)
{
return(spawnPointObject);
}
spawnPointObject = potentialSpawnPoints.Where(g => g.GetComponent <PlayerSpawnPoint>() == null).FirstOrDefault();
if (spawnPointObject != null)
{
return(spawnPointObject);
}
return(null);
}
//====================================================================================
void Start(){
//audio
menuMusic = GameObject.Find("MenuMusic").GetComponent<AudioSource> ();
roundMusic = GameObject.Find("RoundMusic").GetComponent<AudioSource> ();
roundBreakAudio = GameObject.Find("RoundStart").GetComponent<AudioSource> ();
endWhistle = GameObject.Find ("Whistle").GetComponent<AudioSource> ();
scoreAudio = GameObject.Find ("ScoreAudio").GetComponent<AudioSource> ();
menuMusic.Play ();
roundMusic.Stop ();
roundBreakAudio.Stop ();
endWhistle.Stop ();
scoreAudio.Stop ();
//gameplay objects
GameObject[] totems = GameObject.FindGameObjectsWithTag ("Totem");
Debug.Assert (totems.Length == 2);
foreach (GameObject tt in totems) {
if (tt.transform.position.x < 0) {
leftTotem = tt.GetComponentInChildren<SpriteRenderer> ();
leftTotemScore = tt.GetComponentInChildren<TextMesh> ();
} else {
rightTotem = tt.GetComponentInChildren<SpriteRenderer> ();
rightTotemScore = tt.GetComponentInChildren<TextMesh> ();
}
}
PlayerSpawnPoint[] spawns = GameObject.FindObjectsOfType<PlayerSpawnPoint> ();
Debug.Assert (spawns.Length == 2);
foreach (PlayerSpawnPoint sp in spawns) {
if (sp.transform.position.x < 0) {
leftSpawn = sp;
} else {
rightSpawn = sp;
}
}
godPlayer = GameObject.FindObjectOfType<GodHandAnimation> ();
PlayerMovement[] tribesmen = GameObject.FindObjectsOfType<PlayerMovement> ();
Debug.Assert (tribesmen.Length == 2);
foreach (PlayerMovement pl in tribesmen) {
if (pl.transform.position.x < 0) {
leftPlayer = pl;
} else {
rightPlayer = pl;
}
}
//text
godScore = GameObject.Find ("GodScore").GetComponent<Text> ();
idolCount = GameObject.Find ("Pedestal").GetComponentInChildren<TextMesh> ();
pauseText = GameObject.Find ("PauseText").GetComponent<Text> ();
pauseText.enabled = false;
titleText = GameObject.Find ("Image").GetComponent<Image> ();
roundText = GameObject.Find ("RoundText").GetComponent<Text> ();
startRoundText = GameObject.Find ("StartRoundButton").GetComponent<Text>();
endText = GameObject.Find ("EndText").GetComponent<Text> ();
endText.enabled = false;
//screen positioning
cam = Camera.main;
camHorizView = Mathf.Abs(cam.transform.position.z) * Mathf.Tan (0.5f * Mathf.Deg2Rad * cam.fieldOfView) * Screen.width / Screen.height; //the camera's horizontal view extent
Debug.Log ("Cam view = " + camHorizView);
/*
float totemOffsetFromEdge = leftTotem.sprite.bounds.size.x * percentTotemOffscreen;
// Debug.Log ("Totem sprite width = " + leftTotem.sprite.bounds.size.x + ", offset from edge = " + totemOffsetFromEdge);
leftTotem.transform.parent.position = new Vector3(totemOffsetFromEdge - camHorizView, leftTotem.transform.parent.position.y, leftTotem.transform.parent.position.z);
rightTotem.transform.parent.position = new Vector3(camHorizView - totemOffsetFromEdge, rightTotem.transform.parent.position.y, rightTotem.transform.parent.position.z);
*/
InitializeNextRound();
}
void Awake()
{
instance = this;
}
public static void SetSpawnPoint(PlayerSpawnPoint playerSpawn)
{
instance.spawnPoint = playerSpawn;
}
/// <summary>
/// Method to load a map
/// </summary>
/// <param name="filename">file name of map</param>
/// <param name="contentMgr">content manager instance</param>
/// <param name="gfxDevice">graphics device instance</param>
public static void loadMap(String filename, ContentManager contentMgr, GraphicsDevice gfxDevice)
{
XmlReader reader = XmlReader.Create(filename);
XPathDocument docNav = new XPathDocument(reader);
XPathNavigator nav = docNav.CreateNavigator();
XmlNamespaceManager nsmanager = new XmlNamespaceManager(nav.NameTable);
XPathNodeIterator iter;
XPathNavigator mapIter = nav.SelectSingleNode("/Map");
mapRadius = Convert.ToSingle(mapIter.GetAttribute("mapRadius", nsmanager.DefaultNamespace));
XPathNavigator skyboxIter = nav.SelectSingleNode("/Map/Skybox");
String texName = skyboxIter.GetAttribute("texture", nsmanager.DefaultNamespace);
skyBoxRepeat = Convert.ToSingle(skyboxIter.GetAttribute("repeat", nsmanager.DefaultNamespace));
SetUpSkyBox(gfxDevice, contentMgr, texName, Convert.ToString(skyBoxRepeat));
//Now read in path nodes:
iter = nav.Select("/Map/Marker[@className!='SpawnPoint' and @className!='PlayerSpawnPoint']");
while (iter.MoveNext())
{
Node n = new Node();
readMarkerData(contentMgr, reader, docNav, nav, nsmanager, iter, n);
content.Add(n.id, n);
}
//Read spawnpoints:
iter = nav.Select("/Map/Marker[@className='SpawnPoint']");
while (iter.MoveNext())
{
SpawnPoint n = new SpawnPoint();
readMarkerData(contentMgr, reader, docNav, nav, nsmanager, iter, n);
content.Add(n.id, n);
}
//Read player spawnpoints:
iter = nav.Select("/Map/Marker[@className='PlayerSpawnPoint']");
while (iter.MoveNext())
{
SpawnPoint n = new PlayerSpawnPoint();
readMarkerData(contentMgr, reader, docNav, nav, nsmanager, iter, n);
content.Add(n.id, n);
}
//Now read other content:
iter = nav.Select("/Map/ContentItem");
while (iter.MoveNext())
{
Drawer n = new Drawer(false);
n.contentLoader = contentMgr;
readObjectData(contentMgr, reader, docNav, nav, nsmanager, iter, n);
}
List <Edge> edgeList = new List <Edge>();
List <float> edgeDistances = new List <float>();
iter = nav.Select("/Map/PathEdge");
while (iter.MoveNext())
{
float weight = Convert.ToSingle(iter.Current.GetAttribute("weight", nsmanager.DefaultNamespace));
float distance = Convert.ToSingle(iter.Current.GetAttribute("distance", nsmanager.DefaultNamespace));
String firstId = iter.Current.SelectSingleNode("firstNodeId").Value;
String secondId = iter.Current.SelectSingleNode("secondNodeId").Value;
Node first = null, second = null;
foreach (Object item in content.Values)
{
if (item is Node)
{
if ((item as Marker).id == firstId)
{
first = item as Node;
}
else if ((item as Marker).id == secondId)
{
second = item as Node;
}
if (first != null && second != null)
{
break;
}
}
}
edgeList.Add(new Edge(first, second, weight));
edgeDistances.Add(distance);
}
//Connect nodes:
for (int i = 0; i < edgeList.Count; i++)
{
Edge item = edgeList.ElementAt(i);
float distance = edgeDistances.ElementAt(i);
item.node1.connectToNode(item.node2, item.weight, distance);
}
reader.Close();
}
void Awake()
{
instance = this;
}
IEnumerator InitLevel()
{
yield return(new WaitForEndOfFrame());
hasReachedExit = false;
board = GameObject.FindWithTag("Board").GetComponent <Board>();
characterSelectPanel = GameObject.FindWithTag("CharacterSelect").GetComponent <CharacterSelect>();
Level level = Resources.Load("Levels/" + levelToLoad) as Level;
levelName = level.title;
timeLimit = level.timeLimit;
victoryPanel = GameObject.FindGameObjectWithTag("VictoryPanel").transform.GetChild(0).gameObject;
playerSpawnPoints = new List <PlayerSpawnPoint>();
actors = new List <Actor>();
playerAvailableCharactersPrefabs = new List <GameObject>();
playerPreviews = new List <GameObject>();
playerIcons = new List <Sprite>();
foreach (Level.PlayerClass cls in level.classes)
{
GameObject prefab = null;
GameObject preview = null;
Sprite icon = null;
switch (cls)
{
case Level.PlayerClass.ARCHER:
prefab = prefabArcher;
preview = previewArcher;
icon = iconArcher;
break;
case Level.PlayerClass.THIEF:
prefab = prefabThief;
preview = previewThief;
icon = iconThief;
break;
case Level.PlayerClass.WARRIOR:
prefab = prefabWarrior;
preview = previewWarrior;
icon = iconWarrior;
break;
}
playerAvailableCharactersPrefabs.Add(prefab);
playerPreviews.Add(preview);
playerIcons.Add(icon);
}
System.Random rng = new System.Random();
characterSelectPanel.Init();
foreach (Position pos in level.walls)
{
CreateWall(rng, pos.row, pos.col);
}
foreach (Position pos in level.spawnPoints)
{
Vector3 spawnPos = board.GetCoordinates(pos.row, pos.col);
spawnPos += 0.1f * Vector3.up;
GameObject objSP = Instantiate(
prefabSpawnPoint,
spawnPos,
prefabSpawnPoint.transform.rotation);
PlayerSpawnPoint spawn = objSP.GetComponent <PlayerSpawnPoint>();
spawn.r = pos.row;
spawn.c = pos.col;
playerSpawnPoints.Add(spawn);
}
foreach (Position pos in level.coins)
{
Vector3 coinPos = board.GetCoordinates(pos.row, pos.col);
coinPos += prefabCoin.transform.localScale.x * Vector3.up;
Instantiate(
prefabCoin, coinPos, prefabCoin.transform.rotation);
}
foreach (Level.EnemyInstance inst in level.enemies)
{
GameObject prefab = null;
switch (inst.enemyType)
{
case Level.EnemyType.TEST_ENEMY:
prefab = prefabTestEnemy;
break;
case Level.EnemyType.SKELETON:
prefab = prefabSkeleton;
break;
}
Actor actor = Instantiate(prefab).GetComponent <Actor>();
actor.Spawn(board, inst.position.row, inst.position.col);
inst.plan.ForEach(
action => actor.AddAction(action));
actors.Add(actor);
}
if (level.button.row != -1 && level.button.col != -1 && level.door.row != -1 && level.door.col != -1)
{
Vector3 doorPos = board.GetCoordinates(level.door.row, level.door.col);
GameObject door = Instantiate(
prefabDoor, doorPos, Quaternion.identity);
board.Set(level.door.row, level.door.col, door);
Vector3 buttonPos = board.GetCoordinates(level.button.row, level.button.col);
GameObject button = Instantiate(
prefabButton, buttonPos, Quaternion.identity);
button.GetComponent <ButtonBehaviour>().door = door;
button.GetComponent <ButtonBehaviour>().targetCol = level.door.col;
button.GetComponent <ButtonBehaviour>().targetRow = level.door.row;
}
for (int i = 0; i < Board.GRID_ROWS; i++)
{
for (int j = 0; j < Board.GRID_COLS; j++)
{
if (i != level.exit.row || j != level.exit.col)
{
CreateFloorTile(rng, i, j);
}
}
}
Vector3 exitPos = board.GetCoordinates(level.exit.row, level.exit.col);
Instantiate(prefabExit, exitPos, Quaternion.identity);
Init();
}
public void RegisterPlayerSpawnPoint(PlayerSpawnPoint playerSpawnPoint) => _playerSpawnPoint = playerSpawnPoint;
public void AddSpawnPoint(PlayerSpawnPoint sp)
{
spawnPoints.Add(sp);
}
//Teleports/'Spawns' the player at the specified spawn point in the current scene
public void SpawnPlayerAtSpawnPoint(Protagonist player, string spawnPointLabel)
{
PlayerSpawnPoint sp = spawnPoints.First(point => point.label == spawnPointLabel);
Spawn(player, sp.transform.position, sp.transform.rotation);
}
