Пример #1
0
 void UpdateDamageState()
 {
     if (DamageState != DamageStateType.Dead)
     {
         if (CheckUnderObject())
         {
             DamageState = DamageStateType.UnderProtect;
         }
         else
         {
             DamageState = DamageStateType.UnderDamage;
         }
     }
 }
Пример #2
0
 void UpdateHealth()
 {
     if (DamageState == DamageStateType.UnderDamage)
     {
         m_health.OnDamage(Health.FullHealth / damageSetting.lastTime);
     }
     else if (DamageState == DamageStateType.UnderProtect)
     {
         m_health.OnRecover(damageSetting.recover);
     }
     if (m_health.HealthValue < 0 && DamageState == DamageStateType.UnderDamage)
     {
         DamageState = DamageStateType.Dead;
         M_Event.FireLogicEvent(LogicEvents.Death, new LogicArg(this));
     }
 }
        public virtual void ReceiveDamage(Mobile from, int damage, InteractionType interactionType)
        {
            int lightlyDamagedThreshold = (int)(Math.Round((double)MaxHitPoints * LightlyDamagedPercent));
            int heavilyDamagedThreshold = (int)(Math.Round((double)MaxHitPoints * HeavilyDamagedPercent));

            DamageStateType oldDamageStateType = DamageState;
            DamageStateType newDamageStateType = DamageStateType.Normal;

            HitPoints -= damage;

            if (HitPoints <= lightlyDamagedThreshold)
            {
                newDamageStateType = DamageStateType.LightlyDamaged;
            }

            if (HitPoints <= heavilyDamagedThreshold)
            {
                newDamageStateType = DamageStateType.HeavilyDamaged;
            }

            if (HitPoints < 0)
            {
                HitPoints = 0;
            }

            if (HitPoints == 0)
            {
                PublicOverheadMessage(MessageType.Regular, 0, false, "*breaks*");

                Effects.PlaySound(Location, Map, m_BrokenSound);

                if (m_CreateTimedStaticAfterBreak)
                {
                    TimedStatic timedStatic = new TimedStatic(TimedStaticOnBreakItemId, TimedStaticDuration);
                    timedStatic.Name = TimedStaticOnBreakName;
                    timedStatic.Hue  = TimedStaticOnBreakHue;
                    timedStatic.MoveToWorld(Location, Map);
                }

                if (RevealNearbyHiddenItemsOnBreak)
                {
                    IPooledEnumerable itemsOnTile = Map.GetItemsInRange(Location, RevealNearbyHiddenItemsOnBreakRadius);

                    foreach (Item item in itemsOnTile)
                    {
                        if (!item.Visible)
                        {
                            item.Visible = true;
                        }
                    }

                    itemsOnTile.Free();
                }

                AfterReceiveDamage(from, damage, interactionType);

                BeforeBreak(from, interactionType);

                if (m_DeleteOnBreak)
                {
                    Delete();
                }

                AfterBreak(from, interactionType);
            }

            else
            {
                if (oldDamageStateType != newDamageStateType)
                {
                    switch (newDamageStateType)
                    {
                    case DamageStateType.LightlyDamaged:
                        Effects.PlaySound(Location, Map, m_LightlyDamagedSound);
                        NormalToLightlyDamaged(from, interactionType);
                        break;

                    case DamageStateType.HeavilyDamaged:
                        Effects.PlaySound(Location, Map, m_HeavilyDamagedSound);
                        LightlyDamagedToHeavilyDamaged(from, interactionType);
                        break;
                    }
                }

                Effects.SendLocationParticles(EffectItem.Create(new Point3D(Location.X, Location.Y, Location.Z), Map, EffectItem.DefaultDuration), 0x377A, 10, 10, 9502);

                PublicOverheadMessage(MessageType.Regular, 2401, false, "-" + damage.ToString());

                if (from != null)
                {
                    from.SendMessage("You inflict " + damage.ToString() + " damage upon your target. [Remaining durability: " + HitPoints.ToString() + "/" + m_MaxHitPoints.ToString() + "]");
                }

                AfterReceiveDamage(from, damage, interactionType);
            }
        }
        public override void Deserialize(GenericReader reader)
        {
            base.Deserialize(reader);
            int version = reader.ReadInt();

            int storedHitPoints    = 1000;
            int storedMaxHitPoints = 1000;

            //Version 0
            if (version >= 0)
            {
                m_AllowRepair                      = reader.ReadBool();
                m_RepairSound                      = reader.ReadInt();
                m_DamageState                      = (DamageStateType)reader.ReadInt();
                m_InteractionRange                 = reader.ReadInt();
                m_InteractionDelay                 = reader.ReadDouble();
                m_MinInteractDamage                = reader.ReadInt();
                m_MaxInteractDamage                = reader.ReadInt();
                m_InteractDamageScalar             = reader.ReadDouble();
                m_WeaponDamageScalar               = reader.ReadDouble();
                m_LockpickDamageScalar             = reader.ReadDouble();
                m_MiningDamageScalar               = reader.ReadDouble();
                m_LumberjackingDamageScalar        = reader.ReadDouble();
                m_ObjectBreakingDeviceDamageScalar = reader.ReadDouble();

                storedHitPoints    = reader.ReadInt();
                storedMaxHitPoints = reader.ReadInt();

                m_AddLOSBlocker = reader.ReadBool();
                m_HitSound      = reader.ReadInt();

                m_NormalItemId = reader.ReadInt();
                m_NormalHue    = reader.ReadInt();

                m_LightlyDamagedPercent = reader.ReadDouble();
                m_LightlyDamagedSound   = reader.ReadInt();
                m_LightlyDamagedItemId  = reader.ReadInt();
                m_LightlyDamagedHue     = reader.ReadInt();

                m_HeavilyDamagedPercent = reader.ReadDouble();
                m_HeavilyDamagedSound   = reader.ReadInt();
                m_HeavilyDamagedItemId  = reader.ReadInt();
                m_HeavilyDamagedHue     = reader.ReadInt();

                m_BrokenSound  = reader.ReadInt();
                m_BrokenItemId = reader.ReadInt();
                m_BrokenHue    = reader.ReadInt();

                m_DeleteOnBreak = reader.ReadBool();
                m_CreateTimedStaticAfterBreak = reader.ReadBool();

                m_TimedStaticOnBreakItemId             = reader.ReadInt();
                m_TimedStaticOnBreakHue                = reader.ReadInt();
                m_TimedStaticDuration                  = reader.ReadDouble();
                m_TimedStaticOnBreakName               = reader.ReadString();
                m_RevealNearbyHiddenItemsOnBreak       = reader.ReadBool();
                m_RevealNearbyHiddenItemsOnBreakRadius = reader.ReadInt();
                m_RefreshNearbyMovables                = reader.ReadBool();
                m_RefreshNearbyMovablesRadius          = reader.ReadInt();
                m_LOSBlocker = reader.ReadItem() as LOSBlocker;
            }

            //Version 1
            if (version >= 1)
            {
                m_RequiresFullRepair = reader.ReadBool();
                m_PlayerPlaced       = reader.ReadBool();
                m_Facing             = (Direction)reader.ReadInt();
            }


            //--------

            //Make Sure This Gets Fired Off Last
            MaxHitPoints = storedMaxHitPoints;
            HitPoints    = storedHitPoints;
        }
Пример #5
0
 void OnDeathEnd(LogicArg arg)
 {
     DamageState = DamageStateType.UnderProtect;
     m_health.Revive();
 }