/// <summary>
/// Determines the location to respawn the object to and then does the respawn.
/// </summary>
public void Respawn()
{
m_ScheduledRespawnEvent = null;
if (m_PositioningMode != SpawnPositioningMode.None)
{
Vector3 position;
Quaternion rotation;
if (m_PositioningMode == SpawnPositioningMode.SpawnPoint)
{
position = m_Transform.position;
rotation = m_Transform.rotation;
// If the object can't be spawned then try again in the future.
if (!SpawnPointManager.GetPlacement(m_GameObject, m_Grouping, ref position, ref rotation))
{
m_ScheduledRespawnEvent = Scheduler.Schedule(Random.Range(m_MinRespawnTime, m_MaxRespawnTime), Respawn);
return;
}
}
else // Spawn Location.
{
position = m_StartPosition;
rotation = m_StartRotation;
}
Respawn(position, rotation, true);
}
else
{
Respawn(m_Transform.position, m_Transform.rotation, false);
}
}
void Start()
{
Assert.IsNotNull(gameManagers.chaserManagerClass);
Assert.IsNotNull(gameManagers.UIManagerClass);
Assert.IsNotNull(gameManagers.spawnPointManagerClass);
Assert.IsNotNull(gameManagers.asteroidStormManagerClass);
Assert.IsNotNull(players, "playerShips niet geassigned");
//UIManager
UIManager UIManager = Instantiate(gameManagers.UIManagerClass);
UIManager.playerShip = players[0];
// Spawn Point Manager
SpawnPointManager spawnPointManager = Instantiate(gameManagers.spawnPointManagerClass);
// Asteroid Storm Manager
//if (difficulty > 0)
//{
// AsteroidStormManager asteroidStormManager = Instantiate(gameManagers.asteroidStormManagerClass);
// asteroidStormManager.spawnPointManager = spawnPointManager;
//}
// Enemy Managers
ChaserManager chaserManager = Instantiate(gameManagers.chaserManagerClass);
chaserManager.SetPlayers(players);
chaserManager.SetSpawnPoints(spawnPointManager.chaserSpawnPoints);
MoverManager moverManager = Instantiate(gameManagers.MoverManagerClass);
moverManager.SetPlayers(players);
moverManager.SetSpawnPoints(spawnPointManager.movingSpawnPoints);
}
public void MovePlayersToStartPoints(List <IPlayer> players)
{
Debug.Log("Moving " + players.Count + " players to their spawn points");
SpawnPointManager mgr = SpawnPointManager.instance;
if (mgr == null)
{
Debug.LogError("SpawnPointManager.instance was null!");
return;
}
var points = mgr.GetFFAStartPoints(this.Mode).GetEnumerator();
foreach (IPlayer p in players)
{
points.MoveNext();
if (points.Current == null)
{
Debug.LogError("Error; not enough start points for this game mode!");
points.Reset();
}
Debug.Log(points.Current);
Debug.Log(p);
Debug.Log("moving " + p.Username + " to " + points.Current.gameObject);
p.MoveTo(points.Current.gameObject.transform);
}
points.Dispose();
}
private void OnDisable()
{
if (localSpawnPoint == this)
{
localSpawnPoint = null;
}
}
public void InitializePlayer(bool selectOnCreation = true)
{
if (doNotRemoveAssetsWithTag)
{
var player = GameObject.FindWithTag("Player");
if (player != null)
{
playerInstance = player;
}
}
if (playerInstance == null && gameData.PlayerPrefab != null)
{
playerInstance = Instantiate(gameData.PlayerPrefab);
playerInstance.transform.position = SpawnPointManager.GetSpawnPoint(0).Position;
playerInstance.transform.rotation = SpawnPointManager.GetSpawnPoint(0).Rotation;
}
// Select Player on creation.
if (selectOnCreation)
{
UnityEditor.Selection.activeGameObject = playerInstance;
}
}
private void Start()
{
spawnPointManager = gameObject.GetComponent <SpawnPointManager>();
scoreManager = gameObject.GetComponent <ScoreManager>();
explodePosition = new Vector3(transform.position.x, transform.position.y + 3.5f, transform.position.z);
explosion = gameObject.AddComponent <ExplosionEffect>();
}
void Awake()
{
List <PathSample> patrol = new List <PathSample> ();
List <PathSample> hero = new List <PathSample> ();
List <PathSample> spawn = new List <PathSample> ();
foreach (Transform child in patrolPathPoints)
{
patrol.Add(new PathSample(child.position, child.rotation, 0));
}
foreach (Transform child in heroPathPoints)
{
hero.Add(new PathSample(child.position, child.rotation, 0));
}
foreach (Transform child in spawnPoints)
{
spawn.Add(new PathSample(child.position, child.rotation, 0));
}
PatrolPathManager.SetPath(patrol);
HeroPathManager.SetPath(hero);
SpawnPointManager.SetPath(spawn);
}
private void Destroy()
{
if (instance == this)
{
instance = null;
}
}
private void MoveTeamToStartPoints(int team, IEnumerable <IPlayer> players)
{
SpawnPointManager mgr = SpawnPointManager.instance;
if (mgr == null)
{
Debug.LogError("SpawnPointManager.instance was null!");
return;
}
var p = players.GetEnumerator();
var points = mgr.GetStartPointsForTeam(team, this.Mode).GetEnumerator();
while (p.MoveNext())
{
points.MoveNext();
if (points.Current == null)
{
Debug.LogError("Error; not enough start points for team " + team);
points.Reset();
}
p.Current.MoveTo(points.Current.transform);
}
p.Dispose();
points.Dispose();
}
internal IEnumerator RespawnWithDelay(float delay = 0f, GameObject killedBy = null)
{
if (killedBy)
{
Debug.LogFormat("{0} (Team {1}) killed by {2} (Team {3}).", name, team, killedBy.name, killedBy.GetComponent <Entity>().team);
}
else
{
Debug.LogFormat("{0} (Team {1}) killed.", name, team);
}
alive = false;
Deactivate();
yield return(new WaitForSeconds(delay));
Debug.LogFormat("Respawning {0} (Team {1}).", name, team);
GameObject spawnPoint = SpawnPointManager.GetSpawnPoint(team);
rb2D.position = spawnPoint.transform.position;
rb2D.rotation = spawnPoint.transform.rotation.z;
yield return(new WaitForFixedUpdate()); // keeps entity from 'warping' in one frame
alive = true;
health = startHealth;
Activate(Vector2.zero);
}
public SpawnPointManagerData(SpawnPointManager spawnPointManager)
{
spawnPointsActive = new bool[spawnPointManager.spawnPointsActive.Length];
for (int i = 0; i < spawnPointsActive.Length; i++)
{
spawnPointsActive [i] = spawnPointManager.spawnPointsActive [i];
}
}
void Awake()
{
_myTransform = GetComponent<Transform>();
_myAiPath = GetComponent<AIPath>();
_spawnPointManager = GameObject.Find("SpawnPoints").GetComponent<SpawnPointManager>();
}
public void ManualAwake()
{
_player = GetComponent <Player>();
_graphicsGO = _player.graphicsGO;
_spawnPointManager = FindObjectOfType <SpawnPointManager>();
SubscribeEvents();
}
public void PawnRequest(ExamplePlayerController controller)
{
ExamplePawn newPawn = Instantiate(GameManager.instance.pawnPrefab, SpawnPointManager.GetSpawnPoint(), Quaternion.identity);
newPawn.ownerPlayerControllerId = controller.playerControllerId;
newPawn.PlayerName = (controller).userName;
serverManager.SpawnWithClientAuthority(newPawn.gameObject, controller.Conn);
}
void Awake()
{
instance = this;
pathRenderer = Instantiate(pathPrefab, transform);
pathRenderer.numPositions = 0;
// pathRenderer.SetPositions ( new Vector3[0] );
path = new List <PathSample> ();
nodeObjects = new List <Transform> ();
}
private void Start()
{
m_spawnPointManager = SpawnPointManager.Instance;
StartMatch();
Scoreboard.Instance.Initialize(ActorsKills.Count);
Scoreboard.Instance.UpdateScoreBoard();
KillTableUI.Instance.InitScoreTable();
}
void Awake()
{
instance = this;
activePeople = new List <PersonBehavior> ();
spawnTimers = new List <float> ();
spawnPoints = SpawnPointManager.GetPath();
peopleLayer = LayerMask.NameToLayer("People");
peopleParent = new GameObject("People Instances").transform;
}
// Use this for initialization
void Start()
{
GameObject gameController = GameObject.FindGameObjectWithTag("GameController");
spawnPointManager = gameController.GetComponent <SpawnPointManager> ();
#if UNITY_ANDROID
mobile = GameObject.Find("Mobile UI").GetComponent <MobileUI> ();
#endif
}
public override void OnInspectorGUI()
{
EditorGUIUtility.LookLikeInspector();
//get the selected object the inspector is revealing
SpawnPointManager SPManager = target as SpawnPointManager;
SPManager.name = SPManager.name;
CoreFunctions.CreateRGKSpawnPointManagerInspector(SPManager);
}
// Start is called before the first frame update
void Start()
{
SpawnPointManager manager = FindObjectOfType <SpawnPointManager>();
manager.SpawnWave("AlpacaSpawn", 5);
manager.SpawnWave("SheepSpawn", 5);
manager.SpawnWave("TreeSpawn", 5);
manager.SpawnWave("HutSpawn", 5);
manager.SpawnWave("ChickenSpawn", 5);
}
private void Awake()
{
if (instance != null)
{
Destroy(this);
return;
}
instance = this;
}
/**** Spawn Points Manager Methods ****/
public static void SaveSpawnPointsManager(SpawnPointManager spawnPointManager)
{
BinaryFormatter bf = new BinaryFormatter();
FileStream fStream = new FileStream(SpawnPointManagerFilePath, FileMode.Create);
SpawnPointManagerData spawnPointManagerData = new SpawnPointManagerData(spawnPointManager);
bf.Serialize(fStream, spawnPointManagerData);
fStream.Close();
}
/// <summary>
/// Activates the specified demo zone.
/// </summary>
/// <param name="demoZone">The demo zone to active.</param>
/// <param name="teleport">Should the character be teleported to the demo zone?</param>
private void ActiveDemoZone(DemoZone demoZone, bool teleport)
{
// The ride ability should be force stopped.
var ride = m_CharacterLocomotion.GetAbility <UltimateCharacterController.Character.Abilities.Ride>();
if (ride != null && ride.IsActive)
{
m_CharacterLocomotion.TryStopAbility(ride, true);
}
if (m_ActiveZoneIndices.Count == 0 || m_ActiveZoneIndices[m_ActiveZoneIndices.Count - 1] != demoZone.Index)
{
m_ActiveZoneIndices.Add(demoZone.Index);
}
m_LastZoneIndex = demoZone.Index;
ShowText(demoZone.Header, demoZone.Description, demoZone.Action);
if (m_PreviousZoneArrow != null)
{
m_PreviousZoneArrow.SetActive(demoZone.Index != 0);
}
if (m_NextZoneArrow != null)
{
m_NextZoneArrow.SetActive(demoZone.Index != m_DemoZones.Length - 1);
}
m_EnterFrame = Time.frameCount;
for (int i = 0; i < demoZone.EnableObjects.Length; ++i)
{
demoZone.EnableObjects[i].enabled = true;
}
for (int i = 0; i < demoZone.ToggleObjects.Length; ++i)
{
demoZone.ToggleObjects[i].SetActive(true);
}
// When the character reaches the outside section all doors should be unlocked.
if (!m_AddOnDemoManager && !m_FullAccess && demoZone.Index >= m_DemoZones.Length - 6)
{
for (int i = 0; i < m_Doors.Count; ++i)
{
m_Doors[i].CloseOnTriggerExit = false;
m_Doors[i].OpenClose(true, true, false);
}
m_FullAccess = true;
}
if (teleport)
{
var position = Vector3.zero;
var rotation = Quaternion.identity;
SpawnPointManager.GetPlacement(m_Character, demoZone.Index, ref position, ref rotation);
m_CharacterLocomotion.SetPositionAndRotation(position, rotation, true);
}
// Set the group after the state so the default state doesn't override the grouping value.
m_CharacterRespawner.Grouping = demoZone.Index;
}
protected void OnPawnRequestMessage(TinyNetMessageReader netMsg)
{
netMsg.ReadMessage(shortMessage);
ExamplePawn newPawn = Instantiate(GameManager.instance.pawnPrefab, SpawnPointManager.GetSpawnPoint(), Quaternion.identity);
newPawn.ownerPlayerControllerId = shortMessage.value;
newPawn.PlayerName = ((ExamplePlayerController)netMsg.tinyNetConn.GetFirstPlayerController()).userName;
serverManager.SpawnWithClientAuthority(newPawn.gameObject, netMsg.tinyNetConn);
}
// Use this for initialization
protected void Start()
{
Rigidbody2D rigid2D = GetComponent <Rigidbody2D> ();
moveSpeed = DEFAULT_MOVE_SPEED;
jumpForce = DEFAULT_JUMP_FORCE;
rigid2D.freezeRotation = true;
levelManager = LevelManager.instance;
SPManager = SpawnPointManager.instance;
readyPlayer(levelManager);
}
public void Awake()
{
spawnPointManager = GameObject.Find("SpawnPointManager").GetComponent <SpawnPointManager>();
teamOne = new Team(TeamId.SnakeMan);
teamTwo = new Team(TeamId.SantaOnkel);
teams = new List <Team>();
teams.Add(teamOne);
teams.Add(teamTwo);
}
void Awake()
{
if (Instance == null)
{
Instance = this;
}
else
{
Destroy(this);
}
}
/// <summary>
/// Initializes the gamemode with any components it needs.
/// Should be called before anything else.
/// </summary>
/// <param name="gameManager">the current Game Manager.</param>
public virtual void InitGameMode(GameManager gameManager)
{
this.gameManager = gameManager;
simObjectManager = new SimObjectManager();
spawnPointManager = GameObject.FindObjectOfType <SpawnPointManager>();
if (spawnPointManager == null)
{
string tx = $"<color=red>SCENE HAS NO SPAWNPOINTMANAGER!</color>";
gameManager.ConsoleWindow.WriteLine(tx);
}
}
// public class ObserverMessage : MessageBase
// {
// public Replay.Message Message;
//
// public override void Serialize(NetworkWriter writer)
// {
// GeneratedNetworkCode._WriteMessage_Replay(writer, this.Message);
// }
//
// public override void Deserialize(NetworkReader reader)
// {
// this.Message = GeneratedNetworkCode._ReadMessage_Replay(reader);
// }
// }
public void LaunchGame(bool spawnObjects = true)
{
MapLoader = new AssetLoader();
MapLoader.LoadAssetBundle("Bundles/scenes/maps.bundle");
MapLoader.LoadAsset(
$"archive:/buildplayer-robotfactory_opu_gamemode/buildplayer-{GameConfig.Map.ToLower()}");
MapLoader.ConstructCaches();
AssetsLoader = new AssetLoader();
AssetsLoader.LoadAsset("resources.assets");
AssetsLoader.ConstructCaches();
MiscLoader = new AssetLoader();
MiscLoader.LoadAssetBundle("Bundles/scenes/frontend.bundle");
MiscLoader.LoadAsset("archive:/buildplayer-options_ui/buildplayer-clientenvironmentsingletons");
MiscLoader.ConstructCaches();
if (!spawnObjects)
{
return;
}
SpawnObject(MiscLoader, "ApplicationSingletonsNetId", out _);
SpawnObject(MiscLoader, "GameSceneSingletons", out var gameSceneSingletons);
TheatricsManager = gameSceneSingletons.GetComponent <TheatricsManager>();
AbilityModManager = gameSceneSingletons.GetComponent <AbilityModManager>();
SpawnObject(MiscLoader, "SharedEffectBarrierManager", out SharedEffectBarrierManager);
SpawnObject(MiscLoader, "SharedActionBuffer", out SharedActionBuffer);
SharedActionBuffer.Networkm_actionPhase = ActionBufferPhase.Done;
SpawnScene(MapLoader, 1, out var commonGameLogic);
InterfaceManager = commonGameLogic.GetComponent <InterfaceManager>();
GameFlow = commonGameLogic.GetComponent <GameFlow>();
// MatchLogger = commonGameLogic.GetComponent<MatchLogger>();
ServerCombatManager = commonGameLogic.GetComponent <ServerCombatManager>();
ServerEffectManager = commonGameLogic.GetComponent <ServerEffectManager>();
TeamStatusDisplay = commonGameLogic.GetComponent <TeamStatusDisplay>();
ServerActionBuffer = commonGameLogic.GetComponent <ServerActionBuffer>();
TeamSelectData = commonGameLogic.GetComponent <TeamSelectData>();
BarrierManager = commonGameLogic.GetComponent <BarrierManager>();
SpawnObject <Board, Board>(MapLoader, out Board);
SpawnScene(MapLoader, 2, out BrushCoordinator);
SpawnScene(MapLoader, 3, out var sceneGameLogic);
GameFlowData = sceneGameLogic.GetComponent <GameFlowData>();
GameplayData = sceneGameLogic.GetComponent <GameplayData>();
SpoilsManager = sceneGameLogic.GetComponent <SpoilsManager>();
ObjectivePoints = sceneGameLogic.GetComponent <ObjectivePoints>();
SpawnPointManager = sceneGameLogic.GetComponent <SpawnPointManager>();
MatchObjectiveKill = sceneGameLogic.GetComponent <MatchObjectiveKill>();
DumpNetObjects();
}
void Start()
{
score = 0;
scoreText.text = "Score: " + score;
spManager = GetComponent <SpawnPointManager>();
cupsList = new List <GameObject>();
updateChildren();
getCupsInPlay();
updateList();
startCup = cupsList[0];
checkCupCount();
}
static void OnChangePlayMode(PlayModeStateChange playMode)
{
switch (playMode)
{
case PlayModeStateChange.ExitingPlayMode:
SetIsInGameMode(false);
break;
case PlayModeStateChange.EnteredPlayMode:
SetIsInGameMode(true);
ItemIdAssigner.AssignItemId();
ItemTemplateIdAssigner.Execute();
LayerCollisionConfigurer.SetupLayerCollision();
var rootGameObjects = SceneManager.GetActiveScene().GetRootGameObjects();
var spawnPoints = GetComponentsInGameObjectsChildren <ISpawnPoint>(rootGameObjects);
SpawnPointManager = new SpawnPointManager(spawnPoints);
// 疑似Playerの設定
var enterDeviceType = EnterDeviceType.Desktop;
if (XRSettings.enabled)
{
enterDeviceType = EnterDeviceType.VR;
}
var despawnHeight = GetComponentInGameObjectsChildren <IDespawnHeight>(rootGameObjects).Height;
PlayerPresenter = new PlayerPresenter(PermissionType.Audience, enterDeviceType, SpawnPointManager);
new AvatarRespawner(despawnHeight, PlayerPresenter);
var itemCreator = new ItemCreator(GetComponentsInGameObjectsChildren <ICreateItemGimmick>(rootGameObjects));
var itemDestroyer = new ItemDestroyer(PlayerPresenter.PlayerTransform.GetComponent <IItemController>());
new ItemRespawner(despawnHeight, itemCreator, itemDestroyer, GetComponentsInGameObjectsChildren <IMovableItem>(rootGameObjects));
var mainScreenViews = GetComponentsInGameObjectsChildren <IMainScreenView>(rootGameObjects);
MainScreenPresenter = new MainScreenPresenter(mainScreenViews);
var rankingScreenViews = GetComponentsInGameObjectsChildren <IRankingScreenView>(rootGameObjects);
var rankingScreenPresenter = new RankingScreenPresenter(rankingScreenViews);
rankingScreenPresenter.SetRanking(11);
var commentScreenViews =
GetComponentsInGameObjectsChildren <ICommentScreenView>(rootGameObjects);
CommentScreenPresenter = new CommentScreenPresenter(commentScreenViews);
SetupTriggerGimmicks(rootGameObjects, itemCreator, itemDestroyer);
OnInitializedEvent?.Invoke();
break;
}
}
void Awake()
{
spawnPoints = FindObjectsOfType<SpawnPoint>().ToList();
instance = this;
}
void OnLevelWasLoaded()
{
mSpawnManager = GameObject.Find("AvatarSpawnManager").GetComponent<SpawnPointManager>();
}
// Use this for initialization
void Start()
{
mSpawnManager = GameObject.Find("AvatarSpawnManager").GetComponent<SpawnPointManager>();
mAvatarManager = GameObject.Find("ServerObject").GetComponent<AvatarManager>();
mAvatarGraphicsMain = transform.Find("GraphicsMain");
mAvatarGraphicsOverlay = transform.Find("GraphicsOverlay");
mAvatarPickup = GetComponent<AvatarPickup>();
mGraphicsOriginalScale = mAvatarGraphicsMain.localScale;
StartCoroutine("Respawn", true);
DontDestroyOnLoad(gameObject);
}
/*----------------------------------------------------------
* cache reference to spawn point manager object
* and start 'listener' of fire key presses
*/
void Start()
{
spawnPointManager = GetComponent<SpawnPointManager> ();
StartCoroutine("CheckFireKeyAfterShortDelay");
}
void Start ()
{
instance = this;
spawnPoints = GameObject.FindGameObjectsWithTag("SpawnPoints");
}
