Exemplo n.º 1
0
        public void ModifyDamage(DamagableObject target, InputDamage inputDamage)
        {
            if (nebulaObject.Type == (byte)ItemType.Avatar)
            {
                if (HasSkill(m43AID))
                {
                    var skill = GetSkillById(m43AID);
                    if (skill.isOn)
                    {
                        var m43a = skill.GetExecutor() as Skill_0000043A;
                        if (target.health < target.maximumHealth * m43a.hpPc)
                        {
                            if (false == Mathf.Approximately(m43a.dmgMult, 0f))
                            {
                                //log.InfoFormat("modify damage on {0}% with skill 43A", m43a.dmgMult);
                                inputDamage.Mult(m43a.dmgMult);
                                //return inputDamage;
                            }
                        }
                    }
                }
            }

            //return inputDamage;
        }
Exemplo n.º 2
0
        public override void Start()
        {
            base.Start();
            //cache raceable component
            mRaceable  = GetComponent <RaceableObject>();
            mCharacter = GetComponent <CharacterObject>();
            mDamagable = GetComponent <DamagableObject>();

            mConstructionTimer = CONSTRUCTION_INTERVAL;
            SetUnderConstruction(true);
        }
Exemplo n.º 3
0
        public override void Start()
        {
            this.fsm = new BaseFSM <PirateStationState>();
            this.fsm.AddState(new FSMState <PirateStationState>(PirateStationState.Idle, () => { }, () => { }, () => { }));
            this.fsm.AddState(new FSMState <PirateStationState>(PirateStationState.Dead, () => { }, () => { }, () => { }));
            this.fsm.ForceState(PirateStationState.Idle, true);

            mDamagable = RequireComponent <DamagableObject>();
            mMessage   = RequireComponent <MmoMessageComponent>();
            Move(nebulaObject.transform.position, nebulaObject.transform.rotation);
            (nebulaObject as Item).UpdateInterestManagement();
        }
Exemplo n.º 4
0
        private bool ReflectDamage(DamagableObject targetDamagable, ref WeaponHitInfo hit, InputDamage inputDamage)
        {
            bool reflected = targetDamagable.TryReflectDamage();

            if (reflected)
            {
                if (hit.normal)
                {
                    DamageParams damageParams = new DamageParams();
                    damageParams.SetReflrected(true);
                    InputDamage inpDamage = new InputDamage(targetDamagable.nebulaObject, inputDamage.CreateCopy(), damageParams);
                    cachedDamagable.ReceiveDamage(inpDamage);
                }
            }
            return(reflected);
        }
Exemplo n.º 5
0
 public float ModifyCritChance(DamagableObject target, float inputCritChance)
 {
     if (HasSkill(m45CID))
     {
         var skill = GetSkillById(m45CID);
         if (skill.isOn)
         {
             float healpPc = skill.GetFloatInput("hp_pc");
             if (target.health < healpPc * target.maximumHealth)
             {
                 float critChanceMult = skill.GetFloatInput("crit_chance_mult");
                 return(inputCritChance * critChanceMult);
             }
         }
     }
     return(inputCritChance);
 }
Exemplo n.º 6
0
        private void ApplyDamage(ref WeaponHitInfo hit, DamagableObject target, float damageMult, bool useDamageMultSelfAsDamage, InputDamage inputDamage)
        {
            inputDamage.Mult(damageMult * Rand.NormalNumber(0.8f, 1.2f));

            if (useDamageMultSelfAsDamage)
            {
                WeaponDamage dmg = new WeaponDamage(inputDamage.weaponBaseType, 0, 0, 0);
                dmg.SetBaseTypeDamage(damageMult);
                inputDamage.CopyValues(dmg);
            }

            if (cachedSkills)
            {
                cachedSkills.ModifyDamage(target, inputDamage);
            }

            int  level    = 1;
            byte workshop = (byte)Workshop.Arlen;
            byte race     = (byte)Race.None;

            level    = cachedCharacter.level;
            workshop = cachedCharacter.workshop;

            RaceableObject raceable = nebulaObject.Raceable();

            if (raceable)
            {
                race = raceable.race;
            }

            var copy = inputDamage.CreateCopy();

            if (false == ReflectDamage(target, ref hit, inputDamage))
            {
                target.ReceiveDamage(inputDamage);
                StartDamageDron(target, inputDamage.CreateCopy(), workshop, level, race);
            }
            hit.SetRemainTargetHp(target.health);

            if (m_Achievments != null)
            {
                m_Achievments.OnMakeDamage(copy);
            }
        }
Exemplo n.º 7
0
        private void StartHealDron(DamagableObject targetObject, float healValue)
        {
            if (nebulaObject.IsPlayer())
            {
                if (mPassiveBonuses != null && mPassiveBonuses.healDronTier > 0)
                {
                    float dronHealValue = healValue * mPassiveBonuses.healDronBonus;

                    targetObject.RestoreHealth(nebulaObject, dronHealValue);

                    Hashtable dronInfo = new Hashtable {
                        { (int)SPC.Target, targetObject.nebulaObject.Id },
                        { (int)SPC.TargetType, targetObject.nebulaObject.Type },
                        { (int)SPC.HealValue, dronHealValue }
                    };
                    mMessage.SendHealDron(dronInfo);
                }
            }
        }
Exemplo n.º 8
0
        public override void Start()
        {
            base.Start();
            mUpdateImmunityTimer = mUpdateImmunityInterval;
            mDamagable           = GetComponent <DamagableObject>();
            mRaceable            = GetComponent <RaceableObject>();

            mConstructionTimer = CONSTRUCTION_INTERVAL;
            SetUnderConstruction(true);

            var world = nebulaObject.world as MmoWorld;


            if ((byte)world.ownedRace != mRaceable.race)
            {
                log.InfoFormat("change world race on outpost start [red]");
                world.SetCurrentRace((Race)mRaceable.race);
            }
        }
Exemplo n.º 9
0
        public override void Start()
        {
            if (!m_StartCalled)
            {
                m_StartCalled = true;

                mPlayerShip = GetComponent <BaseShip>();
                bonuses     = GetComponent <PlayerBonuses>();
                mDamagable  = GetComponent <DamagableObject>();
                message     = GetComponent <MmoMessageComponent>();
                energy      = GetComponent <ShipEnergyBlock>();

                m439ID = SkillExecutor.SkilIDFromHexString("00000439");
                m43AID = SkillExecutor.SkilIDFromHexString("0000043A");
                m451ID = SkillExecutor.SkilIDFromHexString("00000451");
                m456ID = SkillExecutor.SkilIDFromHexString("00000456");
                m45CID = SkillExecutor.SkilIDFromHexString("0000045C");
            }
            SetBlockedProperty(false);
            started = true;
        }
Exemplo n.º 10
0
        private void StartDamageDron(DamagableObject targetObject, WeaponDamage inputDamage, byte workshop, int level, byte race)
        {
            if (nebulaObject.IsPlayer())
            {
                if (mPassiveBonuses != null && mPassiveBonuses.damageDronTier > 0)
                {
                    WeaponDamage dronDamage = new WeaponDamage();
                    dronDamage.SetFromDamage(inputDamage);
                    dronDamage.Mult(mPassiveBonuses.damageDronBonus);

                    InputDamage inpDamage = new InputDamage(nebulaObject, dronDamage);
                    targetObject.ReceiveDamage(inpDamage);

                    Hashtable dronInfo = new Hashtable {
                        { (int)SPC.Target, targetObject.nebulaObject.Id },
                        { (int)SPC.TargetType, targetObject.nebulaObject.Type },
                        { (int)SPC.Damage, dronDamage.totalDamage }
                    };
                    mMessage.SendDamageDron(dronInfo);
                }
            }
        }
Exemplo n.º 11
0
 public TimedDamage(DamagableObject target)
 {
     mTarget = target;
 }
Exemplo n.º 12
0
 public override void Start()
 {
     base.Start();
     mDamagable = GetComponent <DamagableObject>();
 }