void Update()
{
//Update rotation based on player input
Vector2 axis = new Vector2(Input.GetAxisRaw("P" + playerData.GetPlayerNum() + "_Joystick_L_Horizontal"), Input.GetAxisRaw("P" + playerData.GetPlayerNum() + "_Joystick_L_Vertical"));
if (axis != Vector2.zero && axis.magnitude > 0.5f)
{
playerAngle = TrigUtilities.VectorToDegrees(axis);
}
//Handle input for if the player doesn't have a weapon
if (Input.GetButtonDown("P" + playerData.GetPlayerNum() + "_Fire"))
{
if (!playerData.GetWeapon())
{
ApplyForceForward(1);
}
}
//Handle flying off into infinity
/*if (GameManager.instance.IsTransformOffCamera(transform))
* {
* transform.position = new Vector2(0, 0);
* print("Zoop!");
* };*/
}
public void OnObjectSpawn()
{
float angle = Random.Range(0, 360);
Vector2 direction = TrigUtilities.DegreesToVector(angle);
rb.AddForce(direction * Random.Range(10f, 15f), ForceMode2D.Impulse);
StartCoroutine(InvisibleFrames());
}
void Start()
{
//GetComponent<SpriteRenderer>().color = color;
trailRenderer = GetComponent <TrailRenderer>();
ColorBullet();
circleCollider = GetComponent <CircleCollider2D>();
moveVector = direction * velocityMagnitude;
actualRadius = circleCollider.radius * transform.localScale.x;
//Figure out what to do if the bullet spawned inside of something
Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, circleCollider.radius * transform.localScale.x);
foreach (Collider2D collider in colliders)
{
//This bullet
if (collider == circleCollider)
{
continue;
}
//Other player
if (collider.CompareTag("Player") && collider.gameObject != owner.gameObject)
{
if (causeExplosion)
{
ObjectPooler.instance.SpawnExplosionFromPool(transform.position, damage, damageForce, explosionRadius, owner, canHitOwner);
}
else
{
collider.GetComponent <PlayerData>().TakeDamage(damage, TrigUtilities.VectorToDegrees(direction), damageForce, owner);
}
Destroy(gameObject);
}
//Wall
else if (collider.CompareTag("Wall"))
{
if (causeExplosion)
{
ObjectPooler.instance.SpawnExplosionFromPool(transform.position, damage, damageForce, explosionRadius, owner, canHitOwner);
}
Destroy(gameObject);
}
}
LeanTween.delayedCall(gameObject, lifeSpan, () =>
{
if (causeExplosion)
{
ObjectPooler.instance.SpawnExplosionFromPool(transform.position, damage, damageForce, explosionRadius, owner, canHitOwner);
}
Destroy(gameObject);
});
}
void Update()
{
if (invincible)
{
sr.enabled = !sr.enabled;
}
// Get player input
playerInput = new Vector2(Input.GetAxisRaw("P" + playerNum + "_Horizontal"), Input.GetAxisRaw("P" + playerNum + "_Vertical"));
// Jump control
grounded = Physics2D.OverlapCircle(transform.position, circleCollider2D.radius * 1.5f, groundLayerMask);
if (grounded && playerInput.y == 1)
{
rb.velocity = new Vector2(rb.velocity.x, jumpPower);
}
// Speed limit
if (rb.velocity.x > speedLimit)
{
rb.velocity = new Vector2(speedLimit, rb.velocity.y);
}
else if (rb.velocity.x < -speedLimit)
{
rb.velocity = new Vector2(-speedLimit, rb.velocity.y);
}
// Rotation
if (freeAim)
{
if (playerInput != Vector2.zero)
{
playerAngle = -(TrigUtilities.VectorToDegrees(playerInput) - 90);
}
}
else
{
if (!grounded)
{
playerAngle -= rotationSpeed * Time.deltaTime;
if (playerAngle < 0)
{
playerAngle += 360;
}
}
}
// Off-screen death
if (GameManager.instance.IsTransformOffCamera(transform))
{
Die();
}
}
public void TakeDamage(int damage, float damageAngle, float damageForce, PlayerData damageSource)
{
if (health > 0 && !invincible)
{
health -= damage;
CMShakeHandler.instance.IncreaseShakeAmount(0.004f * damage);
//Death
if (health <= 0)
{
if (damageSource != this)
{
damageSource.IncrementKills();
}
deaths++;
CMShakeHandler.instance.IncreaseShakeAmount(0.5f);
//Spawn corpse
GameObject newCorpse = Instantiate(corpsePrefab, transform.position, Quaternion.identity);
newCorpse.transform.localScale = transform.localScale;
Rigidbody2D corpseRB = newCorpse.GetComponent <Rigidbody2D>();
corpseRB.AddForce(TrigUtilities.DegreesToVector(damageAngle) * damageForce * Time.deltaTime, ForceMode2D.Impulse);
corpseRB.drag = rb.drag;
corpseRB.sharedMaterial = rb.sharedMaterial;
//Remove weapon
if (weapon)
{
Destroy(weapon.gameObject);
}
//Remove player temporarily
LeanTween.delayedCall(gameObject, respawnTime, () => {
Respawn();
});
gameObject.SetActive(false);
}
//Normal damage
else
{
playerMovement.ApplyKnockback(damageAngle, damageForce);
healthbarImage.fillAmount = ((float)health / maxHealth);
playerHurtAS.PlayRandomize(0.25f);
}
}
}
public void OnObjectSpawn()
{
//Apply force
Collider2D[] colliders = Physics2D.OverlapCircleAll(transform.position, explosionRadius);
foreach (Collider2D collider in colliders)
{
if (collider.CompareTag("Player"))
{
CircleCollider2D playerCollider = collider.GetComponent <CircleCollider2D>();
//Add the player's radius to the explosion radius because the distance between the explosion and the player might be farther than the explosion radius
float updatedExplosionRadius = explosionRadius + playerCollider.radius;
//Get angle/distance of explosion to target
Vector2 forceDirection = collider.transform.position - transform.position;
float distance = Vector2.Distance(transform.position, collider.transform.position);
//Calculate damage the target will take
int damage = (int)Mathf.Ceil(explosionDamage * (updatedExplosionRadius - distance) / updatedExplosionRadius);
if (collider.gameObject == owner.gameObject && !canHitOwner)
{
damage = 0;
}
//Tweak the explosion force depending on the distance from the epicenter
explosionForce *= (explosionRadius - distance) / explosionRadius;
//Apply the damage/force
collider.GetComponent <PlayerData>().TakeDamage(damage, TrigUtilities.VectorToDegrees(forceDirection), explosionForce, owner);
}
}
//Setup animation
LeanTween.cancel(gameObject);
sr.color = new Color(sr.color.r, sr.color.g, sr.color.b, 1);
transform.localScale = new Vector2(explosionRadius * 2, explosionRadius * 2);
//Play animation
LeanTween.alpha(gameObject, 0, 1).setEase(LeanTweenType.easeOutCubic);
LeanTween.scale(gameObject, transform.localScale * 1.5f, 1).setEase(LeanTweenType.easeOutCubic).setOnComplete(() =>
{
DeactivateObject();
});
//Shake camera
CMShakeHandler.instance.IncreaseShakeAmount(explosionRadius * 0.1f);
//DrawDebugExplosion();
}
void OnTriggerEnter2D(Collider2D other)
{
if (other.CompareTag("Player") && (other.gameObject != owner.gameObject || (canHitOwner && !safetyTrigger)))
{
if (causeExplosion)
{
ObjectPooler.instance.SpawnExplosionFromPool(transform.position, damage, damageForce, explosionRadius, owner, canHitOwner);
}
else
{
other.GetComponent <PlayerData>().TakeDamage(damage, TrigUtilities.VectorToDegrees(moveVector.normalized), damageForce, owner);
}
Destroy(gameObject);
}
}
void HandlePlayerHit(RaycastHit2D playerHit)
{
lineRend.SetPosition(vertexNum, vertexStart);
lineRend.SetPosition(vertexNum + 1, playerHit.point);
lineRend.positionCount = 2 + vertexNum;
fadingOut = true;
if (causeExplosion)
{
ObjectPooler.instance.SpawnExplosionFromPool(playerHit.point, damage, damageForce, explosionRadius, owner, canHitOwner);
}
else
{
playerHit.transform.GetComponent <PlayerData>().TakeDamage(damage, TrigUtilities.VectorToDegrees(direction), damageForce, owner);
}
}
void Update()
{
//This convoluted algorithm makes it so that the larger the shakeAmount is, the faster it'll decrease (because a larger shakeAmount = a smaller denominator)
//shakeAmount -= (Time.deltaTime / Mathf.Clamp(2 - (shakeAmount * 4), 0.1f, 2f));
//if (shakeAmount < 0) shakeAmount = 0;
shakeAmount *= 0.95f;
if (shakeAmount < 0.1f)
{
shakeAmount = 0;
}
if (shakeAmount > 0)
{
float angle = Random.Range(0f, 360f);
Vector2 offset = TrigUtilities.DegreesToVector(angle) * shakeAmount;
transform.position = originalCameraPosition + new Vector3(offset.x, offset.y);
}
else
{
transform.position = originalCameraPosition;
}
}
protected virtual void CreateProjectile()
{
//Create basic projectile
GameObject newBullet;
if (projectileData.hitscan)
{
newBullet = Instantiate(hitscanProjectilePrefab, projectileStartPos.position, Quaternion.identity);
}
else
{
newBullet = Instantiate(physicalProjectilePrefab, projectileStartPos.position, Quaternion.identity);
}
ProjectileBase projectile = newBullet.GetComponent <ProjectileBase>();
//Set general properties
projectile.SetDirection(TrigUtilities.DegreesToVector(owner.GetPlayerMovement().GetPlayerAngle() + Random.Range(-accuracyDegreeOffsetRange, accuracyDegreeOffsetRange)));
projectile.SetDamage(projectileData.damage);
projectile.SetDamageForce(projectileData.damageForce);
projectile.SetOwner(owner);
projectile.SetCanHitOwner(projectileData.canHitOwner);
projectile.SetColor(owner.GetColor().GetModifiedBrightness(3f));
projectile.SetBounces(projectileData.bounces);
projectile.SetCauseExplosion(projectileData.causeExplosion);
projectile.SetExplosionRadius(projectileData.explosionRadius);
projectile.SetExplodeEveryBounce(projectileData.explodeEveryBounce);
//Set properties depending on if it's hitscan or physical
if (projectileData.hitscan)
{
SetHitscanProperties(newBullet);
}
else
{
SetPhysicalProperties(newBullet);
}
}
void Start()
{
lineRend = GetComponent <LineRenderer>();
initialWidth = lineRend.startWidth;
lineRend.startColor = color;
lineRend.endColor = color;
decayTimer = decayTimerLength;
vertexNum = 0;
vertexStart = transform.position;
//Check if we spawned a bullet in something
Collider2D[] colliders = Physics2D.OverlapPointAll(transform.position);
foreach (Collider2D collider in colliders)
{
//Other player
if (collider.CompareTag("Player") && collider.gameObject != owner.gameObject)
{
if (causeExplosion)
{
ObjectPooler.instance.SpawnExplosionFromPool(transform.position, damage, damageForce, explosionRadius, owner, canHitOwner);
}
else
{
collider.GetComponent <PlayerData>().TakeDamage(damage, TrigUtilities.VectorToDegrees(direction), damageForce, owner);
}
Destroy(gameObject);
}
//Wall
else if (collider.CompareTag("Wall"))
{
if (causeExplosion)
{
ObjectPooler.instance.SpawnExplosionFromPool(transform.position, damage, damageForce, explosionRadius, owner, canHitOwner);
}
Destroy(gameObject);
}
//Everything else
else
{
continue;
}
}
if (instantTravel)
{
lineRend.positionCount = 2 + bounces;
do
{
CastRays();
} while (!fadingOut);
}
else
{
lineRend.positionCount = 2;
}
}
public Vector2 GetPlayerDirection()
{
return(TrigUtilities.DegreesToVector(playerAngle));
}
//Like ApplyForce, but is affected by the knockback multiplier
public void ApplyKnockback(float angle, float force)
{
rb.AddForce(TrigUtilities.DegreesToVector(angle) * force * knockbackMultiplier);
}
public void ApplyForce(float angle, float force)
{
rb.AddForce(TrigUtilities.DegreesToVector(angle) * force);
}
void Update()
{
rb.rotation = -TrigUtilities.VectorToDegrees(rb.velocity);
}
