private void HandleKnockback(CharacterController2D controller)
{
var knockback = new Knockback(Parameters);
knockback.HandleKnockback(controller, _velocity, gameObject);
var projectile = GetComponent<PathedProjectile>();
if (projectile != null)
projectile.DestroyObject();
}
void OnTriggerEnter2D(Collider2D c)
{
//print ("Pokeball pushes back "+c.gameObject.name);
if (c.gameObject.GetComponent<ReceiveKnockback>()!=null && c.gameObject.name != my_parent_name && !c.GetComponent<PlayerController>().locked) {
c.gameObject.GetComponent<Consciousness>().TakeDamage(3, pid);
//if what we hit is a player and isn't the player who made us...
Vector2 knockback = GetComponent<Rigidbody2D>().velocity;
knockback.Normalize ();
knockback.x *= KNOCKBACK_AMOUNT;
knockback.y *= KNOCKBACK_AMOUNT;
Knockback knockbackObject = new Knockback(KNOCKBACK_TIME,knockback);
c.gameObject.SendMessage("GetKnockedBack", knockbackObject);
//...activate the GetKnockedBack function of the thing we just hit
//causing them to fly backward! In players, this function is in PlayerMovement.
}
//ADD EXCEPTIONS FOR DIE_ON_CONTACT object destroys here \/
if (die_on_contact && c.gameObject.name != my_parent_name && c.gameObject.name!="Ring"
&& c.tag != "Coin" && c.tag != "Item" && c.tag != "Melee Hitbox" && c.tag != "Portal"
&& c.tag != "Death Floor"){
//if we hit ANYTHING but the player we came from
GameObject expl_temp = (GameObject) Instantiate(explosion, transform.position, Quaternion.identity);
Destroy(expl_temp, expl_temp.GetComponent<ParticleSystem>().startLifetime);
Destroy (gameObject);
}
}
//Called by Equipment.cs, for when the player is using their fist
public Item(int ID, string name, string desc, ItemType itemType, int dmg, float crtChnce, AttackSpeed attspd, Range range, Knockback knockback, WeaponType weaponType)
{
this.itemID = ID;
this.itemName = name;
this.itemDesc = desc;
this.itemType = itemType;
this.damage = dmg;
this.criticalChance = crtChnce;
this.attackSpeed = attspd;
this.range = range;
this.knockback = knockback;
this.weaponType = weaponType;
this.damageMitigation = 0;
this.defense = 0;
this.sigil = null;
}
public void GetKnockedBack(Knockback knockback)
{
//GetComponent<Rigidbody2D> ().AddForce (knockback);
/*Vector3 delta = new Vector3();
delta.x = transform.position.x + knockback.x;
delta.y = transform.position.y + knockback.y;
delta.z = 0;
transform.position = delta;*/
playerMoveScript.setKnockBack(knockback);
//print ("knocked back! "+transform.position);
//Whatever you do, make sure your walls are bigger than the amount of
//knockback defined in CauseKnockback, or a player may clip through
//walls when shot.
}
// Use this for initialization
void Start()
{
anim = GetComponent<Animator>();
rb = GetComponent<Rigidbody2D>();
velocity = new Vector2(0, 0);
if (PID == 1)
{
up = KeyCode.W;
down = KeyCode.S;
left = KeyCode.A;
right = KeyCode.D;
}
else if (PID == 2)
{
up = KeyCode.UpArrow;
down = KeyCode.DownArrow;
left = KeyCode.LeftArrow;
right = KeyCode.RightArrow;
}
ring = transform.Find("Ring").gameObject.GetComponent<SpriteRenderer>();
if (PID == 1) {
ring.color = Color.red;
}
else if (PID == 2) {
ring.color = Color.blue;
}
else if (PID == 3) {
ring.color = Color.green;
}
else if (PID == 4) {
ring.color = Color.yellow;
}
playerKnockback = null;
}
public KnockbackEffect(Vector2 vector)
{
duration = 1;
effectType = StatusEffectType.CONDITION;
action = new Knockback(vector, null);
dir = Direction.NONE;
}
public void Damage(AttackAgent attackAgent)
{
if (invulnerable || forcedInvulnerable)
{
return;
}
DoDamage(attackAgent.attack);
currentKnockback = new Knockback();
if (attackAgent.knockback > 0)
{
currentKnockback.direction = (transform.position - attackAgent.transform.position).normalized;
currentKnockback.duration = attackAgent.knockback;
currentKnockback.speed = attackAgent.knockbackSpeed;
}
if (currentKnockback.duration > 0)
{
frozen = true;
}
if (onDamageTaken != null)
{
onDamageTaken(attackAgent.attack, currentKnockback);
}
}
public override UnitDisplacement GetDisplacement(Unit unit, Direction dir, Board board)
{
Knockback kb = (Knockback)action;
Vector2 movement = kb.vector;
return(new RelativeDisplacement(unit, movement));
}
private void AddAndConfigureKnockbackComponent()
{
Knockback knockback = newEnemyObject.AddComponent <Knockback>();
knockback.KnockbackAmount = knockbackAmount;
knockback.KnockbackTime = knockbackTime;
}
private void Start()
{
player = GameManager.Instance.player.GetComponent <PlayerController>();
KB = GetComponent <Knockback>();
IN = GetComponent <Invincible>();
spriteDmg.GetComponent <SpriteRenderer>();
}
public override void _PhysicsProcess(float delta)
{
Knockback = Knockback.MoveToward(Vector2.Zero, Friction * delta);
Knockback = MoveAndSlide(Knockback);
switch (state)
{
case Global.BehaviorState.STATE_IDLE:
idleState(delta, Knockback);
break;
case Global.BehaviorState.STATE_WANDER:
wanderState();
break;
case Global.BehaviorState.STATE_CHASE:
chaseState();
break;
}
if (softCollision.IsColliding())
{
Velocity += softCollision.GetPushVector() * 200;
}
MoveAndSlide(Velocity);
batSprite.FlipH = Velocity.x < 0;
}
void OnCollisionEnter(Collision other)
{
Health health = other.gameObject.GetComponentInParent <Health>();
if (health != null)
{
health.DealDamage(10);
explosion.transform.SetParent(null);
explosion.transform.position = other.contacts[0].point + (transform.position - other.transform.position).normalized * .25f;
explosion.Play();
Instantiate(explosionAudioPrefab, transform.position, Quaternion.identity);
Destroy(explosion, 2);
Destroy(gameObject);
Knockback knockback = health.GetComponent <Knockback>();
if (knockback)
{
knockback.DoKnockback(initialVelocity.normalized);
}
}
else
{
rb.useGravity = true;
}
}
void Start()
{
enemy = GetComponent <Enemy>();
entity = GetComponent <Entity>();
knockback = entity.knockback;
Player.player.fightCircle.attackers.Add(entity);
}
public void Start()
{
maxHealth = Health;
_randomSound = GetComponent <PlayRandomSound>();
_knockback = GetComponent <Knockback>();
}
void OnTriggerEnter2D(Collider2D c)
{
//print ("Pokeball pushes back "+c.gameObject.name);
if (c.gameObject.GetComponent <ReceiveKnockback>() != null && c.gameObject.name != my_parent_name && !c.GetComponent <PlayerController>().locked)
{
c.gameObject.GetComponent <Consciousness>().TakeDamage(3, pid);
//if what we hit is a player and isn't the player who made us...
Vector2 knockback = GetComponent <Rigidbody2D>().velocity;
knockback.Normalize();
knockback.x *= KNOCKBACK_AMOUNT;
knockback.y *= KNOCKBACK_AMOUNT;
Knockback knockbackObject = new Knockback(KNOCKBACK_TIME, knockback);
c.gameObject.SendMessage("GetKnockedBack", knockbackObject);
//...activate the GetKnockedBack function of the thing we just hit
//causing them to fly backward! In players, this function is in PlayerMovement.
}
//ADD EXCEPTIONS FOR DIE_ON_CONTACT object destroys here \/
if (die_on_contact && c.gameObject.name != my_parent_name && c.gameObject.name != "Ring" &&
c.tag != "Coin" && c.tag != "Item" && c.tag != "Melee Hitbox" && c.tag != "Portal" &&
c.tag != "Death Floor")
{
//if we hit ANYTHING but the player we came from
GameObject expl_temp = (GameObject)Instantiate(explosion, transform.position, Quaternion.identity);
Destroy(expl_temp, expl_temp.GetComponent <ParticleSystem>().startLifetime);
Destroy(gameObject);
}
}
void Start()
{
_screenShake = Camera.main.GetComponent <ScreenShake>();
_knockback = transform.root.GetComponent <Knockback>();
_muzzleFlash = GetComponent <ParticleSystem>();
_slowMotion = transform.root.GetComponent <SlowMotion>();
}
private void Start()
{
rb = GetComponent <Rigidbody2D>();
kb = GetComponent <Knockback>();
RandomizeDirection();
}
public void TakeDamage(float damageTaken, GameObject damageGiver)
{
if (invulnerable)
{
return;
}
StartCoroutine(IFrames());
currHealth -= damageTaken;
SoundsManager.instance.PlayClip(SoundsManager.Sound.PlayerDamaged);
DamageTaken?.Invoke();
if (currHealth <= 0f)
{
Destroy();
}
else
{
Knockback kB = GetComponent <Knockback>();
if (kB != null)
{
StartCoroutine(kB.KnockBack(damageGiver.gameObject.transform));
GetComponent <PlayerMovement>().ChangeState(PlayerState.Stagger);
}
}
}
IEnumerator knockback(Knockback kb)
{
yield return(new WaitForFixedUpdate());
PlayerMovement pm = GetComponent <PlayerMovement>();
if (pm.grounded || kb.myType != Knockback.KillType.Melee)
{
if (kb.myType == Knockback.KillType.Melee)
{
deathSe.sr.sprite = meleeDeathSprite;
}
else if (kb.myType == Knockback.KillType.Gun)
{
deathSe.sr.sprite = gunDeathSprite;
}
else
{
deathSe.sr.sprite = cannonDeathSprite;
}
deathSe.transform.position = (Vector2)transform.position + new Vector2(0f, 0.2f);
deathSe.show();
StartCoroutine(respawn());
}
else
{
GetComponent <Rigidbody2D>().AddForce(new Vector2(kb.force, kb.force / 2));
}
}
public void setKnockBack(Knockback knockback)
{
if (unconscious)
{
return;
}
this.playerKnockback = knockback;
}
public void setKnockBack(Knockback knockback)
{
playerKnockback = knockback;
if (anim.GetInteger("PlayerState") == 1)
{
playerKnockback = null;
}
}
public virtual void Die()
{
Rigidbody2D rb = GetComponent <Rigidbody2D>();
Knockback kb = GetComponent <Knockback>();
Destroy(kb);
Destroy(rb);
StartCoroutine(DieAnimation());
}
private void Awake()
{
sm = FindObjectOfType <SavingManager>();
sm.AddToArray(null, null, null, this);
currentState = EnemyState.idle;
health = maxHealth.value;
knock = GetComponent <Knockback>();
spriteRenderer = GetComponent <SpriteRenderer>();
SetMaxHealth();
}
// Use this for initialization
void Start()
{
rb2d = GetComponent <Rigidbody2D>();
spriteRenderer = GetComponent <SpriteRenderer>();
animator = GetComponent <Animator>();
currentHealth = max_health;
kb = gameObject.GetComponentInChildren <Knockback>();
}
protected virtual void GiveDamage(Collider2D collision)
{
collision.GetComponent <HurtBox>().TakeDamage(Damage);
Knockback knockback = collision.GetComponent <Knockback>();
if (knockback != null)
{
float directionToEnemy = Mathf.Sign(collision.transform.position.x - gameObject.transform.position.x);
knockback.AddImpulse(directionToEnemy);
}
}
void OnTriggerEnter2D(Collider2D other)
{
if (!dead)
{
Knockback kb = other.GetComponent <Knockback> ();
if (kb != null)
{
StartCoroutine(knockback(kb));
}
}
}
void Awake()
{
inputState = GetComponent <InputState> ();
runBehaviour = GetComponent <Run> ();
jumpBehaviour = GetComponent <Jump> ();
animator = GetComponent <Animator> ();
collisionState = GetComponent <CollisionState> ();
duckBehaviour = GetComponent <Duck> ();
attackBehaviour = GetComponent <Attack> ();
knockbackBehaviour = GetComponent <Knockback> ();
equipBehaviour = GetComponent <Equip> ();
health = GetComponent <HealthPlayer> ();
}
protected override bool Execute()
{
var knockback = new Knockback(Being.Facing, AbilityConstants.IceballKnockbackLength, AbilityConstants.IceballKnockback);
var damage = AbilityConstants.IceballDamage * Being.SkillValue(SkillType.ImprovedIceball, true);
Globals.GameState.Missiles.Add(new IceballMissile((Zerd)Being,
new DamageInstance(knockback, damage, DamageTypes.Frost, Being, AbilityTypes.Iceball), Being.Position));
// replenish mana based on bonuses
Being.Mana += AbilityConstants.IceballManaCost *
((Being.SkillValue(SkillType.FrozenSoul, false) + Being.AbilityValue(AbilityUpgradeType.IceballMana)) /
100f);
return(base.Execute());
}
void Start()
{
// Get the components
animator = GetComponentInChildren <Animator>();
playerController = GetComponent <PlayerController>();
wallSlide = GetComponent <WallSlide>();
wallClimb = GetComponent <WallClimb>();
wallJump = GetComponent <WallJump>();
ledgeGrab = GetComponent <LedgeGrab>();
dash = GetComponent <Dash>();
betterJumping = GetComponent <BetterJumping>();
knockBack = GetComponent <Knockback>();
}
public float knockbackAmount = 5f; // Fuerza de contacto que aplica
/// <summary>
/// Al entrar en contacto con el jugador, le resta vida y le empuja
/// </summary>
void OnCollisionStay2D(Collision2D other)
{
Knockback knockback = other.gameObject.GetComponent <Knockback>();
if (other.gameObject == GameManager.instance.player && other.gameObject.GetComponent <PlayerHealth>().invulnerability == 0f)
{
GameManager.instance.onPlayerTookDamage();
if (knockback != null)
{
knockback.TakeKnockback(-other.contacts[0].normal, knockbackAmount);
}
}
}
void Start()
{
this.health = GetComponent <Health>();
this.attackHitbox = transform.Find("AttackHitbox").GetComponent <Collider2D>();
this.animator = GetComponent <Animator>();
this.faceMouseCursorBehaviour = GetComponent <FaceMouseCursor>();
this.knockbackBehaviour = GetComponent <Knockback>();
this.worldSpaceCanvas = GameObject.Find("WorldSpaceCanvas");
this.effectConnectionRed = this.effectConnectionRedPrefab.GetComponent <EffectConnection>();
this.effectConnectionGreen = this.effectConnectionGreenPrefab.GetComponent <EffectConnection>();
this.effectConnectionBlue = this.effectConnectionBluePrefab.GetComponent <EffectConnection>();
}
private void OnCollisionEnter2D(Collision2D collision)
{
GameObject player = collision.gameObject;
vidaPlayer = player.GetComponent <Vida>();
vida = gameObject.GetComponent <Vida>();
//Comprobamos que el enemigo tiene vida
if (vida != null && vida.GetHealth() <= 0)
{
makeDamage = false;
}
if (makeDamage)
{
//Aplicamos animacion de KnockBack en caso de ser el player
if (player.GetComponentInChildren <PlayerMovement>() != null && produceKnockBack)
{
///Nos interesa que el jugador sea empujado a la derecha o izquierda en funcion de la pos del enemigo.
knockback = player.GetComponentInChildren <Knockback>();
//Detectamos la posicion del jugador respecto al enemigo
if (transform.position.x < collision.transform.position.x)
{
dirKnock = Vector2.right;
}
else
{
dirKnock = Vector2.left;
}
//Aplicamos el KnockBack
if (knockback != null && knockback.enabled)
{
knockback.Impulso(dirKnock, thrust.x, thrust.y);
}
}
//Reducimos su vida en cualquier caso
if (vidaPlayer != null && vidaPlayer.enabled)
{ //Hace daño al personaje en cuestión//
vidaPlayer.QuitaVida(danyo);
//Comprobamos que sea el jugador y le aplicamos daño e invulnerabilidad//
playerInv = player.GetComponent <Invulnerable>();
if (player != null && playerInv != null)
{
playerInv.enabled = true;
}
}
}
}
public void Bump(PhysicalObject bumper)
{
Vector2 Knockback = new Vector2();
Knockback = new Vector2(Hurtbox.Center.X - bumper.Hurtbox.Center.X, Math.Min(Hurtbox.Center.Y, bumper.Hurtbox.Center.Y) - bumper.Hurtbox.Center.Y);
if (Knockback == new Vector2(0, 0))
{
Knockback = new Vector2(0, -1);
}
Knockback.Normalize();
Knockback *= 10;
//if (!world.CheckCollision(Hurtbox, Knockback))
Velocity = Knockback;
}
public bool Casted()
{
Cooldown = TimeSpan.FromMilliseconds(FullCooldown.TotalMilliseconds);
var numMissiles = 10;
for (var i = 0; i < numMissiles; i++)
{
var direction = Being.Facing.Rotate(i * 360f / numMissiles);
var knockback = new Knockback(direction, TimeSpan.FromMilliseconds(250), 500f);
var damageInstance = new DamageInstance(knockback, 45f, DamageTypes.Fire, Being, AbilityTypes.SkeletonKingBlast);
Globals.GameState.Missiles.Add(new SkeletonKingMissile(Being, damageInstance, direction));
}
return(false);
}
protected override bool Execute()
{
var knockback = new Knockback(Being.Facing, AbilityConstants.FireballKnockbackLength, AbilityConstants.FireballKnockback);
var damage = AbilityConstants.FireballDamage * Being.SkillValue(SkillType.ImprovedFireball, true) *
Being.SkillValue(SkillType.FireMastery, true) *
Being.AbilityValue(AbilityUpgradeType.FireballDamage, true);
Globals.GameState.Missiles.Add(new FireballMissile(Being as Zerd,
new DamageInstance(knockback, damage, DamageTypes.Fire, Being, AbilityTypes.Fireball), Being.Position));
// replenish mana based on bonuses
Being.Mana += AbilityConstants.FireballManaCost *
(Being.AbilityValue(AbilityUpgradeType.FireballMana) / 100f);
Being.AddBuff(BuffTypes.BlazingSpeed);
return(base.Execute());
}
private void HandleKnockback(CharacterController2D controller)
{
Knockback knockback = new Knockback(KnockbackParameters);
knockback.HandleKnockback(controller, _velocity, gameObject);
}
public void setKnockBack(Knockback knockback)
{
if (unconscious) return;
this.playerKnockback = knockback;
}
//Item initialization for Sigil, Consumable and KeyItem
public void addItemInfo(int ID, string name, string desc, ItemType itemType)
{
this.itemID = ID;
this.itemName = name;
this.itemDesc = desc;
this.itemType = itemType;
this.damage = 0;
this.criticalChance = 0;
this.attackSpeed = 0;
this.range = 0;
this.knockback = 0;
this.weaponType = WeaponType.none;
this.damageMitigation = 0;
this.defense = 0;
}
public BullCharge()
{
Speed = 12;
InitDelay = 0.6f;
EffectiveDuration = 0.7f + InitDelay;
EffectiveRange = PerformableRange = (TotalDuration - InitDelay) * Speed;
Cooldown = 7;
WeightInc = 100000;
Damage = 240;
ApplyBuffToTargets = new Knockback
{
KnockbackStrength = 4,
ValidTargets = Targets.Enemies
};
ValidTargets = Targets.Enemies;
}
void Start()
{
rb = GetComponent<Rigidbody2D>();
velocity = rb.velocity;
//ignore all collisions between players
List<GameObject> all_players = GameObject.FindGameObjectsWithTag("PlayerObject").ToList();
for (int i = 0; i < all_players.Count; i++)
{
for (int j = 0; j < all_players.Count; j++)
{
if (all_players[i] != all_players[j])
{
Physics2D.IgnoreCollision(all_players[i].GetComponent<Collider2D>(), all_players[j].GetComponent<Collider2D>());
}
}
}
// Color ring around players
ring = transform.Find("Ring").gameObject.GetComponent<SpriteRenderer>();
ring.color = playerColor;
body = GetComponent<Rigidbody2D> ();
anim = GetComponent<Animator>();
playerKnockback = null;
held_item = null;
item_list = new List<Item> ();
locked = false;
speed_boost = 1.0f;
Audio = GetComponent<AudioSource> ();
}
public void setKnockBack(Knockback knockback)
{
playerKnockback = knockback;
if (anim.GetInteger ("PlayerState") == 1) playerKnockback=null;
}
public DemonLordCharge()
{
Speed = 12;
InitDelay = 0.6f;
EffectiveDuration = 1.3f;
EffectiveRange = PerformableRange = (EffectiveDuration) * Speed;
Cooldown = 15;
WeightInc = 100000;
Damage = 240;
ApplyBuffToTargets = new Knockback
{
KnockbackStrength = 4,
};
ValidTargets = Targets.Enemies;
}
void Start()
{
rb = GetComponent<Rigidbody2D>();
velocity = rb.velocity;
velocity_local = new Vector2(0, 0);
prev_position_local = transform.position;
// set PID to the count of players in scene
PID = GameObject.FindGameObjectsWithTag("Player").Length.ToString();
// if local player, set camera to focus
if (isLocalPlayer) gameObject.AddComponent<N_CameraController>();
//ignore all collisions between players
List<GameObject> all_players = GameObject.FindGameObjectsWithTag("Player").ToList();
for (int i = 0; i < all_players.Count; i++)
{
for (int j = 0; j < all_players.Count; j++)
{
if (all_players[i] != all_players[j])
{
Physics2D.IgnoreCollision(all_players[i].GetComponent<Collider2D>(), all_players[j].GetComponent<Collider2D>());
}
}
}
// Color ring around players
ring = transform.Find("Ring").gameObject.GetComponent<SpriteRenderer>();
switch (PID)
{
case "1": ring.color = new Color32(244, 67, 54, 255); break;
case "2": ring.color = new Color32(33, 150, 243, 255); break;
case "3": ring.color = new Color32(76, 175, 80, 255); break;
case "4": ring.color = new Color32(255, 235, 59, 255); break;
}
anim = GetComponent<Animator>();
anim.SetFloat("rangeSpeed", 3);
anim.SetFloat("meleeSpeed", 3);
playerKnockback = null;
}
