void Initialize(GameObject[] ObstacleInstances, GameObject BeginningPlatform)
{
Instance = this;
ManagedPlatforms = new List<ObstacleMovement>();
for( int i = 0; i < NumberOfObstacles; ++i )
{
GameObject newObstacle = Instantiate( ObstacleInstances[Random.Range( 0, ObstacleInstances.Length )]);
newObstacle.SetActive( false );
newObstacle.transform.parent = transform;
ManagedPlatforms.Add( newObstacle.GetComponent<ObstacleMovement>() );
ManagedPlatforms[i].SetSpeed( Speed );
}
IndexToSpawn = 0;
Playing = true;
Vector3 Spawn_platform = new Vector3( EvaPosition.position.x, 0.0f, 0.0f );
ManagedPlatforms[(IndexToSpawn++ % NumberOfObstacles)].Spawn( Spawn_platform );
CurrentPlatform = 0;
GameObject beginningObstacle = (GameObject)Instantiate( BeginningPlatform );
beginningObstacle.transform.parent = transform;
Vector3 End = beginningObstacle.GetComponent<ObstacleMovement>().GetEndPoint();
End.x -= Offset;
Spawn_platform = new Vector3( EvaPosition.position.x - End.x, 0.0f, 0.0f );
beginningObstacle.GetComponent<ObstacleMovement>().Spawn( Spawn_platform );
}
void Start()
{
SM = GameObject.Find("SpawnManager").GetComponent<SpawnManager>();
if(setSpawnPoint)
SM.SetNextSpawnPoint(nextSpawnPoint);
Spawn();
}
static void GetSpawnManager()
{
spawnManager=(SpawnManager)FindObjectOfType(typeof(SpawnManager));
if(spawnManager!=null){
if(spawnManager.spawnMode==_SpawnMode.Continuous) spawnType=0;
else if(spawnManager.spawnMode==_SpawnMode.WaveCleared) spawnType=1;
else if(spawnManager.spawnMode==_SpawnMode.RoundBased) spawnType=2;
else if(spawnManager.spawnMode==_SpawnMode.SkippableContinuous) spawnType=3;
else if(spawnManager.spawnMode==_SpawnMode.SkippableWaveCleared) spawnType=4;
waveLength=spawnManager.waves.Length;
//UpdateWaveLength();
waveFoldList=new bool[waveLength];
for(int i=0; i<waveFoldList.Length; i++){
waveFoldList[i]=true;
}
subWaveLength=new int[waveLength];
for(int i=0; i<waveLength; i++){
Wave wave=spawnManager.waves[i];
//Debug.Log(wave.subWaves);
subWaveLength[i]=wave.subWaves.Length;
}
}
rscManager=(ResourceManager)FindObjectOfType(typeof(ResourceManager));
}
public static void Initialize()
{
ClientDB = ClientDBManager.GetInstance();
Redirect = RedirectManager.GetInstance();
Session = SessionManager.GetInstance();
Player = PlayerManager.GetInstance();
Spawns = SpawnManager.GetInstance();
}
private void Start()
{
_xform = transform;
_startingColor = renderer.material.color;
_pool = PoolManager.Pools[_BULLET_POOL_STRING];
_particleManager = GameObject.Find("ParticleManager").GetComponent<ParticleEffectsManager>();
_spawnManager = GameObject.Find("SpawnMananger").GetComponent<SpawnManager>();
}
void Start()
{
test = GetComponent<LeftRightTest>();
sim = GetComponent<ButtonSimulator>();
sim2 = engineLeft.GetComponent<ForwardBackSimulator>();
AI = transform.parent.GetComponent<SpawnManager>();
AI.isAI = true;
}
void InitialiseData()
{
smScript = transform.parent.GetComponent<SpawnManager>();
GameObject _LevelManager = GameObject.Find("LevelManager");
lmScript = _LevelManager.GetComponent<LevelManager>();
PoolWaves();
}
void Awake()
{
_singleton = this;
enemyPrefabs = new List<GameObject>(2);
_gm = Game.Instance;
enemyPrefabs.Add(Resources.Load("Enemies/Bombman/Bombman") as GameObject);
enemyPrefabs.Add(Resources.Load("Enemies/Eye/Eye") as GameObject);
}
protected override void Awake()
{
base.Awake();
effectColor = new Color(249f / 255f, 158f / 255f, 235f / 255f, 1f);
spawnMgr = GameObject.FindObjectOfType<SpawnManager>();
selectTab = GameObject.FindObjectOfType<SelectTab>();
}
public static void InitializeManager()
{
DataMgr = DataManager.GetInstance();
ObjectMgr = ObjectManager.GetInstance();
SkillMgr = SkillManager.GetInstance();
SpawnMgr = SpawnManager.GetInstance();
SpellMgr = SpellManager.GetInstance();
WorldMgr = WorldManager.GetInstance();
}
// Use this for initialization
void Start()
{
audSource = GameObject.Find("ApplicationGlobal").GetComponent<AudioSource>();
m_light = GameObject.Find("Directional light").GetComponent<Light>();
spawnManager = GameObject.Find("SpawnManager").GetComponent<SpawnManager>();
dragon = Resources.Load<RuntimeAnimatorController>("Animations/Dragon");
dragonIce = Resources.Load<RuntimeAnimatorController>("Animations/DragonIce");
dragon2 = Resources.Load<RuntimeAnimatorController>("Animations/Dragon2");
dragon2Ice = Resources.Load<RuntimeAnimatorController>("Animations/Dragon2Ice");
}
void Start()
{
scoreManager = this.gameObject.AddComponent<ScoreManager> ();
scoreManager.initialize (killGoal);
spawnManager = this.gameObject.AddComponent<SpawnManager> ();
spawnManager.initialize (players);
gameOver = false;
}
void Start()
{
nodeTransform = GameObject.Find("Node1").transform;
currentNode = nodeTransform.GetComponent<Node>();
test = GetComponent<LeftRightTest>();
spawn = parent.GetComponent<SpawnManager>();
velocityL = leftEngine.GetComponent<RigidbodyInfo>();
velocityR = rightEngine.GetComponent<RigidbodyInfo>();
nodeStuffs = GetComponent<NodeRespawn>();
}
public static void Initialize()
{
Character = CharacterManager.GetInstance();
ClientDB = ClientDBManager.GetInstance();
GameAccount = GameAccountManager.GetInstance();
Redirect = RedirectManager.GetInstance();
Session = SessionManager.GetInstance();
Player = PlayerManager.GetInstance();
Spawns = SpawnManager.GetInstance();
}
// Use this for initialization
void Start()
{
if (!gameManager)
{
gameManager = GameObject.FindGameObjectWithTag(gameManagerTag);
spawnManager = gameManager.GetComponent<SpawnManager>();
} else
{
Debug.LogWarning("Cannot respawn bots without a spawnManagerTag");
}
}
// Use this for initialization
void Start()
{
sm = GameObject.FindGameObjectWithTag ("SpawnManager").GetComponent<SpawnManager> ();
rb = GetComponent<Rigidbody> ();
//BhList = new List<IBehaviour> ();
if (isPlayer) {
BhList.Add (new PlayerBhv (this, true, PlayerId));
} else {
BhList.Add(new Seek(this, sm.TeamList[0][0],true));
}
sm.TeamList [Team].Add (gameObject);
}
// Use this for initialization
void Start()
{
ScoreKeeper[] scoreKeepers = GameObject.FindObjectsOfType<ScoreKeeper>();
foreach (ScoreKeeper scoreKeeper in scoreKeepers)
{
if (1 == scoreKeeper.teamNumber) { T1ScoreKeeper = scoreKeeper; }
else if (2 == scoreKeeper.teamNumber) { T2ScoreKeeper = scoreKeeper; }
}
spawnManager = FindObjectOfType<SpawnManager>();
gameManager = FindObjectOfType<GameManager>();
audioSource = GetComponent<AudioSource>();
}
void Start()
{
//Gets a reference to game controller so the score can be updated
GameObject gameControllerObject = GameObject.FindWithTag("GameController");
if (gameControllerObject != null)
{
gameController = gameControllerObject.GetComponent<SpawnManager>();
}
if (gameController == null)
{
Debug.Log("Cannot find 'GameController' Script");
}
}
public static void InitializeManager()
{
ActionMgr = ActionManager.GetInstance();
AddonMgr = AddonManager.GetInstance();
SkillMgr = SkillManager.GetInstance();
SpellMgr = SpellManager.GetInstance();
SpecializationMgr = SpecializationManager.GetInstance();
DataMgr = DataManager.GetInstance();
SpawnMgr = SpawnManager.GetInstance();
GossipMgr = GossipManager.GetInstance();
ObjectMgr = ObjectManager.GetInstance();
WorldMgr = WorldManager.GetInstance();
}
void Awake()
{
if(instance == null)
{
instance = this;
}
else if(instance != null)
{
Destroy(gameObject);
}
}
// Use this for initialization
void Start () {
gameManager = GetComponent<GameManager> ();
// Setup audio listener
AudioListener.volume = 1.0f;
//Initalize our game objects
mainCamera = FindObjectOfType<Camera> ();
playerManager = this.gameObject.GetComponent<PlayerManager>();
spawnManager = this.gameObject.GetComponent<SpawnManager>();
soundManager = this.GetComponent<SoundManager>();
Initiate ();
}
// Use this for initialization
void Start() {
ui = GameObject.Find("StatUI").GetComponent<StatUI>();
spawner = GameObject.Find("SpawnManager").GetComponent<SpawnManager>();
shooter = GameObject.Find("ProjectileManager").GetComponent<ProjectileManager>();
player = GameObject.Find("Player").GetComponent<Player>();
frontInd = transform.Find("LevelIndicator").GetComponent<Text>();
backInd = transform.Find("LevelIndicatorBack").GetComponent<Text>();
overlay = transform.Find("Overlay").gameObject;
fadeImage = overlay.GetComponent<RawImage>();
player.reset();
StartCoroutine(startSequence());
}
void Start()
{
Me = this;
TerrianManager = transform.FindChild("TerrainManager").GetComponent<TerrianManager>();
SpawnManager = transform.FindChild("SpawnManager").GetComponent<SpawnManager>();
TurnManager = transform.FindChild("TurnManager").GetComponent<TurnManager>();
DamageManager = transform.FindChild("DamageAndScoreManager").GetComponent<DamageManager>();
ScoreManager = transform.FindChild("DamageAndScoreManager").GetComponent<ScoreManager>();
DestroyManager = transform.FindChild("DestroyManager").GetComponent<DestroyManager>();
WeaponManager = transform.FindChild("WeaponsManager").GetComponent<WeaponsCombo>();
ModesManager = transform.FindChild("ModesManager").GetComponent<ModesCombo>();
MapsManager = transform.FindChild("MapManager").GetComponent<MapManager>();
PlayerInfos = SpawnManager.GetComponent<PlayerInfo>();
MapsManager.StartMap((MapManager.Maps) RoundManager.RandomMap);
SpawnManager.Spawn(TanksStaringCount);
TurnManager.Begin();
Wind.StartWind();
WeaponsClass.InitiallizeWeaponsQuantities();
ModesClass.InitiallizeModesQuantities();
#if (!Debug)
for (int i = 0; i < WeaponsClass.WeaponsQuantities.Count; i++)
WeaponsClass.WeaponsQuantities[WeaponsClass.WeaponsQuantities.ElementAt(i).Key] = 99;
for (int i = 0; i < ModesClass.ModesQuantities.Count; i++)
ModesClass.ModesQuantities[ModesClass.ModesQuantities.ElementAt(i).Key] = 99;
#endif
PlayerInfos.DrawPlayerInfoInUI_SinglePlayer();
//begin clouds
GameObject.Find("Cloud").GetComponent<Cload_Movement>().Begin();
GameObject.Find("Cloud (1)").GetComponent<Cload_Movement>().Begin();
GameObject.Find("Cloud (2)").GetComponent<Cload_Movement>().Begin();
//
GameObject.Find("UIButtons").GetComponent<UIButtonClick>().InitilizeButtons();
//show round loadout
GameObject fade = GameObject.Find("Fade");
fade.GetComponent<Fade>().ShowLoadout();
HideHUDS();
}
// Use this for initialization
void Awake()
{
var ps = new List<GameObject>();
ps.Add(breacher);
ps.Add(sniper);
spawnManager = new SpawnManager(ps);
var cs = new List<Character>(ps.Select(x =>
{
return x.GetComponent<Character>();
}));
foreach (var p in cs)
{
Debug.Log(p.playerNumber);
}
scoreManager = new ScoreManager(cs, playerOneScore, playerTwoScore);
}
void OnEnable() {
beforeInit();
spawnManager = gameObject.GetComponent<SpawnManager>();
if (forceSpawnAtStart) {
minSpawnInterval = 0;
maxSpawnInterval = 0;
}
if (hasLevel) {
adjustForLevel(3);
}
objPool = new List<GameObject>();
for (int i = 0; i < objAmount; ++i) {
GameObject obj = (GameObject) Instantiate(objPrefab);
obj.SetActive(false);
obj.transform.parent = transform;
objPool.Add(obj);
}
if (objDestroyEffect != null) {
objDestroyEffectPool = new List<GameObject>();
for (int i = 0; i < objAmount; ++i) {
GameObject obj = (GameObject) Instantiate(objDestroyEffect);
obj.SetActive(false);
objDestroyEffectPool.Add(obj);
}
}
if (objEncounterEffect != null) {
objEncounterEffectPool = new List<GameObject>();
for (int i = 0; i < objAmount; ++i) {
GameObject obj = (GameObject) Instantiate(objEncounterEffect);
obj.SetActive(false);
objEncounterEffectPool.Add(obj);
}
}
initRest();
}
// Use this for initialization
void Start()
{
minX = Camera.main.ScreenToWorldPoint(new Vector3(0, 0, 0)).x;
maxX = Camera.main.ScreenToWorldPoint(new Vector3(Screen.width, 0, 0)).x;
renderer = GetComponent<SpriteRenderer>();
spriteColorR = 255;
spriteColorG = 255;
spriteColorB = 255;
transform.position = new Vector3(transform.position.x, transform.position.y, 0);
nextPosition = transform.position;
spawnManager = SpawnManager.instance;
invaderManager = InvaderManager.instance;
}
private void Awake()
{
selectTab = FindObjectOfType<SelectTab>();
spawnMgr = FindObjectOfType<SpawnManager>();
}
private void Start()
{
SpawnManager spawnManager = FindObjectOfType <SpawnManager>();
spawnManager.notifyRespawnObservers += OnRespawn; // observation handler registration
}
public void Set(GameObject mainGO)
{
spawnManager = mainGO.GetComponent <SpawnManager>();
}
/// <summary>
/// Unspawns this GameObject and destroys it for other clients. This should be used if the object should be kept on the server
/// </summary>
public void UnSpawn()
{
SpawnManager.UnSpawnObject(this);
}
/// <summary>
/// Changes the owner of the object. Can only be called from server
/// </summary>
/// <param name="newOwnerClientId">The new owner clientId</param>
public void ChangeOwnership(ulong newOwnerClientId)
{
SpawnManager.ChangeOwnership(this, newOwnerClientId);
}
public override void OnDisable()
{
localInstance = null;
}
// Start is called before the first frame update
void Start()
{
_spawnManager = GameObject.Find("SpawnManager").GetComponent <SpawnManager>();
}
public float rand = 10f; //스폰 장소를 기준으로 생성되는 랜덤거리 조절
// Start is called before the first frame update
void Update()
{
SpawnNum = SpawnManager.SpawnGargoyle(this.gameObject, SpawnNum, rand);
}
private void Start()
{
_rotateSpeed = 20.0f;
_spawnManager = GameObject.Find("SpawnManager").GetComponent <SpawnManager>();
}
private void Start()
{
_spawnManager = FindObjectOfType <SpawnManager>();
_UIManager = FindObjectOfType <UIManager>();
}
void Awake()
{
Instance = this;
}
// Start is called before the first frame update
void Start()
{
_player = GameObject.Find("Player").GetComponent <Player>();
if (_player == null)
{
Debug.LogError("Player is NULL!");
}
_spawnManager = GameObject.Find("Spawn_Manager").GetComponent <SpawnManager>();
if (_spawnManager == null)
{
Debug.LogError("SpawnManager is NULL!");
}
_animator = transform.GetComponent <Animator>();
if (_animator == null)
{
Debug.Log("Animator is null!");
}
_audioSource = transform.GetComponent <AudioSource>();
if (_audioSource == null)
{
Debug.Log("audioSource null!");
}
_material = transform.GetComponent <SpriteRenderer>().material;
if (_material == null)
{
Debug.LogError("Material is NULL!");
}
_health = Random.Range(1, 5);
_cameraShake = GameObject.Find("Main Camera").GetComponent <CameraShake>();
if (_cameraShake == null)
{
Debug.Log("Camera shake is null!");
}
_shieldBreakEffect = transform.GetComponentInChildren <ParticleSystem>();
if (_shieldBreakEffect == null)
{
Debug.LogError("Shield Break Effect is NULL!");
}
_fireRateDelay = new WaitForSeconds(_fireRate);
_speed = Random.Range((_speed - 0.5f), (_speed + 0.5f));
switch (difficulty)
{
case 0:
_movementRandomizer = 0;
break;
case 1:
_movementRandomizer = 0;
break;
case 2:
_movementRandomizer = Random.Range(0, 4);
_isShootingEnemy = true;
StartCoroutine(FireLaserSequence());
break;
case 3:
_movementRandomizer = Random.Range(0, 4);
_isShootingEnemy = true;
StartCoroutine(FireLaserSequence());
/*if (RandomOutOf(3))
* {
* _shield.SetActive(true);
* _shieldActive = true;
* }
*/
if (RandomOutOf(2))
{
_canRamPlayer = true;
}
break;
case 4:
_movementRandomizer = Random.Range(0, 4);
_isShootingEnemy = true;
StartCoroutine(FireLaserSequence());
/*
* if (RandomOutOf(3))
* {
* _shield.SetActive(true);
* _shieldActive = true;
* }
*/
if (RandomOutOf(2))
{
_canRamPlayer = true;
}
if (RandomOutOf(2))
{
_canShootFromBehind = true;
}
if (_movementRandomizer == 0)
{
_canDodgeLaser = true;
}
break;
case 5:
_movementRandomizer = Random.Range(0, 4);
_isShootingEnemy = true;
StartCoroutine(FireLaserSequence());
if (RandomOutOf(3))
{
_shield.SetActive(true);
_shieldActive = true;
}
if (RandomOutOf(2))
{
_canRamPlayer = true;
}
if (RandomOutOf(2))
{
_canShootFromBehind = true;
}
if (_movementRandomizer == 0)
{
_canDodgeLaser = true;
}
break;
case 7:
_enemyType = EnemyType.Stalker;
_movementRandomizer = 4;
_health = 5;
_material.SetColor("_Color", _stalkerColor);
break;
default:
_movementRandomizer = 0;
break;
}
switch (_movementRandomizer)
{
case 0:
_movementType = MovementType.Down;
break;
case 1:
_movementType = MovementType.Left;
break;
case 2:
_movementType = MovementType.Right;
break;
case 3:
_movementType = MovementType.Down;
break;
case 4:
_movementType = MovementType.Teleport;
StartCoroutine(Teleport());
break;
default:
_movementType = MovementType.Down;
break;
}
}
void Awake()
{
instance = this;
}
GameObject[] BlankSpaces; // Reference to Spaces where towers can be added
private void Start()
{
//Making SpawnManager singleton
Instance = this;
}
// Token: 0x060048A1 RID: 18593 RVA: 0x00179164 File Offset: 0x00177364
public override ContinuousBehaviorResult ContinuousUpdate()
{
for (int i = this.m_bulletPositions.Count - 1; i >= 0; i--)
{
float num = this.m_bulletPositions[i].Second + this.m_deltaTime * (float)this.BulletCircleSpeed;
this.m_bulletPositions[i].Second = num;
Projectile first = this.m_bulletPositions[i].First;
if (!(first == null))
{
if (!first)
{
this.m_bulletPositions[i] = null;
}
else
{
Vector2 bulletPosition = this.GetBulletPosition(num);
first.specRigidbody.Velocity = (bulletPosition.ToVector3XUp() - first.transform.position) / BraveTime.DeltaTime;
if (first.shouldRotate)
{
first.transform.rotation = Quaternion.Euler(0f, 0f, 180f + (Quaternion.Euler(0f, 0f, 90f) * (this.ShootPoint.position.XY() - bulletPosition)).XY().ToAngle());
}
first.ResetDistance();
}
}
}
if (this.State == WizardSpinShootBehavior2.SpinShootState.Spawn)
{
while (this.m_stateTimer <= 0f && this.State == WizardSpinShootBehavior2.SpinShootState.Spawn)
{
AIBulletBank.Entry bullet = (EnemyDatabase.GetOrLoadByGuid("c4fba8def15e47b297865b18e36cbef8").bulletBank.GetBullet("default"));
GameObject bulletObject = bullet.BulletObject;
float num2 = 0f;
if (this.m_bulletPositions.Count > 0)
{
num2 = BraveMathCollege.ClampAngle360(this.m_bulletPositions[this.m_bulletPositions.Count - 1].Second - this.BulletAngleDelta);
}
GameObject gameObject = SpawnManager.SpawnProjectile(bulletObject, this.GetBulletPosition(num2), Quaternion.Euler(0f, 0f, 0f), true);
Projectile component = gameObject.GetComponent <Projectile>();
if (bullet != null && bullet.OverrideProjectile)
{
component.baseData.SetAll(bullet.ProjectileData);
}
component.Shooter = this.m_aiActor.specRigidbody;
component.specRigidbody.Velocity = Vector2.zero;
component.ManualControl = true;
component.specRigidbody.CollideWithTileMap = false;
component.collidesWithEnemies = this.m_isCharmed;
component.UpdateCollisionMask();
this.m_bulletPositions.Add(Tuple.Create <Projectile, float>(component, num2));
this.m_stateTimer += this.SpawnDelay;
if (this.m_bulletPositions.Count >= this.NumBullets)
{
this.bottleowhiskey(SpinShootState.Prefire);
}
}
}
else if (this.State == WizardSpinShootBehavior2.SpinShootState.Prefire)
{
if (this.m_stateTimer <= 0f)
{
this.bottleowhiskey(SpinShootState.Fire);
}
}
else if (this.State == WizardSpinShootBehavior2.SpinShootState.Fire)
{
if (this.m_behaviorSpeculator.TargetBehaviors != null && this.m_behaviorSpeculator.TargetBehaviors.Count > 0)
{
this.m_behaviorSpeculator.TargetBehaviors[0].Update();
}
if (this.m_bulletPositions.All((Tuple <Projectile, float> t) => t.First == null))
{
return(ContinuousBehaviorResult.Finished);
}
while (this.m_stateTimer <= 0f)
{
Vector2 vector = this.ShootPoint.position.XY();
Vector2 b = vector + ((!this.m_aiActor.TargetRigidbody) ? Vector2.zero : (this.m_aiActor.TargetRigidbody.UnitCenter - vector)).normalized * this.BulletCircleRadius;
int num3 = -1;
float num4 = float.MaxValue;
for (int j = 0; j < this.m_bulletPositions.Count; j++)
{
Projectile first2 = this.m_bulletPositions[j].First;
if (!(first2 == null))
{
float sqrMagnitude = (first2.specRigidbody.UnitCenter - b).sqrMagnitude;
if (sqrMagnitude < num4)
{
num4 = sqrMagnitude;
num3 = j;
}
}
}
if (num3 >= 0)
{
Projectile first3 = this.m_bulletPositions[num3].First;
first3.ManualControl = false;
first3.specRigidbody.CollideWithTileMap = true;
if (this.m_aiActor.TargetRigidbody)
{
Vector2 unitCenter = this.m_aiActor.TargetRigidbody.specRigidbody.GetUnitCenter(ColliderType.HitBox);
float speed = first3.Speed;
float d = Vector2.Distance(first3.specRigidbody.UnitCenter, unitCenter) / speed;
Vector2 b2 = unitCenter + this.m_aiActor.TargetRigidbody.specRigidbody.Velocity * d;
Vector2 a = Vector2.Lerp(unitCenter, b2, this.LeadAmount);
first3.SendInDirection(a - first3.specRigidbody.UnitCenter, true, true);
}
first3.transform.rotation = Quaternion.Euler(0f, 0f, first3.specRigidbody.Velocity.ToAngle());
this.m_bulletPositions[num3].First = null;
}
else
{
Debug.LogError("WizardSpinShootBehaviour.ContinuousUpdate(): This shouldn't happen!");
}
this.m_stateTimer += this.FireDelay;
if (this.m_bulletPositions.All((Tuple <Projectile, float> t) => t.First == null))
{
return(ContinuousBehaviorResult.Finished);
}
}
}
return(ContinuousBehaviorResult.Continue);
}
void Start()
{
GameObject Enemy;
GameObject Weapon;
GameObject Shield = null;
GameObject[] Weapons;
float time = .1f;
List <float> times = new List <float>();
EnemyGroup[] cpus = GetComponents <EnemyGroup>();
for (int i = 0; i < cpus.Length; i++)
{
times.Add(i * 1.2f);
}
foreach (EnemyGroup e in cpus)
{
Enemy = Instantiate(e.Enemy, e.pos, Quaternion.identity) as GameObject;
AIController Unit = Enemy.GetComponentInChildren <AIController>();
Unit.GetComponent <SphereCollider>().radius += radius_offset;
Enemy.layer = (int)e.cpu_layer;
Unit.gameObject.layer = LayerMask.NameToLayer(
LayerMask.LayerToName(Enemy.layer)
+ "Detection");
Enemy.GetComponentsInChildren <Renderer>()[1].material.color
= SpawnManager.GetTeamColor(Enemy.layer, .5f);
StartCoroutine(Unit.SetState(e.AISetting));
if (e.can_block)
{
Shield = Instantiate(Resources.Load("Bronze Shield"), e.pos, Quaternion.identity) as GameObject;
Unit.Shield = Shield;
NetworkServer.Spawn(Shield);
}
Unit.can_dodge = e.can_dodge;
Gun gun;
Weapons = new GameObject[e.Gun.Length];
int i = 0;
foreach (GameObject g in e.Gun)
{
Weapon = Instantiate(g, e.pos, Quaternion.identity) as GameObject;
NetworkServer.Spawn(Weapon);
gun = Weapon.GetComponent <Gun>();
gun.SetBaseStats(LayerMask.LayerToName(Enemy.layer));
gun.barrel_end = Weapon.transform.GetChild(0);
Weapons[i] = Weapon;
Unit.weapons.Add(gun);
Unit.attack_func_indexes.Add((int)e.AttackSettings[i]);
gun.level = e.weapon_levels[i];
AddLevel(Unit, gun);
i++;
}
Unit.movement_func_index = (int)e.MovementSetting;
Unit.main_gun = Weapons[0].GetComponent <Gun>();
Unit.GetComponentInParent <HealthDefence>().Controller = Unit;
int index = rand.Next(times.Count);
Unit.time_until_next_pathfind = times[index];
times.RemoveAt(index);
NetworkServer.Spawn(Enemy);
StartCoroutine(WaitForMethodsRef(Enemy, Weapons, Unit.Shield, Enemy.layer));
Unit.weapons.RemoveNull();
}
if (watch_only)
{
StartCoroutine(WatchOnly());
}
}
private void Awake()
{
instance = this;
}
private void Awake()
{
Get = this;
}
/// <summary>
/// Removes all ownership of an object from any client. Can only be called from server
/// </summary>
public void RemoveOwnership()
{
SpawnManager.RemoveOwnership(this);
}
private void Awake()
{
_instance = this; //单例模式赋值
}
void Start()
{
transform.position = new Vector3(0, 0, 0);
_spawnManager = GameObject.Find("Spawn Manager").GetComponent <SpawnManager>();
}
// Use this for initialization
void Start()
{
//El punto de spawn se suscribe en la lista.
SpawnManager.GetInstance().NewSpawnPoint(gameObject);
}
private void PostProcessProjectile(Projectile sourceProjectile, float effectChanceScalar)
{
if (sourceProjectile.GetComponent <MoonrockProjectile>())
{
return;
}
if (sourceProjectile is InstantDamageOneEnemyProjectile)
{
return;
}
if (sourceProjectile is InstantlyDamageAllProjectile)
{
return;
}
if (sourceProjectile.GetComponent <ArtfulDodgerProjectileController>())
{
return;
}
PlayerController owner = sourceProjectile.ProjectilePlayerOwner();
int amtOfOrbiters = UnityEngine.Random.Range(0, 4);
if (amtOfOrbiters > 0)
{
for (int i = 0; i < amtOfOrbiters; i++)
{
GameObject gameObject = SpawnManager.SpawnProjectile(moonrockProjectile.gameObject, sourceProjectile.sprite.WorldCenter, Quaternion.Euler(0f, 0f, (base.Owner.CurrentGun == null) ? 0f : base.Owner.CurrentGun.CurrentAngle), true);
Projectile component = gameObject.GetComponent <Projectile>();
if (component != null)
{
component.Owner = owner;
component.Shooter = owner.specRigidbody;
component.baseData.damage *= owner.stats.GetStatValue(PlayerStats.StatType.Damage);
component.baseData.speed *= owner.stats.GetStatValue(PlayerStats.StatType.ProjectileSpeed);
component.baseData.force *= owner.stats.GetStatValue(PlayerStats.StatType.KnockbackMultiplier);
component.UpdateSpeed();
component.specRigidbody.CollideWithTileMap = true;
BulletLifeTimer timer = component.gameObject.GetOrAddComponent <BulletLifeTimer>();
timer.secondsTillDeath = 30f;
OrbitProjectileMotionModule orbitProjectileMotionModule = new OrbitProjectileMotionModule();
orbitProjectileMotionModule.lifespan = 50;
orbitProjectileMotionModule.MinRadius = 0.5f;
orbitProjectileMotionModule.MaxRadius = 2;
orbitProjectileMotionModule.usesAlternateOrbitTarget = true;
orbitProjectileMotionModule.OrbitGroup = -5;
orbitProjectileMotionModule.alternateOrbitTarget = sourceProjectile.specRigidbody;
if (component.OverrideMotionModule != null && component.OverrideMotionModule is HelixProjectileMotionModule)
{
orbitProjectileMotionModule.StackHelix = true;
orbitProjectileMotionModule.ForceInvert = (component.OverrideMotionModule as HelixProjectileMotionModule).ForceInvert;
}
component.OverrideMotionModule = orbitProjectileMotionModule;
component.gameObject.GetOrAddComponent <MoonrockProjectile>();
owner.DoPostProcessProjectile(component);
}
}
}
}
public void GoTo(Client player, string type, int id)
{
if (!AdminController.AdminRankCheck(player, "goto"))
{
return;
}
player.dimension = 0;
switch (type)
{
case "property":
var propertyController = EntityManager.GetProperty(id);
if (propertyController == null)
{
API.sendNotificationToPlayer(player, "~r~[ОШИБКА]: ~w~Вы ввели неверный ID!");
}
else
{
player.position = new Vector3(propertyController.PropertyData.ExtPosX,
propertyController.PropertyData.ExtPosY,
propertyController.PropertyData.ExtPosZ);
}
break;
case "job":
var job = EntityManager.GetJob(id);
if (job == null)
{
API.sendNotificationToPlayer(player, "~r~[ОШИБКА]: ~w~Вы ввели неверный ID!");
}
else
{
player.position = new Vector3(job.JobData.PosX, job.JobData.PosY, job.JobData.PosZ);
}
break;
case "place":
player.dimension = 0;
switch (id)
{
case 0: player.position = SpawnManager.GetSpawnPosition();
player.dimension = SpawnManager.GetSpawnDimension(); break;
case 1: API.setEntityPosition(player, new Vector3(-365.425, -131.809, 37.873)); break;
case 2: API.setEntityPosition(player, new Vector3(-2023.661, -1038.038, 5.577)); break;
case 3: API.setEntityPosition(player, new Vector3(3069.330, -4704.220, 15.043)); break;
case 4: API.setEntityPosition(player, new Vector3(2052.000, 3237.000, 1456.973)); break;
case 5: API.setEntityPosition(player, new Vector3(-129.964, 8130.873, 6705.307)); break;
case 6: API.setEntityPosition(player, new Vector3(134.085, -637.859, 262.851)); break;
case 7: API.setEntityPosition(player, new Vector3(150.126, -754.591, 262.865)); break;
case 8: API.setEntityPosition(player, new Vector3(-75.015, -818.215, 326.176)); break;
case 9: API.setEntityPosition(player, new Vector3(450.718, 5566.614, 806.183)); break;
case 10: API.setEntityPosition(player, new Vector3(24.775, 7644.102, 19.055)); break;
case 11: API.setEntityPosition(player, new Vector3(686.245, 577.950, 130.461)); break;
case 12: API.setEntityPosition(player, new Vector3(205.316, 1167.378, 227.005)); break;
case 13: API.setEntityPosition(player, new Vector3(-20.004, -10.889, 500.602)); break;
case 14: API.setEntityPosition(player, new Vector3(-438.804, 1076.097, 352.411)); break;
case 15: API.setEntityPosition(player, new Vector3(-2243.810, 264.048, 174.615)); break;
case 16: API.setEntityPosition(player, new Vector3(-3426.683, 967.738, 8.347)); break;
case 17: API.setEntityPosition(player, new Vector3(-275.522, 6635.835, 7.425)); break;
case 18: API.setEntityPosition(player, new Vector3(-1006.402, 6272.383, 1.503)); break;
case 19: API.setEntityPosition(player, new Vector3(-517.869, 4425.284, 89.795)); break;
case 20: API.setEntityPosition(player, new Vector3(-1170.841, 4926.646, 224.295)); break;
case 21: API.setEntityPosition(player, new Vector3(-324.300, -1968.545, 67.002)); break;
case 22: API.setEntityPosition(player, new Vector3(-1868.971, 2095.674, 139.115)); break;
case 23: API.setEntityPosition(player, new Vector3(2476.712, 3789.645, 41.226)); break;
case 24: API.setEntityPosition(player, new Vector3(-2639.872, 1866.812, 160.135)); break;
case 25: API.setEntityPosition(player, new Vector3(-595.342, 2086.008, 131.412)); break;
case 26: API.setEntityPosition(player, new Vector3(2208.777, 5578.235, 53.735)); break;
case 27: API.setEntityPosition(player, new Vector3(126.975, 3714.419, 46.827)); break;
case 28: API.setEntityPosition(player, new Vector3(2395.096, 3049.616, 60.053)); break;
case 29: API.setEntityPosition(player, new Vector3(2034.988, 2953.105, 74.602)); break;
case 30: API.setEntityPosition(player, new Vector3(2062.123, 2942.055, 47.431)); break;
case 31: API.setEntityPosition(player, new Vector3(2026.677, 1842.684, 133.313)); break;
case 32: API.setEntityPosition(player, new Vector3(1051.209, 2280.452, 89.727)); break;
case 33: API.setEntityPosition(player, new Vector3(736.153, 2583.143, 79.634)); break;
case 34: API.setEntityPosition(player, new Vector3(2954.196, 2783.410, 41.004)); break;
case 35: API.setEntityPosition(player, new Vector3(2732.931, 1577.540, 83.671)); break;
case 36: API.setEntityPosition(player, new Vector3(486.417, -3339.692, 6.070)); break;
case 37: API.setEntityPosition(player, new Vector3(899.678, -2882.191, 19.013)); break;
case 38: API.setEntityPosition(player, new Vector3(-1850.127, -1231.751, 13.017)); break;
case 39: API.setEntityPosition(player, new Vector3(-1475.234, 167.088, 55.841)); break;
case 40: API.setEntityPosition(player, new Vector3(3059.620, 5564.246, 197.091)); break;
case 41: API.setEntityPosition(player, new Vector3(2535.243, -383.799, 92.993)); break;
case 42: API.setEntityPosition(player, new Vector3(971.245, -1620.993, 30.111)); break;
case 43: API.setEntityPosition(player, new Vector3(293.089, 180.466, 104.301)); break;
case 44: API.setEntityPosition(player, new Vector3(-1374.881, -1398.835, 6.141)); break;
case 45: API.setEntityPosition(player, new Vector3(718.341, -1218.714, 26.014)); break;
case 46: API.setEntityPosition(player, new Vector3(925.329, 46.152, 80.908)); break;
case 47: API.setEntityPosition(player, new Vector3(-1696.866, 142.747, 64.372)); break;
case 48: API.setEntityPosition(player, new Vector3(-543.932, -2225.543, 122.366)); break;
case 49: API.setEntityPosition(player, new Vector3(1660.369, -12.013, 170.020)); break;
case 50: API.setEntityPosition(player, new Vector3(2877.633, 5911.078, 369.624)); break;
case 51: API.setEntityPosition(player, new Vector3(-889.655, -853.499, 20.566)); break;
case 52: API.setEntityPosition(player, new Vector3(-695.025, 82.955, 55.855)); break;
case 53: API.setEntityPosition(player, new Vector3(-1330.911, 340.871, 64.078)); break;
case 54: API.setEntityPosition(player, new Vector3(711.362, 1198.134, 348.526)); break;
case 55: API.setEntityPosition(player, new Vector3(-1336.715, 59.051, 55.246)); break;
case 56: API.setEntityPosition(player, new Vector3(-31.010, 6316.830, 40.083)); break;
case 57: API.setEntityPosition(player, new Vector3(-635.463, -242.402, 38.175)); break;
case 58: API.setEntityPosition(player, new Vector3(-3022.222, 39.968, 13.611)); break;
case 59: API.setEntityPosition(player, new Vector3(-1659993, -128.399, 59.954)); break;
case 60: API.setEntityPosition(player, new Vector3(-549.467, 5308.221, 114.146)); break;
case 61: API.setEntityPosition(player, new Vector3(1070.206, -711.958, 58.483)); break;
case 62: API.setEntityPosition(player, new Vector3(1608.698, 6438.096, 37.637)); break;
case 63: API.setEntityPosition(player, new Vector3(3430.155, 5174.196, 41.280)); break;
case 64: API.setEntityPosition(player, new Vector3(3464.689, 5252.736, 20.29798)); break;
// Prison:
case 65: API.setEntityPosition(player, new Vector3(1675.97961, 2585.18457, 45.92)); break;
// Ballas:
case 70: API.setEntityPosition(player, new Vector3(107.4711, -1942.032, 20.3)); break;
// AutoSchool:
case 71: API.setEntityPosition(player, new Vector3(-1081.233, -1259.916, 5.3)); break;
// Goverment:
case 72: API.setEntityPosition(player, new Vector3(106.7145, -933.4711, 29.3)); break;
// FBI LOBBY:
case 73: API.setEntityPosition(player, new Vector3(110.4, -744.2, 45.7496)); break;
// 1st work:
case 74: API.setEntityPosition(player, new Vector3(-163.145, -940.611, 29.3)); break;
// 2nd work:
case 75: API.setEntityPosition(player, new Vector3(853.3, -2927.611, 6.1)); break;
// Army 2:
case 76: API.setEntityPosition(player, new Vector3(-1869.72, 2998.29, 32.8105)); break;
// BusStation:
case 77: API.setEntityPosition(player, new Vector3(-831.386, -2350.93, 14.5706)); break;
// Taxi station:
case 78: API.setEntityPosition(player, new Vector3(-765.6371, -2058.967, 9.5706)); break;
// Ballas GasStation:
case 79: API.setEntityPosition(player, new Vector3(-49.0201, -1757.64, 29.421)); break;
// Army 1:
case 80: API.setEntityPosition(player, new Vector3(840.3792, -2118.969, 28.85884)); break;
}
break;
default: return;
}
}
// Start is called before the first frame update
void Start()
{
playerControllerScript = GameObject.Find("Player").GetComponent <PlayerContoller>();
spawn = GameObject.Find("SpawnManager").GetComponent <SpawnManager>();
// find the player in the scene by it's name and retrieve its script
}
// Start is called before the first frame update
void Start()
{
groundSpawner = GetComponent <SpawnManager>();
}
// ------------------------------------------------------------------
// Desc:
// ------------------------------------------------------------------
void Awake () {
if( spawnManager == null ) {
spawnManager = this;
// init spawn manager.
for ( int i = 0; i < pools.Length; ++i ) {
pools[i].init();
gameobjLookupTable[pools[i].prefab] = pools[i];
}
pools = null;
}
}
private static void OnSceneUnloadServer(Guid switchSceneGuid)
{
// Justification: Rare alloc, could(should?) reuse
List <NetworkedObject> newSceneObjects = new List <NetworkedObject>();
{
NetworkedObject[] networkedObjects = MonoBehaviour.FindObjectsOfType <NetworkedObject>();
for (int i = 0; i < networkedObjects.Length; i++)
{
if (networkedObjects[i].IsSceneObject == null)
{
SpawnManager.SpawnNetworkedObjectLocally(networkedObjects[i], SpawnManager.GetNetworkObjectId(), true, false, null, null, false, 0, false, true);
newSceneObjects.Add(networkedObjects[i]);
}
}
}
for (int j = 0; j < NetworkingManager.Singleton.ConnectedClientsList.Count; j++)
{
if (NetworkingManager.Singleton.ConnectedClientsList[j].ClientId != NetworkingManager.Singleton.ServerClientId)
{
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteUInt32Packed(CurrentActiveSceneIndex);
writer.WriteByteArray(switchSceneGuid.ToByteArray());
uint sceneObjectsToSpawn = 0;
for (int i = 0; i < newSceneObjects.Count; i++)
{
if (newSceneObjects[i].observers.Contains(NetworkingManager.Singleton.ConnectedClientsList[j].ClientId))
{
sceneObjectsToSpawn++;
}
}
writer.WriteUInt32Packed(sceneObjectsToSpawn);
for (int i = 0; i < newSceneObjects.Count; i++)
{
if (newSceneObjects[i].observers.Contains(NetworkingManager.Singleton.ConnectedClientsList[j].ClientId))
{
if (NetworkingManager.Singleton.NetworkConfig.UsePrefabSync)
{
writer.WriteBool(newSceneObjects[i].IsPlayerObject);
writer.WriteUInt64Packed(newSceneObjects[i].NetworkId);
writer.WriteUInt64Packed(newSceneObjects[i].OwnerClientId);
writer.WriteUInt64Packed(newSceneObjects[i].PrefabHash);
writer.WriteSinglePacked(newSceneObjects[i].transform.position.x);
writer.WriteSinglePacked(newSceneObjects[i].transform.position.y);
writer.WriteSinglePacked(newSceneObjects[i].transform.position.z);
writer.WriteSinglePacked(newSceneObjects[i].transform.rotation.eulerAngles.x);
writer.WriteSinglePacked(newSceneObjects[i].transform.rotation.eulerAngles.y);
writer.WriteSinglePacked(newSceneObjects[i].transform.rotation.eulerAngles.z);
if (NetworkingManager.Singleton.NetworkConfig.EnableNetworkedVar)
{
newSceneObjects[i].WriteNetworkedVarData(stream, NetworkingManager.Singleton.ConnectedClientsList[j].ClientId);
}
}
else
{
writer.WriteBool(newSceneObjects[i].IsPlayerObject);
writer.WriteUInt64Packed(newSceneObjects[i].NetworkId);
writer.WriteUInt64Packed(newSceneObjects[i].OwnerClientId);
writer.WriteUInt64Packed(newSceneObjects[i].NetworkedInstanceId);
if (NetworkingManager.Singleton.NetworkConfig.EnableNetworkedVar)
{
newSceneObjects[i].WriteNetworkedVarData(stream, NetworkingManager.Singleton.ConnectedClientsList[j].ClientId);
}
}
}
}
}
InternalMessageSender.Send(NetworkingManager.Singleton.ConnectedClientsList[j].ClientId, MLAPIConstants.MLAPI_SWITCH_SCENE, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, null);
}
}
}
//Tell server that scene load is completed
if (NetworkingManager.Singleton.IsHost)
{
OnClientSwitchSceneCompleted(NetworkingManager.Singleton.LocalClientId, switchSceneGuid);
}
isSwitching = false;
if (OnSceneSwitched != null)
{
OnSceneSwitched();
}
}
void Awake()
{
sm = this;
}
private static void OnSceneUnloadClient(Guid switchSceneGuid, Stream objectStream)
{
if (NetworkingManager.Singleton.NetworkConfig.UsePrefabSync)
{
SpawnManager.DestroySceneObjects();
using (PooledBitReader reader = PooledBitReader.Get(objectStream))
{
uint newObjectsCount = reader.ReadUInt32Packed();
for (int i = 0; i < newObjectsCount; i++)
{
bool isPlayerObject = reader.ReadBool();
ulong networkId = reader.ReadUInt64Packed();
ulong owner = reader.ReadUInt64Packed();
ulong prefabHash = reader.ReadUInt64Packed();
Vector3 position = new Vector3(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
Quaternion rotation = Quaternion.Euler(reader.ReadSinglePacked(), reader.ReadSinglePacked(), reader.ReadSinglePacked());
NetworkedObject networkedObject = SpawnManager.CreateLocalNetworkedObject(false, 0, prefabHash, position, rotation);
SpawnManager.SpawnNetworkedObjectLocally(networkedObject, networkId, true, isPlayerObject, owner, objectStream, false, 0, true, false);
}
}
}
else
{
NetworkedObject[] networkedObjects = MonoBehaviour.FindObjectsOfType <NetworkedObject>();
SpawnManager.ClientCollectSoftSyncSceneObjectSweep(networkedObjects);
using (PooledBitReader reader = PooledBitReader.Get(objectStream))
{
uint newObjectsCount = reader.ReadUInt32Packed();
for (int i = 0; i < newObjectsCount; i++)
{
bool isPlayerObject = reader.ReadBool();
ulong networkId = reader.ReadUInt64Packed();
ulong owner = reader.ReadUInt64Packed();
ulong instanceId = reader.ReadUInt64Packed();
NetworkedObject networkedObject = SpawnManager.CreateLocalNetworkedObject(true, instanceId, 0, null, null);
SpawnManager.SpawnNetworkedObjectLocally(networkedObject, networkId, true, isPlayerObject, owner, objectStream, false, 0, true, false);
}
}
}
using (PooledBitStream stream = PooledBitStream.Get())
{
using (PooledBitWriter writer = PooledBitWriter.Get(stream))
{
writer.WriteByteArray(switchSceneGuid.ToByteArray());
NetworkedObject networkedObject = null;
InternalMessageSender.Send(NetworkingManager.Singleton.ServerClientId, MLAPIConstants.MLAPI_CLIENT_SWITCH_SCENE_COMPLETED, "MLAPI_INTERNAL", stream, SecuritySendFlags.None, networkedObject);
}
}
isSwitching = false;
if (OnSceneSwitched != null)
{
OnSceneSwitched();
}
}
// Use this for initialization
void Start()
{
spawnManager = GameObject.Find("Bullets").GetComponent <SpawnManager>();
wingFlapping = false;
jumping = false;
}
//variables
// Start is called before the first frame update
void Start()
{
spawnVar = GameObject.Find("SpawnManager").GetComponent <SpawnManager>();
Sun = GameObject.Find("Sun");
}
internal static void HandleConnectionApproved(ulong clientId, Stream stream, float receiveTime)
{
using (PooledBitReader reader = PooledBitReader.Get(stream))
{
NetworkingManager.Singleton.LocalClientId = reader.ReadUInt64Packed();
uint sceneIndex = 0;
Guid sceneSwitchProgressGuid = new Guid();
if (NetworkingManager.Singleton.NetworkConfig.EnableSceneManagement)
{
sceneIndex = reader.ReadUInt32Packed();
sceneSwitchProgressGuid = new Guid(reader.ReadByteArray());
}
bool sceneSwitch = NetworkingManager.Singleton.NetworkConfig.EnableSceneManagement && NetworkSceneManager.HasSceneMismatch(sceneIndex);
float netTime = reader.ReadSinglePacked();
NetworkingManager.Singleton.UpdateNetworkTime(clientId, netTime, receiveTime, true);
NetworkingManager.Singleton.ConnectedClients.Add(NetworkingManager.Singleton.LocalClientId, new NetworkedClient()
{
ClientId = NetworkingManager.Singleton.LocalClientId
});
void DelayedSpawnAction(Stream continuationStream)
{
using (PooledBitReader continuationReader = PooledBitReader.Get(continuationStream))
{
if (!NetworkingManager.Singleton.NetworkConfig.EnableSceneManagement || NetworkingManager.Singleton.NetworkConfig.UsePrefabSync)
{
SpawnManager.DestroySceneObjects();
}
else
{
SpawnManager.ClientCollectSoftSyncSceneObjectSweep(null);
}
uint objectCount = continuationReader.ReadUInt32Packed();
for (int i = 0; i < objectCount; i++)
{
bool isPlayerObject = continuationReader.ReadBool();
ulong networkId = continuationReader.ReadUInt64Packed();
ulong ownerId = continuationReader.ReadUInt64Packed();
bool hasParent = continuationReader.ReadBool();
ulong?parentNetworkId = null;
if (hasParent)
{
parentNetworkId = continuationReader.ReadUInt64Packed();
}
ulong prefabHash;
ulong instanceId;
bool softSync;
if (!NetworkingManager.Singleton.NetworkConfig.EnableSceneManagement || NetworkingManager.Singleton.NetworkConfig.UsePrefabSync)
{
softSync = false;
instanceId = 0;
prefabHash = continuationReader.ReadUInt64Packed();
}
else
{
softSync = continuationReader.ReadBool();
if (softSync)
{
instanceId = continuationReader.ReadUInt64Packed();
prefabHash = 0;
}
else
{
prefabHash = continuationReader.ReadUInt64Packed();
instanceId = 0;
}
}
Vector3? pos = null;
Quaternion?rot = null;
if (continuationReader.ReadBool())
{
pos = new Vector3(continuationReader.ReadSinglePacked(), continuationReader.ReadSinglePacked(), continuationReader.ReadSinglePacked());
rot = Quaternion.Euler(continuationReader.ReadSinglePacked(), continuationReader.ReadSinglePacked(), continuationReader.ReadSinglePacked());
}
NetworkedObject netObject = SpawnManager.CreateLocalNetworkedObject(softSync, instanceId, prefabHash, parentNetworkId, pos, rot);
SpawnManager.SpawnNetworkedObjectLocally(netObject, networkId, softSync, isPlayerObject, ownerId, continuationStream, false, 0, true, false);
}
NetworkingManager.Singleton.IsConnectedClient = true;
if (NetworkingManager.Singleton.OnClientConnectedCallback != null)
{
NetworkingManager.Singleton.OnClientConnectedCallback.Invoke(NetworkingManager.Singleton.LocalClientId);
}
}
}
if (sceneSwitch)
{
UnityAction <Scene, Scene> onSceneLoaded = null;
Serialization.BitStream continuationStream = new Serialization.BitStream();
continuationStream.CopyUnreadFrom(stream);
continuationStream.Position = 0;
void OnSceneLoadComplete()
{
SceneManager.activeSceneChanged -= onSceneLoaded;
NetworkSceneManager.isSpawnedObjectsPendingInDontDestroyOnLoad = false;
DelayedSpawnAction(continuationStream);
}
onSceneLoaded = (oldScene, newScene) => { OnSceneLoadComplete(); };
SceneManager.activeSceneChanged += onSceneLoaded;
NetworkSceneManager.OnFirstSceneSwitchSync(sceneIndex, sceneSwitchProgressGuid);
}
else
{
DelayedSpawnAction(stream);
}
}
}
private void Update()
{
if (!Configured)
{
return;
}
if (m_Initialized && healthHaver && healthHaver.IsDead)
{
StopAllCoroutines();
if (m_LandingVFX)
{
SpawnManager.Despawn(m_LandingVFX);
}
m_Anchor.gameObject.SetLayerRecursively(LayerMask.NameToLayer("Unoccluded"));
m_Anchor.gameObject.SetLayerRecursively(m_CachedLayer);
m_Parachute.transform.DetachChildren();
m_Anchor.DetachChildren();
sprite.DetachRenderer(m_ParachuteSprite);
m_ParachuteSpriteAnimator.PlayAndDestroyObject("ParachuteLanded");
Destroy(m_Anchor.gameObject);
switchState = State.Wait;
}
switch (switchState)
{
case State.Wait:
return;
case State.PopIntoAir:
sprite.renderer.enabled = true;
if (UseLandingVFX)
{
Vector3 m_VFXPosition = (m_cachedPosition + new Vector2(m_CachedPositionOffset.x, m_CachedPositionOffset.y + LandingPositionOffset));
m_LandingVFX = SpawnManager.SpawnVFX(ExpandAssets.LoadOfficialAsset <GameObject>("EmergencyCrate", ExpandAssets.AssetSource.BraveResources).GetComponent <EmergencyCrateController>().landingTargetSprite, m_VFXPosition, Quaternion.identity);
m_LandingVFX.transform.position -= new Vector3(0, m_LandingVFX.GetComponentInChildren <tk2dSprite>().GetBounds().size.y / 2);
m_LandingVFX.GetComponentInChildren <tk2dSprite>().UpdateZDepth();
UseLandingVFX = false;
}
m_Anchor.gameObject.SetLayerRecursively(LayerMask.NameToLayer("Unoccluded"));
if (StartsIntheAir)
{
m_Anchor.position += new Vector3(DropHeightHorizontalOffset, StartHeight);
}
StartCoroutine(HandlePopup());
switchState = State.Wait;
return;
case State.ParaDrop:
if (!m_ParadropStarted)
{
m_ParadropStarted = true;
m_ParachuteSprite.SetSprite("EX_Parachute_Open_01");
m_ParachuteSpriteAnimator.Play("ParachuteDeploy");
m_ParachuteSprite.renderer.enabled = true;
StartCoroutine(HandleDrop());
}
Quaternion Clockwise = Quaternion.Euler(new Vector3(0, 0, m_maxSway));
Quaternion CounterClockwise = Quaternion.Euler(new Vector3(0, 0, -m_maxSway));
float Lerp = 0.5F * (1.0F + Mathf.Sin(Mathf.PI * Time.realtimeSinceStartup * SwaySpeed));
m_Anchor.localRotation = Quaternion.Lerp(Clockwise, CounterClockwise, Lerp);
if (IsItemCrate)
{
Quaternion BoxClockwise = Quaternion.Euler(new Vector3(0, 0, -(m_maxSway / 1.75f)));
Quaternion BoxCounterClockwise = Quaternion.Euler(new Vector3(0, 0, (m_maxSway / 1.75f)));
m_ItemBoxAnchor.transform.localRotation = Quaternion.Lerp(BoxClockwise, BoxCounterClockwise, Lerp);
}
return;
case State.End:
switchState = State.Wait; // Do this first encase somehow there's an exception. Will stay in wait state instead of endlessly causing exceptions. :P
if (knockbackDoer)
{
knockbackDoer.SetImmobile(false, "Paradrop Protection");
}
m_Anchor.gameObject.SetLayerRecursively(m_CachedLayer);
m_Parachute.transform.DetachChildren();
if (IsItemCrate)
{
m_Parachute.SetLayerRecursively(LayerMask.NameToLayer("Unoccluded"));
m_ItemBoxAnchor.transform.DetachChildren();
Destroy(m_ItemBoxAnchor);
}
m_Anchor.DetachChildren();
sprite.DetachRenderer(m_ParachuteSprite);
m_ParachuteSpriteAnimator.PlayAndDestroyObject("ParachuteLanded");
transform.rotation = m_CachedRotation;
if (specRigidbody)
{
// Item crate's collision only used to help with setting up correct offsets for parent objects.
// If it's item crate this setting will be left to it's starting value of false.
if (!IsItemCrate)
{
specRigidbody.CollideWithOthers = true;
}
specRigidbody.UpdateColliderPositions();
specRigidbody.Reinitialize();
}
if (m_ParentEnemy)
{
if (m_ParentEnemy.HasShadow && m_ParentEnemy.ShadowObject)
{
m_ParentEnemy.ShadowObject.GetComponent <tk2dSprite>().renderer.enabled = true;
}
if (m_ParentEnemy.aiShooter)
{
m_ParentEnemy.aiShooter.ToggleGunAndHandRenderers(true, "ParaDrop");
}
m_ParentEnemy.behaviorSpeculator.enabled = true;
m_ParentEnemy.HasBeenEngaged = true;
m_ParentEnemy.behaviorSpeculator.PostAwakenDelay = 0;
m_ParentEnemy.behaviorSpeculator.RemoveDelayOnReinforce = true;
}
if (healthHaver)
{
healthHaver.PreventAllDamage = false;
healthHaver.IsVulnerable = true;
}
Destroy(m_Anchor.gameObject);
if (ParentObjectExplodyBarrel && !IsItemCrate)
{
spriteAnimator.PlayAndDestroyObject("explode");
if (m_CachedExplosionData != null)
{
Exploder.Explode(sprite.WorldCenter, m_CachedExplosionData, Vector2.zero, null, true, CoreDamageTypes.None, false);
}
}
if (!ParentObjectExplodyBarrel && !IsItemCrate)
{
Destroy(this);
}
if (IsItemCrate)
{
sprite.renderer.sortingLayerName = "Background";
sprite.HeightOffGround = -1.5f;
sprite.UpdateZDepth();
StartCoroutine(SpawnItem(ItemDropID));
}
return;
}
}
