private void DrawTooltip()
{
if (!string.IsNullOrWhiteSpace(Tooltip))
{
SpriteReference ui_tooltip = SpriteLoader.Instance.AddSprite("content/ui_box");
TextParameters tooltipParameters = new TextParameters().SetColor(Color.White, Color.Black);
int tooltipWidth = FontUtil.GetStringWidth(Tooltip, tooltipParameters);
int screenWidth = Viewport.Width - 8 - InputState.MouseX + 4;
bool invert = false;
if (tooltipWidth > screenWidth)
{
screenWidth = Viewport.Width - screenWidth;
invert = true;
}
tooltipParameters = new TextParameters().SetColor(Color.White, Color.Black).SetConstraints(screenWidth, int.MaxValue);
tooltipWidth = FontUtil.GetStringWidth(Tooltip, tooltipParameters);
int tooltipHeight = FontUtil.GetStringHeight(Tooltip, tooltipParameters);
int tooltipX = InputState.MouseX + 4;
int tooltipY = Math.Max(0, InputState.MouseY - 4 - tooltipHeight);
if (invert)
{
tooltipX -= tooltipWidth;
}
DrawUI(ui_tooltip, new Rectangle(tooltipX, tooltipY, tooltipWidth, tooltipHeight), Color.White);
DrawText(Tooltip, new Vector2(tooltipX, tooltipY), Alignment.Left, tooltipParameters);
}
}
private void DrawQuests(Map map)
{
if (map == null)
{
return;
}
SpriteReference cursor_tile = SpriteLoader.Instance.AddSprite("content/cursor_tile");
int drawX = (int)(Camera.X / 16);
int drawY = (int)(Camera.Y / 16);
int drawRadius = 30;
foreach (Tile tile in EnumerateCloseTiles(map, drawX, drawY, drawRadius))
{
if (!tile.IsVisible())
{
continue;
}
foreach (var quest in Quests)
{
if (!quest.Completed && quest.PrerequisitesCompleted && quest.ShowMarker(tile))
{
DrawSprite(cursor_tile, Frame / 1, new Vector2(tile.X * 16, tile.Y * 16), SpriteEffects.None, 0);
}
}
}
}
public void DrawUI(SpriteReference sprite, Rectangle area, Color color)
{
sprite.ShouldLoad = true;
if (sprite.Width % 2 == 0 || sprite.Height % 2 == 0)
{
return;
}
int borderX = sprite.Width / 2;
int borderY = sprite.Height / 2;
var leftBorder = area.X - borderX;
var topBorder = area.Y - borderY;
var rightBorder = area.X + area.Width;
var bottomBorder = area.Y + area.Height;
SpriteBatch.Draw(sprite.Texture, new Rectangle(leftBorder, topBorder, borderX, borderY), new Rectangle(0, 0, borderX, borderY), color);
SpriteBatch.Draw(sprite.Texture, new Rectangle(leftBorder, bottomBorder, borderX, borderY), new Rectangle(0, borderY + 1, borderX, borderY), color);
SpriteBatch.Draw(sprite.Texture, new Rectangle(rightBorder, topBorder, borderX, borderY), new Rectangle(borderX + 1, 0, borderX, borderY), color);
SpriteBatch.Draw(sprite.Texture, new Rectangle(rightBorder, bottomBorder, borderX, borderY), new Rectangle(borderX + 1, borderY + 1, borderX, borderY), color);
SpriteBatch.Draw(sprite.Texture, new Rectangle(area.X, topBorder, area.Width, borderY), new Rectangle(borderX, 0, 1, borderY), color);
SpriteBatch.Draw(sprite.Texture, new Rectangle(area.X, bottomBorder, area.Width, borderY), new Rectangle(borderX, borderY + 1, 1, borderY), color);
SpriteBatch.Draw(sprite.Texture, new Rectangle(leftBorder, area.Y, borderX, area.Height), new Rectangle(0, borderY, borderX, 1), color);
SpriteBatch.Draw(sprite.Texture, new Rectangle(rightBorder, area.Y, borderX, area.Height), new Rectangle(borderX + 1, borderY, borderX, 1), color);
SpriteBatch.Draw(sprite.Texture, new Rectangle(area.X, area.Y, area.Width, area.Height), new Rectangle(borderX, borderY, 1, 1), color);
}
private void Load(SpriteReference reference)
{
int count = 1;
FileInfo fileinfo = new FileInfo(reference.FileName + ".png");
if (!fileinfo.Exists)
{
DirectoryInfo dirinfo = fileinfo.Directory;
fileinfo = dirinfo.GetFiles(Path.GetFileNameWithoutExtension(fileinfo.Name) + "_strip*").FirstOrDefault();
}
if (fileinfo == null || !fileinfo.Exists)
{
return;
}
var match = FileNameExpression.Match(fileinfo.Name);
if (match.Success)
{
count = int.Parse(match.Groups[1].Value);
}
FileStream stream = fileinfo.OpenRead();
reference.Texture = Texture2D.FromStream(GraphicsDevice, stream);
reference.SubImageCount = count;
stream.Close();
reference.OnLoad?.Invoke();
}
protected void DrawLabelledUI(Scene scene, SpriteReference sprite, Rectangle rectInterior, string label)
{
Rectangle rectExterior = new Rectangle(rectInterior.X, rectInterior.Y - 20, rectInterior.Width, 16);
scene.DrawUI(sprite, rectInterior, Color.White);
if (!string.IsNullOrWhiteSpace(label))
{
scene.DrawUI(sprite, rectExterior, Color.White);
scene.DrawText(label, new Vector2(rectExterior.X, rectExterior.Y), Alignment.Center, new TextParameters().SetColor(Color.White, Color.Black).SetBold(true).SetConstraints(rectExterior.Width, rectExterior.Height));
}
}
public override void Update()
{
SpriteReference smoke = SpriteLoader.Instance.AddSprite("content/cloud_mist");
Ticks++;
foreach (var part in Parts)
{
if ((part.GetHashCode() + Ticks) % 14 == 0)
{
Vector2 pos = new Vector2(16 * part.Tile.X + Random.Next(16), 16 * part.Tile.Y + Random.Next(16));
new SmokeSpores(World, smoke, pos, Util.AngleToVector(Random.NextFloat() * MathHelper.TwoPi) * 0.1f, new Color(194, 184, 152), 120);
}
}
base.Update();
}
public override void Update()
{
SpriteReference smoke = SpriteLoader.Instance.AddSprite("content/smoke_small");
Ticks++;
foreach (var part in Parts)
{
if ((part.GetHashCode() + Ticks) % 1 == 0)
{
Vector2 pos = new Vector2(16 * part.Tile.X + Random.Next(16), 16 * part.Tile.Y + Random.Next(16));
new SmokeSmall(World, smoke, pos, Vector2.Zero, Color.White, 12);
}
}
base.Update();
}
public override void Update()
{
SpriteReference smoke = SpriteLoader.Instance.AddSprite("content/cloud_big");
Ticks++;
foreach (var part in Parts)
{
if ((part.GetHashCode() + Ticks) % 7 == 0)
{
Vector2 pos = new Vector2(16 * part.Tile.X + Random.Next(16), 16 * part.Tile.Y + Random.Next(16));
new SmokeSmallAdditive(World, smoke, pos, Vector2.Zero, new Color(64, 128, 255), 24);
}
}
base.Update();
}
public void DrawLine(SpriteReference sprite, Vector2 pos1, Vector2 pos2, float widthMod, float lengthMod, float offset)
{
var delta = pos2 - pos1;
var dist = delta.Length();
var side = (delta / dist).TurnLeft();
var width = sprite.Height;
//SetupNormal(WorldTransform, Projection);
SetupColorMatrix(ColorMatrix.Identity, WorldTransform, Projection);
PrimitiveBatch.Begin(PrimitiveType.TriangleStrip, texture: sprite.Texture, blendState: NonPremultiplied, rasterizerState: RasterizerState.CullNone, samplerState: SamplerState.PointWrap, transform: WorldTransform, projection: Projection, effect: Shader);
PrimitiveBatch.AddVertex(new VertexPositionColorTexture(new Vector3(pos1 + side * width * widthMod / 2, 0), Color.White, new Vector2(-offset / sprite.Width, 1)));
PrimitiveBatch.AddVertex(new VertexPositionColorTexture(new Vector3(pos1 - side * width * widthMod / 2, 0), Color.White, new Vector2(-offset / sprite.Width, 0)));
PrimitiveBatch.AddVertex(new VertexPositionColorTexture(new Vector3(pos2 + side * width * widthMod / 2, 0), Color.White, new Vector2((dist * lengthMod - offset) / sprite.Width, 1)));
PrimitiveBatch.AddVertex(new VertexPositionColorTexture(new Vector3(pos2 - side * width * widthMod / 2, 0), Color.White, new Vector2((dist * lengthMod - offset) / sprite.Width, 0)));
PrimitiveBatch.End();
}
public SpriteReference AddSprite(string filename, bool keeploaded)
{
if (Sprites.ContainsKey(filename))
{
return(Sprites[filename]);
}
var rval = new SpriteReference(filename)
{
KeepLoaded = keeploaded
};
Sprites.Add(filename, rval);
AllSprites.Add(rval);
return(rval);
}
public void DrawCircle(SpriteReference sprite, SamplerState samplerState, Vector2 center, int precision, float angleStart, float angleEnd, float radius, float texOffset, int texPrecision, float start, float end)
{
PrimitiveBatch.Begin(PrimitiveType.TriangleStrip, texture: sprite.Texture, blendState: NonPremultiplied, rasterizerState: RasterizerState.CullNone, samplerState: samplerState, transform: WorldTransform, projection: Projection, effect: Shader);
for (int i = 0; i < precision; i++)
{
float angleSlide = (float)i / (precision - 1);
Vector2 offset = Util.AngleToVector(MathHelper.Lerp(angleStart, angleEnd, angleSlide));
var inside = center;// + offset * radius * MathHelper.Clamp(start, 0, 1);
var outside = center + offset * radius * MathHelper.Clamp(end, 0, 1);
var texHorizontal = texPrecision * angleSlide + texOffset;
var texInside = 1 - Util.ReverseLerp(MathHelper.Clamp(0, 0, 1), start, end);
var texOutside = 1 - Util.ReverseLerp(MathHelper.Clamp(end, 0, 1), start, end);
PrimitiveBatch.AddVertex(new VertexPositionColorTexture(new Vector3(inside, 0), Color.White, new Vector2(texHorizontal, texInside)));
PrimitiveBatch.AddVertex(new VertexPositionColorTexture(new Vector3(outside, 0), Color.White, new Vector2(texHorizontal, texOutside)));
}
PrimitiveBatch.End();
}
public void DrawBeamCurve(SpriteReference sprite, Func <float, Vector2> curve, int precision, Func <float, float> thickness, float lengthMod, float offset, float start, float end)
{
List <Vector2> points = new List <Vector2>();
List <float> lengths = new List <float>();
List <Vector2> pivots = new List <Vector2>();
LineSet line = new LineSet();
for (int i = 0; i <= precision; i++)
{
line.AddPoint(curve((float)i / precision));
}
line.GetBeam(start, end, points, pivots, lengths);
var dist = line.TotalDistance;
var width = sprite.Height;
SetupColorMatrix(ColorMatrix.Identity, WorldTransform, Projection);
PrimitiveBatch.Begin(PrimitiveType.TriangleStrip, texture: sprite.Texture, blendState: NonPremultiplied, rasterizerState: RasterizerState.CullNone, samplerState: SamplerState.PointWrap, transform: WorldTransform, projection: Projection, effect: Shader);
for (int i = 0; i < points.Count; i++)
{
var point = points[i];
var side = pivots[i];
var len = lengths[i];
var slide = len / dist;
var tex = (dist * lengthMod * slide - offset) / sprite.Width;
var widthMod = thickness(slide);
PrimitiveBatch.AddVertex(new VertexPositionColorTexture(new Vector3(point + side * width * widthMod / 2, 0), Color.White, new Vector2(tex, 1)));
PrimitiveBatch.AddVertex(new VertexPositionColorTexture(new Vector3(point - side * width * widthMod / 2, 0), Color.White, new Vector2(tex, 0)));
}
PrimitiveBatch.End();
}
private void DrawTextures()
{
SpriteReference lava = SpriteLoader.Instance.AddSprite("content/lava");
SpriteReference water = SpriteLoader.Instance.AddSprite("content/water");
if (Lava == null || Lava.IsContentLost)
{
Lava = new RenderTarget2D(GraphicsDevice, Viewport.Width, Viewport.Height);
}
GraphicsDevice.SetRenderTarget(Lava);
GraphicsDevice.Clear(Color.Transparent);
PushSpriteBatch(shader: Shader, samplerState: SamplerState.PointWrap, blendState: NonPremultiplied, shaderSetup: (matrix, projection) => SetupWave(
new Vector2(-Frame / 30f, -Frame / 30f + MathHelper.PiOver4),
new Vector2(0.2f, 0.2f),
new Vector4(0.1f, 0.0f, 0.1f, 0.0f),
Matrix.Identity,
Projection
));
SpriteBatch.Draw(lava.Texture, new Rectangle(0, 0, Lava.Width, Lava.Height), new Rectangle(0, 0, Lava.Width, Lava.Height), Color.White);
PopSpriteBatch();
if (Water == null || Water.IsContentLost)
{
Water = new RenderTarget2D(GraphicsDevice, Viewport.Width, Viewport.Height);
}
GraphicsDevice.SetRenderTarget(Water);
GraphicsDevice.Clear(Color.Transparent);
PushSpriteBatch(shader: Shader, samplerState: SamplerState.PointWrap, blendState: NonPremultiplied, shaderSetup: (matrix, projection) => SetupWave(
new Vector2(-Frame / 30f, -Frame / 30f + MathHelper.PiOver4),
new Vector2(0.2f, 0.2f),
new Vector4(0.1f, 0.0f, 0.1f, 0.0f),
Matrix.Identity,
Projection
));
SpriteBatch.Draw(water.Texture, new Rectangle(0, 0, Water.Width, Water.Height), new Rectangle(0, 0, Water.Width, Water.Height), Color.White);
PopSpriteBatch();
Menu.PreDraw(this);
}
public SymbolBar(SpriteReference sprite) : base(sprite)
{
}
public SymbolElement(SpriteReference sprite, Element element) : base(sprite)
{
Element = element;
}
public Symbol(SpriteReference sprite)
{
ID = AllSymbols.Count;
Sprite = sprite;
AllSymbols.Add(this);
}
public void DrawSpriteExt(SpriteReference sprite, int frame, Vector2 position, Vector2 origin, float angle, Vector2 scale, SpriteEffects mirror, Color color, float depth)
{
SpriteBatch.Draw(sprite.Texture, position + origin, sprite.GetFrameRect(frame), color, angle, origin, scale.Mirror(mirror), SpriteEffects.None, depth);
}
public override void Draw(GameTime gameTime)
{
DrawTextures();
GraphicsDevice.SetRenderTarget(null);
if (CameraTargetA == null || CameraTargetA.IsContentLost)
{
CameraTargetA = new RenderTarget2D(GraphicsDevice, Viewport.Width, Viewport.Height);
}
if (CameraTargetB == null || CameraTargetB.IsContentLost)
{
CameraTargetB = new RenderTarget2D(GraphicsDevice, Viewport.Width, Viewport.Height);
}
if (DistortionMap == null || DistortionMap.IsContentLost)
{
DistortionMap = new RenderTarget2D(GraphicsDevice, Viewport.Width, Viewport.Height);
}
Projection = Matrix.CreateOrthographicOffCenter(0, Viewport.Width, Viewport.Height, 0, 0, -1);
WorldTransform = CreateViewMatrix();
IEnumerable <VisualEffect> visualEffects = VisualEffects.Where(x => x.ShouldDraw(CameraMap));
IEnumerable <ScreenShake> screenShakes = visualEffects.OfType <ScreenShake>();
if (screenShakes.Any())
{
ScreenShake screenShake = screenShakes.WithMax(effect => effect.Offset.LengthSquared());
if (screenShake != null)
{
WorldTransform *= Matrix.CreateTranslation(screenShake.Offset.X, screenShake.Offset.Y, 0);
}
}
var gameObjects = GameObjects.Where(x => x.ShouldDraw(CameraMap));
var tiles = DrawMap(CameraMap);
var drawPasses = gameObjects.Concat(tiles).ToMultiLookup(x => x.GetDrawPasses());
GraphicsDevice.SetRenderTarget(DistortionMap);
/*var noise = SpriteLoader.Instance.AddSprite("content/noise");
* var noiseOffset = Util.AngleToVector(Frame * 0.1f) * 30;
* noiseOffset = new Vector2(-Frame * 0.2f, -Frame * 0.5f);
* PushSpriteBatch(samplerState: SamplerState.LinearWrap, blendState: BlendState.Additive);
* SpriteBatch.Draw(Pixel, DistortionMap.Bounds, new Color(0,64,0));
* SpriteBatch.Draw(noise.Texture, DistortionMap.Bounds, new Rectangle((int)noiseOffset.X, (int)noiseOffset.Y, DistortionMap.Width, DistortionMap.Height), Color.Red);
* PopSpriteBatch();*/
PushSpriteBatch(samplerState: SamplerState.PointWrap, blendState: NonPremultiplied, transform: WorldTransform, projection: Projection);
drawPasses.DrawPass(this, DrawPass.SeaDistort);
PopSpriteBatch();
GraphicsDevice.SetRenderTarget(CameraTargetA);
//Render Liquid to Target A
PushSpriteBatch(samplerState: SamplerState.PointWrap, blendState: NonPremultiplied, transform: WorldTransform, projection: Projection);
drawPasses.DrawPass(this, DrawPass.SeaFloor);
drawPasses.DrawPass(this, DrawPass.Sea);
PopSpriteBatch();
GraphicsDevice.SetRenderTarget(CameraTargetB);
SwapBuffers();
PushSpriteBatch(samplerState: SamplerState.PointWrap, blendState: NonPremultiplied, transform: WorldTransform, projection: Projection);
drawPasses.DrawPass(this, DrawPass.LiquidFloor);
//Render Target A (Liquid) to Target B (with distortion)
PushSpriteBatch(samplerState: SamplerState.PointWrap, blendState: NonPremultiplied, transform: Matrix.Identity, shader: Shader, shaderSetup: (matrix, projection) =>
{
SetupDistortion(DistortionMap, new Vector2(30f / DistortionMap.Width, 30f / DistortionMap.Height), Matrix.Identity, Matrix.Identity, Projection);
});
SpriteBatch.Draw(CameraTargetB, CameraTargetB.Bounds, Color.White);
//SpriteBatch.Draw(DistortionMap, DistortionMap.Bounds, Color.White);
PopSpriteBatch();
drawPasses.DrawPass(this, DrawPass.Liquid);
//Render Map
drawPasses.DrawPass(this, DrawPass.Tile);
drawPasses.DrawPass(this, DrawPass.Item);
drawPasses.DrawPass(this, DrawPass.EffectLow);
PushSpriteBatch(blendState: BlendState.Additive);
drawPasses.DrawPass(this, DrawPass.EffectLowAdditive);
PopSpriteBatch();
drawPasses.DrawPass(this, DrawPass.Creature);
drawPasses.DrawPass(this, DrawPass.Effect);
PushSpriteBatch(blendState: BlendState.Additive);
drawPasses.DrawPass(this, DrawPass.EffectAdditive);
PopSpriteBatch();
PopSpriteBatch();
GraphicsDevice.SetRenderTarget(CameraTargetB);
SwapBuffers();
//Draw screenflashes
ColorMatrix color = ColorMatrix.Identity;
IEnumerable <ScreenFlash> screenFlashes = visualEffects.OfType <ScreenFlash>();
foreach (ScreenFlash screenFlash in screenFlashes)
{
color *= screenFlash.Color;
}
//SetupColorMatrix(color, Matrix.Identity, Projection);
//SetupGlitch(Game.Noise, Matrix.Identity, Projection, Random);
PushSpriteBatch(samplerState: SamplerState.PointWrap, blendState: NonPremultiplied, shader: Shader, shaderSetup: (transform, projection) =>
{
SetupColorMatrix(color, Matrix.Identity, Projection);
});
SpriteBatch.Draw(CameraTargetB, CameraTargetB.Bounds, Color.White);
PopSpriteBatch();
GraphicsDevice.SetRenderTarget(CameraTargetB);
SwapBuffers();
//Draw glitches
IEnumerable <ScreenGlitch> screenGlitches = visualEffects.OfType <ScreenGlitch>();
foreach (var glitch in screenGlitches)
{
GlitchParams glitchParams = glitch.Glitch;
PushSpriteBatch(samplerState: SamplerState.PointWrap, blendState: NonPremultiplied, shader: Shader, shaderSetup: (transform, projection) =>
{
SetupGlitch(Game.Noise, glitchParams, Random, Matrix.Identity, Projection);
});
SpriteBatch.Draw(CameraTargetB, CameraTargetB.Bounds, Color.White);
PopSpriteBatch();
GraphicsDevice.SetRenderTarget(CameraTargetB);
SwapBuffers();
}
//Draw to screen
GraphicsDevice.SetRenderTarget(null);
PushSpriteBatch(samplerState: SamplerState.PointWrap, blendState: NonPremultiplied, shader: Shader, shaderSetup: (transform, projection) =>
{
SetupColorMatrix(ColorMatrix.Identity, Matrix.Identity, Projection);
});
SpriteBatch.Draw(CameraTargetB, CameraTargetB.Bounds, Color.White);
PopSpriteBatch();
SpriteReference cursor_tile = SpriteLoader.Instance.AddSprite("content/cursor_tile");
SetupNormal(Matrix.Identity, Projection);
//SpriteBatch.Begin(blendState: NonPremultiplied, rasterizerState: RasterizerState.CullNone, samplerState: SamplerState.PointWrap, transformMatrix: WorldTransform);
PushSpriteBatch(blendState: NonPremultiplied, samplerState: SamplerState.PointWrap, transform: WorldTransform, projection: Projection);
if (TileCursor.HasValue)
{
DrawSprite(cursor_tile, Frame / 8, new Vector2(TileCursor.Value.X * 16, TileCursor.Value.Y * 16), SpriteEffects.None, 0);
}
DrawQuests(CameraMap);
drawPasses.DrawPass(this, DrawPass.UIWorld);
//SpriteBatch.End();
PopSpriteBatch();
//SetupNormal(Matrix.Identity);
//SpriteBatch.Begin(blendState: NonPremultiplied, rasterizerState: RasterizerState.CullNone, samplerState: SamplerState.PointWrap);
PushSpriteBatch(blendState: NonPremultiplied, samplerState: SamplerState.PointWrap, projection: Projection);
DrawQuestText(CameraMap);
drawPasses.DrawPass(this, DrawPass.UI);
Menu.Draw(this);
DrawTooltip();
PopSpriteBatch();
}
public int AnimationFrame(SpriteReference sprite, float frame, float frameEnd)
{
return((int)MathHelper.Clamp(sprite.SubImageCount * frame / frameEnd, 0, sprite.SubImageCount - 1));
}
public void DrawSprite(SpriteReference sprite, int frame, Vector2 position, SpriteEffects mirror, Color color, float depth)
{
SpriteBatch.Draw(sprite.Texture, position, sprite.GetFrameRect(frame), color, 0, Vector2.Zero, Vector2.One, mirror, depth);
}
public void DrawSprite(SpriteReference sprite, int frame, Vector2 position, SpriteEffects mirror, float depth)
{
DrawSprite(sprite, frame, position, mirror, Color.White, depth);
}
public void DrawSpriteExt(SpriteReference sprite, int frame, Vector2 position, Vector2 origin, float angle, SpriteEffects mirror, float depth)
{
DrawSpriteExt(sprite, frame, position, origin, angle, Vector2.One, mirror, Color.White, depth);
}
