public MapData(Game gameValues)
{
InitializeComponent();
LAGame = gameValues;
tilesetLoader = new TilesetLoader(LAGame);
getSOGOffset();
numericUpDownSOG.Value = LAGame.gbROM.ReadByte();
getAnimationsOffset();
numericUpDownAnimations.Value = LAGame.gbROM.ReadByte();
getMusicOffset();
numericUpDownMusic.Value = LAGame.gbROM.ReadByte();
getTilePresetOffset();
numericUpDownPresetTiles.Value = LAGame.gbROM.ReadByte();
if (LAGame.overworldFlag)
{
gEventData.Enabled = false;
}
else
{
gEventData.Enabled = true;
getEventData();
}
drawMapAndTiles();
}
CharacterRenderer(TilesetLoader characterLoader, int startingID, CharacterStyleInfo styleInfo)
{
CharacterLoader = characterLoader;
StartingID = startingID;
StyleInfo = styleInfo;
HUDRenderer = new HUDRenderer(StyleInfo);
}
public void WriteCustomTilesetError()
{
MemoryStream writer = new MemoryStream();
// Use incorrect pixel width - Ensure error is thrown
BitmapFile tileset = new BitmapFile(8, 20, 32, new Color[] { DiscreteColor.Red });
Assert.ThrowsException <Exception>(() => TilesetLoader.WriteCustomTileset(writer, tileset));
}
/// <summary>
/// Initializes the handles with given values from map loaded
/// </summary>
private void InitHandlers()
{
_modeHandler = new ModeHandler();
_cameraHandler = new CameraHandler();
_gridHandler = new GridHandler(_cameraHandler);
_tileHandler = new TileHandler(_gridHandler);
_tilesetLoader = new TilesetLoader();
_mapLoader = new MapLoader(_tileHandler, _gridHandler, _tilesetLoader, MapData);
_drawHandler = new DrawHandler(DrawCanvas, _gridHandler, _cameraHandler, _tilesetLoader, _tileHandler, _modeHandler);
InputHandler = new InputHandler(_gridHandler, _cameraHandler, _tileHandler, _modeHandler, DrawCanvas, Information, TileProperty);
}
public void ValidateTileset()
{
TilesetLoader.ValidateTileset(new BitmapFile(8, 32, 32));
// Improper bit depth
Assert.ThrowsException <Exception>(() => TilesetLoader.ValidateTileset(new BitmapFile(1, 32, 32)));
// Improper width
Assert.ThrowsException <Exception>(() => TilesetLoader.ValidateTileset(new BitmapFile(1, 64, 32)));
// Improper Height
Assert.ThrowsException <Exception>(() => TilesetLoader.ValidateTileset(new BitmapFile(1, 32, 70)));
}
public void WriteCustomTileset()
{
MemoryStream writer = new MemoryStream();
BitmapFile tileset1 = new BitmapFile(8, 32, -32, new Color[] { DiscreteColor.Red });
TilesetLoader.WriteCustomTileset(writer, tileset1);
writer.Position = 0;
// Read just written tileset to ensure it was well formed
BitmapFile tileset2 = TilesetLoader.ReadTileset(writer);
Assert.AreEqual(tileset1, tileset2);
}
public static SKSurface Render(MapLoader mapLoader, float scale)
{
var tilesetLoader = new TilesetLoader($"data/maps/{mapLoader.TilesetName}.png", mapLoader.TileSize);
int backgroundHeight = (int)Math.Round(mapLoader.MapPixelHeight * scale);
int backgroundWidth = (int)Math.Round(mapLoader.MapPixelWidth * scale);
var background = SKSurface.Create(new SKImageInfo(backgroundHeight, backgroundWidth));
DrawBackgroundLayer(background, mapLoader, tilesetLoader, 0, scale);
DrawBackgroundLayer(background, mapLoader, tilesetLoader, 1, scale);
return(background);
}
public void PeekIsCustomTileset()
{
// Ensure bool return is correct and that peek does not affect stream position
MemoryStream reader1 = new MemoryStream(TilesetLoader.TagFileSignature.GetBytes());
Assert.IsTrue(TilesetLoader.PeekIsCustomTileset(reader1));
Assert.AreEqual(0u, reader1.Position);
Tag wrongFileSignature = new Tag("TEST");
MemoryStream reader2 = new MemoryStream(wrongFileSignature.GetBytes());
Assert.IsFalse(TilesetLoader.PeekIsCustomTileset(reader2));
Assert.AreEqual(0u, reader2.Position);
}
static void DrawBackgroundLayer(SKSurface surface, MapLoader mapLoader, TilesetLoader tilesetLoader, int index, float scale)
{
var terrainTiles = mapLoader.GetTiles(index);
for (int x = 0; x < terrainTiles.GetLength(0); ++x)
{
for (int y = 0; y < terrainTiles.GetLength(1); ++y)
{
int id = terrainTiles [x, y] - 1;
var tilesetRect = tilesetLoader.GetRect(id);
var renderRect = GetRenderRect(x, y, mapLoader.TileSize, scale);
surface.Canvas.DrawBitmap(tilesetLoader.Tileset, tilesetRect, renderRect);
}
}
}
public void ReadTileset()
{
// Well formed standard bitmap
BitmapFile tileset = new BitmapFile(8, 32, 32, new Color[] { DiscreteColor.Red });
MemoryStream writer = new MemoryStream();
tileset.Serialize(writer);
writer.Position = 0;
BitmapFile newTileset = TilesetLoader.ReadTileset(writer);
Assert.AreEqual(tileset, newTileset);
// Well formed standard bitmap - Wrong width for a tileset
tileset = new BitmapFile(8, 20, 32, new Color[] { DiscreteColor.Red });
tileset.Serialize(writer);
Assert.ThrowsException <Exception>(() => TilesetLoader.ReadTileset(writer));
}
/// <summary>
/// Returns the specified tileset texture from cache.
/// If not found, attempts to load it from the archive directory.
/// </summary>
public static Texture2D LoadTileset(string tilesetFileName)
{
// Get tile bitmap data
Texture2D texture;
if (m_Tilesets.TryGetValue(tilesetFileName, out texture))
{
return(texture);
}
// Image not found in cache. Fetch from archive.
Stream tileImageStream = m_ResourceManager.GetResourceStream(tilesetFileName + ".bmp", true);
if (tileImageStream == null)
{
Debug.LogError("Could not find resource: " + tilesetFileName);
return(null);
}
// Convert image into standard bmp byte data
byte[] tileImageData;
OP2UtilityDotNet.Bitmap.BitmapFile bmpFile = TilesetLoader.ReadTileset(tileImageStream);
using (MemoryStream memStream = new MemoryStream())
{
if (bmpFile.GetScanLineOrientation() == OP2UtilityDotNet.Bitmap.ScanLineOrientation.TopDown)
{
bmpFile.InvertScanLines();
}
bmpFile.Serialize(memStream);
tileImageData = memStream.ToArray();
}
texture = GetTextureFromBMP(tileImageData);
if (texture == null)
{
return(null);
}
texture.filterMode = FilterMode.Point;
texture.wrapMode = TextureWrapMode.Clamp;
m_Tilesets.Add(tilesetFileName, texture);
return(texture);
}
public DrawHandler(Canvas canvas, GridHandler gridHandler, CameraHandler cameraHandler, TilesetLoader tilesetHandler, TileHandler tileHandler, ModeHandler modeHandler)
{
_canvas = canvas;
_gridHandler = gridHandler;
_cameraHandler = cameraHandler;
_tilesetHandler = tilesetHandler;
_tileHandler = tileHandler;
_modeHandler = modeHandler;
_stopWatch = new Stopwatch();
SelectedTileTextureId = 0;
GridThickness = 1;
_gridPen = new System.Drawing.Pen(System.Drawing.Color.WhiteSmoke, GridThickness);
_hoverPen = new System.Drawing.Pen(System.Drawing.Color.LightGray, 3);
_selectedPen = new System.Drawing.Pen(System.Drawing.Color.GhostWhite, 3);
_fpsFont = new System.Drawing.Font("Monospace", 12);
}
public PaletteEditor(Game game)
{
LAGame = new Game(game);
tilesetLoader = new TilesetLoader(LAGame);
tileDrawer = new TileDrawer();
originalDungeon = LAGame.dungeon;
originalMap = LAGame.map;
InitializeComponent();
if (LAGame.overworldFlag)
{
nDungeon.Enabled = false;
}
else
{
nIndex.Enabled = false;
}
loadPalette();
loadTileset();
}
private void OnExtractFileSavePathSelected(ArchiveFile archive, string fileName, string destPath)
{
interactable = true;
try
{
if (Path.GetExtension(fileName).ToLowerInvariant() == ".bmp")
{
// Special processing to convert tileset to a standard bmp format
BitmapFile bitmapFile = TilesetLoader.ReadTileset(archive.ExtractFileToMemory(fileName));
bitmapFile.Serialize(destPath);
}
else
{
archive.ExtractFile(fileName, destPath);
}
}
finally
{
archive.Dispose();
}
Debug.Log(Path.GetFileName(destPath) + " extracted successfully.");
}
public SkillSelectionView(Point position, Size size, ITargettingSelection targetting, IProcessUserAction processAction) : base(position, size)
{
Targetting = targetting;
ProcessAction = processAction;
Loader = new TilesetLoader("data/tf_icon_32.png", 32);
}
public TargettingRenderer()
{
Loader = new TilesetLoader("data/tf_icon_32.png", 32);
}
public HUDRenderer(CharacterStyleInfo styleInfo)
{
StyleInfo = styleInfo;
StatusIconLoader = new TilesetLoader("data/tf_icon_32.png", 32);
}
public static Result LoadTilesets(string TilesetsPath)
{
var returnResult = new Result("Loading tilesets", false);
logger.Info("Loading tilesets");
string[] tilesetDirs;
try
{
tilesetDirs = Directory.GetDirectories(TilesetsPath);
}
catch (Exception ex)
{
returnResult.ProblemAdd(ex.Message);
return(returnResult);
}
Result result;
foreach (var path in tilesetDirs)
{
var tileset = new Tileset();
var loader = new TilesetLoader(ref tileset);
result = loader.Load(path);
returnResult.Add(result);
if (!result.HasProblems)
{
Tilesets.Add(tileset);
}
}
foreach (var tileset in Tilesets)
{
if (tileset.Name == "tertilesc1hw")
{
tileset.Name = "Arizona";
Tileset_Arizona = tileset;
tileset.IsOriginal = true;
tileset.BGColour = new SRgb(204.0f / 255.0f, 149.0f / 255.0f, 70.0f / 255.0f);
}
else if (tileset.Name == "tertilesc2hw")
{
tileset.Name = "Urban";
Tileset_Urban = tileset;
tileset.IsOriginal = true;
tileset.BGColour = new SRgb(118.0f / 255.0f, 165.0f / 255.0f, 203.0f / 255.0f);
}
else if (tileset.Name == "tertilesc3hw")
{
tileset.Name = "Rocky Mountains";
Tileset_Rockies = tileset;
tileset.IsOriginal = true;
tileset.BGColour = new SRgb(182.0f / 255.0f, 225.0f / 255.0f, 236.0f / 255.0f);
}
}
if (Tileset_Arizona == null)
{
returnResult.WarningAdd("Arizona tileset is missing.");
}
if (Tileset_Urban == null)
{
returnResult.WarningAdd("Urban tileset is missing.");
}
if (Tileset_Rockies == null)
{
returnResult.WarningAdd("Rocky Mountains tileset is missing.");
}
return(returnResult);
}
public SkillBarView(Point position, Size size) : base(position, size)
{
Loader = new TilesetLoader("data/tf_icon_32.png", 32);
}
static CharacterRenderer Create(string path, int startingID, CharacterStyleInfo style)
{
TilesetLoader loader = new TilesetLoader(path, style.Width, style.Height);
return(new CharacterRenderer(loader, startingID, style));
}
