private static String RLE_Norm(LevelDefinition levelDefinition)
{
StringBuilder ret = new StringBuilder();
ret.Append(Common(levelDefinition));
ret.Append("0x02, ");
for (int y = 0; y < 16; y++)
{
for (int x = 0; x < 28; x += 2)
{
int left = (int)levelDefinition.Grid[y, x]; if (left == 7)
{
left = 0;
}
int right = (int)levelDefinition.Grid[y, x + 1]; if (right == 7)
{
right = 0;
}
ret.Append("0x" + ((left * 16) + right).ToString("X2"));
ret.Append(", ");
}
}
return(ret.ToString());
}
private void cmdReset_Click(object sender, EventArgs e)
{
if (lstLevels.SelectedItems.Count > 0)
{
LevelDefinition levelDefinition = (LevelDefinition)lstLevels.SelectedItems[0].Tag;
loadLevel(levelDefinition);
lstLevels.Select();
}
}
private void writeFile(String filename)
{
using (StreamWriter writer = new StreamWriter(filename)) {
writer.Write("#pragma once\n\n#include \"../ utils / Arduboy2Ext.h\"\n#include \"../utils/Utils.h\"\n#include \"../utils/Enums.h\"\n\n");
writer.Write("#define GAME_NUMBER 1\n");
writer.Write("#define NUMBER_OF_GAMES " + (dgExport.Rows.Count - 1) + "\n\n");
int offset = 0;
for (int x = 0; x < (dgExport.Rows.Count - 1); x++)
{
DataGridViewRow dgRow = dgExport.Rows[x];
writer.Write("#if GAME_NUMBER == " + (x + 1) + "\n");
writer.Write(" #define LEVEL_COUNT " + dgRow.Cells[1].Value + "\n");
writer.Write(" #define LEVEL_OFFSET " + offset + "\n");
writer.Write("#endif\n");
offset = offset + Convert.ToInt16(dgRow.Cells[1].Value);
}
writer.Write("\n\n");
for (Int16 x = 0; x < lstLevels.Items.Count; x++)
{
ListViewItem item = lstLevels.Items[x];
LevelDefinition levelDefinition = (LevelDefinition)item.Tag;
writer.Write(LevelUtils.getLevelText(item, levelDefinition, x));
}
offset = 0;
for (int y = 0; y < (dgExport.Rows.Count - 1); y++)
{
DataGridViewRow dgRow = dgExport.Rows[y];
int maxPerLevel = Convert.ToInt16(dgRow.Cells[1].Value);
writer.Write("#if GAME_NUMBER == " + (y + 1) + "\n");
writer.Write("const uint8_t *levels[] = { nullptr, \n");
writer.Write(" ");
int z = 0;
for (int x = offset; x < offset + maxPerLevel; x++)
{
z++;
writer.Write(lstLevels.Items[x].Text + ", ");
if (z % 10 == 0)
{
writer.Write("\n ");
}
}
writer.Write("};\n#endif\n");
offset = offset + Convert.ToInt16(dgRow.Cells[1].Value);
}
}
}
private void validate(ListViewItem item, LevelDefinition levelDefinition)
{
bool inError = false;
ArrayList lstErrors = new ArrayList();
if (levelDefinition.Player == null)
{
inError = true; lstErrors.Add("A player must be placed on the level.");
}
if (levelDefinition.ReentryPoints.Count < 4)
{
inError = true; lstErrors.Add("Each level must contain exactly four re-entry points.");
}
if (levelDefinition.Enemies.Count == 0)
{
inError = true; lstErrors.Add("At least one enemy should be placed in a level.");
}
if (getCountOfLevelElements(levelDefinition, LevelElement.Gold) == 0)
{
inError = true; lstErrors.Add("At least one gold piece should be placed in a level.");
}
if (getCountOfLevelElements(levelDefinition, LevelElement.Level_Ladder) == 0)
{
inError = true; lstErrors.Add("At least one level ladder should be placed in a level.");
}
if (inError)
{
lstLevels.ShowItemToolTips = true;
item.ImageIndex = 1;
String toolTip = "";
foreach (String error in lstErrors)
{
toolTip = toolTip + error + "\n";
}
item.ToolTipText = toolTip;
}
else
{
lstLevels.ShowItemToolTips = false;
item.ImageIndex = 0;
}
}
int getCountOfLevelElements(LevelDefinition levelDefinition, LevelElement levelElement)
{
int count = 0;
for (int y = 0; y < 16; y++)
{
for (int x = 0; x < 28; x++)
{
if (levelDefinition.Grid[y, x] == levelElement)
{
count++;
}
}
}
return(count);
}
private void cmdSave_Click(object sender, EventArgs e)
{
if (lstLevels.SelectedItems.Count > 0)
{
LevelDefinition levelDefinition = (LevelDefinition)lstLevels.SelectedItems[0].Tag;
// Enemies ..
levelDefinition.Enemies.Clear();
for (int x = 0; x < picEnemies.Length; x++)
{
if (picEnemies[x].Visible)
{
CoordinateSet coordinate = (CoordinateSet)picEnemies[x].Tag;
levelDefinition.Enemies.Add(coordinate);
}
}
// Reentry points ..
levelDefinition.ReentryPoints.Clear();
for (int x = 0; x < picReentryPoints.Length; x++)
{
if (picReentryPoints[x].Visible)
{
CoordinateSet coordinate = (CoordinateSet)picReentryPoints[x].Tag;
levelDefinition.ReentryPoints.Add(coordinate);
}
}
for (int y = 0; y < 16; y++)
{
for (int x = 0; x < 28; x++)
{
levelDefinition.Grid[y, x] = (LevelElement)pictureBoxes[y, x].Tag;
}
}
levelDefinition.Player = (CoordinateSet)picPlayer.Tag;
validate(lstLevels.SelectedItems[0], levelDefinition);
lstLevels.Select();
}
}
public static String getLevelText(ListViewItem item, LevelDefinition levelDefinition, Int16 levelId)
{
String rleRow = RLE_Row(levelDefinition);
String rleCol = RLE_Col(levelDefinition);
String rleNorm = RLE_Norm(levelDefinition);
if (rleCol.Length < rleRow.Length)
{
rleRow = rleCol;
}
if (rleNorm.Length < rleRow.Length)
{
rleRow = rleNorm;
}
return("const uint8_t PROGMEM level" + levelId + "[] = {\n" + rleRow + "\n};\n\n");
}
private static String RLE_Row(LevelDefinition levelDefinition)
{
StringBuilder ret = new StringBuilder();
int iCount = 0;
LevelElement currentCell = levelDefinition.Grid[0, 0];
ret.Append(Common(levelDefinition));
ret.Append("0x00, ");
// Map data ..
for (int y = 0; y < 16; y++)
{
for (int x = 0; x < 28; x++)
{
if (x != 0 || y != 0)
{
// if ((levelDefinition.Grid[y, x] != LevelElement.Level_Ladder && levelDefinition.Grid[y, x] != currentCell) || iCount == 30) {
if ((levelDefinition.Grid[y, x] == LevelElement.Level_Ladder && currentCell != LevelElement.Blank) ||
(levelDefinition.Grid[y, x] != LevelElement.Level_Ladder && levelDefinition.Grid[y, x] != currentCell) || iCount == 30)
{
ret.Append("0x" + (((int)currentCell * 32) + iCount + 1).ToString("X2"));
ret.Append(", ");
iCount = 0;
currentCell = levelDefinition.Grid[y, x];
}
else
{
iCount++;
}
}
}
}
ret.Append("0x" + (((int)currentCell * 32) + iCount + 1).ToString("X2"));
ret.Append(", 0x00");
return(ret.ToString());
}
private void lstLevels_SelectedIndexChanged(object sender, EventArgs e)
{
if (lstLevels.SelectedItems.Count > 0 && lstLevels.Tag != lstLevels.SelectedItems[0])
{
lstLevels.Tag = lstLevels.SelectedItems[0];
if (lstLevels.SelectedItems.Count > 0)
{
cmdLevelDelete.Enabled = true;
LevelDefinition levelDefinition = (LevelDefinition)lstLevels.SelectedItems[0].Tag;
loadLevel(levelDefinition);
}
else
{
cmdLevelDelete.Enabled = false;
}
cmdLevelUp.ForeColor = (lstLevels.SelectedItems.Count > 0 && lstLevels.SelectedItems[0].Index > 0 ? SystemColors.ControlText : SystemColors.ControlDark);
cmdLevelUp.Enabled = (lstLevels.SelectedItems.Count > 0 && lstLevels.SelectedItems[0].Index > 0);
cmdLevelDown.ForeColor = (lstLevels.SelectedItems.Count > 0 && lstLevels.SelectedItems[0].Index < lstLevels.Items.Count ? SystemColors.ControlText : SystemColors.ControlDark);
cmdLevelDown.Enabled = (lstLevels.SelectedItems.Count > 0 && lstLevels.SelectedItems[0].Index < lstLevels.Items.Count);
}
}
private static String Common(LevelDefinition levelDefinition)
{
StringBuilder common = new StringBuilder();
// Player position ..
common.Append("0x" + levelDefinition.Player.X.ToString("X2"));
common.Append(", ");
common.Append("0x" + levelDefinition.Player.Y.ToString("X2"));
common.Append(", ");
// Number of Enemies ..
common.Append("0x" + levelDefinition.Enemies.Count.ToString("X2"));
common.Append(", ");
for (int x = 0; x < levelDefinition.Enemies.Count; x++)
{
common.Append("0x" + levelDefinition.Enemies[x].X.ToString("X2"));
common.Append(", ");
common.Append("0x" + levelDefinition.Enemies[x].Y.ToString("X2"));
common.Append(", ");
}
// Level ladders ..
int count = 0;
for (int y = 0; y < 16; y++)
{
for (int x = 0; x < 28; x++)
{
if (levelDefinition.Grid[y, x] == LevelElement.Level_Ladder)
{
count++;
}
}
}
common.Append("0x" + count.ToString("X2"));
common.Append(", ");
for (int y = 0; y < 16; y++)
{
for (int x = 0; x < 28; x++)
{
if (levelDefinition.Grid[y, x] == LevelElement.Level_Ladder)
{
common.Append("0x" + x.ToString("X2"));
common.Append(", ");
common.Append("0x" + y.ToString("X2"));
common.Append(", ");
}
}
}
// Reentry points ..
for (int x = 0; x < 4; x++)
{
common.Append("0x" + levelDefinition.ReentryPoints[x].X.ToString("X2"));
common.Append(", ");
common.Append("0x" + levelDefinition.ReentryPoints[x].Y.ToString("X2"));
common.Append(", ");
}
return(common.ToString());
}
private void loadLevel(LevelDefinition levelDefinition)
{
for (int y = 0; y < 16; y++)
{
for (int x = 0; x < 28; x++)
{
pictureBoxes[y, x].BackgroundImage = imgBlocks.Images[(int)levelDefinition.Grid[y, x]];
pictureBoxes[y, x].Tag = (int)levelDefinition.Grid[y, x];
}
}
// Enemies ..
for (int x = 0; x < 6; x++)
{
PictureBox picEnemy = picEnemies[x];
if (x < levelDefinition.Enemies.Count)
{
CoordinateSet enemyCoords = levelDefinition.Enemies[x];
picEnemy.Parent = pictureBoxes[enemyCoords.Y, enemyCoords.X];
picEnemy.BackColor = Color.Transparent;
picEnemy.Location = new System.Drawing.Point(0, 0);
picEnemy.Visible = true;
picEnemy.Tag = enemyCoords;
}
else
{
picEnemy.Visible = false;
picEnemy.Tag = null;
}
}
// Reentry Points ..
for (int x = 0; x < 4; x++)
{
PictureBox picReentryPoint = picReentryPoints[x];
if (x < levelDefinition.ReentryPoints.Count)
{
CoordinateSet reentryPointyCoords = levelDefinition.ReentryPoints[x];
picReentryPoint.Parent = pictureBoxes[reentryPointyCoords.Y, reentryPointyCoords.X];
picReentryPoint.BackColor = Color.Transparent;
picReentryPoint.Location = new System.Drawing.Point(0, 0);
picReentryPoint.Visible = true;
picReentryPoint.Tag = reentryPointyCoords;
}
else
{
picReentryPoint.Visible = false;
picReentryPoint.Tag = null;
}
}
// Player starting point
CoordinateSet playerCoords = levelDefinition.Player;
picPlayer.Visible = false;
if (playerCoords != null)
{
picPlayer.Parent = pictureBoxes[playerCoords.Y, playerCoords.X];
picPlayer.BackColor = Color.Transparent;
picPlayer.Location = new System.Drawing.Point(0, 0);
picPlayer.Visible = true;
picPlayer.Tag = playerCoords;
}
// Enable buttons ..
cmdSave.Enabled = true;
cmdReset.Enabled = true;
cmdClear.Enabled = true;
}
private void mnuLoad_Click(object sender, EventArgs e)
{
clearLevel();
cmdSave.Enabled = false;
cmdClear.Enabled = false;
cmdReset.Enabled = false;
lstLevels.Items.Clear();
bool inLevel = false;
if (dgOpenMapData.ShowDialog() == DialogResult.OK)
{
mnuSave.Enabled = true;
mnuSaveAs.Enabled = true;
const string userRoot = "HKEY_CURRENT_USER";
const string subkey = "LodeRunner";
const string keyName = userRoot + "\\" + subkey;
Registry.SetValue(keyName, "PathName", Path.GetDirectoryName(dgOpenMapData.FileName));
// String[] lines = System.IO.File.ReadAllLines(dgOpenMapData.FileName);
using (FileStream fs = File.Open(dgOpenMapData.FileName, FileMode.Open))
using (BufferedStream bs = new BufferedStream(fs, System.Text.ASCIIEncoding.Unicode.GetByteCount("g")))
using (StreamReader sr = new StreamReader(bs)) {
LevelDefinition levelDefinition = null;
string line;
while ((line = sr.ReadLine()) != null)
{
if (line.StartsWith("#define GAME_NUMBER"))
{
gameNumber = line.Substring(@"#define GAME_NUMBER".Length + 1).Trim();
}
else if (line.StartsWith("#define NUMBER_OF_GAMES"))
{
numberOfGames = line.Substring(@"#define NUMBER_OF_GAMES".Length + 1).Trim();
}
else if (line.StartsWith("#if GAME_NUMBER"))
{
gameNumberId = Int16.Parse(line.Substring(line.IndexOf("==") + 3).Trim());
}
else if (line.StartsWith(" #define LEVEL_COUNT"))
{
Int16 gamesPerLevel = Int16.Parse(line.Substring(@" #define LEVEL_COUNT".Length + 1).Trim());
gamesPerLevels.Add(gamesPerLevel);
dgExport.Rows.Add(dgExport.Rows.Count, gamesPerLevel);
}
else if (line.StartsWith("const uint8_t PROGMEM"))
{
levelDefinition = new LevelDefinition();
levelDefinition.LevelName = line.Substring(line.IndexOf("PROGMEM ") + 8, line.Length - line.IndexOf("PROGMEM ") - 14);
inLevel = true;
}
else if (inLevel)
{
if (line == "};")
{
inLevel = false;
ListViewItem item = new ListViewItem();
item.Text = levelDefinition.LevelName;
item.Tag = levelDefinition;
lstLevels.Items.Add(item);
}
else
{
char[] splitchar = { ',' };
String[] strData = line.Trim().Split(splitchar);
int cursor = 0;
// Player start pos ..
CoordinateSet player = new CoordinateSet();
player.X = Convert.ToInt32(strData[cursor++].Trim(), 16);
player.Y = Convert.ToInt32(strData[cursor++].Trim(), 16);
levelDefinition.Player = player;
// Enemies
int numberOfEnemies = Convert.ToInt32(strData[cursor++].Trim(), 16);
for (int x = 0; x < numberOfEnemies; x++)
{
CoordinateSet enemy = new CoordinateSet();
enemy.X = Convert.ToInt32(strData[cursor++].Trim(), 16);
enemy.Y = Convert.ToInt32(strData[cursor++].Trim(), 16);
levelDefinition.Enemies.Add(enemy);
}
// Level Ladders
int numberOfLevelLadders = Convert.ToInt32(strData[cursor++].Trim(), 16);
for (int x = 0; x < numberOfLevelLadders; x++)
{
CoordinateSet levelLadder = new CoordinateSet();
levelLadder.X = Convert.ToInt32(strData[cursor++].Trim(), 16);
levelLadder.Y = Convert.ToInt32(strData[cursor++].Trim(), 16);
levelDefinition.Ladders.Add(levelLadder);
}
// Reentry points
for (int x = 0; x < 4; x++)
{
CoordinateSet reentryPoint = new CoordinateSet();
reentryPoint.X = Convert.ToInt32(strData[cursor++].Trim(), 16);
reentryPoint.Y = Convert.ToInt32(strData[cursor++].Trim(), 16);
levelDefinition.ReentryPoints.Add(reentryPoint);
}
// Encryption type ..
levelDefinition.EncryptionType = (EncryptionType)Convert.ToInt32(strData[cursor++].Trim(), 16);
int[] data = new int[strData.Length - cursor];
for (int count = cursor; count <= strData.Length - 2; count++)
{
data[count - cursor] = Convert.ToInt32(strData[count].Trim(), 16);
}
loadLevel(levelDefinition, data);
}
}
}
}
}
foreach (ListViewItem item in lstLevels.Items)
{
validate(item, (LevelDefinition)item.Tag);
}
MessageBox.Show("Level data loaded successfully.", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
private void loadLevel(LevelDefinition levelDefinition, int[] data)
{
int dataOffset = 0;
int goldLeft = 0;
if (levelDefinition.EncryptionType == EncryptionType.Grid)
{
for (int y = 0; y < HEIGHT; y++)
{
for (int x = 0; x < WIDTH; x++)
{
int element = data[dataOffset++];
if (leftValue(element) == ((int)LevelElement.Gold))
{
goldLeft++;
}
if (rightValue(element) == ((int)LevelElement.Gold))
{
goldLeft++;
}
levelDefinition.Grid[y, x * 2] = (LevelElement)leftValue(element);
levelDefinition.Grid[y, (x * 2) + 1] = (LevelElement)rightValue(element);
}
}
}
else
{
int cursor = 0;
while (true)
{
int element = data[dataOffset];
int block = (element & 0xE0) >> 5;
int run = element & 0x1F;
if (block == ((int)LevelElement.Gold))
{
goldLeft++;
}
if (run > 0)
{
dataOffset++;
for (int x = 0; x < run; x++)
{
if (levelDefinition.EncryptionType == EncryptionType.RLE_Row)
{
int row = cursor / (WIDTH * 2);
int col = (cursor % (WIDTH * 2));
levelDefinition.Grid[row, col] = (LevelElement)block;
}
else
{
int col = cursor / HEIGHT;
int row = cursor % HEIGHT;
levelDefinition.Grid[row, col] = (LevelElement)block;
}
cursor++;
}
}
else
{
break;
}
}
}
// Map level ladders to grid ..
foreach (CoordinateSet levelLadder in levelDefinition.Ladders)
{
levelDefinition.Grid[levelLadder.Y, levelLadder.X] = LevelElement.Level_Ladder;
}
}
