Wednesday, 10 April 2013

Roundspace Prototype



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. 
Find it at https://dl.dropbox.com/u/46145976/Roundspace.zip
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.






Friday, 22 February 2013

Range Calculation Code - New Version


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;
        }

Sunday, 17 February 2013

Not Quite A* Movement Range Calculation

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);

            openList.Add(startV);

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

            while (openList.Count() != 0)
            {
                workingRangeVertex V = openList[0];
                {
                    openList.Remove(V);
                    closedList.Add(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)
                                            {
                                                openList.Add(new workingRangeVertex(i, V, cost));
                                            }
                                            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)
            {
                returnlist.Add(V.V);
                Console.WriteLine(V.V.X.ToString() + ", " + V.V.Y.ToString());
            }
            return returnlist;
        }

Wednesday, 13 February 2013

A* Pathfinding


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 
//  would make it return to
//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);
            closedList.Add(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);
                closedList.Add(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));
                                    openList.Add(iPath);
                                }
                            }
                        }
                    }
                }
                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());
                    path.Add(nextVertex.V);
                    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

Monday, 28 January 2013

Roguelike...ish


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.

Thursday, 17 January 2013

Random Dungeons


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

Saturday, 12 January 2013

Random Dungeon Generation Attempts



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). 





Friday, 24 August 2012

ADOM Resurrection

I'm trying to get a bit of support for what is one of my top 3 games of all time (with Portal 2 and Grim Fandango): ADOM, or Ancient Domains of Mystery as it tends to be known to its friends.

ADOM is one of the biggest roguelikes that there has been historically (in fact, so big that it even had its own newsgroup), and differs from most other roguelikes in its consistency of atmosphere and storyline. Fwiw - a Roguelike is a generally text-graphics based RPG game, generally with randomised dungeons, permanent death and a ruleset fairly inspired by Dungeons and Dragons. They also tend to be hard. Really hard.

Biskup's already got the base $48000 raised, and is currently up to $52268 as of writing with 7 days remaining. If it hits $55000, he'll commission a full tileset (sample below). Beyond that, there will be more races and classes added ($60000), a hopeful Steam/Desura version ($65000) and beyond that further quests.



I'd really love to see this make it to at least getting Chaos Knights as a class!

Can I encourage anyone remotely interested to check it out?

The campaign page is on http://www.indiegogo.com/resurrect-adom-development


Lachlan

Saturday, 14 July 2012

TBA Progress



Progress. It's beginning to look and feel kind of Gamey!

I'll be referring to it as "Starship" for now until a final name is picked. Assuming that I keep going with it.

TBA Project



Just some screenshots from a little project I've been working on.

We'll see what comes of it.


Lachlan

Thursday, 1 March 2012

Playable Levels



Yup. 7 of them. (Or 6 of them and an intro). And there will be more very soon.

I've put a hiatus on my crappy attempts at level editors, and typed them out in VS's text editor. Initial feedback has been good :)

If you're interested in trying the levels so far (in an alpha state), please pop me an email to lachlan atsign nerdygentleman.com or comment on this post

Thursday, 23 February 2012

Nerdy Gentleman on Gamer Law

I just my first article put up on Jas Purewel's fantastic blog GamerLaw.

In it, I discuss the current state of the R Rating for games in Australia. The introduction is reprinted below:
There is something rotten with the state of gaming in Australia. Unlike other entertainment mediums, games can not be given an R18+ rating or classification. This has two practical effects: Games that are deemed too mature (generally due to violence or sexual references) are banned, making their sale illegal, their importation illegal and in Western Australia, their possession illegal. Other games that have been generally rated R18+ equivalents in other markets (such as The Witcher 2) are downrated to MA15+ to get them through the system.
Find the full article on http://www.gamerlaw.co.uk/2012/02/australia-getting-grown-up-about-games.html

In other news, I got sick of my crappy GUI controls inside Jack's editor. So - I have written network support which can be compiled in or out to provide access to the command interface (which is all the GUI did anyway), and the current state of memory. Then I'll be able to write a fairly simple companion (read: symbiont) program to provide the functions of the editor. I'm thinking I'll probably do it in C# simply because the GUI is pretty easy to program.

Always remember: If you ever find yourself custom coding your own GUI from scratch, its time to step back and do something else. Most OSs provide a decent one. And I can guarantee it is a lot easier to maintain, and far less buggier.

Friday, 17 February 2012

Jack can walk!


I've added the ability to use sprites. Jack can now actually walk!

Wednesday, 15 February 2012

Working Borders

I've finally added borders. It took far longer then intended, but they work. Below is an actual (not mockup) screenshot. Click for more detail


I have a special script file called "styles" which I define each style. Then, the feature has a string identifying which style it uses.

I'm happy that this is slowly coming along!