// Update is called once per frame void Update() { m_attackTimer += Time.deltaTime; if (m_launcher) { GetComponent<LineRenderer>().SetPosition(0, m_launcher.transform.position); GetComponent<LineRenderer>().SetPosition(1, m_launcher.transform.position + (m_launcher.transform.forward * beamLength)); RaycastHit hit; if (Physics.Raycast(m_launcher.transform.position, m_launcher.transform.forward, out hit, beamLength)) { if (hit.transform.gameObject == m_target) { if (m_attackTimer >= m_attackSpeed) { DamageData dmgData = new DamageData(); dmgData.damage = m_damage; MessageHandler msgHandler = m_target.GetComponent<MessageHandler>(); if (msgHandler) { msgHandler.GiveMessage(MessageType.DAMAGED, m_launcher, dmgData); } m_attackTimer = 0.0f; } } } } }
/// <summary> /// Applies explosion damage to a list of found colliders, but makes sure to apply damage only once to the same gameobject. /// </summary> /// <param name="colliders"></param> /// <param name="amount"></param> /// <param name="damageType"></param> /// <param name="inflictor"></param> public static void ApplyExplosionDamage(Collider[] colliders, int amount, DamageType damageType = DamageType.Explosion, GameObject inflictor = null) { List<GameObject> seen = new List<GameObject>(); DamageData dm = new DamageData(amount, damageType, inflictor); IDamagable[] damagables; IDamagable[] rigidBodyDamagables; foreach (Collider coll in colliders) { if (seen.Contains(coll.gameObject)) continue; seen.Add(coll.gameObject); // avoid applying damage twice to the IDamagable components on the same game object damagables = coll.GetComponents(typeof (IDamagable)).Cast<IDamagable>().ToArray(); Array.ForEach(damagables, damagable => damagable.TakeDamage(dm)); ; // Also apply damage to rigidbody of this collider, but only if they're different gameobjects (otherwise we already did) if (coll.attachedRigidbody != null && !seen.Contains(coll.attachedRigidbody.gameObject)) { seen.Add(coll.attachedRigidbody.gameObject); rigidBodyDamagables = coll.attachedRigidbody.GetComponents(typeof(IDamagable)).Cast<IDamagable>().ToArray(); Array.ForEach(rigidBodyDamagables, damagable => damagable.TakeDamage(dm)); } } }
public override void SetDamageData(DamageData damage) { damage.Damage *= DamageModifier; damage.Sources |= Entity.Groups; damage.Types |= DamageTypes; this.damage = damage; }
public override void SetDamageData(DamageData damage) { base.SetDamageData(damage); this.damage.Sources = damage.Sources; this.damage.Types = damage.Types; }
public override void SetDamageData(DamageData damage) { var time = Entity.GetComponent<TimeComponent>(); damage.Damage *= DamageModifier * time.DeltaTime; damage.Types |= DamageTypes.Laser; this.damage = damage; }
protected virtual void OnDamaged(DamageData damage) { CurrentHealth -= damage.Damage; if (!died && CurrentHealth <= 0) { died = true; Entity.SendMessage(EntityMessages.OnDie); } }
public virtual bool Damage(DamageData damage) { if (CanBeDamagedBy(damage)) { Entity.SendMessage(EntityMessages.OnDamaged, damage); return true; } else return false; }
public void transmitDamage(Transform damageTarget, DamageData damage) { if (damageTarget.GetComponent<DamageReceiver>()) { damageTarget.GetComponent<DamageReceiver>().getDamage(damage); } else { GameObject delay = Resources.Load("Prefabs/Objects/Effects/CommonImpactExplosion") as GameObject; Object.Instantiate(delay, this.HittedPoint, this.DirectionRotation * Quaternion.Euler(-180, 0, 0)); } }
/// <summary> /// Apply damage to collider if it, or its rigidbody, has an IDamagable derived component. /// </summary> /// <param name="coll"></param> /// <param name="amount"></param> /// <param name="damageType"></param> /// <param name="inflictor"></param> public static void ApplyTo(Collider coll, int amount, DamageType damageType, GameObject inflictor) { IDamagable[] damagables = coll.GetComponents(typeof(IDamagable)).Cast<IDamagable>().ToArray(); DamageData dm = new DamageData(amount, damageType, inflictor); Array.ForEach(damagables, damagable => damagable.TakeDamage(dm)); // Also apply damage to rigidbody of this collider, but only if they're different gameobjects (otherwise we already did) if (coll.attachedRigidbody != null && coll.gameObject != coll.attachedRigidbody.gameObject) { IDamagable[] rigidBodyDamagables = coll.attachedRigidbody.GetComponents(typeof(IDamagable)).Cast<IDamagable>().ToArray(); Array.ForEach(rigidBodyDamagables, damagable => damagable.TakeDamage(dm)); } }
// Use this for initialization void Start() { rcasting = new RayCasting(); damageData = new DamageData(damage); if (burrelPoint == null) { Debug.LogError("Gun Burrel Point is not recognized"); burrelPoint = this.gameObject.transform; } gunflame = burrelPoint.GetComponent<ParticleSystem>(); }
// Use this for initialization public ServerDamage() { functionName = "Damage"; // Database tables name tableName = "damage_type"; functionTitle = "Damage Configuration"; loadButtonLabel = "Load Damage"; notLoadedText = "No Damage loaded."; // Init dataRegister = new Dictionary<int, DamageData> (); editingDisplay = new DamageData (); originalDisplay = new DamageData (); }
private void CopyData(DamageData source, DamageData destination) { destination.soundname = source.soundname; destination.cStart = source.cStart; destination.cEnd = source.cEnd; destination.ownerID = source.ownerID; destination.Xflipped = source.Xflipped; destination.effectspawn = source.effectspawn; destination.amount = source.amount; destination.type = source.type; destination.knockback_y = source.knockback_y; destination.knockback_x = source.knockback_x; destination.effect = source.effect; destination.stun = source.stun; destination.blockstun = source.blockstun; }
private void CopyData(DamageData source, DamageData destination) { destination.soundname = source.soundname; destination.cStart = source.cStart; destination.cEnd = source.cEnd; destination.ownerID = source.ownerID; destination.Xflipped = source.Xflipped; destination.effectspawn = source.effectspawn; destination.amount = source.amount; destination.type = source.type; destination.knockback_y = source.knockback_y; destination.knockback_x = source.knockback_x; destination.effect = source.effect; destination.stun = source.stun; destination.blockstun = source.blockstun; }
public void SetDamageShow(DamageData damageData, Vector3 orgPos) { showDamage = 0; plusDamage = damageData.damage; speedRatio = Random.Range(0.5f, 1.2f); plusSpeed = damageData.damage / speedRatio; seType = SpecailEffectType.Damage; showTime = 0.5f; damageTxtIdx = System.Convert.ToInt32(damageData.isCrt); damageTxt[damageTxtIdx].GetComponent <TweenPostion>().SetJump(orgPos, orgPos + Vector3.right * Random.Range(-50, 50), speedRatio); damageTxt [damageTxtIdx].color = Const.attriColor [damageData.attributes]; setComplete = true; isRun = false; isShowDamage = false; }
public void TakeDamage(DamageData damageData) { var value = damageData.damage_ammount; var armorPiercing = damageData.armorPiercing; if (armorPiercing == false) { value = value - armor; } currentHealth -= value; if (currentHealth < 0) { currentHealth = 0; } }
private void ApplyDamage(DamageData date) { animator.SetTrigger(hashHit); Vector3 damageVec = date.direction; damageVec.y = 0; damageVec = damageVec.normalized; Vector3 localHurtDir = this.transform.InverseTransformDirection(damageVec); animator.SetFloat(hashHitFromX, localHurtDir.x); animator.SetFloat(hashHitFromY, localHurtDir.z); CameraShake.Shake(hitShakeRadius, hitShakeTime); }
protected override AttackResult DoAttackMonster(Character p_attacker, Monster p_target, Single p_magicPower) { if (p_target != null) { Single criticalMagicHitChance = p_attacker.FightValues.CriticalMagicHitChance; Single magicalCriticalDamageMod = p_attacker.FightValues.MagicalCriticalDamageMod; List <Damage> list = new List <Damage>(); Int32 num = Convert.ToInt32(Math.Round(p_target.CurrentHealth * m_staticData.Damage[0].Minimum / 100f, MidpointRounding.AwayFromZero)); DamageData p_data = new DamageData(EDamageType.EARTH, num, num); list.Add(Damage.Create(p_data, magicalCriticalDamageMod)); Attack p_attack = new Attack(0f, criticalMagicHitChance, list); EDamageType p_damageType = ESkillIDToEDamageType(m_staticData.SkillID); return(p_target.CombatHandler.AttackMonster(p_attacker, p_attack, false, true, p_damageType, true, p_attacker.SkillHandler.GetResistanceIgnoreValue(m_staticData.SkillID))); } return(null); }
// public bool Deserialize(ref DamageData element) { if (GetDataSize() == 0) { // 데이터가 설정되어 있지 않습니다. return(false); } bool ret = true; ret &= Deserialize(ref element.target, DamageData.characterNameLength); ret &= Deserialize(ref element.attacker); ret &= Deserialize(ref element.damage); return(ret); }
public void TakeDamage(DamageData dd) { float shieldBlock = 0f; if (shieldOn) { //shieldBlock = hardwareShield.GetComponent<Shield>().GetShieldBlock(); } dd.armorvalue = shieldBlock; dd.defense = 0f; float take = Const.a.GetDamageTakeAmount(dd); hm.health -= take; PlayerNoise.PlayOneShot(PainSFXClip); //Debug.Log("Player Health: " + health.ToString()); }
public void ApplyDamage(DamageData data) { if (InvalidTimer <= 0.0f && data.Attacker.GetAttackerType() != Status.AttackerType) { InvalidTimer = InvalidTime; if (tag == "Player") { Counter.Instance.Attacked(); } else { Counter.Instance.Attack(); } } }
public void OnHit(DamageData dd) { Tile moveTo = dd.target.Tile; new Mydebuff(dd.target.Character, speedPenalty); //if we can enter the tile if (!(moveTo is WaterTile) & !dd.source.Character.Flight) { // and we can push the target if (Push.SmartStaticApply(moveTo, dd.SourceTile)) { dd.source.AttackInfo.AttackAnimation.Cancel(); dd.source.MoveTo(moveTo); } } }
void ExplodeOnDeath() { ExplosionForce ef = GetComponent <ExplosionForce> (); DamageData ddNPC = Const.SetNPCDamageData(index, Const.aiState.Attack3, gameObject); float take = Const.a.GetDamageTakeAmount(ddNPC); ddNPC.other = gameObject; ddNPC.damage = take; //enemy.GetComponent<HealthManager>().TakeDamage(ddNPC); Handled by ExplodeInner if (ef != null) { ef.ExplodeInner((transform.position + viewVerticalOffset) + explosionOffset, attack3Force, attack3Radius, ddNPC); } healthManager.ObjectDeath(SFXAttack1); GetComponent <MeshRenderer> ().enabled = false; }
public override void FillFightValues(Boolean p_offHand, FightValues p_fightValue) { DamageData baseDamage = GetBaseDamage(); if (p_offHand) { p_fightValue.OffHandDamage.Add(baseDamage); p_fightValue.OffHandCriticalDamageMod = 0f; } else { p_fightValue.MainHandDamage.Add(baseDamage); p_fightValue.MainHandCriticalDamageMod = 0f; } p_fightValue.MagicalCriticalDamageMod += m_staticData.AddCritDamage; }
private void OnTriggerEnter(Collider other) { var damageable = other.GetComponent <IDamagable>(); if (damageable == null) { return; } var damageData = new DamageData(1); damageable.ReceiveDamage(damageData); onHit.OnNext(Unit.Default); Destroy(); }
public void shootWithRayStraight(DamageData damage) { gunSourceDirection = gunSource.TransformDirection(Vector3.forward); if (Physics.Raycast(gunSource.position, gunSourceDirection, out hit, 10000f)) { if (hit.transform != null) { //this.HittedTransform = hit.transform; //this.HittedVector = hit.point; } else { } } }
/**********************************************************************************/ // функция нанесения урона юниту // /**********************************************************************************/ public virtual void TakeDamage(DamageData damage) { m_unitHP -= damage.Damage; // если юнит повержен if (m_unitHP <= 0) { m_unitHP = 0; // извещаем всех о смерти юнита if (UnitIsDown != null) { UnitIsDown(damage); } } }
/// <summary> /// Receive messages. /// Must have the same parameters as the MessageDelegate delegate. /// </summary> /// <param name="messageType"></param> /// <param name="go"></param> /// <param name="data"></param> void ReceiveMessage(MessageType messageType, GameObject go, MessageData data) { switch (messageType) { case MessageType.DAMAGED: // Cast message to damage data DamageData damageData = data as DamageData; if (damageData != null) { ApplyDamage(damageData.damage, go); } break; } }
void ApplyAndShit(Tile ti) { Character user = GetComponent <Unit>().Character; int dmg = user.Level + 4 + user.ModifiedStats.intelligence; foreach (Tile t in _tgts) { if (t.isOccuppied) { DamageData attackData = new DamageData(); attackData.baseDamage = dmg; attackData.resistanceMultiplier = 1f; attackData.defenceMultiplier = 0f; t.Unit.Damage(attackData); } } }
static public int StaticApply(DamageData attackData) { Unit targetUnit = attackData.target; if (targetUnit != null) { // deliver damage to target. return(targetUnit.Damage(attackData)); } else { Debug.LogError("Damage IEffect failed!\n" + "User="******"\n" + "Target=" + attackData.target); return(0); } }
private void BroadcastDamageAction(TriggerEnterData data) { // if the source was with me. if (data.source.transform != transform) { return; } var actionData = new DamageData { target = data.other.transform, damage = CreatureData.damage, source = data.source }; DamageAction(actionData); }
private void Awake() { damageDatas = new DamageData[createDamageObjectCount]; for (int i = 0; i < createDamageObjectCount; i++) { var createObject = GameObject.Instantiate(baseDamageObject, transform); createObject.transform.position = GlobalDefine.DisablePos; DamageData data = new DamageData(); data.transform = createObject.transform; data.animation = createObject.GetComponent <Animation>(); data.text = createObject.GetComponentInChildren <TextMeshProUGUI>(); damageDatas[i] = data; } baseDamageObject.SetActive(false); }
private IEnumerator TakeDamagePerSecondInDuration(DamageData data) { while (data.duration >= 0) { if (data.damageImmediate) { // Would not trigger critical. (Ex: Blood, Ignite, Poison...) DamageData newData = new DamageData(data.damageSource, data.element, data.damage, false); TakeDamage(newData); } yield return(new WaitForSeconds(data.timesOfPerDamage)); data.duration -= data.timesOfPerDamage; data.damageImmediate = true; } yield break; }
/// <summary> /// /// </summary> void MakeDamageRepeting() { DamageData info = new DamageData(); info.Damage = m_RepetingDamage; if (RepetingDamageInfo != null) { info = RepetingDamageInfo; info.Damage = m_RepetingDamage; } else { info.Direction = Vector3.zero; info.Cause = DamageCause.Map; } GetDamage(info); }
} // end MoveBackward private void FlightArrow() { AnimationState state = character.avatar.GetCurrentState("skill1_2"); if (null == state || state.normalizedTime < 0.3f) { return; } // end if isFlight = true; DamageData damage = new DamageData(character); PierceArrow arrow = Object.Instantiate(ResourcesTool.LoadPrefab("pierce_arrow")).AddComponent <PierceArrow>(); arrow.transform.position = character.position + Vector3.up * 0.8f; arrow.transform.rotation = character.rotation; arrow.SetDamage(damage); } // end FlightArrow
public void ProcessDamage(DamageData hit) { TankArmourPiece piece = FindBestPieceAtPoint(hit.point, SearchFlags.FullOnly, true); if (piece == null) { Debug.LogWarning("Something weird happened, I got damaged without finding a best"); } piece.maxHealth -= hit.damage; List <TankArmourPickup> pickups = new List <TankArmourPickup>(); if (piece.maxHealth <= 0) { TryRemovePiece(piece, ref pickups); pickups = piece.ReevaulateChildren(pickups); } }
public void Shoot(GameObject go, DamageData data) { this.go = go; this.data = data; /* * * //go.GetComponent<Health>().TakeDamage(data.damage_ammount); * * //Debug.DrawLine(transform.position, go.transform.position, new Color(5f,5f,5f)); * Vector3[] positions = new Vector3[2]; * positions[0] = transform.position; * * var posX = (transform.position.x + go.transform.position.x)/2; * if(posX < 0) posX *= -1; * * var posY = go.transform.position.y + 10f; * * //position2.y = data.range - position2.x; * //position2.y = transform.position.y + position2.y; * * //positions[1] = new Vector3(posX, posY); * * TravelData ts = go.GetComponent<MoverData>().travel; * * float timeFactor = data.maxTimeProjectileStaysInAir / ts.time; * * * Vector3 predictedPositionFactor = ts.difference * timeFactor; * * * positions[1] = go.transform.position - predictedPositionFactor; * //positions[1] = go.transform.position; */ positionss = GeneratePath(); draw = true; GameObject newGo = Instantiate(data.projectile) as GameObject; //newGo.transform.SetParent(transform.parent); //newGo.transform.localScale = transform.localScale; newGo.GetComponent <Projectile>().HitTarget(positionss, data, go); }
protected virtual void XLDIce(DamageData damaData) { Burnt b = GetComponent <Burnt>(); if (b) { damaData.Mediated = true; b.EndUp(); } else { if (Random.Range(0, 1f) < damaData.IceRatio) { Freeze.Freezed(this, damaData.IceTime); } } }
public void DealDamage(IDamageType damage, GameObject causer = null) { damage.ChangeHealth(this, causer); var data = new DamageData(damage, causer); if (IsAlive()) { BroadcastMessage("OnReceiveDamage", data); } else { BroadcastMessage("OnDeath", data); } actual = Mathf.Clamp(actual, 0, max); }
/// <summary> /// /// </summary> void MakeDamageRepeting() { DamageData info = new DamageData(); info.Damage = m_RepetingDamage; if (RepetingDamageInfo != null) { info = RepetingDamageInfo; info.Damage = m_RepetingDamage; } else { info.Direction = Vector3.zero; info.Cause = DamageCause.Map; } DoDamage((int)info.Damage, "[Burn]", info.Direction, bl_GameManager.m_view, false, PhotonNetwork.LocalPlayer.GetPlayerTeam(), false); }
void RecieveMessage(MessageTypes msgType, GameObject go, MessageData msgData) { switch (msgType) { case MessageTypes.DAMAGED: DamageData dmgData = msgData as DamageData; if (gameObject.tag == "Objects") { if (dmgData != null) { ApplyDamage(dmgData.damage, go); } } break; } }
private static async ETTask CommonAttack_Internal(this CommonAttackComponent self) { MessageHelper.Broadcast(new M2C_CommonAttack() { AttackCasterId = self.Entity.Id, TargetUnitId = self.CachedUnitForAttack.Id, CanAttack = true }); HeroDataComponent heroDataComponent = self.Entity.GetComponent <HeroDataComponent>(); float attackPre = heroDataComponent.NodeDataForHero.OriAttackPre / (1 + heroDataComponent.GetAttribute(NumericType.AttackSpeedAdd)); float attackSpeed = heroDataComponent.GetAttribute(NumericType.AttackSpeed); //播放动画,如果动画播放完成还不能进行下一次普攻,则播放空闲动画 await TimerComponent.Instance.WaitAsync((long)(attackPre * 1000), self.CancellationTokenSource.Token); DamageData damageData = ReferencePool.Acquire <DamageData>().InitData(BuffDamageTypes.PhysicalSingle | BuffDamageTypes.CommonAttack, heroDataComponent.GetAttribute(NumericType.Attack), self.Entity as Unit, self.CachedUnitForAttack); self.Entity.GetComponent <CastDamageComponent>().BaptismDamageData(damageData); float finalDamage = self.CachedUnitForAttack.GetComponent <ReceiveDamageComponent>().BaptismDamageData(damageData); if (finalDamage >= 0) { self.CachedUnitForAttack.GetComponent <HeroDataComponent>().NumericComponent.ApplyChange(NumericType.Hp, -finalDamage); //抛出伤害事件,需要监听伤害的buff(比如吸血buff)需要监听此事件 Game.Scene.GetComponent <BattleEventSystem>().Run($"{EventIdType.ExcuteDamage}{self.Entity.Id}", damageData); //抛出受伤事件,需要监听受伤的Buff(例如反甲)需要监听此事件 Game.Scene.GetComponent <BattleEventSystem>().Run($"{EventIdType.TakeDamage}{self.CachedUnitForAttack.Id}", damageData); } CDComponent.Instance.TriggerCD(self.Entity.Id, "CommonAttack"); CDInfo commonAttackCDInfo = CDComponent.Instance.GetCDData(self.Entity.Id, "CommonAttack"); commonAttackCDInfo.Interval = (long)(1 / attackSpeed - attackPre) * 1000; List <NP_RuntimeTree> targetSkillCanvas = self.Entity.GetComponent <SkillCanvasManagerComponent>().GetSkillCanvas(10001); foreach (var skillCanva in targetSkillCanvas) { skillCanva.GetBlackboard().Set("CastNormalAttack", true); skillCanva.GetBlackboard().Set("NormalAttackUnitIds", new List <long>() { self.CachedUnitForAttack.Id }); } await TimerComponent.Instance.WaitAsync(commonAttackCDInfo.Interval, self.CancellationTokenSource.Token); }
public virtual void TakeDamage(DamageData data, Vector3 forward, Fighter owner) { if (invincible) { return; } currHealth -= data.GetDamage(); // Lose health from damage if (animator) { animator.SetBool("hurt", true); } hitstunning = true; if (data.GetDamage() > 0) { onHurt.Invoke(); } //forward.y = 1f; // For knockback // Death if (currHealth <= 0) { currHealth = 0; if (rb) { rb.velocity = Vector3.zero; // Cancel velocity } if (!dead) { Die(); } return; } if (data.GetDamage() > 0) { rb.velocity = Vector3.zero; // Cancel velocity Knockback(data, forward); } }
public void OnTriggerEnter(Collider other) { var damagable = other.GetComponent <IDamageable>(); if (damagable == null) { return; } DamageData damageData = new DamageData(); damageData.damage = 10f; damageData.buff = null; damageData.player = gameObject; damagable.TakeDamage(damageData); }
void OnCollisionEnter(Collision other) { if (other.gameObject == m_target) { DamageData dmgData = new DamageData(); dmgData.damage = m_damage; MessageHandler msgHandler = m_target.GetComponent<MessageHandler>(); if (msgHandler) { msgHandler.GiveMessage(MessageType.DAMAGED, m_launcher, dmgData); } } if (other.gameObject.GetComponent<BaseProjectile>() == null) Destroy(gameObject); }
public void TakeDamage(DamageData damage) { if (damage.inflictor == gameObject) return; float boomTime = Time.time; if (damage.type == DamageType.Explosion) { float delay = Random.Range(explosionDelayMin, explosionDelayMax); boomTime = Time.time + delay; // delay explosion chains if (explodeTime < 0) // only trigger effect on first explosion contact RpcPrimeForExplosion(delay); } // set explosion timer to whatever f****d it up the fastest if (explodeTime < 0 || explodeTime > boomTime) explodeTime = boomTime; }
public override void Fire() { if (CanFire()) { float laserDistance = range; Ray ray = new Ray(this.transform.position, this.transform.forward); RaycastHit[] hits = Physics.RaycastAll(ray, range, 1 << LayerMask.NameToLayer("PhysicalObject")); foreach (RaycastHit hit in hits) { if (hit.collider.gameObject != this.transform.parent.gameObject) { laserDistance = Vector3.Distance(hit.collider.transform.position, this.transform.position); DamageData damageData = new DamageData(); if (hit.collider.gameObject.tag == "Ship") { damageData.SetData(damage, DamageData.HitLocations.hull); } else if (hit.collider.gameObject.tag == "Shield") { damageData.SetData(damage, DamageData.HitLocations.shield); } hit.collider.gameObject.SendMessageUpwards("ProjectileHit", damageData, SendMessageOptions.DontRequireReceiver); break; } } GameObject projectileObject = (GameObject)Instantiate(projectilePrefab, this.transform.position, Quaternion.identity); Laser laser = projectileObject.GetComponent<Laser>(); laser.SetLaser(this.transform.position, this.transform.position + (this.transform.forward * laserDistance)); base.Fire (); } }
// Load Database Data public override void Load() { if (!dataLoaded) { // Clean old data dataRegister.Clear (); displayKeys.Clear (); // Read all entries from the table string query = "SELECT * FROM " + tableName; // If there is a row, clear it. if (rows != null) rows.Clear (); // Load data rows = DatabasePack.LoadData (DatabasePack.contentDatabasePrefix, query); //Debug.Log("#Rows:"+rows.Count); // Read all the data int fakeId = 0; if ((rows != null) && (rows.Count > 0)) { foreach (Dictionary<string,string> data in rows) { //foreach(string key in data.Keys) // Debug.Log("Name[" + key + "]:" + data[key]); //return; DamageData display = new DamageData (); // As we don have a primary key ID field fakeId++; display.id = fakeId; display.name = data ["name"]; display.resistanceStat = data ["resistance_stat"]; display.isLoaded = true; //Debug.Log("Name:" + display.name + "=[" + display.id + "]"); dataRegister.Add (display.id, display); displayKeys.Add (display.id); } LoadSelectList (); } dataLoaded = true; } }
public override void SetDamageData(DamageData damage) { DamageAmount = damage.Damage; }
void Start() { State = WeaponStates.Hidden; if (damage == 0f) { Debug.LogError("Weapon: " + transform.name + " has 0 damage!"); } damageData = new DamageData(damage); }
public virtual bool CanBeDamagedBy(DamageData damage) { return ((BySources & ~damage.Sources) != BySources) && ((ByTypes & ~damage.Types) != ByTypes); }
public override void CreateNewData() { editingDisplay = new DamageData (); originalDisplay = new DamageData (); selectedDisplay = -1; }
public override void SetDamageData(DamageData damage) { base.SetDamageData(damage); this.damage.Types |= DamageTypes; }
/// <summary> /// Apply damage to game object if it has an IDamagable derived component. /// </summary> /// <param name="obj"></param> /// <param name="amount"></param> /// <param name="damageType"></param> /// <param name="inflictor"></param> public static void ApplyTo(GameObject obj, int amount, DamageType damageType, GameObject inflictor) { IDamagable[] damagables = obj.GetComponents(typeof(IDamagable)).Cast<IDamagable>().ToArray(); DamageData dm = new DamageData(amount, damageType, inflictor); Array.ForEach(damagables, damagable => damagable.TakeDamage(dm)); }
private void Die() { var data = new DamageData(Entity.GetComponent<Status>().Health, Entity.Groups, DamageTypes.None); Entity.GetComponent<Damageable>().Damage(data); }
public abstract void SetDamageData(DamageData damage);
protected virtual void OnDamaged(DamageData damage) { currentColor = Damaged; }
/// <summary> /// 將字典傳入,依json表設定資料 /// </summary> public static void SetData(Dictionary<int, DamageData> _dic) { string jsonStr = Resources.Load<TextAsset>("Json/Damage").ToString(); JsonData jd = JsonMapper.ToObject(jsonStr); JsonData DamageItems = jd["Damage"]; for (int i = 0; i < DamageItems.Count; i++) { DamageData DamageData = new DamageData(DamageItems[i]); int id = int.Parse(DamageItems[i]["ID"].ToString()); _dic.Add(id, DamageData); } }
public void TakeDamage(DamageData damage) { RpcPunchVehicle(); }
// Edit or Create public override void DrawEditor(Rect box, bool newItem) { // Setup the layout Rect pos = box; pos.x += ImagePack.innerMargin; pos.y += ImagePack.innerMargin; pos.width -= ImagePack.innerMargin; pos.height = ImagePack.fieldHeight; // Draw the content database info //pos.y += ImagePack.fieldHeight; if (!linkedTablesLoaded) { LoadStatsOptions (); linkedTablesLoaded = true; } if (newItem) { ImagePack.DrawLabel (pos.x, pos.y, "Create a new Damage"); pos.y += ImagePack.fieldHeight; } editingDisplay.name = ImagePack.DrawField (pos, "Name:", editingDisplay.name, 0.75f); pos.y += ImagePack.fieldHeight; editingDisplay.resistanceStat = ImagePack.DrawCombobox (pos, "Resistance Stat:", editingDisplay.resistanceStat, statOptions); pos.y += ImagePack.fieldHeight; pos.y += 1.5f * ImagePack.fieldHeight; // Save data pos.x -= ImagePack.innerMargin; pos.width /= 3; if (ImagePack.DrawButton (pos.x, pos.y, "Save Data")) { if (newItem) InsertEntry (); else UpdateEntry (); state = State.Loaded; } // Delete data if (!newItem) { pos.x += pos.width; if (ImagePack.DrawButton (pos.x, pos.y, "Delete Data")) { DeleteEntry (); newSelectedDisplay = 0; state = State.Loaded; } } // Cancel editing pos.x += pos.width; if (ImagePack.DrawButton (pos.x, pos.y, "Cancel")) { editingDisplay = originalDisplay.Clone (); if (newItem) state = State.New; else state = State.Loaded; } if (resultTimeout != -1 && resultTimeout > Time.realtimeSinceStartup) { pos.y += ImagePack.fieldHeight; ImagePack.DrawText(pos, result); } }
public void getDamage(DamageData damageData) { Debug.Log("Hitted: " + damageData.Value); //Instantiate(GameObject.CreatePrimitive(PrimitiveType.Cube) as GameObject, damageData.HittedPoint, Quaternion.identity); }