//Animations public void AddTileAnimation(Guid animId, int tileX, int tileY, int dir = -1, Entity owner = null) { var animBase = AnimationBase.Get(animId); if (animBase == null) { return; } var anim = new MapAnimation(animBase, tileX, tileY, dir, owner); LocalAnimations.TryAdd(anim.Id, anim); anim.SetPosition( GetX() + tileX * Options.TileWidth + Options.TileWidth / 2, GetY() + tileY * Options.TileHeight + Options.TileHeight / 2, tileX, tileY, Id, dir ); }
public void RegisterAnimation(AnimationBase animation) { animations.Add(animation); DelayedStartCallbackGenerator( gameEvent: animation.startEvent, startAction: animation.StartAnimation, persistant: animation.persistant, oneShot: animation.oneShot); DelayedStopCallbackGenerator( animation: animation, gameEvent: animation.endEvent, stopAction: animation.EndAnimation, persistant: animation.persistant, oneShot: animation.oneShot); }
public override void PlayAnimation(AnimationBase animation, int playCenter, Point offset) { Canvas canvas; if (playCenter == 1) { canvas = animationCenter1; } else { canvas = animationCenter2; } animation.SetValue(Canvas.LeftProperty, -animation.Width / 2 + offset.X); animation.SetValue(Canvas.TopProperty, -animation.Height / 2 + offset.Y); canvas.Children.Add(animation); animation.Start(); }
/// <summary> /// Applies the specified animation to a dependency property. /// </summary> /// <param name="dp">A <see cref="DependencyProperty"/> instance which identifies the dependency property to animate.</param> /// <param name="animation">The animation to apply to the dependency property, or <see langword="null"/> to cease animating the property.</param> /// <param name="clock">The clock which controls the animation's playback.</param> public void Animate(DependencyProperty dp, AnimationBase animation, Clock clock) { Contract.Require(dp, nameof(dp)); if (dp.IsReadOnly) { throw new InvalidOperationException(PresentationStrings.DependencyPropertyIsReadOnly.Format(dp.Name)); } if (animation != null) { Contract.Require(clock, nameof(clock)); } var wrapper = GetDependencyPropertyValue(dp, dp.PropertyType); wrapper.Animate(animation, clock); }
private void UpdateEditor() { if (mEditorItem != null) { pnlContainer.Show(); txtName.Text = mEditorItem.Name; cmbFolder.Text = mEditorItem.Folder; txtDesc.Text = mEditorItem.Description; cmbType.SelectedIndex = (int)mEditorItem.SpellType; nudCastDuration.Value = mEditorItem.CastDuration; nudCooldownDuration.Value = mEditorItem.CooldownDuration; cmbCastAnimation.SelectedIndex = AnimationBase.ListIndex(mEditorItem.CastAnimationId) + 1; cmbHitAnimation.SelectedIndex = AnimationBase.ListIndex(mEditorItem.HitAnimationId) + 1; chkBound.Checked = mEditorItem.Bound; cmbSprite.SelectedIndex = cmbSprite.FindString(TextUtils.NullToNone(mEditorItem.Icon)); picSpell.BackgroundImage?.Dispose(); picSpell.BackgroundImage = null; if (cmbSprite.SelectedIndex > 0) { picSpell.BackgroundImage = Image.FromFile("resources/spells/" + cmbSprite.Text); } nudHPCost.Value = mEditorItem.VitalCost[(int)Vitals.Health]; nudMpCost.Value = mEditorItem.VitalCost[(int)Vitals.Mana]; UpdateSpellTypePanels(); if (mChanged.IndexOf(mEditorItem) == -1) { mChanged.Add(mEditorItem); mEditorItem.MakeBackup(); } } else { pnlContainer.Hide(); } UpdateToolStripItems(); }
public virtual void PlaySingleFrame(string animation, bool lockAnimation = false, AnimationMode mode = AnimationMode.Loop) { _autoPlay = false; if (CurrentAnimation == null || CurrentAnimation.Frames.Count == 0) { if (DebugMode) { Debug.LogWarning("There is no current animation to play, test, advance against!"); } return; } if (string.IsNullOrEmpty(animation)) { animation = CurrentAnimation.Name; } // If the new animation does not match the current animation, // and there is no lock asserted, change animations. if (animation != CurrentAnimation.Name && !_isLocked) { if (DebugMode) { Debug.Log("No lock; setting lock and animation state."); } _isLocked = lockAnimation; AnimationMode = mode; PreviousAnimation = CurrentAnimation; SetAnimation(animation); } if (DebugMode) { Debug.Log(String.Format("Advancing animation {0} to frame {1}...", CurrentAnimation.Name, CurrentAnimation.Current)); } AdvanceCurrentAnimationOne(); }
//Weather public void DrawWeather() { if (Globals.Me == null || Lookup.Get(Globals.Me.CurrentMap) == null) { return; } var anim = AnimationBase.Get(WeatherAnimationId); if (anim == null || WeatherIntensity == 0) { return; } _removeParticles.Clear(); if ((WeatherXSpeed != 0 || WeatherYSpeed != 0) && Globals.Me.MapInstance == this) { if (Globals.System.GetTimeMs() > _weatherParticleSpawnTime) { _weatherParticles.Add(new WeatherParticle(_removeParticles, WeatherXSpeed, WeatherYSpeed, anim)); var spawnTime = 25 + (int)(475 * (float)(1f - (float)(WeatherIntensity / 100f))); spawnTime = (int)(spawnTime * (480000f / (Graphics.Renderer.GetScreenWidth() * Graphics.Renderer.GetScreenHeight()))); _weatherParticleSpawnTime = Globals.System.GetTimeMs() + spawnTime; } } //Process and draw each weather particle foreach (var w in _weatherParticles) { w.Update(); } //Remove all old particles from the weather particles list from the removeparticles list. foreach (var r in _removeParticles) { r.Dispose(); _weatherParticles.Remove(r); } }
public void SetAnimation(SpriteAnimations animation, float animationTimeInMS = -1) { if (animation == SpriteAnimations.NONE) { if (CurrentAnimation != null) { CurrentAnimation.Reset(); } CurrentAnimation = null; return; } var animationToSet = Animations.GetAnimation(animation); if (animationToSet != CurrentAnimation) { // if my animation had callbacks i will still wanna run them if (CurrentAnimation?.Callbacks.Count > 0) { foreach (var animCallback in CurrentAnimation.Callbacks) { var framesUntilCallback = animCallback.PlayOnFrame - CurrentAnimation.CurrentFrame; animCallback.PlayOnFrame = framesUntilCallback; PendingCallbacks.Add(animCallback); } } CurrentAnimation?.Reset(); CurrentAnimation = animationToSet; CurrentAnimation.Reset(); if (animationTimeInMS > 0) { // CurrentAnimation.AnimationTimeInSeconds = animationTimeInMS / 1000; } if (animation == SpriteAnimations.DEAD) { CurrentAnimation.Loop(Direction); } } }
public void OnLoadObjCallback(Object target, string path) { EquipType type; if (!GetCurTypeByLoadingIndex(out type)) { return; } if (!modelPartPath.ContainsKey(type) || !modelPartPath[type].Equals(path)) { return; } GameObject prefab = target as GameObject; if (null == prefab) { Debug.LogError("Model Asset is null!!!:" + path); return; } GameObject go = GameObject.Instantiate(prefab, modelParent); if (type == EquipType.Main) { model = go; animator = AnimationBase.GetAnimationBase(animationType, go); OnModelChange(go); } else { Transform tempParent = model.transform.Find(CharaDefine.CharaPartParent[type]); if (tempParent != null) { go.transform.SetParent(tempParent); go.transform.localPosition = Vector3.zero; go.transform.localEulerAngles = Vector3.zero; go.transform.localScale = Vector3.one; } } SetParObj(type, go); }
public EventMoveRouteAnimationSelector( EventMoveRouteDesigner moveRouteDesigner, MoveRouteAction action, bool newAction = false ) { InitializeComponent(); cmbAnimation.Items.Clear(); cmbAnimation.Items.Add(Strings.General.none); cmbAnimation.Items.AddRange(AnimationBase.Names); if (!newAction) { cmbAnimation.SelectedIndex = AnimationBase.ListIndex(action.AnimationId) + 1; } mNewAction = newAction; mRouteDesigner = moveRouteDesigner; mMyAction = action; InitLocalization(); }
public override void CreateModel(string path, Transform parent, int type) { if (null != animator) { model.SetActive(true); return; } AssetManager.LoadAsset(path, (Object target, string comePath) => { GameObject prefab = target as GameObject; if (null != prefab) { GameObject go = GameObject.Instantiate(prefab, parent); model = go; animator = AnimationBase.GetAnimationBase(type, go); ChangeTranslucence(0); } }); }
//Attribute References private void UpdateMapAttributes() { var width = Options.MapWidth; var height = Options.MapHeight; for (var x = 0; x < width; x++) { for (var y = 0; y < height; y++) { var att = Attributes[x, y]; if (att == null) { continue; } if (att.Type != MapAttributes.Animation) { continue; } var anim = AnimationBase.Get(((MapAnimationAttribute)att).AnimationId); if (anim == null) { continue; } if (!mAttributeAnimInstances.ContainsKey(att)) { var animInstance = new Animation(anim, true); animInstance.SetPosition( GetX() + x * Options.TileWidth + Options.TileWidth / 2, GetY() + y * Options.TileHeight + Options.TileHeight / 2, x, y, Id, 0 ); mAttributeAnimInstances.Add(att, animInstance); } mAttributeAnimInstances[att].Update(); } } }
private void UpdateEditor() { if (mEditorItem != null) { pnlContainer.Show(); txtName.Text = mEditorItem.Name; cmbFolder.Text = mEditorItem.Folder; cmbToolType.SelectedIndex = mEditorItem.Tool + 1; nudSpawnDuration.Value = mEditorItem.SpawnDuration; cmbAnimation.SelectedIndex = AnimationBase.ListIndex(mEditorItem.AnimationId) + 1; nudMinHp.Value = mEditorItem.MinHp; nudMaxHp.Value = mEditorItem.MaxHp; chkWalkableBefore.Checked = mEditorItem.WalkableBefore; chkWalkableAfter.Checked = mEditorItem.WalkableAfter; chkInitialFromTileset.Checked = mEditorItem.Initial.GraphicFromTileset; chkExhaustedFromTileset.Checked = mEditorItem.Exhausted.GraphicFromTileset; cmbEvent.SelectedIndex = EventBase.ListIndex(mEditorItem.EventId) + 1; chkInitialBelowEntities.Checked = mEditorItem.Initial.RenderBelowEntities; chkExhaustedBelowEntities.Checked = mEditorItem.Exhausted.RenderBelowEntities; txtCannotHarvest.Text = mEditorItem.CannotHarvestMessage; //Regen nudHpRegen.Value = mEditorItem.VitalRegen; PopulateInitialGraphicList(); PopulateExhaustedGraphicList(); UpdateDropValues(); Render(); if (mChanged.IndexOf(mEditorItem) == -1) { mChanged.Add(mEditorItem); mEditorItem.MakeBackup(); } } else { pnlContainer.Hide(); } UpdateToolStripItems(); }
public static void Animation(this object o, string name, double n, uint frameCount, Action act = null) { Type objType = o.GetType(); PropertyInfo property = objType.GetProperty(name); AnimationBase ani = null; if (property != null) { ani = new AnimationBaseProperty <double>(o, property, n, frameCount, AnimationFunc, act); } else { FieldInfo filed = objType.GetField(name); if (filed != null) { ani = new AnimationBaseField <double>(o, filed, n, frameCount, AnimationFunc, act); } } AddAnimationBase(ani); }
public GridContainer CreateAnimation(string buttonText, Color boxColor, AnimationBase animationBase) { BoxView box = null; var container = new GridContainer() { Children = { new BoxView() { HeightRequest = 28, WidthRequest = 28, BackgroundColor = boxColor }.Assign(out box).Row(0).Col(0), new CoreButton() { Text = buttonText, Style = CoreStyles.LightOrange, Triggers = { new EventTrigger() { Event = "Clicked", Actions = { new CoreTriggerAction() { Animation = animationBase, }.AssignTarget(box) } } } }.Row(0).Col(1) } }; return(container); }
public static AnimationBase GetAnimationBase(int type, GameObject go) { ZTAnimationType animationType = ZTAnimationType.Animator; AnimationBase baseAction = null; if (System.Enum.IsDefined(typeof(ZTAnimationType), type)) { animationType = (ZTAnimationType)type; } switch (animationType) { case ZTAnimationType.Animation: baseAction = new AnimationAction(go); break; case ZTAnimationType.Animator: baseAction = new AnimatorAction(go); break; } return(baseAction); }
/// <inheritdoc/> public void Animate(AnimationBase animation, Clock clock) { Contract.Require(animation, nameof(animation)); Contract.Require(clock, nameof(clock)); if (this.animation == animation && this.animationClock == clock) { return; } var oldValue = GetValue(); ClearAnimation(); this.animation = (Animation <T>)animation; this.animationClock = clock; this.animatedValue = GetInitialAnimatedValue(oldValue); this.animatedHandOffValue = oldValue; this.animationClock.Subscribe(this); UpdateRequiresDigest(oldValue); }
private void AddProjectileSpawns() { var spawn = FindSpawnAnimationData(); var animBase = AnimationBase.Get(mMyBase.Animations[spawn].AnimationId); for (var x = 0; x < ProjectileBase.SPAWN_LOCATIONS_WIDTH; x++) { for (var y = 0; y < ProjectileBase.SPAWN_LOCATIONS_WIDTH; y++) { for (var d = 0; d < ProjectileBase.MAX_PROJECTILE_DIRECTIONS; d++) { if (mMyBase.SpawnLocations[x, y].Directions[d] == true) { var s = new ProjectileSpawns( FindProjectileRotationDir(Dir, d), X + FindProjectileRotationX(Dir, x - 2, y - 2), Y + FindProjectileRotationY(Dir, x - 2, y - 2), Z, CurrentMap, animBase, mMyBase.Animations[spawn].AutoRotate, mMyBase, this ); Spawns[mSpawnedAmount] = s; if (Collided(mSpawnedAmount)) { Spawns[mSpawnedAmount].Dispose(); Spawns[mSpawnedAmount] = null; mSpawnCount--; } mSpawnedAmount++; mSpawnCount++; } } } } mQuantity++; mSpawnTime = Globals.System.GetTimeMs() + mMyBase.Delay; }
public void InitEditor() { var selectedId = Guid.Empty; var folderNodes = new Dictionary <string, TreeNode>(); if (lstAnimations.SelectedNode != null && lstAnimations.SelectedNode.Tag != null) { selectedId = (Guid)lstAnimations.SelectedNode.Tag; } lstAnimations.Nodes.Clear(); //Collect folders var mFolders = new List <string>(); foreach (var anim in AnimationBase.Lookup) { if (!string.IsNullOrEmpty(((AnimationBase)anim.Value).Folder) && !mFolders.Contains(((AnimationBase)anim.Value).Folder)) { mFolders.Add(((AnimationBase)anim.Value).Folder); if (!mKnownFolders.Contains(((AnimationBase)anim.Value).Folder)) { mKnownFolders.Add(((AnimationBase)anim.Value).Folder); } } } mFolders.Sort(); mKnownFolders.Sort(); cmbFolder.Items.Clear(); cmbFolder.Items.Add(""); cmbFolder.Items.AddRange(mKnownFolders.ToArray()); lstAnimations.Sorted = !btnChronological.Checked; if (!btnChronological.Checked && !CustomSearch()) { foreach (var folder in mFolders) { var node = lstAnimations.Nodes.Add(folder); node.ImageIndex = 0; node.SelectedImageIndex = 0; folderNodes.Add(folder, node); } } foreach (var itm in AnimationBase.ItemPairs) { var node = new TreeNode(itm.Value); node.Tag = itm.Key; node.ImageIndex = 1; node.SelectedImageIndex = 1; var folder = AnimationBase.Get(itm.Key).Folder; if (!string.IsNullOrEmpty(folder) && !btnChronological.Checked && !CustomSearch()) { var folderNode = folderNodes[folder]; folderNode.Nodes.Add(node); if (itm.Key == selectedId) { folderNode.Expand(); } } else { lstAnimations.Nodes.Add(node); } if (CustomSearch()) { if (!node.Text.ToLower().Contains(txtSearch.Text.ToLower())) { node.Remove(); } } if (itm.Key == selectedId) { lstAnimations.SelectedNode = node; } } var selectedNode = lstAnimations.SelectedNode; if (!btnChronological.Checked) { lstAnimations.Sort(); } lstAnimations.SelectedNode = selectedNode; foreach (var node in mExpandedFolders) { if (folderNodes.ContainsKey(node)) { folderNodes[node].Expand(); } } }
/// <summary> /// Enlists a dependency property on this object into the specified storyboard instance. /// </summary> /// <param name="dp">A <see cref="DependencyProperty"/> that identifies the dependency property to enlist.</param> /// <param name="storyboardInstance">The <see cref="StoryboardInstance"/> into which to enlist the dependency property.</param> /// <param name="animation">The animation to apply to the dependency property.</param> internal void EnlistDependencyPropertyInStoryboard(DependencyProperty dp, StoryboardInstance storyboardInstance, AnimationBase animation) { Contract.Require(dp, nameof(dp)); Contract.Require(storyboardInstance, nameof(storyboardInstance)); Contract.Require(animation, nameof(animation)); if (dp.IsReadOnly) { throw new InvalidOperationException(PresentationStrings.DependencyPropertyIsReadOnly.Format(dp.Name)); } var wrapper = GetDependencyPropertyValue(dp, dp.PropertyType); storyboardInstance.Enlist(wrapper, animation); }
public void PlaceAttribute(MapBase tmpMap, int x, int y) { if (rbBlocked.Checked) { tmpMap.Attributes[x, y] = MapAttribute.CreateAttribute(MapAttributes.Blocked); } else if (rbItem.Checked) { tmpMap.Attributes[x, y] = MapAttribute.CreateAttribute(MapAttributes.Item); ((MapItemAttribute)tmpMap.Attributes[x, y]).ItemId = ItemBase.IdFromList(cmbItemAttribute.SelectedIndex); ((MapItemAttribute)tmpMap.Attributes[x, y]).Quantity = (int)nudItemQuantity.Value; } else if (rbZDimension.Checked) { tmpMap.Attributes[x, y] = MapAttribute.CreateAttribute(MapAttributes.ZDimension); ((MapZDimensionAttribute)tmpMap.Attributes[x, y]).GatewayTo = GetEditorDimensionGateway(); ((MapZDimensionAttribute)tmpMap.Attributes[x, y]).BlockedLevel = GetEditorDimensionBlock(); } else if (rbNPCAvoid.Checked) { tmpMap.Attributes[x, y] = MapAttribute.CreateAttribute(MapAttributes.NpcAvoid); } else if (rbWarp.Checked) { tmpMap.Attributes[x, y] = MapAttribute.CreateAttribute(MapAttributes.Warp); ((MapWarpAttribute)tmpMap.Attributes[x, y]).MapId = MapList.OrderedMaps[cmbWarpMap.SelectedIndex].MapId; ((MapWarpAttribute)tmpMap.Attributes[x, y]).X = (byte)nudWarpX.Value; ((MapWarpAttribute)tmpMap.Attributes[x, y]).Y = (byte)nudWarpY.Value; ((MapWarpAttribute)tmpMap.Attributes[x, y]).Direction = (WarpDirection)cmbDirection.SelectedIndex; } else if (rbSound.Checked) { tmpMap.Attributes[x, y] = MapAttribute.CreateAttribute(MapAttributes.Sound); ((MapSoundAttribute)tmpMap.Attributes[x, y]).Distance = (byte)nudSoundDistance.Value; ((MapSoundAttribute)tmpMap.Attributes[x, y]).File = TextUtils.SanitizeNone(cmbMapAttributeSound.Text); } else if (rbResource.Checked) { tmpMap.Attributes[x, y] = MapAttribute.CreateAttribute(MapAttributes.Resource); ((MapResourceAttribute)tmpMap.Attributes[x, y]).ResourceId = ResourceBase.IdFromList(cmbResourceAttribute.SelectedIndex); if (rbLevel1.Checked) { ((MapResourceAttribute)tmpMap.Attributes[x, y]).SpawnLevel = 0; } else { ((MapResourceAttribute)tmpMap.Attributes[x, y]).SpawnLevel = 1; } } else if (rbAnimation.Checked) { tmpMap.Attributes[x, y] = MapAttribute.CreateAttribute(MapAttributes.Animation); ((MapAnimationAttribute)tmpMap.Attributes[x, y]).AnimationId = AnimationBase.IdFromList(cmbAnimationAttribute.SelectedIndex); } else if (rbGrappleStone.Checked) { tmpMap.Attributes[x, y] = MapAttribute.CreateAttribute(MapAttributes.GrappleStone); } else if (rbSlide.Checked) { tmpMap.Attributes[x, y] = MapAttribute.CreateAttribute(MapAttributes.Slide); ((MapSlideAttribute)tmpMap.Attributes[x, y]).Direction = (byte)cmbSlideDir.SelectedIndex; } }
public MapAnimation(AnimationBase animBase, int tileX, int tileY, int dir, Entity owner = null) : base(animBase, false, false, -1, owner) { mTileX = tileX; mTileY = tileY; mDir = dir; }
/// <summary> /// Initializes a new instance of the <see cref="Enlistment"/> structure. /// </summary> /// <param name="dpValue">The dependency property which has been enlisted.</param> /// <param name="animation">The animation to apply to the dependency property.</param> public Enlistment(IDependencyPropertyValue dpValue, AnimationBase animation) { this.dpValue = dpValue; this.animation = animation; }
public WeatherParticle(List <WeatherParticle> RemoveParticle, int xvelocity, int yvelocity, AnimationBase anim) { TransmittionTimer = Globals.System.GetTimeMs(); bounds = new Rectangle(0, 0, Graphics.Renderer.GetScreenWidth(), Graphics.Renderer.GetScreenHeight()); xVelocity = xvelocity; yVelocity = yvelocity; animInstance = new Animation(anim, true, false); var animSize = animInstance.AnimationSize(); partSize = animSize; if (xVelocity > 0) { originalX = Globals.Random.Next( -Graphics.Renderer.GetScreenWidth() / 4 - animSize.X, Graphics.Renderer.GetScreenWidth() + animSize.X ); } else if (xVelocity < 0) { originalX = Globals.Random.Next( animSize.X, (int)(Graphics.Renderer.GetScreenWidth() * 1.25f) + animSize.X ); } else { originalX = Globals.Random.Next(-animSize.X, Graphics.Renderer.GetScreenWidth() + animSize.X); } if (yVelocity > 0) { originalY = -animSize.Y; } else if (yVelocity < 0) { originalY = Graphics.Renderer.GetScreenHeight() + animSize.Y; } else { originalY = Globals.Random.Next(-animSize.Y, Graphics.Renderer.GetScreenHeight() + animSize.Y); if (xVelocity > 0) { originalX = -animSize.X; } else if (xVelocity < 0) { originalX = Graphics.Renderer.GetScreenWidth(); } } if (originalX < 0) { bounds.X = originalX; bounds.Width += Math.Abs(originalX); } if (originalY < 0) { bounds.Y = originalY; bounds.Height += Math.Abs(originalY); } if (originalY > Graphics.Renderer.GetScreenHeight()) { bounds.Height = originalY; } if (originalX > Graphics.Renderer.GetScreenWidth()) { bounds.Width = originalX; } bounds.X -= animSize.X; bounds.Width += animSize.X * 2; bounds.Y -= animSize.Y; bounds.Height += animSize.Y * 2; X = originalX; Y = originalY; cameraSpawnX = Graphics.Renderer.GetView().Left; cameraSpawnY = Graphics.Renderer.GetView().Top; _RemoveParticle = RemoveParticle; }
private void btnOkay_Click(object sender, EventArgs e) { mMyAction.AnimationId = AnimationBase.IdFromList(cmbAnimation.SelectedIndex - 1); mRouteDesigner.Controls.Remove(this); }
public MapAnimation(AnimationBase animBase, int tileX, int tileY, int dir) : base(animBase, false) { mTileX = tileX; mTileY = tileY; mDir = dir; }
public void AddAnimation(AnimationBase anim) { Engine.AddAnimation(anim); }
private void cmbAttackAnimation_SelectedIndexChanged(object sender, EventArgs e) { mEditorItem.AttackAnimation = AnimationBase.Get(AnimationBase.IdFromList(cmbAttackAnimation.SelectedIndex - 1)); }
private void UpdateEditor() { if (mEditorItem != null) { pnlContainer.Show(); txtName.Text = mEditorItem.Name; cmbFolder.Text = mEditorItem.Folder; cmbSprite.SelectedIndex = cmbSprite.FindString(TextUtils.NullToNone(mEditorItem.Sprite)); nudLevel.Value = mEditorItem.Level; nudSpawnDuration.Value = mEditorItem.SpawnDuration; //Behavior chkAggressive.Checked = mEditorItem.Aggressive; if (mEditorItem.Aggressive) { btnAttackOnSightCond.Text = Strings.NpcEditor.dontattackonsightconditions; } else { btnAttackOnSightCond.Text = Strings.NpcEditor.attackonsightconditions; } nudSightRange.Value = mEditorItem.SightRange; cmbMovement.SelectedIndex = Math.Min(mEditorItem.Movement, cmbMovement.Items.Count - 1); chkSwarm.Checked = mEditorItem.Swarm; nudFlee.Value = mEditorItem.FleeHealthPercentage; chkFocusDamageDealer.Checked = mEditorItem.FocusHighestDamageDealer; //Common Events cmbOnDeathEventKiller.SelectedIndex = EventBase.ListIndex(mEditorItem.OnDeathEventId) + 1; cmbOnDeathEventParty.SelectedIndex = EventBase.ListIndex(mEditorItem.OnDeathPartyEventId) + 1; nudStr.Value = mEditorItem.Stats[(int)Stats.Attack]; nudMag.Value = mEditorItem.Stats[(int)Stats.AbilityPower]; nudDef.Value = mEditorItem.Stats[(int)Stats.Defense]; nudMR.Value = mEditorItem.Stats[(int)Stats.MagicResist]; nudSpd.Value = mEditorItem.Stats[(int)Stats.Speed]; nudHp.Value = mEditorItem.MaxVital[(int)Vitals.Health]; nudMana.Value = mEditorItem.MaxVital[(int)Vitals.Mana]; nudExp.Value = mEditorItem.Experience; chkAttackAllies.Checked = mEditorItem.AttackAllies; chkEnabled.Checked = mEditorItem.NpcVsNpcEnabled; //Combat nudDamage.Value = mEditorItem.Damage; nudCritChance.Value = mEditorItem.CritChance; nudCritMultiplier.Value = (decimal)mEditorItem.CritMultiplier; nudScaling.Value = mEditorItem.Scaling; cmbDamageType.SelectedIndex = mEditorItem.DamageType; cmbScalingStat.SelectedIndex = mEditorItem.ScalingStat; cmbAttackAnimation.SelectedIndex = AnimationBase.ListIndex(mEditorItem.AttackAnimationId) + 1; cmbAttackSpeedModifier.SelectedIndex = mEditorItem.AttackSpeedModifier; nudAttackSpeedValue.Value = mEditorItem.AttackSpeedValue; //Regen nudHpRegen.Value = mEditorItem.VitalRegen[(int)Vitals.Health]; nudMpRegen.Value = mEditorItem.VitalRegen[(int)Vitals.Mana]; // Add the spells to the list lstSpells.Items.Clear(); for (var i = 0; i < mEditorItem.Spells.Count; i++) { if (mEditorItem.Spells[i] != Guid.Empty) { lstSpells.Items.Add(SpellBase.GetName(mEditorItem.Spells[i])); } else { lstSpells.Items.Add(Strings.General.none); } } if (lstSpells.Items.Count > 0) { lstSpells.SelectedIndex = 0; cmbSpell.SelectedIndex = SpellBase.ListIndex(mEditorItem.Spells[lstSpells.SelectedIndex]); } cmbFreq.SelectedIndex = mEditorItem.SpellFrequency; // Add the aggro NPC's to the list lstAggro.Items.Clear(); for (var i = 0; i < mEditorItem.AggroList.Count; i++) { if (mEditorItem.AggroList[i] != Guid.Empty) { lstAggro.Items.Add(NpcBase.GetName(mEditorItem.AggroList[i])); } else { lstAggro.Items.Add(Strings.General.none); } } UpdateDropValues(); DrawNpcSprite(); if (mChanged.IndexOf(mEditorItem) == -1) { mChanged.Add(mEditorItem); mEditorItem.MakeBackup(); } } else { pnlContainer.Hide(); } UpdateToolStripItems(); }
public virtual void PlayAnimation(AnimationBase animation, int playCenter, Point offset) { }
public MapAttribute CreateAttribute() { var attributeType = SelectedMapAttributeType; var attribute = MapAttribute.CreateAttribute(attributeType); switch (SelectedMapAttributeType) { case MapAttributes.Walkable: case MapAttributes.Blocked: case MapAttributes.GrappleStone: case MapAttributes.NpcAvoid: break; case MapAttributes.Item: var itemAttribute = attribute as MapItemAttribute; itemAttribute.ItemId = ItemBase.IdFromList(cmbItemAttribute.SelectedIndex); itemAttribute.Quantity = (int)nudItemQuantity.Value; break; case MapAttributes.ZDimension: var zDimensionAttribute = attribute as MapZDimensionAttribute; zDimensionAttribute.GatewayTo = GetEditorDimensionGateway(); zDimensionAttribute.BlockedLevel = GetEditorDimensionBlock(); break; case MapAttributes.Warp: var warpAttribute = attribute as MapWarpAttribute; warpAttribute.MapId = MapList.OrderedMaps[cmbWarpMap.SelectedIndex].MapId; warpAttribute.X = (byte)nudWarpX.Value; warpAttribute.Y = (byte)nudWarpY.Value; warpAttribute.Direction = (WarpDirection)cmbDirection.SelectedIndex; break; case MapAttributes.Sound: var soundAttribute = attribute as MapSoundAttribute; soundAttribute.Distance = (byte)nudSoundDistance.Value; soundAttribute.File = TextUtils.SanitizeNone(cmbMapAttributeSound.Text); soundAttribute.LoopInterval = (int)nudSoundLoopInterval.Value; break; case MapAttributes.Resource: var resourceAttribute = attribute as MapResourceAttribute; resourceAttribute.ResourceId = ResourceBase.IdFromList(cmbResourceAttribute.SelectedIndex); resourceAttribute.SpawnLevel = (byte)(rbLevel1.Checked ? 0 : 1); break; case MapAttributes.Animation: var animationAttribute = attribute as MapAnimationAttribute; animationAttribute.AnimationId = AnimationBase.IdFromList(cmbAnimationAttribute.SelectedIndex); break; case MapAttributes.Slide: var slideAttribute = attribute as MapSlideAttribute; slideAttribute.Direction = (byte)cmbSlideDir.SelectedIndex; break; default: throw new ArgumentOutOfRangeException(nameof(SelectedMapAttributeType), @"The currently selected attribute type has not been fully implemented."); } return(attribute); }