//Should be changed to calculate life, this function would then be used for all cases in which health pools are changed
	public void CalculateHealth(GameObject aCause, float aValue, EffectType aHealthEffect = EffectType.loss) //GameObject dealing damage, Damage, DamageType
	{
		try
		{
			switch (aHealthEffect)
			{
				case EffectType.loss:
					if (m_Pools.Health > 0)
					{
						m_Pools.Health -= aValue;
						m_Actor.m_HUD.UpdatePools();
					}
					break;
				case EffectType.gain:
					m_Pools.Health += aValue;
					m_Actor.m_HUD.UpdatePools();
					break;
			}

			if (m_Pools.Health > 0)
			{
				return;
			}

			m_Pools.Health = 0;
			m_Actor.m_HUD.DisplayGameOver();
		}
		catch
		{
			Debug.Log(m_Actor.name + " Statistics HUD reference is NULL");
		}
	}
 public Ongoing(Keyword keyword, EffectType effect_type, int modifier, int duration)
 {
     key = keyword;
     type = effect_type;
     mod = modifier;
     dur = duration;
 }
Exemple #3
0
        internal static async Task<IVideoEffectDefinition> CreateEffectDefinitionAsync(EffectType effectType)
        {
            switch (effectType)
            {
                case EffectType.Lumia:
                    return new LumiaEffectDefinition(() =>
                    {
                        return new IFilter[]
                    {
                        new AntiqueFilter(),
                        new FlipFilter(FlipMode.Horizontal)
                    };
                    });

                case EffectType.ShaderNv12:
                    IBuffer shaderY = await PathIO.ReadBufferAsync("ms-appx:///Invert_093_NV12_Y.cso");
                    IBuffer shaderUV = await PathIO.ReadBufferAsync("ms-appx:///Invert_093_NV12_UV.cso");
                    return new ShaderEffectDefinitionNv12(shaderY, shaderUV);

                case EffectType.ShaderBgrx8:
                    IBuffer shader = await PathIO.ReadBufferAsync("ms-appx:///Invert_093_RGB32.cso");
                    return new ShaderEffectDefinitionBgrx8(shader);

                default:
                    throw new ArgumentException("Invalid effect type");
            }
        }
Exemple #4
0
 // --- Constructors ---
 public StatEffect(EffectType pmType, string pmName, string pmDesc, StatEffectEvent pmEffectEvent, int pmTurnsLeft)
 {
     type=	pmType;
     name=	pmName;
     desc=	pmDesc;
     effectEvent=	pmEffectEvent;
     turnsLeft=	pmTurnsLeft;
 }
Exemple #5
0
 public override void Read(PacketReader r)
 {
     EffectType = (EffectType)r.ReadByte();
     TargetId = r.ReadInt32();
     PosA =(Location) new Location().Read(r);
     PosB = (Location) new Location().Read(r);
     Color = ARGB.Read(r);
 }
 public void ReadPacket(IMinecraftStream stream)
 {
     Effect = (EffectType)stream.ReadInt32();
     X = stream.ReadInt32();
     Y = stream.ReadInt8();
     Z = stream.ReadInt32();
     Data = stream.ReadInt32();
 }
Exemple #7
0
 public Effect(Characteristic target, int amount, EffectType type, int duration, DurationType durType)
 {
     Target = target;
     Amount = amount;
     Type = type;
     Duration = duration;
     DurType = durType;
 }
Exemple #8
0
 public CircleObject(CircleObject baseInstance)
 {
     //Copy from baseInstance
     Location = baseInstance.Location;
     Radius = baseInstance.Radius;
     StartTime = baseInstance.StartTime;
     Type = baseInstance.Type;
     Effect = baseInstance.Effect;
 }
 private void Avatars_OnEffect(EffectType type, LLUUID sourceID, LLUUID targetID, 
     LLVector3d targetPos, float duration, LLUUID id)
 {
     if (ShowEffects)
         Console.WriteLine(
         "ViewerEffect [{0}]: SourceID: {1} TargetID: {2} TargetPos: {3} Duration: {4} ID: {5}",
         type, sourceID.ToString(), targetID.ToString(), targetPos, duration,
         id.ToString());
 }
 public void AddStatusEffect(EffectType type)
 {
     StatusEffect effect = GetEffectFromEnum(type);
     if (effect == null)
         return;
     if(type == EffectType.HIT)
         ResetEffects();
     AddStatusEffect(effect);
 }
Exemple #11
0
		//----------------------------------------------------------------------
		//  Here, we are going to search the quadrant that it is ahead of the player, because
		//  he is running
		//----------------------------------------------------------------------
		public static bool FindAhead(
			PlayerMobile pm,
			Point3D centerPoint,
			ref Point3D spawnPoint,
			LandType landType,
			int distance,
			EffectType effectType,
			int effectHue
			)
		{
			Direction dir = (Direction)((int)pm.Direction & 0x0f);

			Point3D foundPoint = new Point3D();

			Tour tour = delegate( Map map, int x, int y )
			{
				if( Utility.RandomDouble() < .5 ) return false; // break it up a little.

				Point2D currentPoint = new Point2D( pm.Location.X + x, pm.Location.Y + y );

				if( FindSpawnTileInternal(
						pm,
						centerPoint,
						currentPoint,
						ref foundPoint,
						landType,
						effectType,
						effectHue
						)
					)
				{
					return true;
				}

				return false;
			};

			bool found = Search.Octant(
				pm.Map,
				dir,
				distance,
				SearchDirection.Inwards,
				tour
				);

			if( found )
			{
				spawnPoint.X = foundPoint.X;
				spawnPoint.Y = foundPoint.Y;
				spawnPoint.Z = foundPoint.Z;

				return true;
			}

			return false;
		}
 public void addEffect(EffectType pType, Vector2 pOrigin, float pAngle)
 {
     for (int i = 0; i < MAX_EFFECTS; i++)
     {
         if (!mAllEffects[i].isAlive())
         {
             mAllEffects[i].initialize(pType, pOrigin, ref mParticles, pAngle);
             break;
         }
     }
 }
 /// <summary>
 /// Basiskonstruktor.
 /// </summary>
 public SpriteEffect()
 {
     elapsedTime = 0;
     CurrentSprite = Vector2.Zero;
     Size = Vector2.Zero;
     SheetSize = Vector2.Zero;
     Offset = 0;
     ChangeSpeed = 0.0f;
     CicleDirection = SpriteCicleDirection.Left;
     SpriteType = EffectType.None;
 }
Exemple #14
0
        /// <summary>
        /// Creates a new instance of Effect
        /// </summary>
        /// <param name="aDuration">The duration of the effect</param>
        public Effect(EffectType aEffectType, int aMagnitude, int aDuration = 1)
        {
            // Set the effect type.
            EffectType = aEffectType;

            // Set the duration of this effect.
            Duration = aDuration;

            // Set the magnitude of this effect.
            Magnitude = aMagnitude;
        }
Exemple #15
0
		//----------------------------------------------------------------------
		//  Opposite of the above; we want the first spawn location closest to
		//  the center -- no closer than the initial distance
		//----------------------------------------------------------------------
		public static bool FindOutwards(
			PlayerMobile pm,
			Point3D centerPoint,
			ref Point3D spawnPoint,
			LandType landType,
			int distance,
			EffectType effectType,
			int effectHue
			)
		{
			return FindSpiral( pm, centerPoint, ref spawnPoint, landType, distance, false, effectType, effectHue );
		}
		public IList<IEffectSpriteInfo> GetEffectInfo(EffectType effectType, int effectID)
		{
			switch (effectType)
			{
				case EffectType.Potion: return ResolvePotionEffect((HardCodedPotionEffect)effectID);
				case EffectType.Spell: return ResolveSpellEffect((HardCodedSpellGraphic)effectID);
				case EffectType.WarpOriginal:
				case EffectType.WarpDestination: return GetWarpEffect(effectType);
				case EffectType.WaterSplashies: return GetWaterEffect();
				default: throw new ArgumentOutOfRangeException("effectType", effectType, null);
			}
		}
		public IList<SoundEffectInstance> GetSoundEffectsForEffect(EffectType type, int id)
		{
			switch (type)
			{
				case EffectType.Potion: return GetPotionSoundEffect(id);
				case EffectType.Spell: return GetSpellSoundEffect(id);
				case EffectType.WarpOriginal:
				case EffectType.WarpDestination: return GetWarpSoundEffect(type);
				case EffectType.WaterSplashies: return GetWaterSoundEffect();
				default: throw new ArgumentOutOfRangeException("type", type, null);
			}
		}
Exemple #18
0
    //
    //-- Send Message Calls
    //     This section is for the MESSAGES such as the ones described in the
    //     test instructions.
    //

    public static bool SendAffectMessage( InstanceID recipient, EffectType type, int intensity, double time = -1.0d )
    {
        Entity targetEntity = null;

        if( s_GameEntities.TryGetValue( target, out targetEntity ) )
        {
            targetEntity.Affect( type, intensity );
            return true;
        }

        return false;
    }
        public void CopyFrom(AttackInformation other)
        {
            this.Id = other.Id;
            this.Power = other.Power;
            this.StayingTime = other.StayingTime;
            this.Type = other.Type;

            this.Effect = other.Effect;

            this.SourcePositionHorizontal = other.SourcePositionHorizontal;
            this.SourcePositionVertical = other.SourcePositionVertical;
        }
Exemple #20
0
		internal EffectAudio(EffectType eType)
            : base(eType)
        {
			try
			{
				aChannels = null; //комментарии в IAudio
			}
			catch
			{
				Fail();
				throw;
			}
		}
Exemple #21
0
 /// <summary>
 /// Primary constructor for Magic class. For single-effect spells.
 /// </summary>
 /// <param name="name">Name of the Spell.</param>
 /// <param name="cost">Cost of the Spell</param>
 /// <param name="description">Detailed Description of the Spell. Should not include Flavor Text.</param>
 /// <param name="potency">Numerical modifier for primary effect of spell.</param>
 /// <param name="accuracy">Base accuracy of the spell.</param>
 /// <param name="spellmagicschooltype">School of magic the spell falls under.</param>
 /// <param name="spellelementtype">Elemental effect of the spell.</param>
 /// <param name="spelleffecttype">Main effect type of the spell.</param>
 public Magic(string name = "", int cost = 0, string description = "", int potency = 0, double accuracy = 0,
     MagicSchoolType spellmagicschooltype = MagicSchoolType.Black, ElementType spellelementtype = ElementType.Light,
     EffectType spelleffecttype = EffectType.Damage)
 {
     Name = name;
     Cost = cost;
     Description = description;
     Potency = potency;
     Accuracy = accuracy;
     SpellMagicSchoolType = spellmagicschooltype;
     SpellElementType = spellelementtype;
     SkillEffectType = spelleffecttype;
 }
        async Task CS_WP_MT_Basic(EffectType effectType)
        {
            StorageFile source = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Input/Car.mp4"));
            StorageFile destination = await KnownFolders.VideosLibrary.CreateFileAsync("CS_WP_MT_Basic" + effectType + ".mp4", CreationCollisionOption.ReplaceExisting);

            var definition = await Utils.CreateEffectDefinitionAsync(effectType);

            var transcoder = new MediaTranscoder();
            transcoder.AddVideoEffect(definition.ActivatableClassId, true, definition.Properties);

            PrepareTranscodeResult transcode = await transcoder.PrepareFileTranscodeAsync(source, destination, MediaEncodingProfile.CreateMp4(VideoEncodingQuality.Qvga));
            await transcode.TranscodeAsync();
        }
Exemple #23
0
		static Color ColorForEffect(EffectType t, Color orig)
		{
			switch (t)
			{
				case EffectType.Black:
					return Color.FromArgb(orig.A, Color.Black);
				case EffectType.Desaturated:
					var lum = (int)(255 * orig.GetBrightness());
					return Color.FromArgb(orig.A, lum, lum, lum);
				default:
				case EffectType.None:
					return orig;
			}
		}
        private XGEffect(EffectType effectType, int value, string name, string description, int[] paramTypeIDs, int[] initialValues)
        {
            Debug.Assert(paramTypeIDs.Length == 16);
            Debug.Assert(initialValues.Length == 16);

            this.EffectValue = value;
            this.Name = name;
            this.Description = description;

            this.ParameterTypes = new ReadOnlyCollection<XGEffectParam>(Array.ConvertAll(paramTypeIDs, id => paramTypeTable[id]));
            this.InitialValues = new ReadOnlyCollection<int>(initialValues);
            this.SelectableForChorus = (effectType & EffectType.Chorus) != 0;
            this.SelectableForReverb = (effectType & EffectType.Reverb) != 0;
            this.ExDataUsed = (effectType & EffectType.UseDataMSB) != 0;
        }
        async Task CS_WP_MC_Basic(EffectType effectType)
        {
            StorageFile source = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///Input/Car.mp4"));
            StorageFile destination = await KnownFolders.VideosLibrary.CreateFileAsync("CS_WP_MC_Basic_" + effectType + ".mp4", CreationCollisionOption.ReplaceExisting);

            var definition = await Utils.CreateEffectDefinitionAsync(effectType);

            var clip = await MediaClip.CreateFromFileAsync(source);
            clip.VideoEffectDefinitions.Add(definition);

            var composition = new MediaComposition();
            composition.Clips.Add(clip);

            await composition.RenderToFileAsync(destination);
        }
    public bool HasEffect(EffectType type)
    {
        for(int i = 0; i< statusEffects.Count; i++)
        {
            Type t = statusEffects[i].GetType();
            Type TT = GetEffectFromEnum(type).GetType();
           if(t.Equals(TT))
           {
               return true;
           }

        }
        return false;
       
    }
 public void Trigger(EffectType effectType)
 {
     switch (effectType)
     {
         case EffectType.RocketTrail:
             {
                 this.TrailEmitter.Trigger(this.Position);
                 break;
             }
         case EffectType.RocketExplosion:
             {
                 this.ExplosionEmitter.Trigger(this.Position);
                 break;
             }
     }
 }
        public void initialize(EffectType pType, Vector2 pOrigin, ref Particle[] particleCollection, float angle = 0.0f)
        {
            mParticles = particleCollection;
                mType = pType;
                mOrigin = pOrigin;
                mAngle = angle;

                switch (mType)
                {
                    case EffectType.explosionOnGround:
                        initFountain();
                        break;
                    case EffectType.explosionFromCannon:
                        initExplosion();
                        break;
                }
        }
    public void CreateFloatingSpecialText(Vector3 position, EffectType type, int percentage)
    {
        GameObject newFloatingText = (GameObject)Instantiate(_floatingText);

        newFloatingText.transform.position = TextReposition(position);

        TextMesh textMesh = newFloatingText.GetComponent<TextMesh>();

        string text = string.Empty;

        switch (type)
        {
            case EffectType.run:
                if (percentage >= 0)
                {
                    text = "speed";
                }
                else
                {
                    text = "slowed";
                }

                break;
            case EffectType.stun:
                text = "stunned";

                break;
            case EffectType.def:
                if (percentage >= 0)
                {
                    text = "defence";
                }
                else
                {
                    text = "volnurable";
                }

                break;
        }

        textMesh.text = text;
        textMesh.color = Color.cyan;

        _gameObjectList.Add(newFloatingText);
    }
Exemple #30
0
		internal EffectVideo(EffectType eType)
			: base(eType)
		{
			try
			{
				bCUDA = Preferences.bCUDA;
				nFrameCurrent = 0;
				stArea = new Area(0, 0, 0, 0);
				nMaxOpacity = 255;
				nInDissolve = 0;
				nOutDissolve = 0;
			}
			catch
			{
				Fail();
				throw;
			}
		}
Exemple #31
0
    //construct for battle effect font
    public BattleEffectFont(Transform parent, PackedSprite effectFont, SpriteText textSkill, PackedSprite number, Vector3 position, Vector3 offset, EffectType type, int val, string skillName)
    {
        // _mainCamera = Globals.Instance.MSceneManager.mMainCamera;
        // _uICamera = Globals.Instance.MGUIManager.MGUICamera;

        this.effectFontPreb = effectFont;
        this.textSkillPreb  = textSkill;
        this.numberPreb     = number;

        this.ReleaseEffect(parent, position, type, val, skillName, offset);
    }
Exemple #32
0
 public override bool triggersAs(EffectType triggerType)
 {
     return(triggerType == EffectType.meta || triggerType == EffectType.cardDrawn);
 }
Exemple #33
0
 public override bool triggersAs(EffectType triggerType)
 {
     return(base.triggersAs(triggerType) || innerEffect.triggersAs(triggerType));
 }                                                                                                                                         //trigger as a meta effect, but also as whatever the target effect is
        /// <summary>
        /// Process an incoming effect
        /// </summary>
        private void ViewerEffectHandler(Packet packet, Simulator simulator)
        {
            ViewerEffectPacket effect = (ViewerEffectPacket)packet;

            foreach (ViewerEffectPacket.EffectBlock block in effect.Effect)
            {
                EffectType type = (EffectType)block.Type;

                //LLColor color;
                //if (block.Color.Length == 4)
                //{
                //    color = new LLColor(block.Color, 0);
                //}
                //else
                //{
                //    Client.Log("Received a ViewerEffect.EffectBlock.Color array with " + block.Color.Length +
                //        " bytes", Helpers.LogLevel.Warning);
                //    color = LLColor.Black;
                //}

                // Each ViewerEffect type uses it's own custom binary format for additional data. Fun eh?
                switch (type)
                {
                case EffectType.Text:
                    Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
                               Helpers.LogLevel.Warning, Client);
                    break;

                case EffectType.Icon:
                    Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
                               Helpers.LogLevel.Warning, Client);
                    break;

                case EffectType.Connector:
                    Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
                               Helpers.LogLevel.Warning, Client);
                    break;

                case EffectType.FlexibleObject:
                    Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
                               Helpers.LogLevel.Warning, Client);
                    break;

                case EffectType.AnimalControls:
                    Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
                               Helpers.LogLevel.Warning, Client);
                    break;

                case EffectType.AnimationObject:
                    Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
                               Helpers.LogLevel.Warning, Client);
                    break;

                case EffectType.Cloth:
                    Logger.Log("Received a ViewerEffect of type " + type.ToString() + ", implement me!",
                               Helpers.LogLevel.Warning, Client);
                    break;

                case EffectType.Glow:
                    Logger.Log("Received a Glow ViewerEffect which is not implemented yet",
                               Helpers.LogLevel.Warning, Client);
                    break;

                case EffectType.Beam:
                case EffectType.Point:
                case EffectType.Trail:
                case EffectType.Sphere:
                case EffectType.Spiral:
                case EffectType.Edit:
                    if (OnEffect != null)
                    {
                        if (block.TypeData.Length == 56)
                        {
                            LLUUID     sourceAvatar = new LLUUID(block.TypeData, 0);
                            LLUUID     targetObject = new LLUUID(block.TypeData, 16);
                            LLVector3d targetPos    = new LLVector3d(block.TypeData, 32);

                            try { OnEffect(type, sourceAvatar, targetObject, targetPos, block.Duration, block.ID); }
                            catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
                        }
                        else
                        {
                            Logger.Log("Received a " + type.ToString() +
                                       " ViewerEffect with an incorrect TypeData size of " +
                                       block.TypeData.Length + " bytes", Helpers.LogLevel.Warning, Client);
                        }
                    }
                    break;

                case EffectType.LookAt:
                    if (OnLookAt != null)
                    {
                        if (block.TypeData.Length == 57)
                        {
                            LLUUID     sourceAvatar = new LLUUID(block.TypeData, 0);
                            LLUUID     targetObject = new LLUUID(block.TypeData, 16);
                            LLVector3d targetPos    = new LLVector3d(block.TypeData, 32);
                            LookAtType lookAt       = (LookAtType)block.TypeData[56];

                            try { OnLookAt(sourceAvatar, targetObject, targetPos, lookAt, block.Duration,
                                           block.ID); }
                            catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
                        }
                        else
                        {
                            Logger.Log("Received a LookAt ViewerEffect with an incorrect TypeData size of " +
                                       block.TypeData.Length + " bytes", Helpers.LogLevel.Warning, Client);
                        }
                    }
                    break;

                case EffectType.PointAt:
                    if (OnPointAt != null)
                    {
                        if (block.TypeData.Length == 57)
                        {
                            LLUUID      sourceAvatar = new LLUUID(block.TypeData, 0);
                            LLUUID      targetObject = new LLUUID(block.TypeData, 16);
                            LLVector3d  targetPos    = new LLVector3d(block.TypeData, 32);
                            PointAtType pointAt      = (PointAtType)block.TypeData[56];

                            try { OnPointAt(sourceAvatar, targetObject, targetPos, pointAt, block.Duration,
                                            block.ID); }
                            catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
                        }
                        else
                        {
                            Logger.Log("Received a PointAt ViewerEffect with an incorrect TypeData size of " +
                                       block.TypeData.Length + " bytes", Helpers.LogLevel.Warning, Client);
                        }
                    }
                    break;

                default:
                    Logger.Log("Received a ViewerEffect with an unknown type " + type, Helpers.LogLevel.Warning, Client);
                    break;
                }
            }
        }
Exemple #35
0
        /// <summary>
        /// /Inserts a list of effects into the Database.
        /// </summary>
        /// <param name="effects"></param>
        public void insertNewEffects(List <Effect> effects, string typeId, int id)
        {
            connection = new SqlConnection(connectionString);
            connection.Open();

            string queryIdSubstring = "";

            switch (typeId)
            {
            case "BaseId":
                queryIdSubstring = "@BaseId, NULL, NULL";
                break;

            case "IngredientId":
                queryIdSubstring = "NULL, @IngredientId, NULL";
                break;

            case "PotionId":
                queryIdSubstring = "NULL, NULL, @PotionId";
                break;
            }

            foreach (Effect e in effects)
            {
                string     query = "";
                EffectType type  = e.getEffectEnumType();
                SqlCommand command;
                switch (type)
                {
                case EffectType.NONE:
                    NoEffect ne = (NoEffect)e;
                    query = "INSERT INTO Effect VALUES(@Name, @EffectType, NULL, NULL, NULL, " + queryIdSubstring + ", NULL)";
                    Console.WriteLine(query);
                    command = new SqlCommand(query, connection);
                    command.Parameters.AddWithValue("@Name", ne.name);
                    command.Parameters.AddWithValue("@EffectType", (int)type);
                    command.Parameters.AddWithValue("@" + typeId, id);
                    command.ExecuteNonQuery();
                    break;

                case EffectType.STAT:
                    StatEffect se = (StatEffect)e;
                    query   = "INSERT INTO Effect VALUES(@Name, @EffectType, @StatType, NULL, NULL, " + queryIdSubstring + ", @Intensity)";
                    command = new SqlCommand(query, connection);
                    command.Parameters.AddWithValue("@Name", se.name);
                    command.Parameters.AddWithValue("@EffectType", (int)type);
                    command.Parameters.AddWithValue("@StatType", (int)se.getAffectedStat());
                    command.Parameters.AddWithValue("@" + typeId, id);
                    command.Parameters.AddWithValue("@Intensity", se.getIntensity());
                    command.ExecuteNonQuery();
                    break;

                case EffectType.BUFF:
                    BuffEffect be = (BuffEffect)e;
                    query   = "INSERT INTO Effect VALUES(@Name, @EffectType, NULL, @BuffType, NULL, " + queryIdSubstring + ", @Intensity)";
                    command = new SqlCommand(query, connection);
                    command.Parameters.AddWithValue("@Name", be.name);
                    command.Parameters.AddWithValue("@EffectType", (int)type);
                    command.Parameters.AddWithValue("@BuffType", (int)be.getBuff());
                    command.Parameters.AddWithValue("@" + typeId, id);
                    command.Parameters.AddWithValue("@Intensity", be.getIntensity());
                    command.ExecuteNonQuery();
                    break;

                case EffectType.DEBUFF:
                    DebuffEffect de = (DebuffEffect)e;
                    query   = "INSERT INTO Effect VALUES(@Name, @EffectType, NULL, NULL, @DebuffType, " + queryIdSubstring + ", @Intensity)";
                    command = new SqlCommand(query, connection);
                    command.Parameters.AddWithValue("@Name", de.name);
                    command.Parameters.AddWithValue("@EffectType", (int)type);
                    command.Parameters.AddWithValue("@DebuffType", (int)de.getDebuff());
                    command.Parameters.AddWithValue("@" + typeId, id);
                    command.Parameters.AddWithValue("@Intensity", de.getIntensity());
                    command.ExecuteNonQuery();
                    break;
                }
            }
            connection.Close();
        }
Exemple #36
0
 //regardless of how the inner effect normally triggers, we want it to fire once every round.  We need to keep the triggertype == EffectType.meta so we dont break EffectData.cloneEffect()
 public override bool triggersAs(EffectType triggerType)
 {
     return((triggerType == EffectType.spawn) || (triggerType == EffectType.meta) || base.triggersAs(triggerType));
 }
Exemple #37
0
        // ========================================================= CONSTRUCTION

        public ActionEffect(string name, EffectType type, Action <T, EffectType> action)
        {
            Name    = name;
            Type    = type;
            _action = action;
        }
Exemple #38
0
 public EffectResult(EffectType type, bool success)
 {
     Type    = type;
     Success = success;
 }
Exemple #39
0
 public Effect(EffectType _type, float seconds, float _value = 0)
 {
     time  = Time.time + seconds;
     type  = _type;
     value = _value;
 }
Exemple #40
0
    }                                                              //always trigger inner effect

    public override bool triggersAs(EffectType triggerType)
    {
        return(triggerType == EffectType.enemyDamaged ||  //allow this to trigger as an onDamage effect even if the child does not
               triggerType == EffectType.sourceTracked || //we want to be notified of the tower when we get added so we can set up the description
               base.triggersAs(triggerType));             //maintain trigger types from the base class
    }
 public EffectBuilder SetType(EffectType type)
 {
     _type = type;
     return(this);
 }
Exemple #42
0
    //crit font
    private void ReleaseEffect(Transform parent, Vector3 position, EffectType type, int val, string skillName, Vector3 offset)
    {
        // Vector3 warshipViewPosition = _mainCamera.WorldToViewportPoint(position);
        // Vector3 uiOffset = new Vector3((warshipViewPosition.x - 0.5f) * Screen.width,(warshipViewPosition.y - 0.5f) * Screen.height,100);

        _gobjCrit = new GameObject("BattleCritFont");
        _gobjCrit.transform.position   = position;
        _gobjCrit.transform.parent     = Globals.Instance.MGUIManager.MGUICamera.transform;
        _gobjCrit.transform.localScale = new Vector3(Globals.Instance.MGUIManager.widthRatio,
                                                     Globals.Instance.MGUIManager.heightRatio, 1);
        // _gobjCrit.transform.localPosition = uiOffset + offset;

        PackedSprite effectFont = null;
        SpriteText   textSkill  = null;
        PackedSprite number     = null;

        switch (type)
        {
        case EffectType.CRIT:
            // effectFont = GameObject.Instantiate(effectFontPreb) as PackedSprite;
            // effectFont.transform.parent = _gobjCrit.transform;
            // effectFont.transform.localPosition = new Vector3 (0, 0, 0);
            // effectFont.PlayAnim ("RedCrit");
            // AnimateScale.Do (_gobjCrit, EZAnimation.ANIM_MODE.To, Vector3.one * 2, EZAnimation.linear, AnimScaleDurationTime, 0f, null, null);
            // FadeSpriteAlpha.Do (effectFont, EZAnimation.ANIM_MODE.To, Color.clear, EZAnimation.linear, AnimAlphaDurationTime, AnimAlphaDelayTime, null, DestroyEffectObj);
            break;

        case EffectType.DODGE:
            effectFont = GameObject.Instantiate(effectFontPreb) as PackedSprite;
            effectFont.transform.parent        = _gobjCrit.transform;
            effectFont.transform.localPosition = new Vector3(0, 0, 0);
            effectFont.transform.localScale    = Vector3.one;
            effectFont.PlayAnim("Shan");

            AnimateScale.Do(_gobjCrit, EZAnimation.ANIM_MODE.To, Vector3.one * 2, EZAnimation.linear, AnimScaleDurationTime, 0f, null, null);
            FadeSpriteAlpha.Do(effectFont, EZAnimation.ANIM_MODE.To, Color.clear, EZAnimation.linear, AnimAlphaDurationTime, AnimAlphaDelayTime, null, DestroyEffectObj);

            break;

        case EffectType.SKILL:
            //delay = 0;
            //duration = 6;
            textSkill = GameObject.Instantiate(textSkillPreb) as SpriteText;
            textSkill.transform.parent        = _gobjCrit.transform;
            textSkill.transform.localPosition = new Vector3(0, 0, 0);
            textSkill.transform.localScale    = Vector3.one;
            textSkill.Text = skillName;
            //textSkill.SetColor(new Color32(255,129,54,255));
            // textSkill.SetColor(new Color32(255,255,0,255));
            textSkill.SeaColor = SeaClientColorType.DarkRed210000005;
            //textSkill.SetColor(Color.magenta);
            textSkill.SetCharacterSize(40);
            FadeText.Do(textSkill, EZAnimation.ANIM_MODE.To, Color.clear, EZAnimation.linear, AnimAlphaDurationTime, AnimAlphaDelayTime, null, DestroyEffectObj);
            break;

        case EffectType.CRIT_SKILL:
            //delay = 0;
            //duration = 6;
            // effectFont = GameObject.Instantiate(effectFontPreb) as PackedSprite;
            // effectFont.transform.parent = _gobjCrit.transform;
            // effectFont.transform.localPosition = new Vector3 (0, 20, 0);
            // effectFont.PlayAnim ("RedCrit");
            // //DoAnimationFade (effectFont, DestroyEffectObj);
            // AnimateScale.Do (_gobjCrit, EZAnimation.ANIM_MODE.To, Vector3.one * 1.5f, EZAnimation.linear, AnimScaleDurationTime, 0f, null, null);
            // FadeSpriteAlpha.Do (effectFont, EZAnimation.ANIM_MODE.To, Color.clear, EZAnimation.linear, AnimAlphaDurationTime, AnimAlphaDelayTime, null, DestroyEffectObj);

            textSkill = GameObject.Instantiate(textSkillPreb) as SpriteText;
            textSkill.transform.parent        = _gobjCrit.transform;
            textSkill.transform.localPosition = new Vector3(0, 0, 0);
            textSkill.transform.localScale    = Vector3.one;
            textSkill.Text = skillName;

            // textSkill.SetColor(new Color32(255,255,0,255));
            textSkill.SeaColor = SeaClientColorType.DarkRed210000005;
            //textSkill.SetColor(Color.magenta);
            textSkill.SetCharacterSize(40);
            FadeText.Do(textSkill, EZAnimation.ANIM_MODE.To, Color.clear, EZAnimation.linear, AnimAlphaDurationTime, AnimAlphaDelayTime, null, DestroyEffectObj);

            break;

        case EffectType.NUMBER_GRAY:
            this.PlayAttackNumber(type, "NumMinus", "NumRed", val);
            break;

        case EffectType.NUMBER_RED:
            this.PlayAttackNumber(type, "NumMinus", "NumRed", val);
            break;

        case EffectType.NUMBER_GREEN:
            this.PlayAttackNumber(type, "GreenPlus", "NumGreen", val);
            break;
        }

        if (type == EffectType.CRIT || type == EffectType.CRIT_SKILL || type == EffectType.NUMBER_RED)
        {
            iTween.ShakePosition(_gobjCrit, new Vector3(5, 5, 0), AnimAlphaDurationTime);
            // _gobjCrit.transform.localScale = new Vector3(2.5f,2.5f,1);
        }
    }
Exemple #43
0
 public void ShowEffect(EffectType effectType, Vector3 position, Quaternion rotation)
 {
     var effect = Instantiate(_effectsMap[effectType], position, rotation);
 }
Exemple #44
0
 private byte[] DoEffectAndUpdate(byte[] image, EffectType effect)
 {
     byte[] buffer = DoEffect(image, effect);
     return(buffer);
 }
    public EffectType type; // The type of the effect

    #endregion
    #region Constructors

    public CardEffect(int newVal, EffectType newType)
    {
        val  = newVal;
        type = newType;
    }
 public AddOrRemoveCounter(EffectType et) : base(et)
 {
 }
Exemple #47
0
        private static Effect GetEffect(EffectType prim)
        {
            Effect eff = null;

            switch (prim)
            {
            case EffectType.Speed:
                eff = new Speed();
                break;

            case EffectType.Slowness:
                eff = new Slowness();
                break;

            case EffectType.Haste:
                eff = new Haste();
                break;

            case EffectType.MiningFatigue:
                eff = new MiningFatigue();
                break;

            case EffectType.Strength:
                eff = new Strength();
                break;

            case EffectType.InstantHealth:
                eff = new InstantHealth();
                break;

            case EffectType.InstantDamage:
                eff = new InstantDamage();
                break;

            case EffectType.JumpBoost:
                eff = new JumpBoost();
                break;

            case EffectType.Nausea:
                eff = new Nausea();
                break;

            case EffectType.Regeneration:
                eff = new Regeneration();
                break;

            case EffectType.Resistance:
                eff = new Resistance();
                break;

            case EffectType.FireResistance:
                eff = new FireResistance();
                break;

            case EffectType.WaterBreathing:
                eff = new WaterBreathing();
                break;

            case EffectType.Invisibility:
                eff = new Invisibility();
                break;

            case EffectType.Blindness:
                eff = new Blindness();
                break;

            case EffectType.NightVision:
                eff = new NightVision();
                break;

            case EffectType.Hunger:
                eff = new Hunger();
                break;

            case EffectType.Weakness:
                eff = new Weakness();
                break;

            case EffectType.Poison:
                eff = new Poison();
                break;

            case EffectType.Wither:
                eff = new Wither();
                break;

            case EffectType.HealthBoost:
                eff = new HealthBoost();
                break;

            case EffectType.Absorption:
                eff = new Absorption();
                break;

            case EffectType.Saturation:
                eff = new Saturation();
                break;
            }
            return(eff);
        }
 public AddOrRemoveCounter(EffectType et, IntegerValue amount) : base(et)
 {
     Amount = amount;
 }
Exemple #49
0
        static void Main(string[] args)
        {
            Utility.WriteExeDetails();

            Utility.LoadStrings(root);

            Utility.LoadClientNpcs(root);

            Utility.LoadItems(root);

            Utility.LoadSkills(root);

            Utility.LoadSkillLearns(root);

            Utility.LoadUltraSkills(root);



            string outputPath = Path.Combine(root, @".\output");

            if (!Directory.Exists(outputPath))
            {
                Directory.CreateDirectory(outputPath);
            }

            var outputFile = new SkillData();

            var settings = new XmlWriterSettings()
            {
                CheckCharacters = false,
                CloseOutput     = false,
                Indent          = true,
                IndentChars     = "\t",
                NewLineChars    = "\n",
                Encoding        = new UTF8Encoding(false)
            };

            #region Pet UltraSkill parsing

            PetSkillTemplates petTemplates = new PetSkillTemplates();
            List <PetSkill>   ultraSkills  = new List <PetSkill>();

            foreach (var ultra in Utility.UltraSkillIndex.UltraSkillList)
            {
                PetSkill petSkill = new PetSkill();
                petSkill.skill_id = Utility.SkillIndex[ultra.ultra_skill].id;
                if (String.Compare("Light_Summon_MagmaElemental_G1", ultra.pet_name) == 0)
                {
                    ultra.pet_name = "Dark_Summon_MagmaElemental_G1";
                }
                else if (String.Compare("Dark_Summon_TempestElemental_G1", ultra.pet_name) == 0)
                {
                    ultra.pet_name = "Light_Summon_TempestElemental_G1";
                }
                petSkill.pet_id = Utility.ClientNpcIndex[ultra.pet_name];
                if (petSkill.pet_id == -1)
                {
                    petSkill.missing_pet_id = ultra.pet_name;
                    petSkill.pet_id         = 0;
                }
                ClientSkill skill = Utility.SkillIndex[ultra.order_skill];
                if (skill != null)
                {
                    petSkill.order_skill = Utility.SkillIndex[ultra.order_skill].id;
                }
                //else
                //    petSkill.missing_order_skill = ultra.order_skill;
                ultraSkills.Add(petSkill);
            }

            petTemplates.SkillList = ultraSkills.OrderBy(s => s.skill_id).ToList();

            try
            {
                using (var fs = new FileStream(Path.Combine(outputPath, "pet_skills.xml"),
                                               FileMode.Create, FileAccess.Write))
                    using (var writer = XmlWriter.Create(fs, settings))
                    {
                        XmlSerializer ser = new XmlSerializer(typeof(PetSkillTemplates));
                        ser.Serialize(writer, petTemplates);
                    }
            }
            catch (Exception ex)
            {
                Debug.Print(ex.ToString());
            }

            #endregion

            /* Old
             *          var skillsetEx = new Dictionary<int, int>() {
             *  { 1566, 1564 }, { 1586, 1564 }, { 2210, 1564 }, { 1574, 1564 }, { 1575, 1564 }, { 1576, 1564 },
             *  { 1596, 1564 }, { 1564, 1564 }, { 1565, 1564 }, { 1590, 1564 },
             *  { 1554, 1554 }, { 1588, 1554 },
             *  { 969, 969 }, { 970, 969 }, { 971, 969 }, { 989, 969 }, { 2181, 969 }, { 1220, 969 },
             *  { 1221, 969 }, { 1222, 969 }, { 1267, 969 }, { 1318, 969 }, { 1319, 969 }, { 1342, 969 },
             *  { 2183, 969 },
             *  { 1105, 1105 }, { 1107, 1105 }, { 1108, 1105 }, { 1187, 1105 }, { 1112, 1105 }, { 1186, 1105 }
             *          };
             */

            // skillset_exception == client_skills.delay_id (All client skills have delay id but skills on same cooldown/exception list have the same delay id)
            var skillsetEx2 = new Dictionary <int, int>()
            {
                { 1564, 2 }, { 1565, 2 }, { 1566, 2 }, { 1574, 2 }, { 1575, 2 }, { 1586, 2 }, { 1590, 2 }, { 1596, 2 }, { 2210, 2 },
                { 1105, 4 }, { 1107, 4 }, { 1108, 4 }, { 1112, 4 }, { 1186, 4 }, { 1187, 4 },
                { 969, 5 }, { 970, 5 }, { 971, 5 }, { 989, 5 }, { 1220, 5 }, { 1221, 5 }, { 1222, 5 }, { 1267, 5 }, { 1318, 5 }, { 1319, 5 }, { 1342, 5 }, { 2181, 5 }, { 2183, 5 },
                { 540, 6 }, { 1636, 6 }, { 1637, 6 }, { 1685, 6 }, { 1708, 6 }, { 1781, 6 }, { 1782, 6 }, { 1935, 6 }, { 2008, 6 }, { 2062, 6 }, { 2231, 6 }, { 2232, 6 }, { 8345, 6 },
                { 173, 7 }, { 524, 7 },
                { 1554, 8 }, { 1555, 8 }, { 1556, 8 }, { 1587, 8 }, { 1588, 8 },
                { 955, 9 }, { 956, 9 }, { 957, 9 }, { 986, 9 }, { 1230, 9 }, { 2159, 9 }, { 2165, 9 }, { 2178, 9 },
                { 559, 175 }, { 582, 175 }, { 851, 175 }, { 858, 175 }, { 948, 175 },
                { 646, 2005 }, { 684, 2005 }, { 693, 2005 }, { 694, 2005 }, { 776, 2005 }, { 777, 2005 }, { 786, 2005 }, { 2075, 2005 }
            };


            // Limit skills with same delay_id to a max # of occurances
            var skillset_maxoccurs = new Dictionary <int, int>()
            {
                { 646, 2 }, { 684, 2 }, { 693, 2 }, { 776, 2 }, { 777, 2 }, { 786, 2 }, { 2075, 2 }
            };

            var delayIdOverrides = new Dictionary <int, int>()
            {
                { 11885, 11885 }, { 11886, 11885 }, { 11887, 11885 }, { 11888, 11885 }, { 11889, 11885 },
                { 11890, 11890 }, { 11891, 11890 }, { 11892, 11890 }, { 11893, 11890 }, { 11894, 11890 }
            };

            //  skills which have 0 cast time or cooldown is smaller and which exclude each other
            var delayIdsForSkills = new Dictionary <int, int>()
            {
                { 1178, 1178 }, { 2148, 1178 }, { 1177, 1178 }, { 2147, 1178 }
            };

            #region Finding the chainDelayIdsInclude

            //Dictionary<int, int> diffDelays = Utility.SkillIndex.SkillList.ToDictionary(s => s.id, s => s.delay_id);
            //Dictionary<int, bool> diffCount = diffDelays.Values.GroupBy(x => x).ToDictionary(x => x.Key, g => g.Count() > 1);

            /*
             * //test lookups
             * int skill_id = 2075; //known to have listed exception
             * int delay_id = 2005; //delay id associated with client skill
             *
             * if (diffCount.ContainsKey(delay_id) && diffCount[delay_id]) {
             *  int skill_exception_test = diffDelays[skill_id];
             * }
             */

            /*
             * var diffDelays = Utility.SkillIndex.SkillList.Where(s => s.delay_id > 0 &&
             *                                                  s.sub_type == SkillSubType.buff &&
             *                                                  s.chain_category_level > 0)
             *                                           .ToLookup(s => s.delay_id, s => s);
             * var chainCategories = new Dictionary<string, List<ClientSkill>>();
             *
             * foreach (var group in diffDelays) {
             *  var skills = diffDelays[group.Key];
             *  string[] chains = skills.Select(s => s.chain_category_priority).Distinct().ToArray();
             *  string categoryName = chains.Where(s => s != null).FirstOrDefault();
             *  if (categoryName == null) {
             *      chains = skills.Select(s => s.prechain_skillname).Distinct().ToArray();
             *      categoryName = chains.Where(s => s != null).FirstOrDefault();
             *  }
             *
             *  if (categoryName == null)
             *      continue;
             *
             *  if (chainCategories.ContainsKey(categoryName)) {
             *      Debug.Print("Different delay id for chain: {0}", categoryName);
             *      chainCategories[categoryName].AddRange(skills.ToList());
             *  } else {
             *      chainCategories.Add(categoryName, skills.ToList());
             *  }
             * }
             *
             * chainCategories = chainCategories.Where(pair => pair.Value.Count > 1)
             *                               .OrderBy(p => p.Value.First().delay_id)
             *                               .ToDictionary(pair => pair.Key, pair => pair.Value);
             *
             * // StringBuilder sb = new StringBuilder();
             * foreach (var pair in chainCategories) {
             *  // sb.AppendFormat("SkillSet by delay: {0}\r\n", pair.Key);
             *  foreach (var skill in pair.Value) {
             *      // string desc = Utility.StringIndex.GetString(skill.desc);
             *      if (skill.casting_delay == 0) {
             *          int dur = 0;
             *          if (skill.effect1_reserved_cond1 == null ||
             *              skill.effect1_reserved_cond1_prob2 == 100 &&
             *              skill.effect1_reserved_cond1 == "EveryHit")
             *              dur = Math.Max(dur, skill.effect1_remain2);
             *          if (skill.effect2_reserved_cond1 == null ||
             *              skill.effect2_reserved_cond1_prob2 == 100 &&
             *              skill.effect2_reserved_cond1 == "EveryHit")
             *              dur = Math.Max(dur, skill.effect2_remain2);
             *          if (skill.effect3_reserved_cond1 == null ||
             *              skill.effect3_reserved_cond1_prob2 == 100 &&
             *              skill.effect3_reserved_cond1 == "EveryHit")
             *              dur = Math.Max(dur, skill.effect3_remain2);
             *          if (skill.effect4_reserved_cond1 == null ||
             *              skill.effect4_reserved_cond1_prob2 == 100 &&
             *              skill.effect4_reserved_cond1 == "EveryHit")
             *              dur = Math.Max(dur, skill.effect4_remain2);
             *          skill.casting_delay = dur;
             *      }
             *
             *      if (skill.casting_delay == 0 || skill.casting_delay / 1000 > skill.delay_time / 100) {
             *          sb.AppendFormat("\tSkill: id={0}; name={1}; delayId={2}; r10={3}/{4}/{5}/{6}; delay={7}; cooldown={8}\r\n",
             *                          skill.id, desc,
             *                          skill.delay_id, skill.effect1_reserved10, skill.effect2_reserved10,
             *                          skill.effect3_reserved10, skill.effect4_reserved10,
             *                          skill.casting_delay, skill.delay_time / 100);
             *      }
             *  }
             * }
             */

            #endregion

            Dictionary <ClientSkill, List <ClientEffect> > list     = new Dictionary <ClientSkill, List <ClientEffect> >();
            Dictionary <string, HashSet <string> >         statData = new Dictionary <string, HashSet <string> >();

            const EffectType filterEffect = EffectType.None;
            const Stat       filterStat   = Stat.None;
            StringBuilder    sb           = new StringBuilder();

            //for (var filterEffect = EffectType.None + 1;
            //     filterEffect <= EffectType.XPBoost; filterEffect++) {

            foreach (var sk in Utility.SkillIndex.SkillList)
            {
                var template = new SkillTemplate();
                template.skill_id = sk.id;
                template.name     = sk.desc;

                // Check Skill Strings for Name ID
                template.nameId = Utility.StringIndex[sk.desc.ToUpper()] * 2 + 1;

                // SKill Name ID is Not in Skill Strings, Check Item Stings
                if (template.nameId == -1)
                {
                    template.nameId = Utility.StringIndex[sk.desc.ToUpper()] * 2 + 1;
                }

                // SKill Name ID is Not in Item Strings, Check Main Strings
                if (template.nameId == -1)
                {
                    template.nameId = Utility.StringIndex[sk.desc.ToUpper()] * 2 + 1;
                }

                // SKill Name ID is Not in General Strings, Check UI Strings
                if (template.nameId == -1)
                {
                    template.nameId = Utility.StringIndex[sk.desc.ToUpper()] * 2 + 1;
                }

                string stack;
                int    level = -1;
                if (level == -1)
                {
                    level = Utility.GetSkillLevelFromName(sk.name, out stack);
                }
                //if (level == -1 && !String.IsNullOrEmpty(sk.skillicon_name))
                //    level = Utility.GetSkillLevelFromName(sk.skillicon_name, out stack);
                if (level == -1)
                {
                    level = 1;
                }
                template.lvl   = level;
                level          = Utility.GetSkillLevelFromName(sk.desc, out stack);
                template.stack = stack.ToUpper();
                // some overides for stack.
                if (sk.id == 251 || sk.id == 258 || sk.id == 385)
                {
                    template.stack = "SKILL_GL_251_258_385";
                }


                template.skilltype    = (skillType)sk.type;
                template.skillsubtype = (skillSubType)sk.sub_type;
                template.tslot        = (TargetSlot)sk.target_slot;
                template.tslot_level  = sk.target_slot_level;
                template.activation   = (activationAttribute)sk.activation_attribute;
                template.cooldown     = sk.delay_time / 100;
                template.cancel_rate  = sk.cancel_rate;
                if (sk.casting_delay > 0)
                {
                    template.duration = sk.casting_delay;
                }
                template.pvp_duration     = sk.pvp_remain_time_ratio;
                template.chain_skill_prob = sk.chain_skill_prob1 == 0 && sk.chain_skill_prob2 != 0 ? sk.chain_skill_prob2 : 0;
                //template.dispel_category = sk.dispel_category.ToString().ToUpper();
                template.dispel_category = sk.getDispellCategory();
                //template.dispel_level = sk.required_dispel_level;
                //template.delay_id = sk.delay_id;

                if (!String.IsNullOrEmpty(sk.penalty_skill_succ))
                {
                    var penaltySkill = Utility.SkillIndex[sk.penalty_skill_succ];
                    if (penaltySkill == null)
                    {
                        Debug.Print("Missing penalty skill: {0}", sk.penalty_skill_succ);
                    }
                    else
                    {
                        template.penalty_skill_id = penaltySkill.id;
                    }
                }

                if (sk.change_stance != Stance.none)
                {
                    template.stance = true;
                }
                template.pvp_damage = sk.pvp_damage_ratio;

                if (sk.first_target != FirstTarget.None)
                {
                    //template.setproperties = new Properties();
                    var properties = new Properties();

                    properties.firsttarget       = new FirstTargetProperty();
                    properties.firsttarget.value = (FirstTargetAttribute)sk.first_target;
                    if (sk.first_target_valid_distance > 0)
                    {
                        properties.firsttargetrange                = new FirstTargetRangeProperty();
                        properties.firsttargetrange.value          = sk.first_target_valid_distance;
                        properties.firsttargetrange.valueSpecified = true;
                    }
                    //else if (sk.first_target == FirstTarget.Target)
                    //	properties.firsttargetrange = new FirstTargetRangeProperty();

                    if (sk.target_range != TargetRange.None)
                    {
                        properties.target_range = new TargetRangeProperty();
                        if (sk.target_range_opt1 != 0)
                        {
                            properties.target_range.distance          = sk.target_range_opt1;
                            properties.target_range.distanceSpecified = true;
                        }
                        if (sk.target_maxcount != 0)
                        {
                            properties.target_range.maxcount          = sk.target_maxcount;
                            properties.target_range.maxcountSpecified = true;
                        }
                        if (sk.target_range != TargetRange.None)
                        {
                            properties.target_range.value = (TargetRangeAttribute)sk.target_range;
                        }
                    }


                    if (sk.target_relation_restriction != RelationRestriction.None)
                    {
                        properties.targetrelation       = new TargetRelationProperty();
                        properties.targetrelation.value = (TargetRelationAttribute)sk.target_relation_restriction;
                    }


                    if (sk.target_species_restriction != SpeciesRestriction.None)
                    {
                        properties.targetspecies       = new TargetSpeciesProperty();
                        properties.targetspecies.value = (TargetSpeciesAttribute)sk.target_species_restriction;
                    }


                    var           importUtil = Utility <ClientSkill> .Instance;
                    List <string> states     = new List <string>();
                    importUtil.Export <string>(sk, "target_valid_status", states);
                    TargetState state = 0;
                    foreach (string s in states)
                    {
                        try
                        {
                            TargetState s1 = (TargetState)Enum.Parse(typeof(TargetState), s, true);
                            state |= s1;
                        }
                        catch (Exception e) { }
                    }
                    //if (state != TargetState.NONE)
                    //{
                    //    states = states.ConvertAll(s => s.ToUpper());
                    //    List<TargetStatusProperty> statusProperties = states.ConvertAll(s => { TargetStatusProperty t = new TargetStatusProperty(); t.value = s; return t; });
                    //    properties.targetstatus = statusProperties;
                    //}

                    if (sk.add_wpn_range)
                    {
                        template.initproperties = new Properties();
                        template.initproperties.addweaponrange = new AddWeaponRangeProperty();
                    }

                    template.setproperties = properties;
                }

                template.useconditions   = new Conditions();
                template.startconditions = new Conditions();
                template.actions         = new Actions();

                List <Condition> useList = new List <Condition>();
                List <Condition> useEquipmentConditionsList = new List <Condition>();
                List <Condition> startList  = new List <Condition>();
                List <Action>    actionList = new List <Action>();

                //TargetFlyingCondition targetflyingcondition = null;
                TargetCondition targetcondition = null;

                /*
                 * if (sk.target_species_restriction != SpeciesRestriction.None && sk.target_species_restriction != SpeciesRestriction.All)
                 * {
                 *  targetcondition = new TargetCondition((FlyingRestriction)sk.target_species_restriction);
                 *  startList.Add(targetcondition);
                 * }*/

                /*
                 * if (sk.required_leftweapon != LeftWeapon.None)
                 * {
                 *  useEquipmentConditionsList.Add(new ArmorCondition(sk.required_leftweapon.ToString().ToUpper()));
                 * }
                 */

                // Periodic Actions
                if (sk.cost_checktime > 0 || sk.cost_toggle > 0)
                {
                    PeriodicAction periodicAction = new PeriodicAction();
                    CostType       parameter      = sk.cost_checktime_parameter;

                    if (parameter == CostType.NONE)
                    {
                        parameter = sk.cost_parameter;
                    }

                    if (parameter == CostType.MP || parameter == CostType.MP_RATIO)
                    {
                        var mpUseAction = new MpUseAction();
                        periodicAction.checktime = sk.cost_time;
                        mpUseAction.percent      = parameter == CostType.MP_RATIO;

                        if (sk.cost_checktime_lv > 0 || sk.cost_checktime > 0)
                        {
                            mpUseAction.value = sk.cost_checktime;
                            mpUseAction.delta = sk.cost_checktime_lv;
                        }
                        else if (sk.cost_toggle_lv > 0 || sk.cost_toggle > 0)
                        {
                            mpUseAction.value = sk.cost_toggle;
                            mpUseAction.delta = sk.cost_toggle_lv;
                        }
                        periodicAction.mpuse = mpUseAction;
                    }
                    else if (parameter == CostType.HP || parameter == CostType.HP_RATIO)
                    {
                        var hpUseAction = new HpUseAction();
                        periodicAction.checktime = sk.cost_time;
                        hpUseAction.percent      = parameter == CostType.HP_RATIO;

                        if (sk.cost_checktime_lv > 0 || sk.cost_checktime > 0)
                        {
                            hpUseAction.value = sk.cost_checktime;
                            hpUseAction.delta = sk.cost_checktime_lv;
                        }
                        else if (sk.cost_toggle_lv > 0 || sk.cost_toggle > 0)
                        {
                            hpUseAction.value = sk.cost_toggle;
                            hpUseAction.delta = sk.cost_toggle_lv;
                        }

                        periodicAction.hpuse = hpUseAction;
                    }

                    //template.periodicactions = periodicAction;
                }
                else
                {
                    // Non Periodic Actions
                    if (sk.cost_parameter != CostType.NONE && sk.cost_checktime == 0)
                    {
                        CostType parameter = sk.cost_checktime_parameter;

                        if (parameter == CostType.NONE)
                        {
                            parameter = sk.cost_parameter;
                        }

                        if (parameter == CostType.MP || parameter == CostType.MP_RATIO)
                        {
                            var mpUseAction = new MpUseAction();
                            mpUseAction.percent = parameter == CostType.MP_RATIO;

                            if (sk.cost_end > 0 || sk.cost_end_lv > 0)
                            {
                                mpUseAction.value = sk.cost_end;
                                mpUseAction.delta = sk.cost_end_lv;
                                actionList.Add(mpUseAction);
                            }
                            else if (sk.cost_toggle_lv > 0 || sk.cost_toggle > 0)
                            {
                                mpUseAction.value = sk.cost_toggle;
                                mpUseAction.delta = sk.cost_toggle_lv;
                                actionList.Add(mpUseAction);
                            }
                        }
                        else if (parameter == CostType.HP || parameter == CostType.HP_RATIO)
                        {
                            var hpUseAction = new HpUseAction();
                            hpUseAction.percent = parameter == CostType.HP_RATIO;

                            if (sk.cost_end > 0 || sk.cost_end_lv > 0)
                            {
                                hpUseAction.value = sk.cost_end;
                                hpUseAction.delta = sk.cost_end_lv;
                                actionList.Add(hpUseAction);
                            }
                            else if (sk.cost_toggle_lv > 0 || sk.cost_toggle > 0)
                            {
                                hpUseAction.value = sk.cost_toggle;
                                hpUseAction.delta = sk.cost_toggle_lv;
                                actionList.Add(hpUseAction);
                            }
                        }
                    }
                }

                if (sk.cost_end != 0)
                {
                    startList.Add(new MpCondition(sk.cost_end, sk.cost_end_lv));
                }

                /*
                 * if (sk.required_leftweapon != LeftWeapon.None)
                 * {
                 *  startList.Add(new ArmorCondition(sk.required_leftweapon.ToString().ToUpper()));
                 * }*/

                if (sk.use_arrow != null && sk.use_arrow != "0")
                { // 3 arena skills have FX_pow, FX_HIT and weaponbody
                    startList.Add(new ArrowCheckCondition());
                }
                else
                {
                    if (sk.use_arrow_count != 0)
                    {
                        startList.Add(new ArrowCheckCondition());
                    }
                }

                if (sk.cost_dp > 0)
                {
                    startList.Add(new DpCondition(sk.cost_dp));
                    actionList.Add(new DpUseAction(sk.cost_dp, sk.cost_dp_lv));
                }

                /*
                 * string required_weapons = getRequiredWeapons(sk);
                 * if (required_weapons != null)
                 * {
                 *  startList.Add(new WeaponCondition(required_weapons));
                 * }
                 *
                 * // Target Flying Start Condition
                 * FlyRestriction restriction = (FlyRestriction)sk.target_flying_restriction;
                 * if (restriction != FlyRestriction.NONE)
                 * {
                 *  if (targetflyingcondition == null)
                 *      startList.Add(new TargetFlyingCondition(restriction));
                 *  else
                 *      targetflyingcondition.restriction = restriction;
                 * }
                 *
                 * if (sk.chain_category_name != null)
                 * {
                 *  ChainCondition chain = new ChainCondition();
                 *  chain.category = sk.chain_category_name.ToUpper();
                 *
                 *  if (sk.prechain_category_name != null) chain.precategory = sk.prechain_category_name.ToUpper();
                 *  if (sk.chain_time != null) chain.time = Int32.Parse(sk.chain_time);
                 *
                 *  startList.Add(chain);
                 * }
                 */

                // Self Flying Start Condition

                /*
                 * restriction = (FlyRestriction)sk.self_flying_restriction;
                 * if (restriction != FlyRestriction.NONE)
                 *  startList.Add(new SelfCondition(restriction));
                 *
                 * if (sk.nouse_combat_state == 1)
                 * {
                 *  startList.Add(new CombatCheckCondition());
                 * }
                 */

                if (sk.component != null)
                {
                    Item item = Utility.ItemIndex.GetItem(sk.component);
                    if (item == null)
                    {
                        Debug.Print("Missing item for skill {0}", sk.id);
                    }
                    else
                    {
                        actionList.Add(new ItemUseAction(item.id, sk.component_count));
                    }
                }

                if (!sk.move_casting)
                {
                    useList.Add(new PlayerMovedCondition(false));
                }

                #region Fill conditions and actions

                // Use Conditions
                if (useList.Count == 0)
                {
                    template.useconditions = null;
                }
                else
                {
                    template.useconditions.ConditionList = useList;
                }

                // Start Conditions
                if (startList.Count == 0)
                {
                    template.startconditions = null;
                }
                else
                {
                    template.startconditions.ConditionList = startList;
                }


                // Skill Actions
                if (actionList.Count == 0)
                {
                    template.actions = null;
                }
                else
                {
                    template.actions.ActionList = actionList;
                }

                #endregion

                if (skillsetEx2.ContainsKey(sk.id))
                {
                    template.skillset_exception = skillsetEx2[sk.id];
                }

                /*
                 * if (sk.delay_id != 0)
                 *  template.skillset_exception = diffCount.ContainsKey(sk.delay_id) && diffCount[sk.delay_id] == true ? diffDelays[sk.id] : 0;
                 */


                //if (delayIdsForSkills.ContainsKey(sk.id))
                //{
                //    template.delay_id = delayIdsForSkills[sk.id];
                //}
                //else if (delayIdOverrides.ContainsKey(sk.id))
                //{
                //    template.delay_id = delayIdOverrides[sk.id];
                //}

                string descrStr = sk.desc_long == null ? sk.desc : sk.desc_long;
                var    desc     = Utility.StringIndex.GetStringDescription(descrStr);
                string desc_2nd;
                if (!String.IsNullOrEmpty(sk.desc_long_2nd))
                {
                    desc_2nd = Utility.StringIndex.GetStringDescription(sk.desc_long_2nd).body;
                }

                if (sk.motion_name != ClientMotion.None)
                {
                    Motion motion = new Motion();
                    motion.name          = sk.motion_name != ClientMotion.None ? sk.motion_name.ToString().ToLower() : null;
                    motion.instant_skill = sk.instant_skill != null && sk.instant_skill == "1" ? true : false;
                    motion.speed         = sk.motion_play_speed != 0 && sk.motion_play_speed != 100 ? sk.motion_play_speed : 0;
                    template.motion      = motion;
                }


                #region Effect processing

                var utility = Utility <ClientSkill> .Instance;
                List <ClientEffect> effects = new List <ClientEffect>();
                utility.Export(sk, "effect", effects);

                var  validEffects = effects.Where(e => e.type != EffectType.None).ToArray();
                bool save         = validEffects.Where(e => e.type == filterEffect).Any();
                // var validEffects = effects.Where(e => e.changeStat != Stat.None).ToArray();
                // bool save = validEffects.Where(e => e.changeStat == filterStat).Any();

                string text = desc == null ? String.Empty : desc.body;
                int    idx  = 0;
                var    vars = (from v in Utility.GetVarStrings(text)
                               let parts = v.Split('.')
                                           let parsed = Int32.TryParse(parts[0].Remove(0, 1), out idx)
                                                        let name = parsed ? parts[1] : v
                                                                   let var = parsed ? parts[2] : String.Empty
                                                                             select new { Id = idx, Data = new StatData(name, var) })
                              .ToLookup(a => a.Id, a => a);

                if (save)
                {
                    sb.Append("\r\n");
                    sb.AppendFormat("---Skill Id = {0}, Name = '{1}' ---\r\n",
                                    sk.id, Utility.StringIndex.GetString(sk.desc));
                    if (desc == null)
                    {
                        sb.AppendFormat("NO DESCRIPTION\r\n");
                    }
                    else
                    {
                        sb.AppendFormat("{0}: {1}\r\n", desc.name, desc.body);
                    }
                    if (sk.desc_abnormal != null)
                    {
                        sb.AppendFormat("ABNORMAL: {0}\r\n", Utility.StringIndex.GetString(sk.desc_abnormal));
                    }
                }

                foreach (var eff in validEffects)
                {
                    EffectClass @class = (EffectClass)eff.type;

                    #region Overrides


                    #endregion

                    Type type = effectsAssembly.GetType(String.Format("{0}.{1}", typeof(Effect).Namespace,
                                                                      @class.ToString()));
                    Effect ourEffect = null;

                    if (save)
                    {
                        sb.AppendFormat("Data for {0}:\r\n", @class);
                    }

                    if (vars.Any())
                    {
                        if (vars.Contains(idx + 1))
                        {
                            foreach (var v in vars[idx + 1])
                            {
                                if (!statData.ContainsKey(v.Data.Name))
                                {
                                    statData.Add(v.Data.Name, new HashSet <string>());
                                }
                                statData[v.Data.Name].Add(v.Data.Var);
                                if (save)
                                {
                                    sb.AppendFormat("\tEffect = {0}, Var = {1}\r\n",
                                                    v.Data.Name, v.Data.Var);
                                }
                            }
                        }
                    }
                    if (save)
                    {
                        sb.AppendFormat("\tE{0} Reserved: ", eff.e);
                        using (TextWriter wr = new StringWriter(sb))
                        {
                            ObjectDumper.Write(eff.reserved, wr);
                            sb.Append("\r\n");
                            if (!String.IsNullOrEmpty(eff.reserved_cond1))
                            {
                                sb.AppendFormat("\tCondition = {0}, Prob. = ", eff.reserved_cond1);
                                ObjectDumper.Write(eff.reserved_cond1_prob, wr);
                                sb.Append("\r\n");
                            }
                            if (!String.IsNullOrEmpty(eff.reserved_cond2))
                            {
                                sb.AppendFormat("\tCondition = {0}, Prob. = ", eff.reserved_cond2);
                                ObjectDumper.Write(eff.reserved_cond2_prob, wr);
                                sb.Append("\r\n");
                            }
                        }
                    }

                    if (type == null)
                    {
                        string skillName = Utility.StringIndex.GetString(sk.desc);
                        Debug.Print("Effect {0} not handled (skillId={1}; name='{2}')", @class, sk.id, skillName);
                        continue;
                    }
                    else
                    {
                        ourEffect = (Effect)Activator.CreateInstance(type);
                    }

                    if (template.effects == null)
                    {
                        template.effects = new Effects();/*
                                                          * if (sk.skillicon_name != null)
                                                          * template.effects.food = sk.skillicon_name.EndsWith("_food"); */
                    }

                    eff.Skill    = sk;
                    eff.Template = template;
                    ourEffect.Import(eff, null);

                    template.effects.EffectList.Add(ourEffect);
                }

                #endregion

                //if (template.effects != null && template.effects.EffectList != null) {
                //    if (template.effects.EffectList.Count == 0)
                //        template.effects.EffectList = null;
                //    else if (template.activation != activationAttribute.PASSIVE) {
                //        foreach (var eff in template.effects.EffectList) {
                //            if (eff is DeformEffect || eff is PolymorphEffect || eff is ShapeChangeEffect ||
                //                eff is WeaponDualEffect) {
                //            } else
                //                eff.basiclvl = 0; // not used for active skills
                //        }
                //    }
                //}
                if (template.effects != null && template.effects.EffectList == null)
                {
                    template.effects = null;
                }

                outputFile.SkillList.Add(template);

                if (filterEffect != EffectType.None)
                {
                    string fileName = /*"stat_" + filterStat*/ filterEffect.ToString() + ".txt";
                    using (var fs = new FileStream(Path.Combine(outputPath, fileName), FileMode.Create,
                                                   FileAccess.Write))
                    {
                        using (TextWriter wr = new StreamWriter(fs))
                        {
                            wr.Write(sb.ToString());
                        }
                    }
                }

                sb.Length = 0;
            }

            try
            {
                using (var fs = new FileStream(Path.Combine(outputPath, "skill_templates.xml"),
                                               FileMode.Create, FileAccess.Write))
                    using (var writer = XmlWriter.Create(fs, settings))
                    {
                        XmlSerializer ser = new XmlSerializer(typeof(SkillData));
                        ser.UnknownAttribute += new XmlAttributeEventHandler(OnUnknownAttribute);
                        ser.UnknownElement   += new XmlElementEventHandler(OnUnknownElement);
                        ser.Serialize(writer, outputFile);
                    }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }

            Console.WriteLine("Process completed");
            Console.Read();
        }
Exemple #50
0
        //----------------------------------------------------------------------
        //  Here we do the actual work of studying tiles to see if they are suitable
        //  for spawn; if something is wrong with the spawn finder, it's probably
        //  here
        //----------------------------------------------------------------------
        private static bool FindSpawnTileInternal(
            PlayerMobile pm,
            Point3D centerPoint,
            Point2D currentPoint,
            ref Point3D spawnPoint,
            LandType landType,
            EffectType effectType,
            int effectHue
            )
        {
            Map    map          = pm.Map;
            Region sourceRegion = pm.Region;

            LandTile landTile  = map.Tiles.GetLandTile(centerPoint.X, centerPoint.Y);
            LandTile spawnTile = map.Tiles.GetLandTile(currentPoint.X, currentPoint.Y);

            StaticTile[] staticTiles = map.Tiles.GetStaticTiles(currentPoint.X, currentPoint.Y, true);

            Region r = Region.Find(new Point3D(currentPoint.X, currentPoint.Y, landTile.Z), map);

            if (r.GetType() != sourceRegion.GetType())
            {
                //Console.WriteLine( "player.Location="+pm.Location );
                //Console.WriteLine( "rquery={0},{1}", currentPoint.X, currentPoint.Y );
                //Console.WriteLine( "sourceRegion="+sourceRegion.GetType() );
                //Console.WriteLine( "r="+r.GetType() );
                return(false);
            }

            if (r is HouseRegion)
            {
                return(false);
            }

            //--------------------------------------------------------------
            //  WATER LOCATION:
            //--------------------------------------------------------------
            if ((TileData.LandTable[spawnTile.ID & 0x3FFF].Flags & TileFlag.Wet) == TileFlag.Wet)
            {
                if (landType != LandType.Water)
                {
                    return(false);                                             // water tile, isn't a water encounter
                }
                //----------------------------------------------------------
                // Instead of the CanSpawn function we use can fit, as it allows us to not require
                // a surface (which defaults to true otherwise)
                //----------------------------------------------------------

                if (map.CanFit(currentPoint.X, currentPoint.Y, spawnTile.Z, 16, true, true, false))
                {
                    spawnPoint.X = currentPoint.X;
                    spawnPoint.Y = currentPoint.Y;
                    spawnPoint.Z = spawnTile.Z;

                    return(true);
                }
                //----------------------------------------------------------
                // XXX -- note; there is a degenerate case where the static and not the land tile
                //        determines water. This is along coastlines, and in rivers and the like;
                //        may be useful later, as we can take "Wet" cells to generally be "at sea".
                //  For now, though, we are ignoring these static wet tiles. One reason for
                //        this is that if we don't we could end up getting dolphins in small
                //        inland lakes.
                //----------------------------------------------------------
            }
            //--------------------------------------------------------------
            //  LAND LOCATION:
            //--------------------------------------------------------------
            else
            {
                if (landType == LandType.Water)
                {
                    return(false);                                             // land tile, isn't a land encounter
                }
                //  search for wet static tiles; these are coastal cells;
                //  if we we want land, we don't want to spawn in cells like these:

                bool foundWet = false;

                foreach (StaticTile staticTile in staticTiles)
                {
                    if ((TileData.ItemTable[staticTile.ID].Flags & TileFlag.Wet) == TileFlag.Wet)
                    {
                        foundWet = true;
                        break;
                    }
                }

                if (foundWet)
                {
                    return(false);
                }

                //if( RandomEncounterEngine.DebugEffect )
                //Effects.SendLocationParticles(
                //EffectItem.Create( new Point3D( currentPoint.X, currentPoint.Y, centerPoint.Z), map, EffectItem.DefaultDuration ),
                //0x37CC, 1, 40, 36, 3, 9917, 0
                //);

                // we will probe highest to lowest if the player is above ground level (e.g, they are in  a tower),
                // or lowest to highest otherwise:

                ArrayList staticTileArray = new ArrayList(staticTiles);
                staticTileArray.Sort(new TileComparer());
                if (centerPoint.Z > landTile.Z)
                {
                    staticTileArray.Reverse();
                }

                foreach (StaticTile staticTile in staticTileArray)
                {
                    if (map.CanSpawnMobile(currentPoint.X, currentPoint.Y, staticTile.Z))
                    {
                        spawnPoint.X = currentPoint.X;
                        spawnPoint.Y = currentPoint.Y;
                        spawnPoint.Z = staticTile.Z;

                        if (RandomEncounterEngine.DebugEffect)
                        {
                            Effects.SendLocationParticles(
                                EffectItem.Create(new Point3D(spawnPoint.X, spawnPoint.Y, spawnPoint.Z), map, EffectItem.DefaultDuration),
                                0x37CC, 1, 40, 96, 3, 9917, 0
                                );
                        }
                        else if (effectType != EffectType.None)
                        {
                            EffectEntry effect = EffectEntry.Lookup[(int)effectType];

                            Effects.SendLocationParticles(
                                EffectItem.Create(new Point3D(spawnPoint.X, spawnPoint.Y, spawnPoint.Z), map, EffectItem.DefaultDuration),
                                effect.Animation, effect.Speed, effect.Duration, effectHue, effect.RenderMode, effect.Effect, 0
                                );
                        }
                        //Console.WriteLine("Found good point at static.Z");
                        return(true);
                    }

                    //if( RandomEncounterEngine.DebugEffect )
                    //Effects.SendLocationParticles(
                    //EffectItem.Create( new Point3D( currentPoint.X, currentPoint.Y, staticTile.Z), map, EffectItem.DefaultDuration ),
                    //0x37CC, 1, 40, 36, 3, 9917, 0
                    //);
                }

                // probe spawn tile Z
                if (map.CanSpawnMobile(currentPoint.X, currentPoint.Y, spawnTile.Z))
                {
                    spawnPoint.X = currentPoint.X;
                    spawnPoint.Y = currentPoint.Y;
                    spawnPoint.Z = spawnTile.Z;

                    if (RandomEncounterEngine.DebugEffect)
                    {
                        Effects.SendLocationParticles(
                            EffectItem.Create(new Point3D(spawnPoint.X, spawnPoint.Y, spawnPoint.Z), map, EffectItem.DefaultDuration),
                            0x37CC, 1, 40, 36, 3, 9917, 0
                            );
                    }
                    else if (effectType != EffectType.None)
                    {
                        EffectEntry effect = EffectEntry.Lookup[(int)effectType];

                        Effects.SendLocationParticles(
                            EffectItem.Create(new Point3D(spawnPoint.X, spawnPoint.Y, spawnPoint.Z), map, EffectItem.DefaultDuration),
                            effect.Animation, effect.Speed, effect.Duration, effectHue, effect.RenderMode, effect.Effect, 0
                            );
                    }
                    //Console.WriteLine("Found good point at search point.Z");
                    return(true);
                }

                // probe player tile Z
                if (map.CanSpawnMobile(currentPoint.X, currentPoint.Y, centerPoint.Z))
                {
                    spawnPoint.X = currentPoint.X;
                    spawnPoint.Y = currentPoint.Y;
                    spawnPoint.Z = centerPoint.Z;

                    if (RandomEncounterEngine.DebugEffect)
                    {
                        Effects.SendLocationParticles(
                            EffectItem.Create(new Point3D(spawnPoint.X, spawnPoint.Y, spawnPoint.Z), map, EffectItem.DefaultDuration),
                            0x37CC, 1, 40, 167, 3, 9917, 0
                            );
                    }
                    else if (effectType != EffectType.None)
                    {
                        EffectEntry effect = EffectEntry.Lookup[(int)effectType];

                        Effects.SendLocationParticles(
                            EffectItem.Create(new Point3D(spawnPoint.X, spawnPoint.Y, spawnPoint.Z), map, EffectItem.DefaultDuration),
                            effect.Animation, effect.Speed, effect.Duration, effectHue, effect.RenderMode, effect.Effect, 0
                            );
                    }
                    //Console.WriteLine("Found good point at center point.Z");
                    return(true);
                }

                //if( RandomEncounterEngine.DebugEffect )
                //Effects.SendLocationParticles(
                //EffectItem.Create( new Point3D( currentPoint.X, currentPoint.Y, spawnTile.Z), map, EffectItem.DefaultDuration ),
                //0x37CC, 1, 40, 36, 3, 9917, 0
                //);
            }

            return(false);
        }
Exemple #51
0
 public RuntimeEffect(Effect effect)
 {
     this.Type      = effect.Type;
     this.Magnitude = effect.Magnitude;
     this.Duration  = effect.Duration;
 }
Exemple #52
0
    public bool DidEffectProc(EffectType effectType, int avoidance)
    {
        float chance = effectData[effectType].Chance;

        return(Helpers.RollChance((chance - avoidance) / 100f));
    }
Exemple #53
0
 //regardless of how the child normally triggers, we only want it to fire when this attacks.
 public override bool triggersAs(EffectType triggerType)
 {
     return(triggerType == EffectType.attack || triggerType == EffectType.meta);
 }
Exemple #54
0
 public void ApplyEffectToTarget(Actor target, EffectType effectType, float effectPower)
 {
     ActorEffect.ApplyEffectToTarget(target, SourceActor, effectType, effectPower, effectData[effectType].Duration);
 }
Exemple #55
0
 //regardless of how the inner effect normally triggers, we want it to fire once every round.  We need to keep the triggertype == EffectType.meta so we dont break EffectData.cloneEffect()
 public override bool triggersAs(EffectType triggerType)
 {
     return((triggerType == EffectType.everyRound) || (triggerType == EffectType.meta));
 }
 /// <summary>
 /// Initializes a new instance of the <see cref="UnitColorEffect"/> class.
 /// </summary>
 /// <param name="color">Color.</param>
 /// <param name="turns">Turns.</param>
 public UnitColorEffect(Color color, int turns, EffectType incomingEffectType = EffectType.TEMPORARY)
 {
     _color     = color;
     _turns     = turns;
     effectType = incomingEffectType;
 }
Exemple #57
0
    }                                                              //always trigger inner effect

    //allow this to trigger as an onDamage effect even if the child does not
    public override bool triggersAs(EffectType triggerType)
    {
        return(triggerType == EffectType.enemyDamaged || base.triggersAs(triggerType));
    }
Exemple #58
0
 public Effect(EffectType type, float time, float value)
 {
     this.type     = type;
     this.timeLeft = time;
     this.value    = value;
 }
Exemple #59
0
    }                                                              //always trigger inner effect

    //allow this to trigger as an onDamage effect even if the child does not
    public override bool triggersAs(EffectType triggerType)
    {
        return(triggerType == EffectType.periodic || base.triggersAs(triggerType));
    }
Exemple #60
0
 public void AddEffect(EffectType type, float time)
 {
     effects.Add(new Effect(type, time));
     UpdateFlags();
 }