Nerdy Gentleman Games

Roundspace Prototype

4/10/2013 07:25:00 pm Posted by Lachlan

I made this little prototype last night. It still needs tweaking for maximum "fun", menus, sound, better graphics etc - but this was a 1 bit of night prototype. For what it is, I'm actually happy, and I enjoyed playing it.

Any feedback? Anything you'd change?
If it doesn't work - you may need the .net distributable - http://go.microsoft.com/fwlink/?LinkId=199021 and the XNA distributable - http://go.microsoft.com/fwlink/?LinkID=148786. It'll probably work anyway.

Range Calculation Code - New Version

2/22/2013 12:53:00 am Posted by Lachlan

My old range calculation code (found here) was, as I admitted, slow and... well... rubbish.

Completely rewritten. Almost no trace of the old code whatsoever, and I do it in a far, far, far simpler manner now.

Again - licensed under Lachlan's Very Public License, being a modified Unlicense. Do whatever you want with it, don't blame me if something goes wrong, and donations/attribution/a comment saying its useful would be really nice.

```public List<coord> GetRange(coord start, int range, bool PlayerCollides = true)
{

List<coord> returnlist = new List<coord>();

int[,] distances = new int[range * 2 + 3, range * 2 + 3];
for (int ix = 0; ix < distances.GetLength(0); ix++)
{
for (int iy = 0; iy < distances.GetLength(1); iy++)
{
// -1 is not yet visited
// -2 is a collision point
distances[ix, iy] = (PlayerCollides ?
(CheckCollision(ix + start.X - range - 1, iy + start.Y - range - 1)) :
(TileCollides(ix + start.X - range - 1, iy + start.Y - range - 1))) ?
-2 : -1;
}
}

const int STRAIGHT_COST = 10;
const int DIAG_COST = 14;

distances[range + 1 ,range + 1] = 0;

for (int i = 1; i <= range; i++)
{
for (int jx = -i; jx <= i; jx++) { for (int jy =  -i; jy <= i; jy++)
{
if (distances[jx + range + 1, jy + range + 1] == -1)
{
int minDistance = int.MaxValue;
for (int lx = -1; lx < 2; lx++)
{
for (int ly = -1; ly < 2; ly++)
{
if (!(lx == 0 && ly == 0))
{
int distance = distances[jx + range + lx + 1, jy + range + ly + 1];
if (distance >= 0)
{
minDistance = Math.Min(minDistance, distance +
(((lx == 0) || (ly == 0)) ? STRAIGHT_COST : DIAG_COST));
}
}
}
}
if (minDistance != int.MaxValue)
{
distances[jx + range + 1, jy + range + 1] = minDistance;
if (minDistance <= (range * STRAIGHT_COST))
{
returnlist.Add(new coord(jx + start.X, jy + start.Y));
}
}
}
}}
}

return returnlist;
}```

Not Quite A* Movement Range Calculation

2/17/2013 03:02:00 pm Posted by Lachlan
Update - 22/02/13 -
Turns out this code really really did suck. Don't use it. I've completely rewritten it, actually using a little thought rather then misappropriating a poorly chosen algorithm and trying to shove it in.

The new one is on here

I looked at A*, then made something similar to calculate ranges of movement. This code is so you can determine the locations that a character can move to, knowing where collisions are and the like. You will have to provide functions CheckCollision and TileCollides, and probably change a couple of other things to make it work for you. Comments are pretty much non existent, and the code works  but isn't optimised or very fast.

Again, I figured since I'd done it, that this code could be useful. It's released under the following license:

Lachlan's Very Public Licence - which is a slightly modified Unlicense
This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.
In jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law.
If you use the source, the Author (Lachlan Kingsford) would actually like to know - but it's by no means necessary. Feel welcome to provide a copy of what you do via email, or comment on www.nerdygentleman.com. Attribution is also nice and appreciated, but again, by no means necessary. Donations via paypal are also nice.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

```    public class coord
{
public int X;
public int Y;
public coord() { X = 0; Y = 0;  }
public coord(int _X, int _Y) { X = _X; Y = _Y; }
public static bool operator==(coord first, coord second)
{
return ((first.X == second.X) && (first.Y == second.Y));
}
public static bool operator !=(coord first, coord second)
{
return !((first.X == second.X) && (first.Y == second.Y));
}
public override bool Equals(object O)
{
return (coord)this == (coord)O;
}
public override string ToString()
{
return "(" + X.ToString() + ", " + Y.ToString() + ")";
}
}

public class workingRangeVertex// : IComparable<workingRangeVertex>
{
public int G;
public coord V;
public workingRangeVertex parent;
public workingRangeVertex(coord _V, workingRangeVertex _Parent, int _G)
{
V = _V;
parent = _Parent;
G = _G;
}
public override string ToString()
{
return V.ToString();
}
}

public List<coord> GetRange(coord start, int range, bool PlayerCollides = true)
{
List<workingRangeVertex> openList = new List<workingRangeVertex>();
List<workingRangeVertex> closedList = new List<workingRangeVertex>();

workingRangeVertex startV = new workingRangeVertex(start, null, 0);

const int STRAIGHT_COST = 10;
const int DIAG_COST = 14;

while (openList.Count() != 0)
{
workingRangeVertex V = openList[0];
{
openList.Remove(V);
for (int ix = -1; ix < 2; ix++)
{
for (int iy = -1; iy < 2; iy++)
{
if (!(ix == 0 && iy == 0))
{
coord i = new coord(V.V.X + ix, V.V.Y + iy);
workingRangeVertex closePath = closedList.Find((f) => { return ((f.V.X == i.X) && (f.V.Y == i.Y)); });
if (closePath == null)
{
if (PlayerCollides ? (!CheckCollision(i.X, i.Y)) : (!TileCollides(i.X, i.Y)))
{
int cost = V.G + (((ix == 0) || (iy == 0)) ? STRAIGHT_COST : DIAG_COST);
if (cost <= range)
{
workingRangeVertex openPath = openList.Find((f) => { return ((f.V.X == i.X) && (f.V.Y == i.Y)); });
if (openPath == null)
{
}
else
{
openPath.G = Math.Min((V.G + (((ix == 0) || (iy == 0)) ? STRAIGHT_COST : DIAG_COST)), openPath.G);
}
}
}
}
else
{
closePath.G = Math.Min((V.G + (((ix == 0) || (iy == 0)) ? STRAIGHT_COST : DIAG_COST)), closePath.G);
}
}
}
}
}
}

List<coord> returnlist = new List<coord>();
foreach (workingRangeVertex V in closedList)
{
Console.WriteLine(V.V.X.ToString() + ", " + V.V.Y.ToString());
}
return returnlist;
}```

A* Pathfinding

2/13/2013 08:14:00 pm Posted by Lachlan

Work is still progressing (between study and work-proper) on Roguelikish.

I've added A* pathfinding. As a result, you actually do some path finding to move when you click somewhere, and your party isn't quite as stupid when trying to follow.

I figured since I'd done it, that the pathfinding code could be useful. It's released under the following license:
Lachlan's Very Public Licence - which is a slightly modified Unlicense

This is free and unencumbered software released into the public domain.
Anyone is free to copy, modify, publish, use, compile, sell, or distribute this software, either in source code form or as a compiled binary, for any purpose, commercial or non-commercial, and by any means.
In jurisdictions that recognize copyright laws, the author or authors of this software dedicate any and all copyright interest in the software to the public domain. We make this dedication for the benefit of the public at large and to the detriment of our heirs and successors. We intend this dedication to be an overt act of relinquishment in perpetuity of all present and future rights to this software under copyright law.
If you use the source, the Author (Lachlan Kingsford) would actually like to know - but it's by no means necessary. Feel welcome to provide a copy of what you do via email, or comment on www.nerdygentleman.com. Attribution is also nice and appreciated, but again, by no means necessary.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

I've attempted to implement the A* algorithm as described on A* Pathfinding for Beginners. There's probably bugs. Diagonals are costly (they cost 1.4 x the movement of verticals).  The comments are probably old, inaccurate, or just plain wrong and probably shouldn't be relied on. The programming style is amateur, but it works.

The function provides a list<coord> of the path to take to reach coord end from coord start.

Any questions - I may or may not be able to answer. I implemented the algorithm, but only mostly understood it.

```//Required classes
public class coord
{
public int X;
public int Y;
public coord() { X = 0; Y = 0;  }
public coord(int _X, int _Y) { X = _X; Y = _Y; }
public static bool operator==(coord first, coord second)
{
return ((first.X == second.X) && (first.Y == second.Y));
}
public static bool operator !=(coord first, coord second)
{
return !((first.X == second.X) && (first.Y == second.Y));
}
}

public class workingPathVertex : IComparable<workingPathVertex>
{
public coord V;
public int G;
public int H;
public int F() { return G + H; }
public workingPathVertex parent ;
public workingPathVertex(coord _V, workingPathVertex _Parent, int _G, int _H)
{
V = _V;
parent = _Parent;
G = _G;
H = _H;
}
public int CompareTo(workingPathVertex that)
{
return (that.F() > F()) ? -1 : 1;
}
}

//Functions
//Relies on two 2d boolean arrays - which can fairly easily be written out.
//One is CheckCollision(int, int) which returns whether the tile can be collided
//  with - and whether the thing on the tile can be collided with. So - players
//The other is TileCollides (int,int) which returns whether the tile can be
//  collided with. Behaviour is controlled from "playercollides" arg
//Some debugging codes still in there, and the comments are old, barely updated
//  and possibly flatly wrong.

public List<coord> GetPath(coord start, coord end, bool PlayerCollides = true)
{
List<workingPathVertex> openList = new List<workingPathVertex>();
List<workingPathVertex> closedList = new List<workingPathVertex>();

workingPathVertex startV = new workingPathVertex(start, null, 0, Manhatten(start,end)) ;
workingPathVertex V = startV;

const int STRAIGHT_COST = 10;
const int DIAG_COST = 14;

for (int ix = -1; ix < 2; ix++)
{
for (int iy = -1; iy < 2; iy++)
{
if (!(ix == 0 && iy == 0))
{
coord i = new coord(V.V.X + ix, V.V.Y + iy);
if (PlayerCollides ? (!CheckCollision(i.X,i.Y)) : (!TileCollides(i.X, i.Y)))
{
openList.Add(new workingPathVertex(i, V, V.G + (((ix == 0) || (iy == 0)) ? STRAIGHT_COST : DIAG_COST), Manhatten(i, end)));
}
}
}
}

openList.Remove(V);

bool finished = false;
bool succeeded = false;
workingPathVertex endVertex = null;

bool surroundtarget = false;

if (PlayerCollides ? (CheckCollision(end.X,end.Y)) : (TileCollides(end.X, end.Y))) {
surroundtarget = true;
bool surroundPossible = false;
for (int ix = -1; ix < 2; ix++)
{
for (int iy = -1; iy < 2; iy++)
{
if (!(ix == 0 && iy == 0))
{
coord i = new coord(V.V.X + ix, V.V.Y + iy);
surroundPossible = (PlayerCollides ? (!CheckCollision(i.X, i.Y)) : (!TileCollides(i.X, i.Y))) || surroundPossible;
}
}
}
finished = !surroundPossible;
};

//This is lazy looping I know, but it's late, and I'm tired, and it should work
while (!finished)
{

V = openList.Min();
openList.Remove(V);

////Debuggy stuff
//Console.WriteLine("ITERATION:\n V moved is " + V.V.X.ToString() + "  " + V.V.Y.ToString());
//Console.WriteLine("OPEN LIST:");
//foreach (workingPathVertex Z in openList)
//{
//    Console.WriteLine(Z.V.X.ToString() + "\t" + Z.V.Y.ToString() + ") " + Z.F() + "\t" + Z.G + "\t" + Z.H);
//}

//foreach (workingPathVertex Z in closedList)
//{
//    Console.WriteLine(Z.V.X.ToString() + "\t" + Z.V.Y.ToString() + ") " + Z.F() + "\t" + Z.G + "\t" + Z.H);
//}

if (!surroundtarget)
{
if ((V.V.X == end.X) && (V.V.Y) == end.Y) { finished = true; succeeded = true; endVertex = V; };
}
else
{
if ((Math.Abs(V.V.X - end.X) <= 1) && ((Math.Abs(V.V.Y - end.Y) <= 1))) { finished = true; succeeded = true; endVertex = V; };
}

//Find lowest F
for (int ix = -1; ix < 2; ix++)
{
for (int iy = -1; iy < 2; iy++)
{
if (!(ix == 0 && iy == 0))
{
coord i = new coord(V.V.X + ix, V.V.Y + iy);
workingPathVertex closePath = closedList.Find((f) => { return ((f.V.X == i.X) && (f.V.Y == i.Y)); });
if ((closePath == null) && (PlayerCollides ? (!CheckCollision(i.X, i.Y)) : (!TileCollides(i.X, i.Y))))
{
workingPathVertex iPath = openList.Find((f) => { return ((f.V.X == i.X) && (f.V.Y == i.Y)); });
if (iPath != null)
{
//If iPath is already on openList
int GviaV = V.G + (((ix == 0) || (iy == 0)) ? STRAIGHT_COST : DIAG_COST);
if (GviaV < iPath.G) { iPath.G = GviaV; iPath.parent = V; }
}
else
{
//If iPath is not on the openlist
iPath = new workingPathVertex(i, V, V.G + (((ix == 0) || (iy == 0)) ? STRAIGHT_COST : DIAG_COST), Manhatten(i, end));
}
}
}
}
}
if (openList.Count <= 0) { finished = true; }
}

if (succeeded)
{
//Console.WriteLine("SUCCESS: ");
List<coord> path = new List<coord>();

workingPathVertex nextVertex = endVertex;
while (nextVertex != null)
{
//Console.WriteLine(nextVertex.V.X.ToString() + " " + nextVertex.V.Y.ToString());
nextVertex = nextVertex.parent;
}
path.Reverse();
path.RemoveAt(0);
return path;
}
else
{
//Console.WriteLine("FAILED");
return null;
}

}

//Calculates manhatten distance
int Manhatten(coord A, coord B)
{
return (Math.Abs(A.X - B.X) + Math.Abs(A.Y + B.Y));
}
}```
Edit (12.29AM 13/02/2013 AEDST) Fixed Bug

Roguelike...ish

1/28/2013 11:15:00 pm Posted by Lachlan

Bit further along. Borrowed more David Gervais and Angband tiles.

There is now mouse control, 4 PCs and random rooms filled with Orcs and Skeevers. No combat yet though.

Basic idea is a Party Based, Short (aiming for 1h long) Roguelike. Probably with optional permadeath.

Random Dungeons

1/17/2013 06:52:00 pm Posted by Lachlan

I don't know what I want to do with it, but I'm enjoying it.

Random Dungeon Generation Attempts

1/12/2013 01:13:00 am Posted by Lachlan

They're not perfect, but my first attempts in a while of Random Dungeon/Level Generation. I've used a BSPish process (see http://roguebasin.roguelikedevelopment.org/index.php?title=Basic_BSP_Dungeon_generation).