void OnEnable()
{
_objectPoolingManager = ObjectPoolingManager.Instance;
_startAngleRad = StartAngle * Mathf.Deg2Rad;
_endAngleRad = EndAngle * Mathf.Deg2Rad;
_totalAngleRad = Mathf.Abs(_endAngleRad - _startAngleRad);
_isMovingTowardsEndPoint = true;
_directionFactor = _startAngleRad > _endAngleRad
? -1f
: 1f;
var platform = _objectPoolingManager.GetObject(FloatingAttachedPlatform.name);
_currentAngle = _startAngleRad;
var initial = new Vector3(transform.position.x + Radius, transform.position.y, transform.position.z);
var rotated = new Vector3(
Mathf.Cos(_currentAngle) * (initial.x - transform.position.x) - Mathf.Sin(_currentAngle) * (initial.y - transform.position.y) + transform.position.x,
Mathf.Sin(_currentAngle) * (initial.x - transform.position.x) + Mathf.Cos(_currentAngle) * (initial.y - transform.position.y) + transform.position.y,
transform.position.z);
platform.transform.position = rotated;
_platform = platform;
_nextStartTime = Time.time + StopDuration;
}
void OnEnable()
{
_objectPoolingManager = ObjectPoolingManager.Instance;
Logger.Info("Enabling wheel " + this.name);
List <GameObjectContainer> platforms = new List <GameObjectContainer>();
for (float angle = 0f; angle < 360 * Mathf.Deg2Rad; angle += 360 * Mathf.Deg2Rad / totalPlatforms)
{
GameObject platform = _objectPoolingManager.GetObject(floatingAttachedPlatform.name);
Vector3 initial = new Vector3(transform.position.x + radius, transform.position.y, transform.position.z);
Vector3 rotated = new Vector3(
Mathf.Cos(angle) * (initial.x - transform.position.x) - Mathf.Sin(angle) * (initial.y - transform.position.y) + transform.position.x
, Mathf.Sin(angle) * (initial.x - transform.position.x) - Mathf.Cos(angle) * (initial.y - transform.position.y) + transform.position.y
, transform.position.z);
platform.transform.position = rotated;
platforms.Add(new GameObjectContainer()
{
GameObject = platform, Angle = angle
});
}
_platforms = platforms;
}
void Update()
{
#region now check whether we can see the player
if (!onlyShootWhenInvisible || _cameraController.IsPointVisible(this.transform.position))
{
if (_lastRoundFiredTime + _rateOfFireInterval <= Time.time)
{
for (int i = 0; i < fireDirectionVectorGroups[_currentfireDirectionVectorGroupIndex].vectors.Count; i++)
{
GameObject enemyProjectileGameObject = _objectPoolingManager.GetObject(projectilePrefab.name, this.transform.position);
IEnemyProjectile enemyProjectile = enemyProjectileGameObject.GetComponent <IEnemyProjectile>();
Logger.Assert(enemyProjectile != null, "Enemy projectile must not be null");
Vector2 direction;
if (fireDirectionSpace == Space.World)
{
direction = fireDirectionVectorGroups[_currentfireDirectionVectorGroupIndex].vectors[i];
}
else
{
direction = this.transform.TransformDirection(fireDirectionVectorGroups[_currentfireDirectionVectorGroupIndex].vectors[i]);
}
enemyProjectile.StartMove(this.transform.position, direction, projectileAcceleration, projectileTargetVelocity);
}
_currentfireDirectionVectorGroupIndex = _currentfireDirectionVectorGroupIndex == fireDirectionVectorGroups.Count - 1 ? 0 : _currentfireDirectionVectorGroupIndex + 1;
_lastRoundFiredTime = Time.time;
}
}
#endregion
}
void OnEnable()
{
_objectPoolingManager = ObjectPoolingManager.Instance;
var platforms = new List <GameObjectContainer>();
var twoPi = Mathf.PI * 2f;
for (var angle = 0f; angle < twoPi; angle += twoPi / TotalPlatforms)
{
var platform = _objectPoolingManager.GetObject(FloatingAttachedPlatform.name);
var quaternion = Quaternion.AngleAxis(angle, Vector3.forward);
var rotated = new Vector3(
Width * Mathf.Cos(angle),
Height * Mathf.Sin(angle),
0.0f);
rotated = quaternion * rotated + transform.position;
platform.transform.position = rotated;
platforms.Add(new GameObjectContainer {
GameObject = platform, Angle = angle
});
}
_platforms = platforms;
}
void OnEnable()
{
_objectPoolingManager = ObjectPoolingManager.Instance;
Logger.Info("Enabling half wheel " + name);
var platform = _objectPoolingManager.GetObject(FloatingAttachedPlatform.name);
_currentAngle = StartDirection == Direction.Right
? -Mathf.PI
: 0f;
Vector3 initial = new Vector3(
transform.position.x + Radius,
transform.position.y,
transform.position.z);
Vector3 rotated = new Vector3(
Mathf.Cos(_currentAngle) * (initial.x - transform.position.x) - Mathf.Sin(_currentAngle) * (initial.y - transform.position.y) + transform.position.x,
Mathf.Sin(_currentAngle) * (initial.x - transform.position.x) + Mathf.Cos(_currentAngle) * (initial.y - transform.position.y) + transform.position.y,
transform.position.z);
platform.transform.position = rotated;
_platform = platform;
_currentDirection = StartDirection;
_nextStartTime = Time.time + StopDuration;
}
void Start()
{
_objectPoolingManager = ObjectPoolingManager.Instance;
if (TotalVisiblePlatforms >= PlatformPositions.Count)
{
throw new ArgumentOutOfRangeException("Total visible platforms must be less or equal the number of platform positions.");
}
if (TotalInitialVisiblePlatforms >= PlatformPositions.Count)
{
throw new ArgumentOutOfRangeException("Total initial visible platforms must be less or equal the number of platform positions.");
}
for (var i = 0; i < PlatformPositions.Count; i++)
{
_worldSpacePlatformCoordinates.Add(transform.TransformPoint(PlatformPositions[i]));
}
for (var i = 0; i < TotalInitialVisiblePlatforms; i++)
{
var platform = _objectPoolingManager.GetObject(
PlatformPrefab.name,
_worldSpacePlatformCoordinates[i]);
_currentPlatforms.Enqueue(platform);
_currentIndex = i;
}
}
private void Spawn()
{
GameObject spawnedEnemy = _objectPoolingManager.GetObject(enemyToSpawn.name, this.transform.position);
EnemyController enemyController = spawnedEnemy.GetComponent <EnemyController>();
if (enemyController == null)
{
throw new MissingComponentException("Enemies spawned by an enemy spawn manager must contain an EnemyController component.");
}
enemyController.Reset(startDirection);
Logger.Trace("Spawning enemy from " + this.gameObject.name + " at " + spawnedEnemy.transform.position + ", active: " + spawnedEnemy.activeSelf + ", layer: " + LayerMask.LayerToName(spawnedEnemy.layer));
if (ballisticTrajectorySettings.isEnabled)
{
enemyController.PushControlHandler(new BallisticTrajectoryControlHandler(enemyController.characterPhysicsManager
, this.transform.position
, this.transform.position + new Vector3(ballisticTrajectorySettings.endPosition.x, ballisticTrajectorySettings.endPosition.y, transform.position.z)
, ballisticTrajectorySettings.projectileGravity
, ballisticTrajectorySettings.angle));
}
enemyController.GotDisabled += enemyController_Disabled;
_spawnedEnemies.Add(spawnedEnemy);
}
void OnEnable()
{
_objectPoolingManager = ObjectPoolingManager.Instance;
List <GameObjectContainer> platforms = new List <GameObjectContainer>();
float twoPi = Mathf.PI * 2f;
for (float angle = 0f; angle < twoPi; angle += twoPi / totalPlatforms)
{
GameObject platform = _objectPoolingManager.GetObject(floatingAttachedPlatform.name);
Quaternion q = Quaternion.AngleAxis(angle, Vector3.forward);
Vector3 rotated = new Vector3(width * Mathf.Cos(angle), height * Mathf.Sin(angle), 0.0f);
rotated = q * rotated + this.transform.position;
platform.transform.position = rotated;
platforms.Add(new GameObjectContainer()
{
GameObject = platform, Angle = angle
});
}
_platforms = platforms;
}
void OnEnable()
{
_objectPoolingManager = ObjectPoolingManager.Instance;
Logger.Info("Enabling half wheel " + this.name);
GameObject platform = _objectPoolingManager.GetObject(floatingAttachedPlatform.name);
_currentAngle = startDirection == Direction.Right ? -Mathf.PI : 0f;
#if USE_CIRCLE
Quaternion q = Quaternion.AngleAxis(_currentAngle, Vector3.forward);
Vector3 rotated = new Vector3(width * Mathf.Cos(_currentAngle), height * Mathf.Sin(_currentAngle), 0.0f);
rotated = q * rotated + this.transform.position;
#else
Vector3 initial = new Vector3(transform.position.x + radius, transform.position.y, transform.position.z);
Vector3 rotated = new Vector3(
Mathf.Cos(_currentAngle) * (initial.x - transform.position.x) - Mathf.Sin(_currentAngle) * (initial.y - transform.position.y) + transform.position.x
, Mathf.Sin(_currentAngle) * (initial.x - transform.position.x) + Mathf.Cos(_currentAngle) * (initial.y - transform.position.y) + transform.position.y
, transform.position.z);
#endif
platform.transform.position = rotated;
_platform = platform;
_currentDirection = startDirection;
_nextStartTime = Time.time + stopDuration;
}
void OnEnable()
{
if (PlatformGroups.Count < 1)
{
throw new ArgumentOutOfRangeException("There must be at least two platform position groups.");
}
_playerController = GameManager.Instance.Player;
_objectPoolingManager = ObjectPoolingManager.Instance;
for (var i = 0; i < PlatformGroups.Count; i++)
{
PlatformGroups[i].GameObjects = new List <GameObjectContainer>();
}
var index = 0;
var twoPi = Mathf.PI * 2f;
for (var angle = 0f; angle < twoPi; angle += twoPi / TotalPlatforms)
{
var quaternion = Quaternion.AngleAxis(angle, Vector3.forward);
var rotated = new Vector3(Width * Mathf.Cos(angle), Height * Mathf.Sin(angle), 0.0f);
rotated = quaternion * rotated + transform.position;
GameObject platform = null; // note: we do allow null game objects in case it is a wheel with a single platform switch group
if (PlatformGroups[index].DisabledGameObject != null)
{
platform = _objectPoolingManager.GetObject(PlatformGroups[index].DisabledGameObject.name);
platform.transform.position = rotated;
}
PlatformGroups[index].GameObjects.Add(
new GameObjectContainer()
{
GameObject = platform, Angle = angle
});
index = index < PlatformGroups.Count - 1
? index + 1
: 0;
}
if (PlatformGroupStartIndex < 0 || PlatformGroupStartIndex >= PlatformGroups.Count)
{
SwitchGroups(0);
}
else
{
SwitchGroups(PlatformGroupStartIndex);
}
_playerController.JumpedThisFrame += OnPlayerJumpedThisFrame;
}
void OnEnable()
{
if (platformGroups.Count < 1)
{
throw new ArgumentOutOfRangeException("There must be at least two platform position groups.");
}
_playerController = GameManager.instance.player;
_objectPoolingManager = ObjectPoolingManager.Instance;
for (int i = 0; i < platformGroups.Count; i++)
{
platformGroups[i].gameObjects = new List <GameObjectContainer>();
}
int index = 0;
float twoPi = Mathf.PI * 2f;
for (float angle = 0f; angle < twoPi; angle += twoPi / totalPlatforms)
{
Quaternion q = Quaternion.AngleAxis(angle, Vector3.forward);
Vector3 rotated = new Vector3(width * Mathf.Cos(angle), height * Mathf.Sin(angle), 0.0f);
rotated = q * rotated + this.transform.position;
GameObject platform = null; // note: we do allow null game objects in case it is a wheel with a single platform switch group
if (platformGroups[index].disabledGameObject != null)
{
platform = _objectPoolingManager.GetObject(platformGroups[index].disabledGameObject.name);
platform.transform.position = rotated;
}
platformGroups[index].gameObjects.Add(new GameObjectContainer()
{
GameObject = platform, Angle = angle
});
index = index < platformGroups.Count - 1 ? index + 1 : 0;
}
if (platformGroupStartIndex < 0 || platformGroupStartIndex >= platformGroups.Count)
{
SwitchGroups(0);
}
else
{
SwitchGroups(platformGroupStartIndex);
}
_playerController.OnJumpedThisFrame += _playerController_OnJumpedThisFrame;
}
private void Spawn()
{
GameObject spawnedProjectile = _objectPoolingManager.GetObject(projectileToSpawn.name);
spawnedProjectile.transform.position = this.transform.position;
Logger.Trace("Spawning projectile from " + this.GetHashCode() + " (" + this.transform.position + ") at " + spawnedProjectile.transform.position + ", active: " + spawnedProjectile.activeSelf + ", layer: " + LayerMask.LayerToName(spawnedProjectile.layer));
if (ballisticTrajectorySettings.isEnabled)
{
ProjectileController projectileController = spawnedProjectile.GetComponent <ProjectileController>();
Logger.Assert(projectileController != null, "A projectile with ballistic trajectory must have a projectile controller script attached.");
projectileController.PushControlHandler(new BallisticProjectileControlHandler(projectileController, ballisticTrajectorySettings));
}
}
void Update()
{
#region now check whether we can see the player
bool isSeeingPlayer = false;
Vector3 playerVector = _playerController.transform.position - this.transform.position;
float angle = Mathf.Atan2(playerVector.y, playerVector.x);
if (angle < 0f)
{
angle += 2 * Mathf.PI;
}
if (angle >= _startAngleRad && angle <= _endAngleRad)
{
RaycastHit2D raycastHit2D = Physics2D.Raycast(this.gameObject.transform.position, playerVector.normalized, playerVector.magnitude, scanRayCollisionLayers);
if (raycastHit2D && raycastHit2D.collider.gameObject.layer == LayerMask.NameToLayer("Player"))
{
isSeeingPlayer = true;
_playerInSightDuration += Time.deltaTime;
}
}
DrawRay(this.gameObject.transform.position, playerVector, isSeeingPlayer ? Color.red : Color.gray);
if (!isSeeingPlayer)
{
_playerInSightDuration = 0f;
}
if (_playerInSightDuration >= timeNeededToDetectPlayer)
{
if (_lastRoundFiredTime + _rateOfFireInterval <= Time.time)
{
GameObject enemyProjectileGameObject = _objectPoolingManager.GetObject(projectilePrefab.name, this.transform.position);
IEnemyProjectile enemyProjectile = enemyProjectileGameObject.GetComponent <IEnemyProjectile>();
Logger.Assert(enemyProjectile != null, "Enemy projectile must not be null");
enemyProjectile.StartMove(this.transform.position, playerVector, projectileAcceleration, projectileTargetVelocity);
_lastRoundFiredTime = Time.time;
}
}
#endregion
}
public SpawnRoutine(ObjectPoolingManager objectPoolingManager, GameObject platformPrefab, Vector3 spawnLocation, float stableDuration, float fallGravity)
{
_fallGravity = fallGravity;
_stableDuration = stableDuration;
_currentState = CurrentState.Idle;
_objectPoolingManager = objectPoolingManager;
_velocity = Vector2.zero;
gameObject = _objectPoolingManager.GetObject(platformPrefab.name);
gameObject.transform.position = spawnLocation;
AttachPlayerControllerToObject attachPlayerControllerToObject = gameObject.GetComponent <AttachPlayerControllerToObject>();
if (attachPlayerControllerToObject == null)
{
throw new MissingComponentException("Game object " + gameObject.name + " must contain 'AttachPlayerControllerToObject' script.");
}
attachPlayerControllerToObject.OnPlayerControllerGotGrounded += attachPlayerControllerToObject_OnPlayerControllerGotGrounded;
}
public SpawnRoutine(ObjectPoolingManager objectPoolingManager, GameObject platformPrefab, Vector3 spawnLocation, float stableDuration, float fallGravity)
{
_fallGravity = fallGravity;
_stableDuration = stableDuration;
_currentState = SpawnRoutineState.Idle;
_objectPoolingManager = objectPoolingManager;
_velocity = Vector2.zero;
GameObject = _objectPoolingManager.GetObject(platformPrefab.name);
GameObject.transform.position = spawnLocation;
var attachPlayerControllerToObject = GameObject.GetComponentOrThrow <AttachPlayerControllerToObject>();
attachPlayerControllerToObject.PlayerControllerGotGrounded += OnPlayerControllerGotGrounded;
}
private void SwitchGroups(int enabledIndex)
{
_currentEnabledGroupIndex = enabledIndex;
for (int i = 0; i < platformGroupPositions.Count; i++)
{
for (int j = 0; j < platformGroupPositions[i].worldSpaceCoordinates.Length; j++)
{
if (platformGroupPositions[i].gameObjects[j] != null)
{
_objectPoolingManager.Deactivate(platformGroupPositions[i].gameObjects[j]);
platformGroupPositions[i].gameObjects[j] = null;
}
platformGroupPositions[i].gameObjects[j] = _objectPoolingManager.GetObject(
_currentEnabledGroupIndex == i
? platformGroupPositions[i].enabledGameObject.name
: platformGroupPositions[i].disabledGameObject.name
, platformGroupPositions[i].worldSpaceCoordinates[j]);
}
}
}
private void SwitchGroups(int enabledIndex)
{
_currentEnabledGroupIndex = enabledIndex;
for (int i = 0; i < platformGroups.Count; i++)
{
for (int j = 0; j < platformGroups[i].gameObjects.Count; j++)
{
if (platformGroups[i].gameObjects[j].GameObject != null)
{
Vector3 position = platformGroups[i].gameObjects[j].GameObject.transform.position;
_objectPoolingManager.Deactivate(platformGroups[i].gameObjects[j].GameObject);
platformGroups[i].gameObjects[j].GameObject = _objectPoolingManager.GetObject(
_currentEnabledGroupIndex == i
? platformGroups[i].enabledGameObject.name
: platformGroups[i].disabledGameObject.name
, position);
}
}
}
}
public override PlayerStateUpdateResult Update(XYAxisState axisState)
{
if (CanFire(axisState))
{
var direction = GetDirectionVector(axisState);
var spawnLocation = GetSpawnLocation(direction);
var projectile = _objectPoolingManager.GetObject(
_projectileWeaponSettings.ProjectilePrefab.name,
spawnLocation);
if (projectile != null)
{
var projectileBehaviour = projectile.GetComponent <PlayerProjectileBehaviour>();
projectileBehaviour.StartMove(
spawnLocation,
direction * _projectileWeaponSettings.DistancePerSecond);
_lastBulletTime = Time.time;
_lastAnimationName = GetAnimationName(axisState);
return(PlayerStateUpdateResult.CreateHandled(
_lastAnimationName,
1));
}
}
if ((PlayerController.PlayerState & PlayerState.EnemyContactKnockback) == 0 &&
IsAttacking())
{
return(PlayerStateUpdateResult.CreateHandled(GetAnimationName(axisState), 1));
}
return(PlayerStateUpdateResult.Unhandled);
}
private void Spawn()
{
_enemyToSpawnPrefab.transform.position = transform.position;
if (!_spawnablePrefabComponent.CanSpawn())
{
ScheduleSpawn();
return;
}
var spawnedEnemy = _objectPoolingManager.GetObject(_enemyToSpawnPrefab.name, transform.position);
spawnedEnemy.transform.localScale = _enemyToSpawnPrefab.transform.localScale;
var spawnable = spawnedEnemy.GetComponent <ISpawnable>();
spawnable.Reset();
spawnable.GotDisabled += OnEnemyControllerGotDisabled;
_spawnedEnemies.Add(spawnedEnemy);
}
private void Spawn()
{
var spawnedProjectile = _objectPoolingManager.GetObject(ProjectileToSpawn.name);
spawnedProjectile.transform.position = transform.position;
Logger.TraceFormat("Spawning projectile from {0} ({1}) at {2}, active: {3}, layer: {4}",
GetHashCode(),
transform.position,
spawnedProjectile.transform.position,
spawnedProjectile.activeSelf,
LayerMask.LayerToName(spawnedProjectile.layer));
if (BallisticTrajectorySettings.IsEnabled)
{
var projectileController = spawnedProjectile.GetComponent <ProjectileController>();
Logger.Assert(projectileController != null,
"A projectile with ballistic trajectory must have a projectile controller script attached.");
projectileController.PushControlHandler(
new BallisticProjectileControlHandler(projectileController, BallisticTrajectorySettings));
}
}
protected override bool DoUpdate()
{
if (_playerInSightDuration == 0f || // either we don't see the player
!_pauseAtEdgeEndTime.HasValue // or we have not reached the edge yet
)
{
// first move in patrolling mode
MoveHorizontally(ref _moveDirectionFactor, _enemyController.speed, _enemyController.gravity, PlatformEdgeMoveMode.TurnAround, _enemyController.edgeTurnAroundPause);
}
Vector3 raycastOrigin;
raycastOrigin = _moveDirectionFactor > 0f
? new Vector3(_enemyController.gameObject.transform.position.x + _boxCollider2D.size.x / 2f, _enemyController.gameObject.transform.position.y)
: new Vector3(_enemyController.gameObject.transform.position.x - _boxCollider2D.size.x / 2f, _enemyController.gameObject.transform.position.y);
if (_playerInSightDuration > 0f &&
_playerInSightDuration > _enemyController.detectPlayerDuration &&
_pauseAtEdgeEndTime.HasValue)
{
// TODO (Roman): shoot, look at hazard spawn manager and copy/paste logic here
if (_lastShotTime + _enemyController.shootIntervalDuration < Time.time)
{
GameObject spawnedProjectile = _objectPoolingManager.GetObject(_enemyController.projectileToSpawn.name);
spawnedProjectile.transform.position = raycastOrigin;
ProjectileController projectileController = spawnedProjectile.GetComponent <ProjectileController>();
Logger.Assert(projectileController != null, "A projectile with ballistic trajectory must have a projectile controller script attached.");
BallisticTrajectorySettings ballisticTrajectorySettings = new BallisticTrajectorySettings();
ballisticTrajectorySettings.angle = 0f; // horizontal launch
ballisticTrajectorySettings.projectileGravity = -200f;
ballisticTrajectorySettings.endPosition = new Vector2(
GameManager.instance.player.transform.position.x - raycastOrigin.x
, Mathf.Min(GameManager.instance.player.transform.position.y - raycastOrigin.y, -1f)
);
Debug.Log("Endpos: " + ballisticTrajectorySettings.endPosition + ", " + (GameManager.instance.player.transform.position.y - raycastOrigin.y));
projectileController.PushControlHandler(new BallisticProjectileControlHandler(projectileController, ballisticTrajectorySettings, _enemyController.maxVelocity));
_lastShotTime = Time.time;
}
}
#region now check whether we can see the player
float startAngleRad = _moveDirectionFactor > 0f
? (-90f + _enemyController.scanAngleClipping / 2f) * Mathf.Deg2Rad
: (-180f + _enemyController.scanAngleClipping / 2f) * Mathf.Deg2Rad;
float endAngleRad = _moveDirectionFactor > 0f
? (0f - _enemyController.scanAngleClipping / 2f) * Mathf.Deg2Rad
: (-90f - _enemyController.scanAngleClipping / 2f) * Mathf.Deg2Rad;
float step = (endAngleRad - startAngleRad) / (float)(_enemyController.totalScanRays);
bool isSeeingPlayer = false;
for (float theta = endAngleRad; theta > startAngleRad - step / 2; theta -= step)
{
Vector2 vector = new Vector2((float)(_enemyController.scanRayLength * Mathf.Cos(theta)), (float)(_enemyController.scanRayLength * Mathf.Sin(theta)));
RaycastHit2D raycastHit2D = Physics2D.Raycast(raycastOrigin, vector.normalized, vector.magnitude, _enemyController.scanRayCollisionLayers);
if (raycastHit2D)
{
if (raycastHit2D.collider.gameObject.layer == LayerMask.NameToLayer("Player"))
{
_playerInSightDuration += Time.deltaTime;
isSeeingPlayer = true;
DrawRay(raycastOrigin, raycastHit2D.point.ToVector3() - _enemyController.gameObject.transform.position, Color.red);
break;
}
else
{
DrawRay(raycastOrigin, raycastHit2D.point.ToVector3() - _enemyController.gameObject.transform.position, Color.grey);
}
}
else
{
DrawRay(raycastOrigin, vector, Color.grey);
}
}
if (!isSeeingPlayer)
{
_playerInSightDuration = 0f;
}
else
{
if (_pauseAtEdgeEndTime.HasValue)
{
_pauseAtEdgeEndTime += Time.deltaTime;
}
}
#endregion
return(true);
}
void OnDisappearWhenLostGround(GroundedPlatformChangedInfo groundedPlatformChangedInfo)
{
var lostGround = groundedPlatformChangedInfo.CurrentPlatform == null;
if (lostGround)
{
if (_hasLandedOnPlatform)
{
if (_isOnPlatform)
{
if (PlatformMode == JumpControlledDisappearingPlatformMode.DisappearWhenLostGround)
{
if (_currentPlatforms.Count >= TotalVisiblePlatforms)
{
GameObject platformToRemove = _currentPlatforms.Dequeue();
StartCoroutine(FadeOutPlatform(platformToRemove, .2f));
}
}
}
}
_isOnPlatform = false;
_currentPlatform = null;
}
else
{
if (groundedPlatformChangedInfo.CurrentPlatform != _currentPlatform)
{
if (_currentPlatforms.Contains(groundedPlatformChangedInfo.CurrentPlatform))
{
_currentPlatform = groundedPlatformChangedInfo.CurrentPlatform;
_hasLandedOnPlatform = true;
_isOnPlatform = true;
if (groundedPlatformChangedInfo.CurrentPlatform.transform.position == _worldSpacePlatformCoordinates[_currentIndex])
{
// we are on last platform. Make sure we have the correct count
while (_currentPlatforms.Count >= TotalVisiblePlatforms)
{
var platformToRemove = _currentPlatforms.Dequeue();
StartCoroutine(FadeOutPlatform(platformToRemove, .2f));
}
while (_currentPlatforms.Count < TotalVisiblePlatforms)
{
_currentIndex++;
if (_currentIndex >= _worldSpacePlatformCoordinates.Count)
{
_currentIndex = 0;
}
var platform = _objectPoolingManager.GetObject(
PlatformPrefab.name,
_worldSpacePlatformCoordinates[_currentIndex]);
_currentPlatforms.Enqueue(platform);
}
}
}
else
{
_currentPlatform = null;
}
}
}
}
void _playerController_DisappearWhenLostGround_OnGroundedPlatformChanged(object sender, PlayerController.GroundedPlatformChangedEventArgs e)
{
if (e.currentPlatform == null)
{// lost ground
if (_hasLandedOnPlatform)
{
if (_isOnPlatform)
{
switch (jumpControlledDisappearingPlatformMode)
{
case JumpControlledDisappearingPlatformMode.DisappearWhenLostGround:
if (_currentPlatforms.Count >= totalVisiblePlatforms)
{
GameObject platformToRemove = _currentPlatforms.Dequeue();
StartCoroutine(FadeOutPlatform(platformToRemove, .2f));
}
break;
}
}
}
_isOnPlatform = false;
_currentPlatform = null;
}
else
{
if (e.currentPlatform != _currentPlatform)
{
if (_currentPlatforms.Contains(e.currentPlatform))
{
_currentPlatform = e.currentPlatform;
_hasLandedOnPlatform = true;
_isOnPlatform = true;
if (e.currentPlatform.transform.position == _worldSpacePlatformCoordinates[_currentIndex])
{
// we are on last platform. Make sure we have the correct count
while (_currentPlatforms.Count >= totalVisiblePlatforms)
{
GameObject platformToRemove = _currentPlatforms.Dequeue();
StartCoroutine(FadeOutPlatform(platformToRemove, .2f));
}
while (_currentPlatforms.Count < totalVisiblePlatforms)
{
_currentIndex++;
if (_currentIndex >= _worldSpacePlatformCoordinates.Count)
{
_currentIndex = 0;
}
GameObject platform = _objectPoolingManager.GetObject(platformPrefab.name, _worldSpacePlatformCoordinates[_currentIndex]);
_currentPlatforms.Enqueue(platform);
}
}
}
else
{
_currentPlatform = null;
}
}
}
}