private IEnumerator LoadSceneAsyncCoroutine(string sceneName, bool newGame)
{
AsyncOperation asyncOperation = SceneManager.LoadSceneAsync(sceneName);
gameDataHolder = null;
while (!asyncOperation.isDone)
{
yield return(new WaitForEndOfFrame());
}
if (sceneName == mainSceneName)
{
gameDataHolder = GameObject.FindGameObjectWithTag("Game Data Holder");
InitializeGame();
if (newGame)
{
DeleteSaveData();
SaveData();
}
else
{
LoadData(false);
}
}
currentSceneName = sceneName;
CoroutineManager.DeleteCoroutine("LoadSceneAsyncCoroutine");
}
private IEnumerator ChangeResolutionCoroutine()
{
Screen.SetResolution(selectedResolution.width, selectedResolution.height, true, selectedResolution.refreshRate);
yield return(new WaitForSeconds(0.2f));
currentResolution = Screen.currentResolution;
ResetDropdownValues();
applyButton.gameObject.SetActive(false);
CoroutineManager.DeleteCoroutine("ChangeResolutionCoroutine");
}
private static IEnumerator IgnoreLayerCollisionCoroutine(LayerMask layerMask, LayerMask layerMaskToIgnore,
bool ignore,
float time)
{
for (var i = 0; i <= 1; i++)
{
Physics2D.IgnoreLayerCollision(layerMask.value, layerMaskToIgnore.value, ignore);
ignore = !ignore;
yield return(new WaitForSeconds(time));
}
CoroutineManager.DeleteCoroutine("IgnoreLayerCollisionCoroutine");
}
private IEnumerator GetNativeResolutionCoroutine()
{
var initialResolution = Screen.currentResolution;
Screen.SetResolution(initialResolution.width, initialResolution.height, false,
initialResolution.refreshRate);
yield return(new WaitForSeconds(0.2f));
NativeResolution = Screen.currentResolution;
Screen.SetResolution(initialResolution.width, initialResolution.height, true,
initialResolution.refreshRate);
CoroutineManager.DeleteCoroutine("GetNativeResolutionCoroutine");
}
private IEnumerator EffectCoroutine(float areaOfEffectAngle, Vector3 position)
{
var contactFilter2D = new ContactFilter2D
{
useTriggers = true,
useLayerMask = true,
layerMask = LayerMask.GetMask("Enemy", "Player")
};
var collider2Ds = new Collider2D[5];
while (Time.time < durationCurrentTime && hasExploded)
{
var areaOfEffect = Physics2D.OverlapBox(position, new Vector2(area, 1), areaOfEffectAngle,
contactFilter2D, collider2Ds);
if (areaOfEffect > 0)
{
for (var i = 0; i < collider2Ds.Length; i++)
{
if (collider2Ds[i] != null)
{
PhysicsHelpers.IgnoreCollision(triggerCollider2D, collider2Ds[i], true);
var enemy = collider2Ds[i].GetComponent <Enemy>();
if (enemy != null)
{
enemy.TakeDamage(damage * Time.fixedDeltaTime);
}
else
{
var player = collider2Ds[i].GetComponent <PlayerStatusController>();
if (player != null)
{
player.TakeDamage(damage * Time.fixedDeltaTime);
}
}
}
}
}
yield return(new WaitForFixedUpdate());
}
CoroutineManager.DeleteCoroutine("EffectCoroutine");
Destroy(this.gameObject);
}
public static IEnumerator ZoomCameraCoroutine(float zoomSize, float steps, bool zoomOut)
{
float f = 0;
while (f <= 1)
{
Camera.main.orthographicSize =
zoomOut ? Mathf.Lerp(initialSize, zoomSize, f) : Mathf.Lerp(zoomSize, initialSize, f);
f += 1f / steps;
yield return(new WaitForSeconds(timeToZoomCamera / steps));
}
CoroutineManager.DeleteCoroutine("ZoomCameraCoroutine");
}
private IEnumerator MorphinEffectCoroutine(float staminaRegenMultiplier, float velocityMultiplier)
{
playerStatusController.StaminaRegenMultiplier = staminaRegenMultiplier;
playerHorizontalMovement.VelocityMultiplier = velocityMultiplier;
while (Time.time <= currentTimeMorphinEffect)
{
yield return(new WaitForFixedUpdate());
}
playerStatusController.StaminaRegenMultiplier = 1f;
playerHorizontalMovement.VelocityMultiplier = 1f;
playerStatusVariables.isMorphinActive = false;
CoroutineManager.DeleteCoroutine("MorphinEffectCoroutine", this);
}
private IEnumerator RegenStaminaCoroutine()
{
var t = Time.fixedDeltaTime;
while (currentStamina < maxStamina)
{
currentStamina += staminaRegenRatePerSecond * StaminaRegenMultiplier * t;
if (currentStamina > maxStamina)
{
currentStamina = maxStamina;
}
staminaBar.value = currentStamina;
yield return(new WaitForFixedUpdate());
}
CoroutineManager.DeleteCoroutine("RegenStaminaCoroutine");
}
protected virtual void RevokeControl(float timeToRevoke, bool revoke,
ControlTypeToRevoke controlTypeToRevoke, RevokeControlVariables revokeControlVariables,
MonoBehaviour monoBehaviour)
{
var coroutine = CoroutineManager.FindCoroutine("RevokeControlCoroutine", monoBehaviour);
if (coroutine == null)
{
CoroutineManager.AddCoroutine(
RevokeControlCoroutine(timeToRevoke, controlTypeToRevoke, revokeControlVariables, true, monoBehaviour),
"RevokeControlCoroutine", monoBehaviour);
}
else if (!coroutine.IsRunning)
{
CoroutineManager.DeleteCoroutine("RevokeControlCoroutine", monoBehaviour);
CoroutineManager.AddCoroutine(
RevokeControlCoroutine(timeToRevoke, controlTypeToRevoke, revokeControlVariables, true, monoBehaviour),
"RevokeControlCoroutine", monoBehaviour);
}
}
public void SpendStamina(float percentOfStaminaToSpent, bool imediate)
{
if (CoroutineManager.CheckIfCoroutineExists("RegenStaminaCoroutine"))
{
CoroutineManager.DeleteCoroutine("RegenStaminaCoroutine");
}
if (imediate)
{
currentStamina -= maxStamina * percentOfStaminaToSpent / 100;
}
else if (Time.time >= timeTrackerForSpendingStamina)
{
timeTrackerForSpendingStamina = Time.time + Time.fixedDeltaTime;
currentStamina -= maxStamina * percentOfStaminaToSpent / 100 * Time.fixedDeltaTime;
}
currentStamina = currentStamina <= 0 ? 0 : currentStamina;
staminaBar.value = currentStamina;
currentTimeToStartStaminaRegen = Time.time + timeToStartStaminaRegen;
}
public IEnumerator PrimaryAttack()
{
apostleStatusVariables.isAttacking = true;
yield return(new WaitForSeconds(0.6f));
RaycastHit2D ray = Physics2D.Raycast(
transform.position,
apostleStatusVariables.facingDirection == FacingDirection.Right ? Vector2.right : Vector2.right * -1,
range, LayerMask.GetMask("Player"));
if (ray.collider != null &&
!Physics.GetIgnoreLayerCollision(LayerMask.NameToLayer("Enemy"), LayerMask.NameToLayer("Player")))
{
var player = ray.collider.GetComponent <PlayerStatusController>();
if (player != null)
{
player.TakeDamage(baseDamage);
}
}
apostleController.RevokeControl(1f, true, ControlTypeToRevoke.AllMovement, this);
apostleStatusVariables.isAttacking = false;
CoroutineManager.DeleteCoroutine("PrimaryAttackCoroutine", this);
}
public IEnumerator RegenLifeTemporaryCoroutine(float lifeToRegen, bool deactivateMorphin)
{
originalHealth = CurrentLife;
RegenLife(lifeToRegen);
while (regenLifeTemporaryTime > Time.time)
{
if (CurrentLife > originalHealth)
{
yield return(new WaitForFixedUpdate());
}
else
{
regenLifeTemporaryTime = Time.time;
}
}
if (deactivateMorphin)
{
playerStatusVariables.isMorphinActive = false;
}
currentLife = originalHealth;
lifeBar.value = currentLife;
CoroutineManager.DeleteCoroutine("RegenLifeTemporaryCoroutine");
}
public override void StartMovement()
{
playerController.CheckForVerticalInput();
playerStatusVariables.canJump = CheckGroundForJump();
playerStatusVariables.isOnAir = playerStatusVariables.CheckIsOnAir();
if (playerStatusVariables.canClimbLadder && playerController.ClimbLadderPress)
{
playerStatusVariables.isClimbingLadder =
playerStatusVariables.canClimbLadder && playerController.ClimbLadderPress ||
playerStatusVariables.isClimbingLadder;
}
if (playerStatusVariables.canClimbObstacle && playerController.ClimbObstaclePress)
{
playerStatusVariables.isClimbingObstacle =
playerStatusVariables.canClimbObstacle && playerController.ClimbObstaclePress ||
playerStatusVariables.isClimbingObstacle;
}
playerStatusVariables.isJumping = playerStatusVariables.canJump && playerController.Jump &&
!playerStatusVariables.isClimbingObstacle && player.CheckStamina(20, true);
//Para velocidades ridiculamente altas, vai bugar
if (playerStatusVariables.isClimbingLadder && playerStatusVariables.canJump)
{
var coroutine = CoroutineManager.FindCoroutine("ClimbOntoLadderCoroutine");
if (coroutine != null && !coroutine.IsRunning)
{
PhysicsHelpers.IgnoreCollision(capsuleCollider2D,
GetLadderPosition().GetComponent <LadderController>().adjacentCollider, false);
playerStatusVariables.isClimbingLadder = false;
playerController.RevokeControl(0.3f, false, ControlTypeToRevoke.AllMovement, monoBehaviour);
PhysicsHelpers.SwitchGravity(rigidbody2D, true, currentGravityScale);
PhysicsHelpers.ResetVelocityY(rigidbody2D);
rigidbody2D.isKinematic = false;
CoroutineManager.DeleteCoroutine("ClimbOntoLadderCoroutine");
}
}
if (playerStatusVariables.isClimbingObstacle && playerStatusVariables.canJump)
{
var coroutine = CoroutineManager.FindCoroutine("ClimbOntoObstacleCoroutine");
if (coroutine != null && !coroutine.IsRunning)
{
playerStatusVariables.isClimbingObstacle = false;
playerController.RevokeControl(0.3f, false, ControlTypeToRevoke.AllMovement, monoBehaviour);
PhysicsHelpers.SwitchGravity(rigidbody2D, true, currentGravityScale);
rigidbody2D.isKinematic = false;
CoroutineManager.DeleteCoroutine("ClimbOntoObstacleCoroutine");
}
}
CheckForClimbingStairs();
if (playerStatusVariables.isOnAir)
{
VerticalMovementState = VerticalMovementState.OnAir;
}
else
{
if (playerStatusVariables.isJumping)
{
VerticalPressMovementState = VerticalPressMovementState.Jump;
}
else if (playerStatusVariables.canClimbLadder && playerController.ClimbLadderPress)
{
VerticalPressMovementState = VerticalPressMovementState.ClimbLadder;
}
else if (playerStatusVariables.canClimbObstacle && playerController.ClimbObstaclePress)
{
VerticalPressMovementState = VerticalPressMovementState.ClimbObstacle;
}
if (playerStatusVariables.isClimbingLadder &&
!MathHelpers.Approximately(playerController.VerticalMovement, 0, float.Epsilon))
{
VerticalMovementState = VerticalMovementState.ClimbingLadder;
}
else if (playerStatusVariables.isClimbingObstacle)
{
VerticalMovementState = VerticalMovementState.ClimbingObstacle;
}
else if (playerStatusVariables.isJumping)
{
VerticalMovementState = VerticalMovementState.OnAir;
}
else
{
VerticalMovementState = VerticalMovementState.Grounded;
}
}
}