public void AfterTakedInitialize(IEnemy target, DamageMessage damage)
{
this.Target = target;
this.DamageMessage = damage;
SetLinePosition(this.DamageMessage.Damager.position, this.Target.Transform.position);
this.StartMagicBall.position = this.DamageMessage.Damager.position;
}
public void FillLifeLostEventData(Damageable damageable, DamageMessage enemyData)
{
LayerMask playerMask = LayerMask.NameToLayer("Player");
if (damageable.gameObject.layer == playerMask)
{
LifeLostEvent newLifeLostEvent = new LifeLostEvent();
newLifeLostEvent.pdata = playerData;
newLifeLostEvent.eventID = ++evendIdCount;
newLifeLostEvent.position = damageable.gameObject.GetComponent <Transform>().position;
if (enemyData.damager.gameObject.name == "Spitter")
{
newLifeLostEvent.enemyType = "Spitter";
}
else if (enemyData.damager.GetComponent <GrenadierGrenade>())
{
newLifeLostEvent.enemyType = "Spitter";
}
else if (enemyData.damager.gameObject.transform.parent.gameObject.name == "Chomper")
{
newLifeLostEvent.enemyType = "Chomper";
}
newLifeLostEvent.timeStamp = Time.time;
lifeLostEvents.events.Add(newLifeLostEvent);
}
}
public void CheckToUpdateHealthMeter(DamageMessage damageData)
{
Debug.Log("Checking player's health meter, " + damageData.amount);
if (damageData.victim == player.health)
{
healthCounter.text = player.health.values.current.ToString();
FillMeter(healthBar, player.health.values.current, player.health.values.max);
if (player.health.values.IsCritical)
{
healthCounter.color = resourceCriticalColour;
// Do other stuff for critical health e.g. greyscale screen, warnings
}
else
{
healthCounter.color = resourceNormalColour;
}
/*
* if (damageData.amount > 0)
* {
*
* }
*/
}
}
void OnCollisionEnter(Collision col)
{
if (col.gameObject.name == "Ground")
{
Enemylist = GameObject.FindGameObjectsWithTag("Enemy");
foreach (GameObject Enemy in Enemylist)
{
var target = Enemy.GetComponent <LivingEntity>();
if (Enemy.GetComponent <Transform>().position.y > 1)
{
continue;
}
distance = (Enemy.GetComponent <Transform>().position - transform.position).magnitude;
if (distance < range)
{
Debug.Log(Enemy.name);
// ContactPoint contact = col.contacts[0];
var message = new DamageMessage();
message.amount = damage;
message.damager = gameObject;
message.hitPoint = target.transform.position;
message.hitNormal = transform.position - target.transform.position;
// Quaternion rot = Quaternion.FromToRotation(Vector3.up, contact.norm);
target.ApplyDamage(message);
}
}
Instantiate(effect, transform.position, Quaternion.identity);
Destroy(this.gameObject);
}
}
public void ApplyDamage(DamageMessage data)
{
// Ignore any damage. It is already dead
if (currentHitPoints <= 0)
{
return;
}
// Decrease the hit points
currentHitPoints -= data.amount;
// If hitpoints <= 0, then dead
// otherwise object receives damage
// Get the message type
var messageType = currentHitPoints <= 0 ? MessageType.DEAD : MessageType.DAMAGED;
// Notify the object with a message
for (int i = 0; i < onDamageMessageReceivers.Count; i++)
{
var receiver = onDamageMessageReceivers[i] as IMessageReceiver;
// Apply the message type and data (damage) to this object...
receiver.OnReceiveMessage(messageType, this, data);
}
}
void combo1()
{
gizmoColor = Color.black;
float timerCombo = timerAttack1 + timerAttack2;
bool attacked1 = attacked;
if (seconds < timerCombo)
{
seconds += Time.deltaTime;
if (seconds <= 0.3 * timerCombo)
{
//Attack1
Debug.Log("Combo 1");
DamageMessage m = new DamageMessage(transform, player, typeof(life), 10);
MessageManager.get().SendMessage(m);
attacked1 = true;
}
else if (seconds >= 0.5f * timerCombo || attacked1)
{
Debug.Log("Combo 2");
DamageMessage m = new DamageMessage(transform, player, typeof(life), 20);
MessageManager.get().SendMessage(m);
attacked = true;
//Attack2
}
}
else if (seconds >= timerCombo || attacked)
{
Debug.Log("Going idle battle combo");
setState(getState("battle"));
}
}
private void FixedUpdate()
{
if (dead)
{
return;
}
// 공격이 아직 안들어감 공격이 들어가는중(애니메이션에 의해 통제됨
if (state == State.AttackBegin || state == State.Attacking)
{
//공격시작이거나 공격중이라면 적이 바라보는 방향은 플레이어가 되어야함
var lookRotation = Quaternion.LookRotation(targetEntity.transform.position - transform.position);
var targetAngleY = lookRotation.eulerAngles.y;
//타켓을 바라보게 할때 부드럽게 턴하기 위함
targetAngleY = Mathf.SmoothDampAngle(transform.eulerAngles.y, targetAngleY, ref turnSmoothVelocity, turnSmoothTime);
transform.eulerAngles = Vector3.up * targetAngleY;
}
if (state == State.Attacking)
{
var direction = transform.forward;
var deltaDistance = agent.velocity.magnitude * Time.deltaTime;//Time.deltaTime동안 움직이게될 거리를 계산
//Sphere의 시작 지점부터 어떤 거리만큼 이동한다 했을때 그 사이에 있는 콜라이더를 반환함(SphereCast,SphereCastAll)
//NonAlloc은 콜라이더의 개수가 몇개인지를 반환
var size = Physics.SphereCastNonAlloc(attackRoot.position, attackRadius,
direction, hits, deltaDistance, whatIsTarget);
for (var i = 0; i < size; i++)
{
var attackTargetEntity = hits[i].collider.GetComponent <LivingEntity>();
if (attackTargetEntity != null && !lastAttackedTargets.Contains(attackTargetEntity))//공격 중에 중복공격을 막기위함
{
var message = new DamageMessage();
message.amount = damage;
message.damager = gameObject;
message.hitPoint = hits[i].point;
if (hits[i].distance <= 0f)
{
message.hitPoint = attackRoot.position;
}
else
{
message.hitPoint = hits[i].point;
}
message.hitNormal = hits[i].normal;
attackTargetEntity.ApplyDamage(message);
lastAttackedTargets.Add(attackTargetEntity);
break;
}
}
}
}
public static void Transmit(DamageMessage message)
{
if (OnDamage != null)
{
OnDamage.Invoke(message);
}
}
public void HandleMessage(DamageMessage m)
{
dmg = m;
receviedDMG = true;
Debug.Log ("get msg");
}
public void ApplyDamage(DamageMessage data)
{
if (currentHitPoints <= 0)
{
return;
}
if (isInvulnerable)
{
return;
}
isInvulnerable = true;
currentHitPoints -= data.amount;
if (currentHitPoints <= 0)
{
myEvent += OnDeath.Invoke;
}
else
{
OnHit.Invoke();
}
var messageType = currentHitPoints <= 0 ? MessageType.DEAD : MessageType.DAMAGED;
for (var i = 0; i < onDamageMessageReceivers.Count; ++i)
{
var receiver = onDamageMessageReceivers[i] as IMessageReceiver;
receiver.OnReceiveMessage(messageType, this, data);
}
}
void OnDamaged(DamageMessage msg)
{
float receivedDamage = msg.damage;
Vector2 repelForce = msg.repelForce;
if (!isInvincible)
{
// take damage
gm.playerStatus.currentHp -= receivedDamage;
isInvincible = true;
isTransparent = true;
invincibleCountdown = gm.playerStatus.invincibleDuration;
spriteBlinkCountdown = spriteBlinkDuration;
// repel from enemy
rb2d.velocity = new Vector2(0f, 0f);
rb2d.AddForce(repelForce, ForceMode2D.Impulse);
}
if (gm.playerStatus.currentHp <= 0)
{
Instantiate(pm.explosionType, transform.position, transform.rotation);
LevelManager lm = GameObject.Find("LevelManager").GetComponent <LevelManager>();
lm.EnableRestartBtn();
transform.position = new Vector2(0, 0);
transform.rotation = new Quaternion(0, 0, 0, 0);
lm.DevpKillEnemy();
lm.SetBtnIsActive(false);
}
}
public void FillDeathEventData(Damageable damageable, DamageMessage enemyData)
{
LayerMask enemyMask = LayerMask.NameToLayer("Enemy");
LayerMask environmentMask = LayerMask.NameToLayer("Environment");
if (enemyData.damager.gameObject.layer == enemyMask || enemyData.damager.gameObject.layer == environmentMask || enemyData.damager.GetComponent <GrenadierGrenade>() || enemyData.damager.transform.parent.gameObject.layer == enemyMask)
{
DeathEvent newDeathEvent = new DeathEvent();
newDeathEvent.pdata = playerData;
newDeathEvent.eventID = ++evendIdCount;
newDeathEvent.position = damageable.gameObject.GetComponent <Transform>().position;
newDeathEvent.rotation = damageable.gameObject.GetComponent <Transform>().rotation;
if (enemyData.damager.gameObject.name == "Spitter")
{
newDeathEvent.enemyType = "Spitter";
}
else if (enemyData.damager.gameObject.name == "Acid")
{
newDeathEvent.enemyType = "Acid";
}
else if (enemyData.damager.GetComponent <GrenadierGrenade>())
{
newDeathEvent.enemyType = "Spitter";
}
else
{
newDeathEvent.enemyType = "Chomper";
}
newDeathEvent.timeStamp = Time.time;
deathEvents.events.Add(newDeathEvent);
}
}
public void OnNetworkDamageMessage(DamageMessage m)
{
if (this.myPlayerNumber == m.targetPlayer)
{
this.health = m.health;
}
}
private void FixedUpdate()
{
if (dead)
{
return;
}
//대상을 바라보게 하는 코드
if (state == State.AttackBegin || state == State.Attacking)
{
var lookRotation = Quaternion.LookRotation(targetEntity.transform.position - transform.position);
//y축회전만 고려
//스르륵 바라보기
var targetAngleY = lookRotation.eulerAngles.y;
targetAngleY = Mathf.SmoothDampAngle(transform.eulerAngles.y,
targetAngleY, ref turnSmoothVelocity, turnSmoothTime);
transform.eulerAngles = Vector3.up * targetAngleY;
}
//공격궤적. 타임안에 들어오면 감지
if (state == State.Attacking)
{
var direction = transform.forward;
var deltaDistance = agent.velocity.magnitude * Time.deltaTime;
//감지 정확도 높이기
var size = Physics.SphereCastNonAlloc(attackRoot.position,
attackRadius, direction, hits, deltaDistance, whatIsTarget);
//Debug.Log("Stone size: "+size);
//실제 damage주는 코드
for (var i = 0; i < size; i++)
{
var attackTargetEntity = hits[i].collider.GetComponent <LivingEntity>();
//Debug.Log("Stone's attackTargetEntity: " + attackTargetEntity);
if (attackTargetEntity != null && !lastAttackedTargets.Contains(attackTargetEntity))
{
var message = new DamageMessage();
message.amount = damage;
message.damager = gameObject;
if (hits[i].distance <= 0f)
{
message.hitPoint = attackRoot.position;
}
else
{
message.hitPoint = hits[i].point;
}
message.hitNormal = hits[i].normal;
attackTargetEntity.ApplyDamage(message);
lastAttackedTargets.Add(attackTargetEntity);
break;
}
}
}
}
public void DamageRecieve(DamageMessage message)
{
rigidbody.AddForce(message.damageForce * message.damageDirection);
missileHealth -= message.damage;
if (missileHealth <= 0)
Abort();
}
void OnTriggerEnter2D(Collider2D other)
{
if (!other.isTrigger && other.CompareTag("Enemy"))
{
DamageMessage msg = new DamageMessage(damage);
other.SendMessageUpwards("OnDamaged", msg);
}
}
public void OnMessage(DamageMessage damageMsg)
{
HP -= damageMsg.PhysicalDamage + damageMsg.MagicalDamage;
Debug.Log("Damaged");
var dir = Vector3.Scale(transform.position - damageMsg.Sender.transform.position, new Vector3(1, 0, 1));
GetComponent <SkillController>().MovementSkill.KnockBack(dir.normalized * damageMsg.KnockBack);
}
public void CheckForHitMarker(DamageMessage message)
{
if (message.attacker == player && message.victim != player)
{
Debug.Log("Damaged enemy on frame " + Time.frameCount);
damageEffect.Invoke();
}
}
public override void Dispatch(Message m)
{
DamageMessage mD = ((DamageMessage)m);
life -= mD.damage;
mD.sender.gameObject.SetActive(false);
}
void OnTriggerEnter2D(Collider2D other)
{
if (!other.isTrigger && other.CompareTag("Enemy"))
{
Debug.Log("Sword wind hits enemy!");
DamageMessage msg = new DamageMessage(gm.weaponStatus.chargeSwordDamage);
other.SendMessageUpwards("OnDamaged", msg, SendMessageOptions.DontRequireReceiver);
}
}
public override bool ApplyDamage(DamageMessage damageMessage)
{
if (!base.ApplyDamage(damageMessage))
{
return(false);
}
healthSlider.value = health;
return(true);
}
// Update is called once per frame
void Update()
{
if (Input.GetKeyDown(KeyCode.Q))
{
DamageMessage m = new DamageMessage(transform, transform, typeof(life), 10);
MessageManager.get().SendMessage(m);
}
}
protected override void FireRound(Vector3 _, Transform __)
{
var shot = Instantiate(ProjectilePrefab, Muzzle.transform.position, transform.rotation);
shot.Launch(DamageMessage.Create(Stats.Damage, Stats.DamageTypes));
Animator.SetTrigger("Fire");
Muzzle.Play();
FireSfx.Play();
}
public override bool ApplyDamage(DamageMessage damageMessage)
{
if (!base.ApplyDamage(damageMessage))
{
return(false);
}
return(true);
}
/// <summary>
/// Called when the effect is meant to be deactivated
/// </summary>
public override void Deactivate()
{
if (mMessage != null)
{
mMessage.Release();
mMessage = null;
}
base.Deactivate();
}
public override bool ApplyDamage(DamageMessage damageMessage)
{
Debug.Log("TowerHealth: " + health);
if (!base.ApplyDamage(damageMessage))
{
return(false);
}
healthSlider.value = health;
return(true);
}
private void Shot(Vector3 startPoint, Vector3 direction)
{
// 레이캐스트에 의한 충돌 정보를 저장하는 컨테이너
RaycastHit hit;
// 총알이 맞은 곳을 저장할 변수
var hitPosition = Vector3.zero;
// 레이캐스트(시작지점, 방향, 충돌 정보 컨테이너, 사정거리)
if (Physics.Raycast(startPoint, direction, out hit, fireDistance, ~excludeTarget))
{
// 레이가 어떤 물체와 충돌한 경우
// 충돌한 상대방으로부터 IDamageable 오브젝트를 가져오기 시도
var target =
hit.collider.GetComponent <IDamageable>();
// 상대방으로 부터 IDamageable 오브젝트를 가져오는데 성공했다면
if (target != null)
{
DamageMessage damageMessage = null;
damageMessage.damager = gunHolder.gameObject;
damageMessage.amount = damage;
damageMessage.hitPoint = hit.point;
damageMessage.hitNormal = hit.normal;
// 상대방의 OnDamage 함수를 실행시켜서 상대방에게 데미지 주기
target.ApplyDamage(damageMessage);
}
else
{
//EffectManager.Instance.PlayHitEffect(hit.point, hit.normal, hit.transform);
}
// 레이가 충돌한 위치 저장
hitPosition = hit.point;
}
else
{
// 레이가 다른 물체와 충돌하지 않았다면
// 총알이 최대 사정거리까지 날아갔을때의 위치를 충돌 위치로 사용
hitPosition = startPoint + direction * fireDistance;
}
// 발사 이펙트 재생 시작
StartCoroutine(ShotEffect(hitPosition));
// 남은 탄환의 수를 -1
magAmmo--;
if (magAmmo <= 0)
{
// 탄창에 남은 탄약이 없다면, 총의 현재 상태를 Empty으로 갱신
state = State.Empty;
}
}
public int Damage(DamageMessage damage)
{
if (damage.buffadd != null)
{
for (int i = 0; i < damage.buffadd.Count; i++)
{
BuffManager(damage.buffadd[i], damage.buff[i]);
}
}
return(Hit(damage.hit));
}
public void Damage(DamageMessage damage)
{
if (damage.Types.Contains(DamageType.Fragmentation))
{
AttachedHealth.ReceiveDamage(DamageMessage.Create(damage, DamageMultiplier * FgramentationDamageMultiplier));
}
else
{
AttachedHealth.ReceiveDamage(damage);
}
}
/// <summary>
/// Used to test if the reactor should process
/// </summary>
/// <returns></returns>
public override bool TestActivate(IMessage rMessage)
{
if (!base.TestActivate(rMessage))
{
return(false);
}
if (mActorCore == null || !mActorCore.IsAlive)
{
return(false);
}
DamageMessage lDamageMessage = rMessage as DamageMessage;
if (lDamageMessage == null)
{
return(false);
}
if (lDamageMessage.Damage == 0f)
{
return(false);
}
if (lDamageMessage.ID != 0)
{
if (lDamageMessage.ID == CombatMessage.MSG_DEFENDER_KILLED)
{
return(false);
}
if (lDamageMessage.ID != CombatMessage.MSG_DEFENDER_ATTACKED)
{
return(false);
}
}
CombatMessage lCombatMessage = rMessage as CombatMessage;
if (lCombatMessage != null && lCombatMessage.Defender.transform.root.gameObject != mActorCore.gameObject)
{
return(false);
}
mDamageHandler = lCombatMessage.Defender.GetComponent <IDamageHandler>();
if (mDamageHandler == null)
{
Debug.LogError(mOwner + " recieved a damage message with a hit on " + lCombatMessage.Defender.transform + " but there is no IDamageHandler attached. Damage is ignored.");
return(false);
}
mMessage = lDamageMessage;
return(true);
}
public override void Dispatch(Message m)
{
DamageMessage mDmgMessage = ((DamageMessage)m);
Life -= mDmgMessage.Damage;
if (Life <= 0)
{
gameObject.SetActive(false);
}
}
/// <summary>
/// Tells the actor to die and triggers any effects or animations.
/// </summary>
/// <param name="rMessage">Message that defines the damage that is taken.</param>
public virtual void OnKilled(DamageMessage rMessage)
{
IsAlive = false;
if (AttributeSource != null && HealthID.Length > 0)
{
AttributeSource.SetAttributeValue(HealthID, 0f);
}
StartCoroutine(InternalDeath(rMessage));
}
public void DamageRecieve(DamageMessage message)
{
// Don't allow player to hit player and AI to hit AI
if (message.hasShip && message.player != null)
{
bool isPlayer = false;
if (this is PlayerShip)
isPlayer = true;
if (isPlayer == message.player)
return;
}
rigidbody.AddForce(message.damageForce * message.damageDirection);
CalculateDamages(message);
}
void CalculateDamages(DamageMessage message)
{
float damageLeft = message.damage;
float shieldChange = 0;
float armorChange = 0;
float structureChange = 0;
if (attributes.shieldHealth > 0 && damageLeft > 0)
{
shieldChange = DamageModifier(damageLeft, message.bias, Weapon.DamageBias.SHIELD);
attributes.shieldHealth -= shieldChange;
damageLeft -= attributes.shieldHealth;
if (attributes.shieldHealth < 0)
attributes.shieldHealth = 0;
}
if (attributes.armorHealth > 0 && damageLeft > 0)
{
armorChange = DamageModifier(damageLeft, message.bias, Weapon.DamageBias.ARMOR);
attributes.armorHealth -= armorChange;
damageLeft -= attributes.armorHealth;
if (attributes.armorHealth < 0)
attributes.armorHealth = 0;
}
if (attributes.structureHealth > 0 && damageLeft > 0)
{
////Debug.Log(attributes.structureHealth + " Ship Before: " + name);
structureChange = DamageModifier(damageLeft, message.bias, Weapon.DamageBias.HULL);
attributes.structureHealth -= structureChange;
damageLeft -= attributes.structureHealth;
////Debug.Log(attributes.structureHealth + " Ship After: " + name);
if (attributes.structureHealth <= 0 && photonView.isMine)
{
DestroyShip();
return;
}
}
CalculateHealth();
photonView.RPC("DamageSyncRPC", PhotonTargets.Others, message.viewID, shieldChange, armorChange, structureChange, health);
if (message.owner != null && message.owner.gameObject != null)
AddAggressors(message.owner.gameObject);
}
private void OnDamage(DamageMessage damage)
{
_state = State.Hurt;
_hurtTimer = 1f;
}
