mirror of
https://github.com/electronicarts/CnC_Remastered_Collection
synced 2024-04-29 18:02:36 +12:00
836 lines
36 KiB
C#
836 lines
36 KiB
C#
//
|
|
// Copyright 2020 Electronic Arts Inc.
|
|
//
|
|
// The Command & Conquer Map Editor and corresponding source code is free
|
|
// software: you can redistribute it and/or modify it under the terms of
|
|
// the GNU General Public License as published by the Free Software Foundation,
|
|
// either version 3 of the License, or (at your option) any later version.
|
|
|
|
// The Command & Conquer Map Editor and corresponding source code is distributed
|
|
// in the hope that it will be useful, but with permitted additional restrictions
|
|
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
|
|
// distributed with this program. You should have received a copy of the
|
|
// GNU General Public License along with permitted additional restrictions
|
|
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
|
|
using MobiusEditor.Interface;
|
|
using MobiusEditor.Model;
|
|
using MobiusEditor.Utility;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using System.Linq;
|
|
|
|
namespace MobiusEditor.Render
|
|
{
|
|
public static class MapRenderer
|
|
{
|
|
private static readonly int[] Facing16 = new int[256]
|
|
{
|
|
0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,
|
|
2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,
|
|
4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,6,6,6,6,6,6,6,6,
|
|
6,6,6,6,6,6,6,6,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,7,8,8,8,8,8,8,8,8,
|
|
8,8,8,8,8,8,8,8,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,10,10,10,10,10,10,10,10,
|
|
10,10,10,10,10,10,10,10,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,
|
|
12,12,12,12,12,12,12,12,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,
|
|
14,14,14,14,14,14,14,14,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,15,0,0,0,0,0,0,0,0
|
|
};
|
|
|
|
private static readonly int[] Facing32 = new int[256]
|
|
{
|
|
0,0,0,0,0,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,
|
|
3,4,4,4,4,4,4,5,5,5,5,5,5,5,6,6,6,6,6,6,6,7,7,7,7,7,7,7,8,8,8,8,
|
|
8,8,8,9,9,9,9,9,9,9,10,10,10,10,10,10,10,11,11,11,11,11,11,11,12,12,12,12,12,12,12,12,
|
|
13,13,13,13,13,13,13,13,14,14,14,14,14,14,14,14,14,15,15,15,15,15,15,15,15,15,16,16,16,16,16,16,
|
|
16,16,16,16,16,17,17,17,17,17,17,17,17,17,18,18,18,18,18,18,18,18,18,19,19,19,19,19,19,19,19,19,
|
|
19,20,20,20,20,20,20,21,21,21,21,21,21,21,22,22,22,22,22,22,22,23,23,23,23,23,23,23,24,24,24,24,
|
|
24,24,24,25,25,25,25,25,25,25,26,26,26,26,26,26,26,27,27,27,27,27,27,27,28,28,28,28,28,28,28,28,
|
|
29,29,29,29,29,29,29,29,30,30,30,30,30,30,30,30,30,31,31,31,31,31,31,31,31,31,0,0,0,0,0,0
|
|
};
|
|
|
|
private static readonly int[] HumanShape = new int[32]
|
|
{
|
|
0,0,7,7,7,7,6,6,6,6,5,5,5,5,5,4,4,4,3,3,3,3,2,2,2,2,1,1,1,1,1,0
|
|
};
|
|
|
|
private static readonly int[] BodyShape = new int[32]
|
|
{
|
|
0,31,30,29,28,27,26,25,24,23,22,21,20,19,18,17,16,15,14,13,12,11,10,9,8,7,6,5,4,3,2,1
|
|
};
|
|
|
|
private static readonly Point[] TurretAdjust = new Point[]
|
|
{
|
|
new Point(1, 2), // N
|
|
new Point(-1, 1),
|
|
new Point(-2, 0),
|
|
new Point(-3, 0),
|
|
new Point(-3, 1), // NW
|
|
new Point(-4, -1),
|
|
new Point(-4, -1),
|
|
new Point(-5, -2),
|
|
new Point(-5, -3), // W
|
|
new Point(-5, -3),
|
|
new Point(-3, -3),
|
|
new Point(-3, -4),
|
|
new Point(-3, -4), // SW
|
|
new Point(-3, -5),
|
|
new Point(-2, -5),
|
|
new Point(-1, -5),
|
|
new Point(0, -5), // S
|
|
new Point(1, -6),
|
|
new Point(2, -5),
|
|
new Point(3, -5),
|
|
new Point(4, -5), // SE
|
|
new Point(6, -4),
|
|
new Point(6, -3),
|
|
new Point(6, -3),
|
|
new Point(6, -3), // E
|
|
new Point(5, -1),
|
|
new Point(5, -1),
|
|
new Point(4, 0),
|
|
new Point(3, 0), // NE
|
|
new Point(2, 0),
|
|
new Point(2, 1),
|
|
new Point(1, 2)
|
|
};
|
|
|
|
private static readonly int[] tiberiumCounts = new int[] { 0, 1, 3, 4, 6, 7, 8, 10, 11 };
|
|
private static readonly int randomSeed;
|
|
|
|
static MapRenderer()
|
|
{
|
|
randomSeed = Guid.NewGuid().GetHashCode();
|
|
}
|
|
|
|
public static void Render(GameType gameType, Map map, Graphics graphics, ISet<Point> locations, MapLayerFlag layers, int tileScale)
|
|
{
|
|
var tileSize = new Size(Globals.OriginalTileWidth / tileScale, Globals.OriginalTileHeight / tileScale);
|
|
var tiberiumOrGoldTypes = map.OverlayTypes.Where(t => t.IsTiberiumOrGold).Select(t => t).ToArray();
|
|
var gemTypes = map.OverlayTypes.Where(t => t.IsGem).ToArray();
|
|
|
|
var overlappingRenderList = new List<(Rectangle, Action<Graphics>)>();
|
|
|
|
Func<IEnumerable<Point>> renderLocations = null;
|
|
if (locations != null)
|
|
{
|
|
renderLocations = () => locations;
|
|
}
|
|
else
|
|
{
|
|
IEnumerable<Point> allCells()
|
|
{
|
|
for (var y = 0; y < map.Metrics.Height; ++y)
|
|
{
|
|
for (var x = 0; x < map.Metrics.Width; ++x)
|
|
{
|
|
yield return new Point(x, y);
|
|
}
|
|
}
|
|
}
|
|
|
|
renderLocations = allCells;
|
|
}
|
|
|
|
if ((layers & MapLayerFlag.Template) != MapLayerFlag.None)
|
|
{
|
|
foreach (var topLeft in renderLocations())
|
|
{
|
|
map.Metrics.GetCell(topLeft, out int cell);
|
|
|
|
var template = map.Templates[topLeft];
|
|
var name = template?.Type.Name ?? map.TemplateTypes.Where(t => t.Equals("clear1")).FirstOrDefault().Name;
|
|
var icon = template?.Icon ?? ((cell & 0x03) | ((cell >> 4) & 0x0C));
|
|
|
|
if (Globals.TheTilesetManager.GetTileData(map.Theater.Tilesets, name, icon, out Tile tile))
|
|
{
|
|
var renderBounds = new Rectangle(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height, tileSize.Width, tileSize.Height);
|
|
graphics.DrawImage(tile.Image, renderBounds);
|
|
}
|
|
else
|
|
{
|
|
Debug.Print(string.Format("Template {0} ({1}) not found", name, icon));
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((layers & MapLayerFlag.Smudge) != MapLayerFlag.None)
|
|
{
|
|
foreach (var topLeft in renderLocations())
|
|
{
|
|
var smudge = map.Smudge[topLeft];
|
|
if (smudge != null)
|
|
{
|
|
Render(map.Theater, topLeft, tileSize, smudge).Item2(graphics);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((layers & MapLayerFlag.OverlayAll) != MapLayerFlag.None)
|
|
{
|
|
foreach (var topLeft in renderLocations())
|
|
{
|
|
var overlay = map.Overlay[topLeft];
|
|
if (overlay == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if ((overlay.Type.IsResource && ((layers & MapLayerFlag.Resources) != MapLayerFlag.None)) ||
|
|
(overlay.Type.IsWall && ((layers & MapLayerFlag.Walls) != MapLayerFlag.None)) ||
|
|
((layers & MapLayerFlag.Overlay) != MapLayerFlag.None))
|
|
{
|
|
Render(map.Theater, tiberiumOrGoldTypes, gemTypes, topLeft, tileSize, tileScale, overlay).Item2(graphics);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((layers & MapLayerFlag.Terrain) != MapLayerFlag.None)
|
|
{
|
|
foreach (var (topLeft, terrain) in map.Technos.OfType<Terrain>())
|
|
{
|
|
if ((locations != null) && !locations.Contains(topLeft))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
string tileName = terrain.Type.Name;
|
|
if ((terrain.Type.TemplateType & TemplateTypeFlag.OreMine) != TemplateTypeFlag.None)
|
|
{
|
|
tileName = "OREMINE";
|
|
}
|
|
|
|
if (Globals.TheTilesetManager.GetTileData(map.Theater.Tilesets, tileName, terrain.Icon, out Tile tile))
|
|
{
|
|
var tint = terrain.Tint;
|
|
var imageAttributes = new ImageAttributes();
|
|
if (tint != Color.White)
|
|
{
|
|
var colorMatrix = new ColorMatrix(new float[][]
|
|
{
|
|
new float[] {tint.R / 255.0f, 0, 0, 0, 0},
|
|
new float[] {0, tint.G / 255.0f, 0, 0, 0},
|
|
new float[] {0, 0, tint.B / 255.0f, 0, 0},
|
|
new float[] {0, 0, 0, tint.A / 255.0f, 0},
|
|
new float[] {0, 0, 0, 0, 1},
|
|
}
|
|
);
|
|
imageAttributes.SetColorMatrix(colorMatrix);
|
|
}
|
|
|
|
var location = new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height);
|
|
var size = new Size(tile.Image.Width / tileScale, tile.Image.Height / tileScale);
|
|
var terrainBounds = new Rectangle(location, size);
|
|
overlappingRenderList.Add((terrainBounds, g => g.DrawImage(tile.Image, terrainBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes)));
|
|
}
|
|
else
|
|
{
|
|
Debug.Print(string.Format("Terrain {0} ({1}) not found", tileName, terrain.Icon));
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((layers & MapLayerFlag.Buildings) != MapLayerFlag.None)
|
|
{
|
|
foreach (var (topLeft, building) in map.Buildings.OfType<Building>())
|
|
{
|
|
if ((locations != null) && !locations.Contains(topLeft))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
overlappingRenderList.Add(Render(gameType, map.Theater, topLeft, tileSize, tileScale, building));
|
|
}
|
|
}
|
|
|
|
if ((layers & MapLayerFlag.Infantry) != MapLayerFlag.None)
|
|
{
|
|
foreach (var (topLeft, infantryGroup) in map.Technos.OfType<InfantryGroup>())
|
|
{
|
|
if ((locations != null) && !locations.Contains(topLeft))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
for (int i = 0; i < infantryGroup.Infantry.Length; ++i)
|
|
{
|
|
var infantry = infantryGroup.Infantry[i];
|
|
if (infantry == null)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
overlappingRenderList.Add(Render(map.Theater, topLeft, tileSize, infantry, (InfantryStoppingType)i));
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((layers & MapLayerFlag.Units) != MapLayerFlag.None)
|
|
{
|
|
foreach (var (topLeft, unit) in map.Technos.OfType<Unit>())
|
|
{
|
|
if ((locations != null) && !locations.Contains(topLeft))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
overlappingRenderList.Add(Render(gameType, map.Theater, topLeft, tileSize, unit));
|
|
}
|
|
}
|
|
|
|
foreach (var (location, renderer) in overlappingRenderList.Where(x => !x.Item1.IsEmpty).OrderBy(x => x.Item1.Bottom))
|
|
{
|
|
renderer(graphics);
|
|
}
|
|
}
|
|
|
|
public static void Render(GameType gameType, Map map, Graphics graphics, ISet<Point> locations, MapLayerFlag layers)
|
|
{
|
|
Render(gameType, map, graphics, locations, layers, Globals.TileScale);
|
|
}
|
|
|
|
public static (Rectangle, Action<Graphics>) Render(TheaterType theater, Point topLeft, Size tileSize, Smudge smudge)
|
|
{
|
|
var tint = smudge.Tint;
|
|
var imageAttributes = new ImageAttributes();
|
|
if (tint != Color.White)
|
|
{
|
|
var colorMatrix = new ColorMatrix(new float[][]
|
|
{
|
|
new float[] {tint.R / 255.0f, 0, 0, 0, 0},
|
|
new float[] {0, tint.G / 255.0f, 0, 0, 0},
|
|
new float[] {0, 0, tint.B / 255.0f, 0, 0},
|
|
new float[] {0, 0, 0, tint.A / 255.0f, 0},
|
|
new float[] {0, 0, 0, 0, 1},
|
|
}
|
|
);
|
|
imageAttributes.SetColorMatrix(colorMatrix);
|
|
}
|
|
|
|
if (Globals.TheTilesetManager.GetTileData(theater.Tilesets, smudge.Type.Name, smudge.Icon, out Tile tile))
|
|
{
|
|
var location = new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height);
|
|
var smudgeBounds = new Rectangle(location, smudge.Type.RenderSize);
|
|
|
|
void render(Graphics g)
|
|
{
|
|
g.DrawImage(tile.Image, smudgeBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes);
|
|
}
|
|
|
|
return (smudgeBounds, render);
|
|
}
|
|
else
|
|
{
|
|
Debug.Print(string.Format("Smudge {0} ({1}) not found", smudge.Type.Name, smudge.Icon));
|
|
return (Rectangle.Empty, (g) => { });
|
|
}
|
|
}
|
|
|
|
public static (Rectangle, Action<Graphics>) Render(TheaterType theater, OverlayType[] tiberiumOrGoldTypes, OverlayType[] gemTypes, Point topLeft, Size tileSize, int tileScale, Overlay overlay)
|
|
{
|
|
var name = overlay.Type.Name;
|
|
if (overlay.Type.IsGem)
|
|
{
|
|
name = gemTypes[new Random(randomSeed ^ topLeft.GetHashCode()).Next(tiberiumOrGoldTypes.Length)].Name;
|
|
}
|
|
else if (overlay.Type.IsTiberiumOrGold)
|
|
{
|
|
name = tiberiumOrGoldTypes[new Random(randomSeed ^ topLeft.GetHashCode()).Next(tiberiumOrGoldTypes.Length)].Name;
|
|
}
|
|
|
|
if (Globals.TheTilesetManager.GetTileData(theater.Tilesets, name, overlay.Icon, out Tile tile))
|
|
{
|
|
var size = (overlay.Type.IsCrate || overlay.Type.IsFlag) ? new Size(tile.Image.Width / tileScale, tile.Image.Height / tileScale) : tileSize;
|
|
var location = new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height)
|
|
+ new Size(tileSize.Width / 2, tileSize.Height / 2)
|
|
- new Size(size.Width / 2, size.Height / 2);
|
|
var overlayBounds = new Rectangle(location, size);
|
|
|
|
var tint = overlay.Tint;
|
|
void render(Graphics g)
|
|
{
|
|
var imageAttributes = new ImageAttributes();
|
|
if (tint != Color.White)
|
|
{
|
|
var colorMatrix = new ColorMatrix(new float[][]
|
|
{
|
|
new float[] {tint.R / 255.0f, 0, 0, 0, 0},
|
|
new float[] {0, tint.G / 255.0f, 0, 0, 0},
|
|
new float[] {0, 0, tint.B / 255.0f, 0, 0},
|
|
new float[] {0, 0, 0, tint.A / 255.0f, 0},
|
|
new float[] {0, 0, 0, 0, 1},
|
|
}
|
|
);
|
|
imageAttributes.SetColorMatrix(colorMatrix);
|
|
}
|
|
|
|
g.DrawImage(tile.Image, overlayBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes);
|
|
}
|
|
|
|
return (overlayBounds, render);
|
|
}
|
|
else
|
|
{
|
|
Debug.Print(string.Format("Overlay {0} ({1}) not found", overlay.Type.Name, overlay.Icon));
|
|
return (Rectangle.Empty, (g) => { });
|
|
}
|
|
}
|
|
|
|
public static (Rectangle, Action<Graphics>) Render(GameType gameType, TheaterType theater, Point topLeft, Size tileSize, int tileScale, Building building)
|
|
{
|
|
var tint = building.Tint;
|
|
|
|
var stringFormat = new StringFormat
|
|
{
|
|
Alignment = StringAlignment.Center,
|
|
LineAlignment = StringAlignment.Center
|
|
};
|
|
var fakeBackgroundBrush = new SolidBrush(Color.FromArgb(building.Tint.A / 2, Color.Black));
|
|
var fakeTextBrush = new SolidBrush(Color.FromArgb(building.Tint.A, Color.White));
|
|
var baseBackgroundBrush = new SolidBrush(Color.FromArgb(building.Tint.A / 2, Color.Black));
|
|
var baseTextBrush = new SolidBrush(Color.FromArgb(building.Tint.A, Color.Red));
|
|
|
|
var icon = 0;
|
|
if (building.Type.HasTurret)
|
|
{
|
|
icon = BodyShape[Facing32[building.Direction.ID]];
|
|
if (building.Strength < 128)
|
|
{
|
|
switch (gameType)
|
|
{
|
|
case GameType.TiberianDawn:
|
|
icon += 64;
|
|
break;
|
|
case GameType.RedAlert:
|
|
icon += building.Type.Equals("sam") ? 35 : 64;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (building.Strength <= 1)
|
|
{
|
|
icon = -1;
|
|
}
|
|
else if (building.Strength < 128)
|
|
{
|
|
icon = -2;
|
|
if (building.Type.Equals("weap") || building.Type.Equals("weaf"))
|
|
{
|
|
icon = 1;
|
|
}
|
|
else if ((gameType == GameType.TiberianDawn) && building.Type.Equals("proc"))
|
|
{
|
|
icon = 30;
|
|
}
|
|
else if (building.Type.Equals("eye"))
|
|
{
|
|
icon = 16;
|
|
}
|
|
else if (building.Type.Equals("silo"))
|
|
{
|
|
icon = 5;
|
|
}
|
|
else if (building.Type.Equals("fix"))
|
|
{
|
|
icon = 7;
|
|
}
|
|
else if (building.Type.Equals("v19"))
|
|
{
|
|
icon = 14;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Globals.TheTilesetManager.GetTeamColorTileData(theater.Tilesets, building.Type.Tilename, icon, Globals.TheTeamColorManager[building.House.BuildingTeamColor], out Tile tile))
|
|
{
|
|
var location = new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height);
|
|
var size = new Size(tile.Image.Width / tileScale, tile.Image.Height / tileScale);
|
|
var maxSize = new Size(building.Type.Size.Width * tileSize.Width, building.Type.Size.Height * tileSize.Height);
|
|
if ((size.Width >= size.Height) && (size.Width > maxSize.Width))
|
|
{
|
|
size.Height = size.Height * maxSize.Width / size.Width;
|
|
size.Width = maxSize.Width;
|
|
}
|
|
else if ((size.Height >= size.Width) && (size.Height > maxSize.Height))
|
|
{
|
|
size.Width = size.Width * maxSize.Height / size.Height;
|
|
size.Height = maxSize.Height;
|
|
}
|
|
var buildingBounds = new Rectangle(location, size);
|
|
|
|
Tile factoryOverlayTile = null;
|
|
if (building.Type.FactoryOverlay != null)
|
|
{
|
|
int overlayIcon = 0;
|
|
if (building.Strength < 128)
|
|
{
|
|
switch (gameType)
|
|
{
|
|
case GameType.TiberianDawn:
|
|
overlayIcon = 10;
|
|
break;
|
|
case GameType.RedAlert:
|
|
overlayIcon = 4;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Globals.TheTilesetManager.GetTeamColorTileData(theater.Tilesets, building.Type.FactoryOverlay, overlayIcon, Globals.TheTeamColorManager[building.House.BuildingTeamColor], out factoryOverlayTile);
|
|
}
|
|
|
|
void render(Graphics g)
|
|
{
|
|
var imageAttributes = new ImageAttributes();
|
|
if (tint != Color.White)
|
|
{
|
|
var colorMatrix = new ColorMatrix(new float[][]
|
|
{
|
|
new float[] {tint.R / 255.0f, 0, 0, 0, 0},
|
|
new float[] {0, tint.G / 255.0f, 0, 0, 0},
|
|
new float[] {0, 0, tint.B / 255.0f, 0, 0},
|
|
new float[] {0, 0, 0, tint.A / 255.0f, 0},
|
|
new float[] {0, 0, 0, 0, 1},
|
|
}
|
|
);
|
|
imageAttributes.SetColorMatrix(colorMatrix);
|
|
}
|
|
|
|
if (factoryOverlayTile != null)
|
|
{
|
|
g.DrawImage(tile.Image, buildingBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes);
|
|
g.DrawImage(factoryOverlayTile.Image, buildingBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes);
|
|
}
|
|
else
|
|
{
|
|
g.DrawImage(tile.Image, buildingBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes);
|
|
}
|
|
|
|
if (building.Type.IsFake)
|
|
{
|
|
var text = Globals.TheGameTextManager["TEXT_UI_FAKE"];
|
|
var textSize = g.MeasureString(text, SystemFonts.CaptionFont) + new SizeF(6.0f, 6.0f);
|
|
var textBounds = new RectangleF(buildingBounds.Location, textSize);
|
|
g.FillRectangle(fakeBackgroundBrush, textBounds);
|
|
g.DrawString(text, SystemFonts.CaptionFont, fakeTextBrush, textBounds, stringFormat);
|
|
}
|
|
|
|
if (building.BasePriority >= 0)
|
|
{
|
|
var text = building.BasePriority.ToString();
|
|
var textSize = g.MeasureString(text, SystemFonts.CaptionFont) + new SizeF(6.0f, 6.0f);
|
|
var textBounds = new RectangleF(buildingBounds.Location +
|
|
new Size((int)((buildingBounds.Width - textSize.Width) / 2.0f), (int)(buildingBounds.Height - textSize.Height)),
|
|
textSize
|
|
);
|
|
g.FillRectangle(baseBackgroundBrush, textBounds);
|
|
g.DrawString(text, SystemFonts.CaptionFont, baseTextBrush, textBounds, stringFormat);
|
|
}
|
|
}
|
|
|
|
return (buildingBounds, render);
|
|
}
|
|
else
|
|
{
|
|
Debug.Print(string.Format("Building {0} (0) not found", building.Type.Name));
|
|
return (Rectangle.Empty, (g) => { });
|
|
}
|
|
}
|
|
|
|
public static (Rectangle, Action<Graphics>) Render(TheaterType theater, Point topLeft, Size tileSize, Infantry infantry, InfantryStoppingType infantryStoppingType)
|
|
{
|
|
var icon = HumanShape[Facing32[infantry.Direction.ID]];
|
|
|
|
string teamColor = infantry.House?.UnitTeamColor;
|
|
if (Globals.TheTilesetManager.GetTeamColorTileData(theater.Tilesets, infantry.Type.Name, icon, Globals.TheTeamColorManager[teamColor], out Tile tile))
|
|
{
|
|
var baseLocation = new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height)
|
|
+ new Size(tileSize.Width / 2, tileSize.Height / 2);
|
|
|
|
var offset = Point.Empty;
|
|
switch (infantryStoppingType)
|
|
{
|
|
case InfantryStoppingType.UpperLeft:
|
|
offset.X = -tileSize.Width / 4;
|
|
offset.Y = -tileSize.Height / 4;
|
|
break;
|
|
case InfantryStoppingType.UpperRight:
|
|
offset.X = tileSize.Width / 4;
|
|
offset.Y = -tileSize.Height / 4;
|
|
break;
|
|
case InfantryStoppingType.LowerLeft:
|
|
offset.X = -tileSize.Width / 4;
|
|
offset.Y = tileSize.Height / 4;
|
|
break;
|
|
case InfantryStoppingType.LowerRight:
|
|
offset.X = tileSize.Width / 4;
|
|
offset.Y = tileSize.Height / 4;
|
|
break;
|
|
}
|
|
baseLocation.Offset(offset);
|
|
|
|
var virtualBounds = new Rectangle(
|
|
new Point(baseLocation.X - (tile.OpaqueBounds.Width / 2), baseLocation.Y - tile.OpaqueBounds.Height),
|
|
tile.OpaqueBounds.Size
|
|
);
|
|
var renderBounds = new Rectangle(
|
|
baseLocation - new Size(infantry.Type.RenderSize.Width / 2, infantry.Type.RenderSize.Height / 2),
|
|
infantry.Type.RenderSize
|
|
);
|
|
|
|
var tint = infantry.Tint;
|
|
void render(Graphics g)
|
|
{
|
|
var imageAttributes = new ImageAttributes();
|
|
if (tint != Color.White)
|
|
{
|
|
var colorMatrix = new ColorMatrix(new float[][]
|
|
{
|
|
new float[] {tint.R / 255.0f, 0, 0, 0, 0},
|
|
new float[] {0, tint.G / 255.0f, 0, 0, 0},
|
|
new float[] {0, 0, tint.B / 255.0f, 0, 0},
|
|
new float[] {0, 0, 0, tint.A / 255.0f, 0},
|
|
new float[] {0, 0, 0, 0, 1},
|
|
}
|
|
);
|
|
imageAttributes.SetColorMatrix(colorMatrix);
|
|
}
|
|
g.DrawImage(tile.Image, renderBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes);
|
|
}
|
|
|
|
return (virtualBounds, render);
|
|
}
|
|
else
|
|
{
|
|
Debug.Print(string.Format("Infantry {0} ({1}) not found", infantry.Type.Name, icon));
|
|
return (Rectangle.Empty, (g) => { });
|
|
}
|
|
}
|
|
|
|
public static (Rectangle, Action<Graphics>) Render(GameType gameType, TheaterType theater, Point topLeft, Size tileSize, Unit unit)
|
|
{
|
|
int icon = 0;
|
|
if (gameType == GameType.TiberianDawn)
|
|
{
|
|
if (unit.Type == TiberianDawn.UnitTypes.GunBoat)
|
|
{
|
|
switch (unit.Direction.Facing)
|
|
{
|
|
case FacingType.NorthEast:
|
|
case FacingType.East:
|
|
case FacingType.SouthEast:
|
|
icon = 96;
|
|
break;
|
|
default:
|
|
icon = 0;
|
|
break;
|
|
}
|
|
}
|
|
else if ((unit.Type == TiberianDawn.UnitTypes.Tric) ||
|
|
(unit.Type == TiberianDawn.UnitTypes.Trex) ||
|
|
(unit.Type == TiberianDawn.UnitTypes.Rapt) ||
|
|
(unit.Type == TiberianDawn.UnitTypes.Steg))
|
|
{
|
|
var facing = ((unit.Direction.ID + 0x10) & 0xFF) >> 5;
|
|
icon = BodyShape[facing + ((facing > 0) ? 24 : 0)];
|
|
}
|
|
else if ((unit.Type == TiberianDawn.UnitTypes.Hover) ||
|
|
(unit.Type == TiberianDawn.UnitTypes.Visceroid))
|
|
{
|
|
icon = 0;
|
|
}
|
|
else
|
|
{
|
|
icon = BodyShape[Facing32[unit.Direction.ID]];
|
|
}
|
|
}
|
|
else if (gameType == GameType.RedAlert)
|
|
{
|
|
if (unit.Type.IsAircraft)
|
|
{
|
|
if ((unit.Type == RedAlert.UnitTypes.Tran) ||
|
|
(unit.Type == RedAlert.UnitTypes.Heli) ||
|
|
(unit.Type == RedAlert.UnitTypes.Hind))
|
|
{
|
|
icon = BodyShape[Facing32[unit.Direction.ID]];
|
|
}
|
|
else
|
|
{
|
|
icon = BodyShape[Facing16[unit.Direction.ID] * 2] / 2;
|
|
}
|
|
}
|
|
else if (unit.Type.IsVessel)
|
|
{
|
|
if ((unit.Type == RedAlert.UnitTypes.Transport) ||
|
|
(unit.Type == RedAlert.UnitTypes.Carrier))
|
|
{
|
|
icon = 0;
|
|
}
|
|
else
|
|
{
|
|
icon = BodyShape[Facing16[unit.Direction.ID] * 2] >> 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((unit.Type == RedAlert.UnitTypes.Ant1) ||
|
|
(unit.Type == RedAlert.UnitTypes.Ant2) ||
|
|
(unit.Type == RedAlert.UnitTypes.Ant3))
|
|
{
|
|
icon = ((BodyShape[Facing32[unit.Direction.ID]] + 2) / 4) & 0x07;
|
|
}
|
|
else
|
|
{
|
|
icon = BodyShape[Facing32[unit.Direction.ID]];
|
|
}
|
|
}
|
|
}
|
|
|
|
string teamColor = null;
|
|
if (unit.House != null)
|
|
{
|
|
if (!unit.House.OverrideTeamColors.TryGetValue(unit.Type.Name, out teamColor))
|
|
{
|
|
teamColor = unit.House.UnitTeamColor;
|
|
}
|
|
}
|
|
|
|
if (Globals.TheTilesetManager.GetTeamColorTileData(theater.Tilesets, unit.Type.Name, icon, Globals.TheTeamColorManager[teamColor], out Tile tile))
|
|
{
|
|
var location =
|
|
new Point(topLeft.X * tileSize.Width, topLeft.Y * tileSize.Height) +
|
|
new Size(tileSize.Width / 2, tileSize.Height / 2);
|
|
var renderBounds = new Rectangle(
|
|
location - new Size(unit.Type.RenderSize.Width / 2, unit.Type.RenderSize.Height / 2),
|
|
unit.Type.RenderSize
|
|
);
|
|
|
|
Tile radarTile = null;
|
|
if ((unit.Type == RedAlert.UnitTypes.MGG) ||
|
|
(unit.Type == RedAlert.UnitTypes.MRJammer) ||
|
|
(unit.Type == RedAlert.UnitTypes.Tesla))
|
|
{
|
|
Globals.TheTilesetManager.GetTeamColorTileData(theater.Tilesets, unit.Type.Name, 32, Globals.TheTeamColorManager[teamColor], out radarTile);
|
|
}
|
|
|
|
Tile turretTile = null;
|
|
if (unit.Type.HasTurret)
|
|
{
|
|
var turretName = unit.Type.Name;
|
|
var turretIcon = icon + 32;
|
|
if (unit.Type == RedAlert.UnitTypes.Phase)
|
|
{
|
|
turretIcon += 6;
|
|
}
|
|
#if TODO
|
|
else if (unit.Type == RedAlert.UnitTypes.Cruiser)
|
|
{
|
|
turretName = "TURR";
|
|
turretIcon = BodyShape[Facing32[unit.Direction.ID]];
|
|
}
|
|
else if (unit.Type == RedAlert.UnitTypes.Destroyer)
|
|
{
|
|
turretName = "SSAM";
|
|
turretIcon = BodyShape[Facing32[unit.Direction.ID]];
|
|
}
|
|
else if (unit.Type == RedAlert.UnitTypes.PTBoat)
|
|
{
|
|
turretName = "MGUN";
|
|
turretIcon = BodyShape[Facing32[unit.Direction.ID]];
|
|
}
|
|
#endif
|
|
|
|
Globals.TheTilesetManager.GetTeamColorTileData(theater.Tilesets, turretName, turretIcon, Globals.TheTeamColorManager[teamColor], out turretTile);
|
|
}
|
|
|
|
var tint = unit.Tint;
|
|
void render(Graphics g)
|
|
{
|
|
var imageAttributes = new ImageAttributes();
|
|
if (tint != Color.White)
|
|
{
|
|
var colorMatrix = new ColorMatrix(new float[][]
|
|
{
|
|
new float[] {tint.R / 255.0f, 0, 0, 0, 0},
|
|
new float[] {0, tint.G / 255.0f, 0, 0, 0},
|
|
new float[] {0, 0, tint.B / 255.0f, 0, 0},
|
|
new float[] {0, 0, 0, tint.A / 255.0f, 0},
|
|
new float[] {0, 0, 0, 0, 1},
|
|
}
|
|
);
|
|
imageAttributes.SetColorMatrix(colorMatrix);
|
|
}
|
|
|
|
g.DrawImage(tile.Image, renderBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes);
|
|
|
|
if (radarTile != null)
|
|
{
|
|
Point turretAdjust = Point.Empty;
|
|
if (unit.Type == RedAlert.UnitTypes.MGG)
|
|
{
|
|
turretAdjust = TurretAdjust[Facing32[unit.Direction.ID]];
|
|
}
|
|
else if (unit.Type != RedAlert.UnitTypes.Tesla)
|
|
{
|
|
turretAdjust.Y = -5;
|
|
}
|
|
|
|
var radarBounds = renderBounds;
|
|
radarBounds.Offset(
|
|
turretAdjust.X * tileSize.Width / Globals.PixelWidth,
|
|
turretAdjust.Y * tileSize.Height / Globals.PixelHeight
|
|
);
|
|
|
|
g.DrawImage(radarTile.Image, radarBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes);
|
|
}
|
|
if (turretTile != null)
|
|
{
|
|
Point turretAdjust = Point.Empty;
|
|
if (gameType == GameType.RedAlert)
|
|
{
|
|
if (unit.Type.IsVessel)
|
|
{
|
|
|
|
}
|
|
else if (unit.Type == RedAlert.UnitTypes.Jeep)
|
|
{
|
|
turretAdjust.Y = -4;
|
|
}
|
|
}
|
|
else if (gameType == GameType.TiberianDawn)
|
|
{
|
|
if ((unit.Type == TiberianDawn.UnitTypes.Jeep) ||
|
|
(unit.Type == TiberianDawn.UnitTypes.Buggy))
|
|
{
|
|
turretAdjust.Y = -4;
|
|
}
|
|
else if ((unit.Type == TiberianDawn.UnitTypes.SAM) ||
|
|
(unit.Type == TiberianDawn.UnitTypes.MLRS))
|
|
{
|
|
turretAdjust = TurretAdjust[Facing32[unit.Direction.ID]];
|
|
}
|
|
}
|
|
|
|
var turretBounds = renderBounds;
|
|
turretBounds.Offset(
|
|
turretAdjust.X * tileSize.Width / Globals.PixelWidth,
|
|
turretAdjust.Y * tileSize.Height / Globals.PixelHeight
|
|
);
|
|
|
|
g.DrawImage(turretTile.Image, turretBounds, 0, 0, tile.Image.Width, tile.Image.Height, GraphicsUnit.Pixel, imageAttributes);
|
|
}
|
|
}
|
|
|
|
return (renderBounds, render);
|
|
}
|
|
else
|
|
{
|
|
Debug.Print(string.Format("Unit {0} ({1}) not found", unit.Type.Name, icon));
|
|
return (Rectangle.Empty, (g) => { });
|
|
}
|
|
}
|
|
}
|
|
}
|