/// <summary>
/// Initializes a new instance of the <see cref="MoveManyTransBox"/> class.
/// </summary>
/// <param name="owner">The <see cref="TransBoxManager"/>.</param>
/// <param name="spatials">The <see cref="ISpatial"/>s.</param>
/// <param name="position">The position.</param>
/// <param name="camera">The camera.</param>
public MoveManyTransBox(TransBoxManager owner, IEnumerable<ISpatial> spatials, Vector2 position, ICamera2D camera)
{
_owner = owner;
_camera = camera;
_position = position;
_spatials = spatials.ToImmutable();
}
/// <summary>
/// Checks if the <see cref="ISpatial"/> contains a point.
/// </summary>
/// <param name="spatial">The spatial.</param>
/// <param name="p">Point to check if the <paramref name="spatial"/> contains.</param>
/// <returns>True if the <paramref name="spatial"/> contains <paramref name="p"/>; otherwise false.</returns>
public static bool Contains(this ISpatial spatial, Vector2 p)
{
var min = spatial.Position;
var max = spatial.Max;
return (min.X <= p.X && max.X >= p.X && min.Y <= p.Y && max.Y >= p.Y);
}
/// <summary>
/// Finds the Minimal Translational Distance between two <see cref="ISpatial"/>s.
/// </summary>
/// <param name="srcMin">Top-left of the source (dynamic) <see cref="ISpatial"/> that will be the one moving.</param>
/// <param name="srcMax">Bottom-right of the source (dynamic) <see cref="ISpatial"/> that will be the one moving.</param>
/// <param name="tarMin">Top-left of the target (static) <see cref="ISpatial"/> that will not move.</param>
/// <param name="tarMax">Bottom-right of the target (static) <see cref="ISpatial"/> that will not move.</param>
/// <returns>The MTD for the source to no longer intersect the target.</returns>
public static Vector2 MTD(Vector2 srcMin, Vector2 srcMax, Vector2 tarMin, Vector2 tarMax)
{
// Down
float mtd = srcMax.Y - tarMin.Y;
BoxSide side = BoxSide.Bottom;
// Left
float diff = srcMax.X - tarMin.X;
if (diff < mtd)
{
mtd = diff;
side = BoxSide.Left;
}
// Right
diff = tarMax.X - srcMin.X;
if (diff < mtd)
{
mtd = diff;
side = BoxSide.Right;
}
// Up
diff = tarMax.Y - srcMin.Y;
if (diff < mtd)
{
mtd = diff;
side = BoxSide.Top;
}
if (mtd < 0.0f)
return Vector2.Zero;
return CreateMTDVector(side, mtd + 1);
}
/// <summary>
/// Checks if this <see cref="ITransBox"/> contains the given world point.
/// </summary>
/// <param name="worldPos">The world point.</param>
/// <returns>True if this <see cref="ITransBox"/> contains the <paramref name="worldPos"/>; otherwise false.</returns>
public bool ContainsPoint(Vector2 worldPos)
{
var w = worldPos;
var lo = Position;
var hi = Max;
return (lo.X <= w.X) && (lo.Y <= w.Y) && (hi.X >= w.X) && (hi.Y >= w.Y);
}
Vector2 Align(Vector2 v)
{
if (_owner == null || _owner.GridAligner == null)
return v;
return _owner.GridAligner.Align(v);
}
/// <summary>
/// Initializes a new instance of the <see cref="ChatForm"/> class.
/// </summary>
/// <param name="parent">The parent.</param>
/// <param name="pos">The pos.</param>
public ChatForm(Control parent, Vector2 pos) : base(parent, pos, new Vector2(300, 150))
{
// Create the input and output TextBoxes
_input = new TextBox(this, Vector2.Zero, new Vector2(32, 32))
{
IsMultiLine = false,
IsEnabled = true,
Font = GameScreenHelper.DefaultChatFont,
MaxInputTextLength = GameData.MaxClientSayLength,
BorderColor = new Color(255, 255, 255, 100)
};
_output = new TextBox(this, Vector2.Zero, new Vector2(32, 32))
{
IsMultiLine = true,
IsEnabled = false,
Font = GameScreenHelper.DefaultChatFont,
BorderColor = new Color(255, 255, 255, 100)
};
_input.KeyPressed -= Input_KeyPressed;
_input.KeyPressed += Input_KeyPressed;
// Force the initial repositioning
RepositionTextBoxes();
}
/// <summary>
/// Draws the <see cref="SkeletonBodyItem"/>.
/// </summary>
/// <param name="sb"><see cref="ISpriteBatch"/> to draw to.</param>
/// <param name="position">Position to draw at.</param>
/// <param name="scale">Amount to scale the Grh in percent (1.0f for no scaling).</param>
/// <param name="color">The color.</param>
/// <param name="effect">SpriteEffects to use when drawing.</param>
internal void Draw(ISpriteBatch sb, Vector2 position, float scale, Color color, SpriteEffects effect)
{
// Validate
if (Source == null)
return;
// Find the effect
Vector2 m;
switch (effect)
{
case SpriteEffects.FlipHorizontally:
m = new Vector2(-1, 1);
break;
case SpriteEffects.FlipVertically:
m = new Vector2(1, -1);
break;
default:
m = new Vector2(1, 1);
break;
}
// Calculate the angle
float angle;
if (Dest == null)
angle = 0.0f;
else
angle = SkeletonNode.GetAngle(Source.Position * m, Dest.Position * m) - MathHelper.PiOver2;
// Draw
var v = Source.Position + ItemInfo.Offset;
Grh.Draw(sb, (v * m) + position, color, effect, angle, ItemInfo.Origin, scale);
}
/// <summary>
/// Finds the <see cref="Direction"/> from a <see cref="Vector2"/>.
/// </summary>
/// <param name="v">The <see cref="Vector2"/> containing the relative direction, where
/// (0,0) is the center.</param>
/// <returns>The <see cref="Direction"/> for the <paramref name="v"/>, or null if
/// <paramref name="v"/> is equal to <see cref="Vector2.Zero"/>.</returns>
public static Direction? FromVector(Vector2 v)
{
if (v.Y < 0)
{
if (v.X < 0)
return Direction.NorthWest;
else if (v.X == 0)
return Direction.North;
else
return Direction.NorthEast;
}
else if (v.Y == 0)
{
if (v.X < 0)
return Direction.West;
else if (v.X == 0)
return null;
else
return Direction.East;
}
else
{
if (v.X < 0)
return Direction.SouthWest;
else if (v.X == 0)
return Direction.South;
else
return Direction.SouthEast;
}
}
/// <summary>
/// Plays a sound.
/// </summary>
/// <param name="soundManager">The sound manager.</param>
/// <param name="name">The name of the sound to play.</param>
/// <param name="source">The source of the sound.</param>
/// <returns>
/// True if the sound was successfully played; otherwise false.
/// </returns>
public static bool Play(this ISoundManager soundManager, string name, Vector2 source)
{
var info = soundManager.GetSoundInfo(name);
if (info == null)
return false;
return soundManager.Play(info.ID, source);
}
/// <summary>
/// Initializes a new instance of the <see cref="SkeletonBodyItemInfo"/> class.
/// </summary>
/// <param name="grhIndex">The <see cref="GrhIndex"/> for the sprite to draw for the body item.</param>
/// <param name="sourceName">Name of the source node.</param>
/// <param name="destName">Name of the destination node (String.Empty for no destination).</param>
/// <param name="offset">Grh drawing offset.</param>
/// <param name="origin">Grh drawing origin.</param>
public SkeletonBodyItemInfo(GrhIndex grhIndex, string sourceName, string destName, Vector2 offset, Vector2 origin)
{
GrhIndex = grhIndex;
_sourceName = sourceName;
_destName = destName;
Offset = offset;
Origin = origin;
}
/// <summary>
/// Initializes a new instance of the <see cref="Toolbar"/> class.
/// </summary>
/// <param name="parent">The parent.</param>
/// <param name="pos">The pos.</param>
public Toolbar(Control parent, Vector2 pos) : base(parent, pos, Vector2.One)
{
ResizeToChildren = true;
ResizeToChildrenPadding = _padding;
_items = CreateToolbarItems();
Position = pos;
}
static IEnumerable<Entity> CreateEntities(int amount, Vector2 minPos, Vector2 maxPos)
{
var ret = new Entity[amount];
for (var i = 0; i < amount; i++)
{
ret[i] = new TestEntity { Position = RandomHelper.NextVector2(minPos, maxPos) };
}
return ret;
}
/// <summary>
/// Initializes a new instance of the <see cref="TransBox"/> class.
/// </summary>
/// <param name="owner">The <see cref="TransBoxManager"/>.</param>
/// <param name="type">The <see cref="TransBoxType"/>.</param>
/// <param name="spatial">The <see cref="ISpatial"/>.</param>
TransBox(TransBoxManager owner, TransBoxType type, ISpatial spatial)
{
_owner = owner;
_type = type;
_spatial = spatial;
_size = GetTransBoxSize(type);
_position = GetPosition();
}
/// <summary>
/// Draws a rectangle.
/// </summary>
/// <param name="sb"><see cref="ISpriteBatch"/> to draw to.</param>
/// <param name="position">Top-left corner position.</param>
/// <param name="size">The size of the rectangle.</param>
/// <param name="color">Color of the rectangle.</param>
public static void Draw(ISpriteBatch sb, Vector2 position, Vector2 size, Color color)
{
var drawRect = _drawRectBorder;
drawRect.Size = size;
drawRect.Position = position;
drawRect.FillColor = color;
sb.Draw(drawRect);
}
public ThralledNPC(World parent, CharacterTemplate template, Map map, Vector2 position)
: base(parent, template, map, position)
{
// This NPC should never respawn. Once it's dead, that should be it!
RespawnMapID = null;
RespawnPosition = Vector2.Zero;
if (log.IsDebugEnabled)
log.DebugFormat("Created ThralledNPC `{0}` on map `{1}` at `{2}` with template `{3}`.", this, Map, Position,
template);
}
/// <summary>
/// Gets the selectable object currently under the cursor.
/// </summary>
/// <param name="map">The <see cref="EditorMap"/>.</param>
/// <param name="worldPos">The world position.</param>
/// <returns>The selectable object currently under the cursor, or null if none.</returns>
protected override object GetObjUnderCursor(EditorMap map, Vector2 worldPos)
{
var closestLight = map.Lights.MinElementOrDefault(x => worldPos.QuickDistance(x.Center));
if (closestLight == null)
return null;
if (worldPos.QuickDistance(closestLight.Center) > 10)
return null;
return closestLight;
}
/// <summary>
/// Draws a rectangle.
/// </summary>
/// <param name="sb"><see cref="ISpriteBatch"/> to draw to.</param>
/// <param name="position">Top-left corner position.</param>
/// <param name="size">The size of the rectangle.</param>
/// <param name="color">Color of the box.</param>
/// <param name="borderColor">Color of the border to draw around the rectangle.</param>
/// <param name="borderThickness">The thickness of the border in pixels. Default is 1.</param>
public static void Draw(ISpriteBatch sb, Vector2 position, Vector2 size, Color color, Color borderColor, float borderThickness = 1f)
{
var drawRect = _drawRectNoBorder;
drawRect.Size = size;
drawRect.Position = position;
drawRect.FillColor = color;
drawRect.OutlineColor = borderColor;
drawRect.OutlineThickness = borderThickness;
sb.Draw(drawRect);
}
/// <summary>
/// Draws a string with shading.
/// </summary>
/// <param name="spriteBatch"><see cref="ISpriteBatch"/> to use to draw.</param>
/// <param name="font"><see cref="Font"/> to draw the string with.</param>
/// <param name="text">The string to draw.</param>
/// <param name="position">The position of the top-left corner of the string to draw.</param>
/// <param name="fontColor">The font color.</param>
/// <param name="borderColor">The shading color.</param>
public static void DrawStringShaded(this ISpriteBatch spriteBatch, Font font, string text, Vector2 position,
Color fontColor, Color borderColor)
{
position = position.Round();
spriteBatch.DrawString(font, text, position - new Vector2(0, 1), borderColor);
spriteBatch.DrawString(font, text, position - new Vector2(1, 0), borderColor);
spriteBatch.DrawString(font, text, position + new Vector2(0, 1), borderColor);
spriteBatch.DrawString(font, text, position + new Vector2(1, 0), borderColor);
spriteBatch.DrawString(font, text, position, fontColor);
}
/// <summary>
/// Finds the mean for a collection of values of the specified type.
/// </summary>
/// <param name="values">Values to find the mean of.</param>
/// <param name="offset">Array offset to start at.</param>
/// <param name="count">Number of elements in the array to use.</param>
/// <returns>Mean of the values in the <paramref name="values"/> array.</returns>
public static Vector2 Mean(Vector2[] values, int offset, int count)
{
if (count == 0)
return Vector2.Zero;
var sum = Vector2.Zero;
for (var i = offset; i < offset + count; i++)
{
sum += values[i];
}
return sum / count;
}
public Particle(Vector2 position, Vector2 direction, float decayTime, Vector2 size, Color color)
{
_position = position;
_direction = direction;
_decayTime = decayTime;
_startTime = Game.ElapsedTime;
_shape = new RectangleShape
{
Size = size,
Rotation = RandomHelper.RandomFloat(360),
FillColor = color,
Origin = size / 2
};
}
void FocusCameraAtScreenPoint(MouseEventArgs e)
{
if (Camera == null || Camera.Map == null)
return;
if (e.Button == MouseButtons.Left)
{
var percent = new Vector2(e.X, e.Y) / new Vector2(Size.Width, Size.Height);
var min = Vector2.Zero;
var max = Vector2.One;
Vector2.Clamp(ref percent, ref min, ref max, out percent);
var worldPos = Camera.Map.Size * percent;
Camera.CenterOn(worldPos);
}
}
/// <summary>
/// Activates the DamageText.
/// </summary>
/// <param name="damage">Damage value to display.</param>
/// <param name="entity">Entity the damage was done to.</param>
/// <param name="currTime">Current time.</param>
public void Activate(int damage, Entity entity, TickCount currTime)
{
if (entity == null)
{
Debug.Fail("entity is null.");
return;
}
// Set the starting values
_alpha = 255;
_pos = entity.Position;
_lastUpdate = currTime;
_text = damage.ToString();
// Get a random velocity
_velocity = new Vector2(-1.0f + (float)_random.NextDouble() * 2.0f, -2.0f - (float)_random.NextDouble() * 0.25f);
}
/// <summary>
/// Draws a line.
/// </summary>
/// <param name="sb"><see cref="ISpriteBatch"/> to draw to.</param>
/// <param name="p1">First point of the line.</param>
/// <param name="p2">Second point of the line.</param>
/// <param name="color">Color of the line.</param>
/// <param name="thickness">The thickness of the line in pixels. Default is 1.</param>
public static void Draw(ISpriteBatch sb, Vector2 p1, Vector2 p2, Color color, float thickness = 1f)
{
if (sb == null)
{
Debug.Fail("sb is null.");
return;
}
if (sb.IsDisposed)
{
Debug.Fail("sb is disposed.");
return;
}
using (var s = Shape.Line(p1, p2, thickness, color))
{
sb.Draw(s);
}
}
public FireballProjectile(IProjectileOwner owner, Vector2 direction)
: base(owner, 0)
{
_direction = direction;
Position = owner.Position;
fireballAge = Game.ElapsedTime + 10;
_centerShapes = new List<RectangleShape>();
_particles = new List<Particle>();
for (int i = 0; i < 3; i++)
{
_centerShapes.Add(new RectangleShape
{
Size = new Vector2(15, 15),
Origin = new Vector2(7.5f, 7.5f),
Rotation = RandomHelper.RandomFloat(360),
FillColor = Color.Red
});
}
}
/// <summary>
/// Handles initialization of the GameScreen. This will be invoked after the GameScreen has been
/// completely and successfully added to the ScreenManager. It is highly recommended that you
/// use this instead of the constructor. This is invoked only once.
/// </summary>
public override void Initialize()
{
base.Initialize();
var cScreen = new Panel(GUIManager, Vector2.Zero, ScreenManager.ScreenSize);
// Create the menu buttons
_menuButtons = GameScreenHelper.CreateMenuButtons(ScreenManager, cScreen, "Accept", "Cancel");
_menuButtons["Accept"].Clicked += accept_Clicked;
_menuButtons["Cancel"].Clicked += cancel_Clicked;
// Create the options
var pos = new Vector2(60, 180);
var lblSound = GameScreenHelper.CreateMenuLabel(cScreen, pos, "Sound (0 to 100):");
_txtSound = new TextBox(cScreen, pos + new Vector2(lblSound.Size.X + 10, -6),
new Vector2(128, lblSound.ClientSize.Y + 4)) { AllowKeysHandler = TextEventArgsFilters.IsDigitFunc };
pos.Y += _txtSound.Size.Y + 16;
var lblMusic = GameScreenHelper.CreateMenuLabel(cScreen, pos, "Music (0 to 100):");
_txtMusic = new TextBox(cScreen, pos + new Vector2(lblMusic.Size.X + 10, -6),
new Vector2(128, lblMusic.ClientSize.Y + 4)) { AllowKeysHandler = TextEventArgsFilters.IsDigitFunc };
}
public TestEntity(Vector2 pos, Vector2 size) : base(pos, size)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="MapGrhEffectTimed"/> class.
/// </summary>
/// <param name="grh">Grh to draw.</param>
/// <param name="position">Position to draw on the map.</param>
/// <param name="life">How long the effect will last in milliseconds.</param>
public MapGrhEffectTimed(Grh grh, Vector2 position, int life) : base(grh, position)
{
_expireTime = (TickCount)(TickCount.Now + life);
}
/// <summary>
/// Initializes a new instance of the <see cref="CharacterEntity"/> class.
/// </summary>
/// <param name="position">The initial world position.</param>
/// <param name="size">The initial size.</param>
protected CharacterEntity(Vector2 position, Vector2 size) : base(position, size)
{
}
/// <summary>
/// Moves the character to the new location. Unlike Teleport(), this will not set the
/// velocity to zero, and is intended for position corrections / resynchronization.
/// </summary>
/// <param name="position">Correct position.</param>
public virtual void UpdatePosition(Vector2 position)
{
base.Teleport(position);
}
/// <summary>
/// Moves the character to a new location instantly. The character's velocity will
/// also be set to zero upon teleporting.
/// </summary>
/// <param name="position">New position</param>
protected override void Teleport(Vector2 position)
{
// Force the character to stop moving
#if !TOPDOWN
_state = CharacterState.Falling;
#endif
SetVelocity(Vector2.Zero);
StopMoving();
// Teleport
base.Teleport(position);
}
