public ThrowingWeapon(Vector2f position, Vector2f direction, int damage, float attackSpeed)
{
displayComponent = new DisplayComponent(Config.HeroWeaponName);
displayComponent.Position = position;
moveComponent = new MoveComponent(displayComponent, Config.WeaponSpeed);
moveComponent.GetNextPosition_Event += MoveComponent_GetNextPosition;
moveComponent.CheckMove_Event += MoveComponent_CheckMove_Event;
healthComponent = new HealthComponent(Config.WeaponHealth);
healthComponent.Died += HealthComponent_Died;
damageComponent = new DamageComponent(damage, attackSpeed);
damageComponent.Attacked += DamageComponent_Attacked;
collisionComponent = new CollisionComponent(displayComponent, damageComponent, Config.WeaponCollisionRect, "player");
collisionComponent.OnCollisiton += CollisionComponent_OnCollisiton;
this.direction = direction;
Vector2f origin = displayComponent.Origin;
origin.X = displayComponent.Size.X / 2;
origin.Y = displayComponent.Size.Y / 2;
displayComponent.Origin = origin;
}
public virtual bool ReceiveAttack(AttackManager atkMngr)
{
if (atkMngr == null)
{
return(false);
}
OwnerComponent ownerComponent = atkMngr.GetAttackComponent <OwnerComponent>();
List <IAttacker> owners = ownerComponent.owners;
IAttacker thisAttacker = (this as IAttacker);
Entity destroyer = null;
foreach (IAttacker owner in owners)
{
if (owner is Entity e)
{
destroyer = e;
break;
}
}
if (thisAttacker != null && owners.Contains(thisAttacker))
{
return(false);
}
DamageComponent damageComponent = atkMngr.GetAttackComponent <DamageComponent>();
if (damageComponent != null)
{
float damage = damageComponent.DamageIncludingBonuses;
TakeDamage(damage, atkMngr.Position, destroyer, 1f, true);
}
return(true);
}
void Awake()
{
m_OverlappingMobs = new Dictionary <Mob, float>();
m_MobIsOverlapping = false;
m_damageComponent = gameObject.GetComponent <DamageComponent>();
m_powerTimer = 1.0f;
}
public virtual void DamageOtherCharacter(CharacterBase other, Vector2 dir)
{
//Debug.LogError(this.gameObject.name + "-->" + other.name + "===>" + simpleAttackDamage);
var damage = new DamageComponent()
{
fromUserId = userID, targetUserId = other.userID,
value = simpleAttackDamage, dir = new Dir2D(dir)
};
if (_isNet)
{
if (_isSelf)
{
//Send DamageEvent
FrameData frame = new FrameData()
{
dataType = DataType.Damage, data = damage
};
GameNetWork.Inst.SendFrameData(frame);
}
}
else
{
other.SetComponentData <DamageComponent>(damage);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Start()
{
m_CachedCameraRaycaster = Camera.main.GetComponent <CameraRayCaster>();
m_CachedMovementComponent = GetComponent <CharacterMovementComponent>();
m_CachedWeaponComponent = GetComponent <WeaponComponent>();
m_CachedDamageComponent = GetComponent <DamageComponent>();
m_CachedDamageComponent.SetCurrentTeam(CharacterTeamEnum.CharacterTeamEnum_Player);
}
public override void ApplyAbilityEffect()
{
DamageComponent ownerDamageComponent = gameObject.GetComponent <DamageComponent>();
if (ownerDamageComponent != null)
{
ownerDamageComponent.TakeHealing((m_AbilityConfig as HealAbilityConfig).GetHealAmount());
}
}
void ApplyTickDamageToTarget()
{
targetDamageComponent = m_AbilityCurrentTarget.GetComponent <DamageComponent>();
if (targetDamageComponent != null)
{
targetDamageComponent.TakeDamage(10);
}
}
void DamageEntity(DamageComponent _damageable)
{
if (_damageable == null)
{
return;
}
_damageable.Damage(damage_per_shot);
}
private void HandleDamage(DamageComponent damage)
{
try{
CheckIfDamagable(damage.Target);
damage.Target.ReplaceCurrentHealth(
damage.Target.currentHealth - damage.Value
);
}
catch {}
}
public void Damage(DamageComponent incomingDamage)
{
this.CurrentHitpoints -= incomingDamage.Damage;
if (this.CurrentHitpoints <= 0)
{
this.CurrentHitpoints = 0;
}
OnHealthPercentChanged(this.CurrentHitpoints / this.MaximumHitpoints);
}
public override void Execute(Spell spell, RollContext context)
{
context.GetCaster().OnSpellComponentCaster.Invoke(spell, context, this);
int dmg = GetValue();
GetTargets(context).ForEach(pawn => {
DamageComponent singleTarget = new DamageComponent(targetType, dmg);
pawn.OnSpellComponentTarget.Invoke(spell, context, singleTarget);
EventBus.DamageHealEvent damageEvent = new EventBus.DamageHealEvent(spell, singleTarget, singleTarget.GetValue());
pawn.CmdDamage(damageEvent);
});
}
public override void Initialize()
{
base.Initialize();
_mana = GetComponent <ManaComponent>();
_damage = GetComponent <DamageComponent>();
_resist = GetComponent <ResistComponent>();
_movingComponent = GetComponent <CharacterMovingComponent>();
_animator = GetComponent <Animator>();
_attackComponent = GetComponent <CharacterMeleeAttackComponent>();
_movingComponent.OnJump += SetJumpTrigger;
_attackComponent.OnAttack += SetAttackAnimation;
}
///////////////////////////////////////////////////////////////////////////////////////////////////////
void Start()
{
m_CachedPlayerGameObject = GameObject.FindGameObjectWithTag("Player");//Replace with static helper?
m_CachedMovementComponent = GetComponent <CharacterMovementComponent>();
m_CachedWeaponComponent = GetComponent <WeaponComponent>();
m_CachedAnimatorComponent = GetComponent <Animator>();
m_CachedDamageComponent = GetComponent <DamageComponent>();
m_CachedSpecialAbilityComponent = GetComponent <SpecialAbiltyComponent>();
m_CachedWeaponComponent.SetCurrentTarget(m_CachedPlayerGameObject);//Target will always be player
m_CurrentAIState = AIState.AIState_Idle;
m_CachedDamageComponent.SetCurrentTeam(CharacterTeamEnum.CharacterTeamEnum_AI);
}
public void HandleDamage(DamageComponent damage)
{
CharacterBase character = GameManager.Inst.GetCharacter(damage.targetUserId);
if (character != null)
{
character.SetComponentData <DamageComponent>(damage);
}
else
{
Debug.LogError("Damage cannot find targetCharacter id = " + damage.targetUserId);
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
public override void ApplyAbilityEffect()
{
GameObject abilityTarget = m_AbilityOwnerWeaponComponent.GetCurrentTarget();
if (abilityTarget != null)
{
float totalDamage = (m_AbilityConfig as PowerAttackConfig).GetPowerAttackDamage();
DamageComponent targetDamageComponent = abilityTarget.GetComponent <DamageComponent>();
targetDamageComponent.TakeDamage(totalDamage);
}
PlayAbilitySounds();
}
public void OnPathComplete()
{
m_IsDone = true;
DamageComponent damageComponent = GetComponent <DamageComponent>();
if (damageComponent != null)
{
damageComponent.enabled = false;
}
StartCoroutine(DeathAnim());
Game.Instance.LooseHouseHealth();
FindObjectOfType <House>().LooseHealth();
}
private void Update()
{
if (Input.GetMouseButtonDown(1))
{
if (_isSelf)
{
var damage = new DamageComponent()
{
fromUserId = 0, targetUserId = userID, value = simpleAttackDamage
};
SetComponentData <DamageComponent>(damage);
}
}
}
public void Start()
{
_playerInput = GetComponent <PlayerInput>();
_damageComponent = GetComponent <DamageComponent>();
/* Instantiated this way to allow more precise
* control over movement via polling. */
moveAction = _playerInput.actions["move"];
maxSpeed = maxWalkingSpeed;
walkingState = new PlayerWalkingState(this);
boostState = new PlayerBoostState(this);
fallState = new PlayerFallState(this);
idleState = new PlayerIdleState(this);
currentState = walkingState;
}
public void Setup(Vector3 end)
{
m_Start = transform.position;
m_End = end;
DamageComponent damageComponent = GetComponent <DamageComponent>();
if (damageComponent != null)
{
damageComponent.enabled = false;
}
BoxCollider[] colliders = GetComponentsInChildren <BoxCollider>();
foreach (BoxCollider collider in colliders)
{
collider.enabled = false;
}
}
public void Execute()
{
foreach (Entity e in _group.GetEntities())
{
HealthComponent health = e.health;
DamageComponent damage = e.damage;
health.health -= damage.damage;
if (health.health < 0)
{
e.isDestroyEntity = true;
e.isCollisionDeath = true;
}
e.RemoveDamage();
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
public override void ApplyAbilityEffect()
{
m_ZoneOfEffectCollisions = Physics.OverlapSphere(m_AbilityCurrentTarget.transform.position, 2f);
foreach (Collider currentCollider in m_ZoneOfEffectCollisions)
{
DamageComponent currentDamageComponent = currentCollider.gameObject.GetComponent <DamageComponent>();
CharacterMovementComponent currentMovementComponent = currentCollider.gameObject.GetComponent <CharacterMovementComponent>();
if (currentDamageComponent != null && currentMovementComponent != null)
{
if (m_AbilityOwnerDamageComponent.GetCurrentTeam() != currentDamageComponent.GetCurrentTeam())
{
AoeSlowAbilityConfig abilityConfig = m_AbilityConfig as AoeSlowAbilityConfig;
currentMovementComponent.ApplyMovementSpeedModifier(abilityConfig.GetAbilitySlowPercentage(), abilityConfig.GetAbilityDuration());
}
}
}
}
void ApplyDamage(Mob mobComponent)
{
if (!mobComponent)
{
return;
}
DamageComponent damageComponent = mobComponent.gameObject.GetComponent <DamageComponent>();
if (damageComponent)
{
damageComponent.TakeDamage(m_DamageOverTime, mobComponent.gameObject, GetDamageType());
}
if (!mobComponent)
{
m_OverlappingMobs.Remove(mobComponent);
}
}
private void Moving(GameObject facingTower)
{
if (m_Graphics != null)
{
m_GraphicsTimer += Time.deltaTime;
float sin = WiggleAmplitude * Mathf.Sin(WiggleSpeed * m_GraphicsTimer);
Quaternion quaternion = m_Graphics.rotation;
quaternion.eulerAngles = new Vector3(quaternion.eulerAngles.x, quaternion.eulerAngles.y, sin);
m_Graphics.rotation = quaternion;
}
DamageComponent damageComponent = GetComponent <DamageComponent>();
if (damageComponent != null)
{
damageComponent.enabled = true;
}
if (facingTower != null)
{
Tour facingTowerComponent = facingTower.GetComponent <Tour>();
if (facingTowerComponent)
{
if (facingTowerComponent.m_TourType == TourType.TourType_AOE)
{
return;
}
}
m_State = State.Attacking;
PathComponent pathComponent = GetComponent <PathComponent>();
if (pathComponent != null)
{
pathComponent.FollowPath = false;
}
Rigidbody rigidBody = GetComponent <Rigidbody>();
if (rigidBody != null)
{
rigidBody.isKinematic = true;
}
m_AttackTimer = AttackTime;
}
}
public override void ApplyAbilityEffect()
{
Vector3 center = m_AbilityOwner.transform.position;
float radius = m_AbilityConfig.GetAbilityMaxRange();
Collider[] hitColliders = Physics.OverlapSphere(center, radius);
DamageComponent abilityOwnerDamageComponent = m_AbilityOwner.GetComponent <DamageComponent>();
foreach (Collider hitcol in hitColliders)
{
DamageComponent hitDamageComponent = hitcol.gameObject.GetComponent <DamageComponent>();
if (hitDamageComponent != null && abilityOwnerDamageComponent != null &&
hitDamageComponent.GetCurrentTeam() != abilityOwnerDamageComponent.GetCurrentTeam())
{
hitDamageComponent.TakeDamage((m_AbilityConfig as CleaveAbilityConfig).GetCleaveDamage());
}
}
}
public virtual AttackManager Attack(float damageMultiplier, List <IAttacker> owners)
{
if (!ShouldAttack)
{
return(null);
}
AttackManager attack = SpawnAttack();
attack.SetData <OwnerComponent>(owners, true);
DamageComponent damageComponent = attack.GetAttackComponent <DamageComponent>();
if (damageComponent != null)
{
damageComponent.Multiply(DamageMultiplier);
}
cooldownComponent.SetValue(CooldownDuration);
owners.ForEach(t => t.ReceiveRecoveryDuration(recoveryDuration));
AudioMngr.PlaySFX(clip, transform.position, null);
return(attack);
}
public override void Start()
{
engineComponent = FindObjectOfType <EngineComponent>();
aimingComponent = FindObjectOfType <AimingComponent>();
damageComponent = FindObjectOfType <DamageComponent>();
aimingComponent.PropertyChanged += (sender, args) =>
playerGun.ShootingAbility.shootingPeriodCoefficient = aimingComponent.Value;
damageComponent.PropertyChanged += (sender, args) =>
playerGun.ShootingAbility.bullet.damageCoefficient = damageComponent.Value;
rb = GetComponent <Rigidbody2D>();
playerCollider = GetComponent <Collider2D>();
playerGun = GetComponentInChildren <GunController>();
damagePart = Vars.GetCarPart(PartType.Damage);
shootingPart = Vars.GetCarPart(PartType.Shooting);
armorPart = Vars.GetCarPart(PartType.Armor);
enginePart = Vars.GetCarPart(PartType.Engine);
base.Start();
StartCoroutine(ApplyParts());
}
private void Attacking(GameObject facingTower)
{
if (m_Graphics != null)
{
m_Graphics.transform.rotation = Quaternion.Slerp(m_Graphics.transform.rotation, Quaternion.identity, 3.0f * Time.deltaTime);
}
m_AttackTimer -= Time.deltaTime;
if (m_AttackTimer < 0)
{
if (facingTower != null)
{
m_AttackTimer = AttackTime;
DamageComponent damageComponent = facingTower.GetComponent <DamageComponent>();
if (damageComponent != null)
{
damageComponent.TakeDamage(AttackDamage, gameObject, DamageType.Mob);
}
}
}
if (facingTower == null)
{
m_State = State.Moving;
PathComponent pathComponent = GetComponent <PathComponent>();
if (pathComponent != null)
{
pathComponent.FollowPath = true;
}
Rigidbody rigidBody = GetComponent <Rigidbody>();
if (rigidBody != null)
{
rigidBody.isKinematic = false;
}
}
}
private void Spawning()
{
m_SpawnTimer -= Time.deltaTime;
Rigidbody rigidbody = GetComponent <Rigidbody>();
if (rigidbody != null)
{
rigidbody.MovePosition(Vector3.Lerp(m_End, m_Start, m_SpawnTimer / SpawnTime));
}
if (m_SpawnTimer < 0)
{
m_State = State.Moving;
transform.position = m_End;
if (rigidbody != null)
{
rigidbody.position = m_End;
}
PathComponent pathComponent = GetComponent <PathComponent>();
if (pathComponent != null)
{
pathComponent.FollowPath = true;
}
DamageComponent damageComponent = GetComponent <DamageComponent>();
if (damageComponent != null)
{
damageComponent.enabled = true;
}
BoxCollider[] colliders = GetComponentsInChildren <BoxCollider>();
foreach (BoxCollider collider in colliders)
{
collider.enabled = true;
}
}
}
private void ProcessCollision(Collider collider)
{
DamageComponent damageComponent = collider.GetComponent <DamageComponent>();
if (damageComponent == null && collider.transform.parent != null)
{
damageComponent = collider.transform.parent.GetComponent <DamageComponent>();
}
if (damageComponent != null)
{
Mob mob = collider.GetComponent <Mob>();
if (mob == null || !mob.IsSpawning)
{
damageComponent.TakeDamage(Damage, gameObject, DamageType);
}
}
m_CurrentPiercingCount--;
if (m_CurrentPiercingCount <= 0)
{
Destroy(gameObject);
}
}
void Update()
{
transform.position += Vector3.left * Speed * Time.deltaTime;
if (transform.position.x <= KillX)
{
Destroy(gameObject);
return;
}
Tour[] towers = FindObjectsOfType <Tour>();
foreach (Tour tower in towers)
{
if (tower.transform.position.x >= transform.position.x &&
tower.transform.position.x <= transform.position.x + 1 &&
!tower.IsProtectedFromWolf())
{
DamageComponent damageComponent = tower.GetComponent <DamageComponent>();
if (damageComponent != null)
{
damageComponent.TakeDamage(1000, gameObject, DamageType.Wolf);
}
}
}
}
