Print

Please login or register.
1 Hour 1 Day 1 Week 1 Month Forever
Login with username, password and session length

[Angle]

I'm working on a basic roguelike engine in C++. I've never really programmed anything before, so I may be overreaching, but I couldn't think of anything else I really wanted to program.

The below source is thoroughly outdated. Up to date source can be found here.

What I want to do is codify each different type of square of terrain as a const instance of a class. Like I have an instance for smooth ice, and an instance for rough rock cave floor, and for polished cave floor, etc. I then have localareas that store 2d vectors of pointers to these const instances of terraintypes. What I'm working on right now is having a player and having it draw the world from around the player. next I'm going to have the local areas keep track of what other localareas are next to them. The reason I'm doing it this way, instead of just having an array or something is because this will allow me to do all sorts of weird things. Like have gradual slopes, instead of staircases. Or do horribly deviant things to space and distance. or play mean tricks on anyone who plays my games. etc.

Anyway, heres the source code. Tell me what you think!

Spoiler: Main.cpp (click to show/hide)

#include <iostream>
#include "LocalArea.h"

using namespace std;
int main()
{
    const TerrainType floor('.');
    const TerrainType wall('#');
    LocalArea place = LocalArea(floor, 20, 20);
    place.fillTerrain(wall);
    place.setTerrain(floor, 3, 3);
    cout << place << endl;
    return 0;
}

Spoiler: LocalArea.h (click to show/hide)

#ifndef LOCALAREA_H
#define LOCALAREA_H

#include "TerrainType.h"
#include <vector>
#include <iostream>

class LocalArea
{
    public:
        /** Default constructor */
        LocalArea(const TerrainType& = TerrainType(' '), int height = 1, int width = 1);
        /** Default destructor */
        virtual ~LocalArea();
        /** Fill terrain with char */
        void fillTerrain(const TerrainType &type);
        void setTerrain(const TerrainType& type, int x, int y) {terrain[y]

• = &type;}

        friend ostream& operator<< (ostream &out, LocalArea &area);
    protected:
    private:
        vector<vector<const TerrainType*> > terrain; //!< Member variable "terrain"
};

#endif // LOCALAREA_H

Spoiler: LocalArea.cpp (click to show/hide)

#include "LocalArea.h"

LocalArea::LocalArea(const TerrainType& type, int height, int width)
{
    terrain = vector<vector<const TerrainType*> >();
    int i, j;
    for (i = 0; i < height; i++)
    {
        terrain.push_back(vector<const TerrainType*> ());
    }
    unsigned int k;
    for (k = 0; k < terrain.size(); k++)
    {
        for (j = 0; j < width; j++)
        {
            terrain[k].push_back(&type);
        }
    }
}

LocalArea::~LocalArea()
{
    //dtor
}

void LocalArea::fillTerrain(const TerrainType& type)
{
    unsigned int i, j;
    for (i = 0; i < terrain.size(); i++)
    {
        for (j = 0; j < terrain.size(); j++)
        {
            terrain[j] = &type;
        }
    }
}

ostream& operator<< (ostream &out, LocalArea &area)
{
    using namespace std;
    unsigned int i,j;
    for (i= 0; i < area.terrain.size(); i++)
    {
        for (j = 0; j < area.terrain.size(); j++)
        out << *area.terrain[j];
        out << endl;
    }
    return out;
}

Spoiler: TerrainType.h (click to show/hide)

#ifndef TERRAINTYPE_H
#define TERRAINTYPE_H

#include <iostream>
using namespace std;

class TerrainType
{
    public:
        /** char constructor */
        TerrainType(char display = '.', bool pass = true);
        /** Default destructor */
        virtual ~TerrainType();
        /** Access displayChar
         * \return The current value of displayChar
         */
        char GetDisplayChar() const { return displayChar; }
        void setDisplayChar(char symbol) {displayChar = symbol;}
        friend ostream& operator<< (ostream &out,const TerrainType &type);
    protected:
    private:
        char displayChar; //!< Member variable "displayChar"
        bool passable;
};

#endif // TERRAINTYPE_H

Spoiler: TerrainType.cpp (click to show/hide)

#include "TerrainType.h"

TerrainType::TerrainType(char display, bool pass) : displayChar(display), passable(pass)
{
}

ostream& operator<< (ostream &out,const TerrainType &type)
{
    out << type.GetDisplayChar();
    return out;
}

TerrainType::~TerrainType()
{
    //dtor
}

Spoiler: Entity.h (click to show/hide)

#ifndef ENTITY_H
#define ENTITY_H

#include "Location.h"

class Entity
{
    public:
        /** Default constructor */
        Entity(Location);
        /** Default destructor */
        virtual ~Entity();
    protected:
    private:
    Location location;
};

#endif // ENTITY_H

Spoiler: Entity.cpp (click to show/hide)

#include "Entity.h"

Entity::Entity(Location place) : location(place)
{
    //ctor
}

Entity::~Entity()
{
    //dtor
}

Spoiler: Location.h (click to show/hide)

#ifndef LOCATION_H
#define LOCATION_H

#include "LocalArea.h"

class Location
{
    public:
        /** Default constructor */
        Location(LocalArea, int X = 1, int Y = 1);
        /** Default destructor */
        virtual ~Location();
        /** Access x
         * \return The current value of x
         */
        int getX() { return x; }
        /** Set x
         * \param val New value to set
         */
        void setX(int val) { x = val; }
        /** Access y
         * \return The current value of y
         */
        int getY() { return y; }
        /** Set y
         * \param val New value to set
         */
        void setY(int val) { y = val; }
        /** Access localArea
         * \return The current value of localArea
         */
        LocalArea getLocalArea() { return localArea; }
        /** Set localArea
         * \param val New value to set
         */
        void setLocalArea(LocalArea val) { localArea = val; }
    protected:
    private:
        LocalArea localArea; //!< Member variable "localArea"
        int x; //!< Member variable "x"
        int y; //!< Member variable "y"
};

#endif // LOCATION_H

Spoiler: Location.cpp (click to show/hide)

#include "Location.h"

Location::Location(LocalArea area, int X, int Y) :localArea(area), x(X), y(Y)
{

}

Location::~Location()
{
    //dtor
}

Spoiler: Player.h (click to show/hide)

#ifndef PLAYER_H
#define PLAYER_H

#include "Entity.h"

class Player
{
    public:
        /** Default constructor */
        Player(Entity, bool incontrol = true);
        /** Default destructor */
        virtual ~Player();

    protected:
    private:
        Entity character;
        Entity viewpoint;
        bool inControl;
};

#endif // PLAYER_H

Spoiler: Player.cpp (click to show/hide)

#include "Player.h"

Player::Player(Entity pc, bool incontrol) : character(pc), viewpoint(pc), inControl(incontrol)
{
}

Player::~Player()
{
    //dtor
}

[MorleyDev]

Don't think of it as an Engine. Think of it as a game. You can refactor out the reusable stuff later, for now: Get that ascii representation of a man fighting ascii representations of orcs, or whatever you want the finished product to contain. Then you add functionality to the game.

Seriously, this little blog post needs to be mandatory reading: http://scientificninja.com/blog/write-games-not-engines

Engines come from games, not the other way round.

[Angle]

well, alright then. Ascii orcs it is then.

[Aramco]

If only I knew C++, I could have an opinion. Through my knowledge of C#, I sort of know what I'm looking at, but only barely.

[Angle]

I've done some more programming, and would like some criticism. I've done some more stuff with the LocalAreas and they work, but somehow I think that there must be a better way to do these things. The way I've got it right now, I have these LocalAreas that store 2d vectors of pointers to these const instances of terraintypes. I also have the LocalAreas keep track of what other LocalAreas are next to them, and the direction, rotation, offset, and mirroring of these bordering LocalAreas. I have this implemented through a nested class, LocalArea::BorderArea, and a vector of these BorderAreas.

The main two functions that bother me are LocalArea::getTerrain(int x, int y) and LocalArea::getBorder(int x, int y), which are in files LocalAreaTerrain.cpp and LocalAreaBorder.cpp. They're both huge ugly masses of nested switch statements. getTerrain looks within it's own area for a tile located at (x,y) and if it can't find it then it looks in the LocalArea's that border it. GetBorder looks at the coordinates of (x,y) and figures out witch, if any, of it's borders they lie in.

So, without further ado, the code.

Spoiler: TerrainType.h (click to show/hide)

#ifndef TERRAINTYPE_H
#define TERRAINTYPE_H

#include <iostream>
using namespace std;

class TerrainType
{
    public:
        /** char constructor */
        TerrainType(char display = '.', bool pass = true, bool see = true);
        /** Default destructor */
        virtual ~TerrainType();
        /** Access displayChar
         * \return The current value of displayChar
         */
        char GetDisplayChar() const {return displayChar;}
        void setDisplayChar(char symbol) {displayChar = symbol;}
    protected:
    private:
        char displayChar; //!< Member variable "displayChar"
        bool passable;
        bool transparent;
};

#endif // TERRAINTYPE_H

Spoiler: TerrainType.cpp (click to show/hide)

#include "TerrainType.h"

TerrainType::TerrainType(char display, bool pass, bool see) : displayChar(display), passable(pass), transparent(see)
{
}

TerrainType::~TerrainType()
{
    //dtor
}

Spoiler: LocalArea.h (click to show/hide)

#ifndef LOCALAREA_H
#define LOCALAREA_H

#include "TerrainType.h"
#include <vector>
#include <iostream>
#include <ncurses.h>
#include <stdexcept>
/*
This class represents a small chunk of terrain. These LocalAreas remember what they've got inside them and what other LocalAreas border them.
*/

enum Direction
{
    NO_DIRECTION,
    DIRECTION_NORTH,
    DIRECTION_EAST,
    DIRECTION_SOUTH,
    DIRECTION_WEST
};
//Rotates Clockwise
enum Rotation
{
    DEGREE_0,
    DEGREE_90,
    DEGREE_180,
    DEGREE_270
};

class LocalArea
{

    private:
        vector<vector<const TerrainType*> > terrain; //!< Member variable "terrain"
        int height;
        int width;
    public:

         class BorderArea
        {
            public:
                /** Default constructor */
                BorderArea(LocalArea&, Direction dir = DIRECTION_NORTH, int realignment = 0, Rotation rot = DEGREE_0, bool mirror = false);
                /** Default destructor */
                virtual ~BorderArea();
                /** Access offset
                * \return The current value of offset
                */
                int getOffset() { return offset; }
                /** Set offset
                * \param val New value to set
                */
                void setOffset(int val) { offset = val; }
                /** Access direction
                * \return The current value of direction
                */
                Direction getDirection() { return direction; }
                /** Set direction
                * \param val New value to set
                */
                void setDirection(Direction dir) { direction = dir; }
                /** Access rotation
                * \return The current value of rotation
                */
                Rotation getRotation() { return rotation; }
                /** Set rotation
                * \param val New value to set
                */
                void setRotation(Rotation rot) { rotation = rot; }
                /** Access mirroring
                * \return The current value of mirroring
                */
                bool getMirroring() { return mirroring; }
                /** Set mirroring
                * \param val New value to set
                */
                void setMirroring(bool val) { mirroring = val; }
                /** Access area
                * \return The current value of area
                */
                LocalArea& getArea() { return *area; }
                /** Set area
                * \param val New value to set
                */
                void setArea(LocalArea& val) { area = &val; }
            protected:
            private:
                LocalArea* area; //!< Member variable "area"
                Direction direction; //!< Member variable "direction"
                int offset; //!< Member variable "offset"
                Rotation rotation; //!< Member variable "rotation"
                bool mirroring; //!< Member variable "mirroring". This represents whether the LocalArea is flipped along the axis that goes through it and the current area.
        };
        /** Default constructor */
        LocalArea(const TerrainType& = TerrainType(' '), int width = 1, int height = 1);
        /** Default destructor */
        virtual ~LocalArea();
        /** Fill terrain with char */
        void fillTerrain(const TerrainType &type);
        /** Access single tile of terrain */
        const TerrainType& getTerrain(int x, int y, bool checkBorders = true);
        /** Set single tile of terrain */
        void setTerrain(const TerrainType& type, int x, int y) {terrain[y]

• = &type;}

        /** Add BorderArea to borders */
        void addBorderArea(LocalArea::BorderArea);
        /** Access width
        * \return The current value of width
        */
        int getWidth() {return width;}
        /** Access height
        * \return The current value of width
        */
        int getHeight() {return height;}
        void setWidth(int w) {width = w;}
        void setHeight(int h) {height = h;}
        LocalArea::BorderArea getBorder(int x, int y, bool checkborders = true);
        void print();
        void print(int x, int y);
        void print(int x1, int y1, int x2, int y2);
    protected:
    private:
        vector<LocalArea::BorderArea> borders;
};

#endif // LOCALAREA_H

Spoiler: LocalArea.cpp (click to show/hide)

#include "LocalArea.h"

LocalArea::LocalArea(const TerrainType& type, int width, int height)
{
    terrain = vector<vector<const TerrainType*> >();
    borders = vector<BorderArea>();
    setHeight(height);
    setWidth(width);
    int i, j;
    for (i = 0; i < height; i++)
    {
        terrain.push_back(vector<const TerrainType*> ());
    }
    unsigned int k;
    for (k = 0; k < terrain.size(); k++)
    {
        for (j = 0; j < width; j++)
        {
            terrain[k].push_back(&type);
        }
    }
}

LocalArea::~LocalArea()
{
    //dtor
}

void LocalArea::print()
{
    using namespace std;
    unsigned int i,j;
    for (i= 0; i < terrain.size(); i++)
    {
        for (j = 0; j < terrain.size(); j++)
        addch(getTerrain(j, i).GetDisplayChar());
        printw("\n");
    }
    return;
}

void LocalArea::print(int x, int y)
{
    addch(getTerrain(x,y).GetDisplayChar());
}

void LocalArea::print(int x1, int y1, int x2, int y2)
{
    int i,j;
    for (i= y1; i < y2; i++)
    {
        for (j = x1; j < x2; j++)
        addch(getTerrain(j, i).GetDisplayChar());
        printw("\n");
    }
}

Spoiler: LocalAreaTerrain.cpp (click to show/hide)

#include "LocalArea.h"

/*
This next function is an unholy moster. Basically, what it does, is it goes through the LocalArea and gets the specified peice of terrain.
however, if that piece of terrain is outside the LocalArea and the function is told to look for it, it will check the neighboring LocalAreas.
The part where this becomes a pain is where we take into account that those can be rotated and flipped.
This means a giant block of code to account for every possible combination. Which means massive nested switch statements. Which are ugly.

Alos take note, most if not all of the magic number 1's are to account for width and height measuring the number of items,
while the coordinates have a zero and are thus offset by 1.
*/
const TerrainType& LocalArea::getTerrain(int x, int y, bool checkBorders)
{
    if (x < 0 || x >= getWidth() || y < 0 || y >= getHeight())
    {
        if (checkBorders)
        {
            BorderArea* borderA;
            try
            {
                borderA = &getBorder(x,y);
            }
            catch(std::domain_error e)
            {

                return TerrainType(' ');
            }
            int getx, gety;
            switch (borderA->getDirection())
            {
                case DIRECTION_NORTH:
                {
                    switch (borderA->getRotation())
                    {
                        case DEGREE_0:
                        {
                            gety = borderA->getArea().getHeight() + y;
                            if (borderA->getMirroring())
                            getx = (borderA->getArea().getWidth() - 1) - (x - borderA->getOffset());
                            else
                            getx = x - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_270:
                        {
                            getx = (-y) - 1;
                            if (borderA->getMirroring())
                            gety = (borderA->getArea().getHeight() -1) - (x - borderA->getOffset());
                            else
                            gety = x - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_180:
                        {
                            gety = (-y) - 1;
                            if (borderA->getMirroring())
                            getx = x - borderA->getOffset();
                            else
                            getx = (borderA->getArea().getWidth()-1) - (x - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_90:
                        {
                            getx = borderA->getArea().getWidth() + y;
                            if (borderA->getMirroring())
                            gety = x - borderA->getOffset();
                            else
                            gety = (borderA->getArea().getHeight()-1) - (x - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                    }

                }
                case DIRECTION_EAST:
                {
                    switch (borderA->getRotation())
                    {
                        case DEGREE_0:
                        {
                            getx = x - getWidth();
                            if (borderA->getMirroring())
                            gety = (borderA->getArea().getHeight() - 1) - (y - borderA->getOffset());
                            else
                            gety = y - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_270:
                        {
                            gety = x - getWidth();
                            if (borderA->getMirroring())
                            getx = y - borderA->getOffset();
                            else
                            getx = (borderA->getArea().getWidth() - 1) - (y - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_180:
                        {
                            getx = (borderA->getArea().getWidth() - 1) - (x - getWidth());
                            if (borderA->getMirroring())
                            gety = y - borderA->getOffset();
                            else
                            gety = (borderA->getArea().getHeight() - 1) - (y - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_90:
                        {
                            gety = (borderA->getArea().getHeight() - 1) - (x - getWidth());
                            if (borderA->getMirroring())
                            getx = (borderA->getArea().getWidth() - 1) - (y - borderA->getOffset());
                            else
                            getx = y - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                    }

                }
                case DIRECTION_SOUTH:
                {
                    switch (borderA->getRotation())
                    {
                        case DEGREE_0:
                        {
                            gety = y - getHeight();
                            if (borderA->getMirroring())
                            getx = (borderA->getArea().getWidth() - 1) - (x - borderA->getOffset());
                            else
                            getx = x - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_270:
                        {
                            getx = (borderA->getArea().getWidth() - 1) - (y - getHeight());
                            if (borderA->getMirroring())
                            gety = (borderA->getArea().getWidth() - 1) - (x - borderA->getOffset());
                            else
                            gety = x - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_180:
                        {
                            gety = (borderA->getArea().getHeight() - 1) - (y - getHeight());
                            if (borderA->getMirroring())
                            getx = x - borderA->getOffset();
                            else
                            getx = (borderA->getArea().getWidth() - 1) - (x - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_90:
                        {
                            getx = y - getHeight();
                            if (borderA->getMirroring())
                            gety = x - borderA->getOffset();
                            else
                            gety = (borderA->getArea().getWidth() - 1) - (x - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                    }

                }
                case DIRECTION_WEST:
                {
                    switch (borderA->getRotation())
                    {
                        case DEGREE_0:
                        {
                            getx = borderA->getArea().getWidth() + x;
                            if (borderA->getMirroring())
                            gety = (borderA->getArea().getHeight() - 1) - (y - borderA->getOffset());
                            else
                            gety = y - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_270:
                        {
                            gety = (borderA->getArea().getWidth() - 1) + x;
                            if (borderA->getMirroring())
                            getx = y - borderA->getOffset();
                            else
                            getx = (borderA->getArea().getWidth() - 1) - (y - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_180:
                        {
                            getx = (-x) - 1;
                            if (borderA->getMirroring())
                            gety = y - borderA->getOffset();
                            else
                            gety = (borderA->getArea().getHeight() - 1) - (y - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_90:
                        {
                            gety = (-x) - 1;
                            if (borderA->getMirroring())
                            getx = (borderA->getArea().getWidth() - 1) - (y - borderA->getOffset());
                            else
                            getx = y - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                    }

                }
            }
        }
        else
        return TerrainType('Y');
    }
    return *terrain[y]

• ;

}

void LocalArea::fillTerrain(const TerrainType& type)
{
    unsigned int i, j;
    for (i = 0; i < terrain.size(); i++)
    {
        for (j = 0; j < terrain.size(); j++)
        {
            terrain[j] = &type;
        }
    }
}

Spoiler: LocalAreaBorder.cpp (click to show/hide)

#include "LocalArea.h"

void LocalArea::addBorderArea(BorderArea border)
{
    borders.push_back(border);
}



/*
Thus next function is another unholy monster. What it does, is look through the given borders of an area for
*/

LocalArea::BorderArea LocalArea::getBorder(int x, int y, bool checkborders)
{
    unsigned int i;
    if (x < 0)
    {
        for (i = 0; i < borders.size(); i++)
        {
            if (borders.getDirection() == DIRECTION_WEST)
            {
                if (borders.getRotation() == DEGREE_90 || borders.getRotation() == DEGREE_270)
                {
                    if (borders.getOffset() + borders.getArea().getWidth() > y && borders.getOffset() <= y && borders.getArea().getHeight() + x >= 0)
                    return borders;
                }
                else
                {
                    if ((borders.getOffset() + borders.getArea().getHeight()) > y && borders.getOffset() <= y && borders.getArea().getWidth() + x >= 0)
                    return borders;
                }

            }

        }
    }
    if (x >= getWidth())
    {
        for (i = 0; i < borders.size(); i++)
        {
            if (borders.getDirection() == DIRECTION_EAST)
            {
                if (borders.getRotation() == DEGREE_90 || borders.getRotation() == DEGREE_270)
                {
                    if (borders.getOffset() + borders.getArea().getWidth() > y && borders.getOffset() <= y && (x - getWidth()) < borders.getArea().getHeight())
                    return borders;
                }
                else
                {
                    if (borders.getOffset() + borders.getArea().getHeight() > y && borders.getOffset() <= y && (x - getWidth()) < borders.getArea().getWidth())
                    return borders;
                }

            }
        }
    }
    if (y < 0)
    {
        for (i = 0; i < borders.size(); i++)
        {
            if (borders.getDirection() == DIRECTION_NORTH)
            {
                if (borders.getRotation() == DEGREE_90 || borders.getRotation() == DEGREE_270)
                {
                    if (borders.getOffset() + borders.getArea().getHeight() > x && borders.getOffset() <= x && borders.getArea().getWidth() + y >= 0)
                    return borders;
                }
                else
                {
                    if (borders.getOffset() + borders.getArea().getWidth() > x && borders.getOffset() <= x && borders.getArea().getHeight() + y >= 0)
                    return borders;
                }

            }
        }
    }
    if (y >= getHeight())
    {
        for (i = 0; i < borders.size(); i++)
        {
            if (borders.getDirection() == DIRECTION_SOUTH)
            {
                if (borders.getRotation() == DEGREE_90 || borders.getRotation() == DEGREE_270)
                {
                    if (borders.getOffset() + borders.getArea().getHeight() > x && borders.getOffset() <= x && (y - getHeight()) < borders.getArea().getWidth())
                    return borders;
                }
                else
                {
                    if (borders.getOffset() + borders.getArea().getWidth() > x && borders.getOffset() <= x && (y - getHeight()) < borders.getArea().getHeight())
                    return borders;
                }

            }
        }
    }

    throw domain_error("No Border!");
}

LocalArea::BorderArea::BorderArea(LocalArea& borderArea, Direction dir, int realignment, Rotation rot, bool mirror):
area(&borderArea), direction(dir), offset(realignment), rotation(rot), mirroring(mirror)
{
    //ctor
}

LocalArea::BorderArea::~BorderArea()
{
    //dtor
}

Also- I have a game in mind. It's called "Beneath the <Adjective> Mountains". You start the game at the entrance to these massive caverns beneath these mountains. In the caverns, you encounter all sorts of creatures and strange civilizations and stuff. The game is mostly about exploration and discovery.

[Ehndras]

I have no idea what the hell any of this means, but I'll say this:

Ever read 'At the mountains of madness' by H. P. Lovecraft? Ever heard of Cthulhu? YES.

THAT. Do THAT! Doing a crazy alien/supernatural context beneath the earth like finding ancient hidden civilizations that may have created humanity and sure as hell predate us would be awesome and, crappy game or not, more interesting than yet another half-made game about orcs and elves. Gives it a little mystery, some interesting twists, and something to work towards.

In other words, orcs/elves/dungeons has been done, over-done, resurrected, and then killed again. To death. Did that make sense? No? Exactly.

[Angle]

I have read'At the mountains of madness' by H. P. Lovecraft. And I will do some thing like that, but mostly it's going to be various mythical underground civilizations living their day to day lives.

I am thinking of doing a cosmic horror roguelike at some date well in the future, though.

[Neonivek]

Doing a crazy alien/supernatural context beneath the earth like finding ancient hidden civilizations that may have created humanity and sure as hell predate us would be awesome and, crappy game or not, more interesting than yet another half-made game about orcs and elves

You are aware "Alien who predates humanity" is a much more common a trope in RPGs then you think right? In fact there are three series entirely based around this concept.

In fact more common then elves and DEFINATELY more common then orcs.

The problem with doing a proper lovecraftian Roguelike is the amount of talent, planning, and foresight required NOT to turn it into a hack and slash. It is a game where you can't trust your eyes and yet even within insanity there is truth (plus other stuff blaw blaw)

[Angle]

The problem with doing a proper lovecraftian Roguelike is the amount of talent, planning, and foresight required NOT to turn it into a hack and slash. It is a game where you can't trust your eyes and yet even within insanity there is truth (plus other stuff blaw blaw)

Yeah, that's WAY the hell down the road. Especially because the idea I had calls for simulating basically all of society as a background.

[Ehndras]

Aye, proper details comes WAY later, after ensuring all the mechanics actually function properly. You can easily change names/descriptors around later on and get new graphics once the mechanics are going well.

I'll leave the coding to you, Angle, as I as of yet may as well be reading a lecture on quantum mechanics in Arabic, considering how well I understood any of that.

Let me know when you've got something functional, I'll do bug testing as is needed Once I actually know what you're talking about, I'll also join in. As of now though, I'll sit on the sidelines and watch.

[Ehndras]

Doing a crazy alien/supernatural context beneath the earth like finding ancient hidden civilizations that may have created humanity and sure as hell predate us would be awesome and, crappy game or not, more interesting than yet another half-made game about orcs and elves

You are aware "Alien who predates humanity" is a much more common a trope in RPGs then you think right? In fact there are three series entirely based around this concept.

In fact more common then elves and DEFINATELY more common then orcs.

The problem with doing a proper lovecraftian Roguelike is the amount of talent, planning, and foresight required NOT to turn it into a hack and slash. It is a game where you can't trust your eyes and yet even within insanity there is truth (plus other stuff blaw blaw)

I was not aware. The sheer volume (thousands) of elf-orc-bladi-blah-hack&slash dungeon crawlers seems to outnumber scifi-based rpgs by a ton, considering how I actively seek those types of games out and only ever seem to come across really SHITTY scifi rpgs, when I'm not bombarded by hundreds of classic fantasy rpgs about kingdoms and knights and dragons and bladiblah.

Considering how my literary style started with H. P. Lovecraft, I'd say I'm good enough to half-ass something.

Here's a little philosophical crap I wrote after my last reading of Lovecraft... Had been a good 5 years since I had read any Lovecraft, sadly. Once I read every single one of his stories, I sort of gave up on reading for a while >_>

You might, uhh, notice a few Lovecraftian references.


http://gjstruck.wordpress.com/2011/02/01/ephemeral-visions-of-atlantean-vistas/

[Ehndras]

Btw, I apologize if its a bit dense. I have a very... Complicated writing style, and I may or may not have been slightly drunk and/or without sleep for several days.

[Angle]

It's a nice little article, although you were right about it being dense.

Come on, people, can't anyone criticize my code? Constructively, of course.

[Angle]

I now have a very basic game. There are open spaces you can run around in, and walls that block movement. Next I want to implement walls that block vision. Any advice or criticism?

Spoiler: Main.cpp (click to show/hide)

Code: [Select]

#include <iostream>
#include "LocalArea.h"
#include "Player.h"
#include <ncurses.h>

using namespace std;
int main()
{
    initscr();
    raw();
    noecho();
    keypad(stdscr, true);
    const TerrainType floor('.');
    const TerrainType wall('#', false, false);
    const TerrainType six('6');
    const TerrainType four('4');
    const TerrainType five('5');
    LocalArea place = LocalArea(floor, 10, 10);
    LocalArea place2 = LocalArea(floor, 10, 10);
    place.setTerrain(floor, 2, 2);
    for (int i = 0; i < place.getHeight(); i++)
    {
        if (i != place.getHeight()/2)
        {
            place.setTerrain(wall, 0, i);
            place.setTerrain(wall, place.getWidth()-1, i);
        }
    }
    for (int j = 0; j < place.getWidth(); j++)
    {
        if (j != place.getWidth()/2)
        {
            place.setTerrain(wall, j, 0);
            place.setTerrain(wall, j, place.getHeight()-1);
        }
    }
    LocalArea place3(four, 6, 4);
    LocalArea place4(five, 6, 4);
    LocalArea place5(six, 6, 5);
    place2.setTerrain(floor, 0, 0);
    place3.setTerrain(floor, 0, 0);
    place4.setTerrain(floor, 0, 0);
    place5.setTerrain(floor, 0, 0);
    place.addBorderArea(LocalArea::BorderArea(place2, DIRECTION_NORTH));
    place.addBorderArea(LocalArea::BorderArea(place2, DIRECTION_EAST));
    place.addBorderArea(LocalArea::BorderArea(place2, DIRECTION_SOUTH));
    place.addBorderArea(LocalArea::BorderArea(place2, DIRECTION_WEST));
    place2.addBorderArea(LocalArea::BorderArea(place, DIRECTION_NORTH));
    place2.addBorderArea(LocalArea::BorderArea(place, DIRECTION_EAST));
    place2.addBorderArea(LocalArea::BorderArea(place, DIRECTION_SOUTH));
    place2.addBorderArea(LocalArea::BorderArea(place, DIRECTION_WEST));
    Player player(Entity(Location(place, 2, 2), 5));
    player.getCharacter().print();
    refresh();
    player.controlLoop();
    endwin();
    return 0;
}


Spoiler: LocalArea.h (click to show/hide)

Code: [Select]

#ifndef LOCALAREA_H
#define LOCALAREA_H

#include "TerrainType.h"
#include <vector>
#include <iostream>
#include <ncurses.h>
#include <stdexcept>
/*
This class represents a small chunk of terrain. These LocalAreas remember what they've got inside them and what other LocalAreas border them.
*/

enum Direction
{
    NO_DIRECTION,
    DIRECTION_NORTH,
    DIRECTION_EAST,
    DIRECTION_SOUTH,
    DIRECTION_WEST
};
//Rotates Clockwise
enum Rotation
{
    DEGREE_0,
    DEGREE_90,
    DEGREE_180,
    DEGREE_270
};

class Location;

class LocalArea
{

    private:
        vector<vector<const TerrainType*> > terrain; //!< Member variable "terrain"
        int height;
        int width;
    public:

         class BorderArea
        {
            public:
                /** Default constructor */
                BorderArea(LocalArea&, Direction dir = DIRECTION_NORTH, int realignment = 0, Rotation rot = DEGREE_0, bool mirror = false);
                /** Default destructor */
                virtual ~BorderArea();
                /** Access offset
                * \return The current value of offset
                */
                int getOffset() { return offset; }
                /** Set offset
                * \param val New value to set
                */
                void setOffset(int val) { offset = val; }
                /** Access direction
                * \return The current value of direction
                */
                Direction getDirection() { return direction; }
                /** Set direction
                * \param val New value to set
                */
                void setDirection(Direction dir) { direction = dir; }
                /** Access rotation
                * \return The current value of rotation
                */
                Rotation getRotation() { return rotation; }
                /** Set rotation
                * \param val New value to set
                */
                void setRotation(Rotation rot) { rotation = rot; }
                /** Access mirroring
                * \return The current value of mirroring
                */
                bool getMirroring() { return mirroring; }
                /** Set mirroring
                * \param val New value to set
                */
                void setMirroring(bool val) { mirroring = val; }
                /** Access area
                * \return The current value of area
                */
                LocalArea& getArea() { return *area; }
                /** Set area
                * \param val New value to set
                */
                void setArea(LocalArea& val) { area = &val; }
            protected:
            private:
                LocalArea* area; //!< Member variable "area"
                Direction direction; //!< Member variable "direction"
                int offset; //!< Member variable "offset"
                Rotation rotation; //!< Member variable "rotation"
                bool mirroring; //!< Member variable "mirroring". This represents whether the LocalArea is flipped along the axis that goes through it and the current area.
        };
        /** Default constructor */
        LocalArea(const TerrainType& = TerrainType(' '), int width = 1, int height = 1);
        /** Default destructor */
        virtual ~LocalArea();
        /** Fill terrain with char */
        void fillTerrain(const TerrainType &type);
        /** Access single tile of terrain */
        const TerrainType& getTerrain(int x, int y, bool checkBorders = true);
        /** Set single tile of terrain */
        void setTerrain(const TerrainType& type, int x, int y) {terrain[y][x] = &type;}
        /** Add BorderArea to borders */
        void addBorderArea(LocalArea::BorderArea);
        /** Access width
        * \return The current value of width
        */
        int getWidth() {return width;}
        /** Access height
        * \return The current value of width
        */
        int getHeight() {return height;}
        void setWidth(int w) {width = w;}
        void setHeight(int h) {height = h;}
        LocalArea::BorderArea& getBorder(int x, int y, bool checkborders = true);
        void print();
        void print(int x, int y);
        void print(int x1, int y1, int x2, int y2);
        bool outsideArea(int x, int y) {return (x < 0 || x >= getWidth() || y < 0 || y >= getHeight());}
        Location getBorderingLocation(int x, int y);
    protected:
    private:
        vector<LocalArea::BorderArea> borders;
};

#endif // LOCALAREA_H


Spoiler: LocalArea.cpp (click to show/hide)

Code: [Select]

#include "LocalArea.h"

LocalArea::LocalArea(const TerrainType& type, int width, int height)
{
    terrain = vector<vector<const TerrainType*> >();
    borders = vector<BorderArea>();
    setHeight(height);
    setWidth(width);
    int i, j;
    for (i = 0; i < height; i++)
    {
        terrain.push_back(vector<const TerrainType*> ());
    }
    unsigned int k;
    for (k = 0; k < terrain.size(); k++)
    {
        for (j = 0; j < width; j++)
        {
            terrain[k].push_back(&type);
        }
    }
}

LocalArea::~LocalArea()
{
    //dtor
}

void LocalArea::print()
{
    using namespace std;
    unsigned int i,j;
    for (i= 0; i < terrain.size(); i++)
    {
        for (j = 0; j < terrain[i].size(); j++)
        addch(getTerrain(j, i).GetDisplayChar());
        printw("\n");
    }
    return;
}

void LocalArea::print(int x, int y)
{
    addch(getTerrain(x,y).GetDisplayChar());
}

void LocalArea::print(int x1, int y1, int x2, int y2)
{
    int i,j;
    for (i= y1; i < y2; i++)
    {
        for (j = x1; j < x2; j++)
        addch(getTerrain(j, i).GetDisplayChar());
        printw("\n");
    }
}


Spoiler: TerrainType.h (click to show/hide)

Code: [Select]

#ifndef TERRAINTYPE_H
#define TERRAINTYPE_H

#include <iostream>
using namespace std;

class TerrainType
{
    public:
        /** char constructor */
        TerrainType(char display = '.', bool pass = true, bool see = true);
        /** Default destructor */
        virtual ~TerrainType();
        /** Access displayChar
         * \return The current value of displayChar
         */
        char GetDisplayChar() const {return displayChar;}
        void setDisplayChar(char symbol) {displayChar = symbol;}
        bool isPassable() const {return passable;}
    protected:
    private:
        char displayChar; //!< Member variable "displayChar"
        bool passable;
        bool transparent;
};

#endif // TERRAINTYPE_H


Spoiler: TerrainType.cpp (click to show/hide)

Code: [Select]

#include "TerrainType.h"

TerrainType::TerrainType(char display, bool pass, bool see) : displayChar(display), passable(pass), transparent(see)
{
}

TerrainType::~TerrainType()
{
    //dtor
}


Spoiler: Entity.h (click to show/hide)

Code: [Select]

#ifndef ENTITY_H
#define ENTITY_H

#include "Location.h"

/** Represents most creatures

*/

class Entity
{
    public:
        /** Default constructor */
        Entity(Location, int sight = 1, char rep = '@');
        /** Default destructor */
        virtual ~Entity();
        /** Access sightRange
        * \return The current value of sightRange
        */
        int getSightRange() {return sightRange;}
        /** Set sightRange
        *\param sight New value to set
        */
        void setSightRange(int sight) {sightRange = sight;}
        Location getLocation() {return location;}
        void setLocation(Location place) {location = place;}
        void print();
        void move(int x, int y) {location.setX(x); location.setY(y);}
        void moveRel(int x, int y);
    protected:
    private:
    Location location;
    int sightRange;
    char symbol;
};

#endif // ENTITY_H


Spoiler: Entity.cpp (click to show/hide)

Code: [Select]

#include "Entity.h"

Entity::Entity(Location place, int sight, char rep) : location(place), sightRange(sight), symbol(rep)
{
    //ctor
}

Entity::~Entity()
{
    //dtor
}

void Entity::print()
{
    for (int i = -getSightRange(); i < getSightRange(); i++)
    {
        for (int j = -getSightRange(); j < getSightRange(); j++)
        {
            if (j == 0 && i == 0)
            addch('@');
            else
            addch(getLocation().getLocalArea().getTerrain(j + getLocation().getX(), i + getLocation().getY()).GetDisplayChar());
        }
        addch('\n');
    }
    ;
}

void Entity::moveRel(int x, int y)
{
    if (location.getLocalArea().outsideArea(location.getX() + x, location.getY() + y))
    {
        Location loc = location.getLocalArea().getBorderingLocation(location.getX() + x, location.getY() + y);
        if (loc.getTerrain().isPassable())
        location = loc;
        return;
    }
    else if (location.getLocalArea().getTerrain(location.getX() + x, location.getY() + y).isPassable())
    {
        location.setX(location.getX() + x);
        location.setY(location.getY() + y);
    }
}


Spoiler: Location.h (click to show/hide)

Code: [Select]

#ifndef LOCATION_H
#define LOCATION_H

#include "LocalArea.h"

class Location
{
    public:
        /** Default constructor */
        Location(LocalArea&, int X = 0, int Y = 0);
        /** Default destructor */
        virtual ~Location();
        /** Access x
         * \return The current value of x
         */
        int getX() { return x; }
        /** Set x
         * \param val New value to set
         */
        void setX(int val) { x = val; }
        /** Access y
         * \return The current value of y
         */
        int getY() { return y; }
        /** Set y
         * \param val New value to set
         */
        void setY(int val) { y = val; }
        /** Access localArea
         * \return The current value of localArea
         */
        LocalArea getLocalArea() {return *localArea;}
        /** Set localArea
         * \param val New value to set
         */
        void setLocalArea(LocalArea val) { localArea = &val; }
        const TerrainType& getTerrain() {return getLocalArea().getTerrain(getX(), getY());}
    protected:
    private:
        LocalArea* localArea; //!< Member variable "localArea"
        int x; //!< Member variable "x"
        int y; //!< Member variable "y"
};

#endif // LOCATION_H


Spoiler: Location.cpp (click to show/hide)

Code: [Select]

#include "Location.h"

Location::Location(LocalArea& area, int X, int Y) :localArea(&area), x(X), y(Y)
{

}

Location::~Location()
{
    //dtor
}


Spoiler: Player.h (click to show/hide)

Code: [Select]

#ifndef PLAYER_H
#define PLAYER_H

#include "Entity.h"

class Player
{
    public:
        /** Default constructor */
        Player(Entity, bool incontrol = true);
        /** Default destructor */
        virtual ~Player();
        /** Access character
        * \return Current value of character.
        */
        Entity getCharacter() {return character;}
        void controlLoop();

    protected:
    private:
        Entity character;
        Location viewpoint;
        bool inControl;
};

#endif // PLAYER_H

Spoiler: Player.cpp (click to show/hide)

Code: [Select]

#include "Player.h"

Player::Player(Entity pc, bool incontrol) : character(pc), viewpoint(pc.getLocation()), inControl(incontrol)
{
}

Player::~Player()
{
    //dtor
}

void Player::controlLoop()
{
    int ch;
    while((ch = getch()) != 'q')
    {
        switch (ch)
        {
            case  KEY_LEFT:
            {
                character.moveRel(-1, 0);
                break;
            }
            case KEY_RIGHT:
            {
                character.moveRel(1, 0);
                break;
            }
            case KEY_UP:
            {
                character.moveRel(0, -1);
                break;
            }
            case KEY_DOWN:
            {
                character.moveRel(0, 1);
                break;
            }

        }
        move(0, 0);
        erase();
        character.print();
        refresh();
    }
}


Spoiler: LocalAreaTerrain.cpp (click to show/hide)

Code: [Select]

#include "LocalArea.h"

/*
This next function is an unholy moster. Basically, what it does, is it goes through the LocalArea and gets the specified peice of terrain.
however, if that piece of terrain is outside the LocalArea and the function is told to look for it, it will check the neighboring LocalAreas.
The part where this becomes a pain is where we take into account that those can be rotated and flipped.
This means a giant block of code to account for every possible combination. Which means massive nested switch statements. Which are ugly.

Alos take note, most if not all of the magic number 1's are to account for width and height measuring the number of items,
while the coordinates have a zero and are thus offset by 1.
*/
const TerrainType& LocalArea::getTerrain(int x, int y, bool checkBorders)
{
    if (outsideArea(x,y))
    {
        if (checkBorders)
        {
            BorderArea* borderA;
            try
            {
                borderA = &getBorder(x,y);
            }
            catch(std::domain_error e)
            {

                return TerrainType(' ');
            }
            int getx, gety;
            switch (borderA->getDirection())
            {
                case DIRECTION_NORTH:
                {
                    switch (borderA->getRotation())
                    {
                        case DEGREE_0:
                        {
                            gety = borderA->getArea().getHeight() + y;
                            if (borderA->getMirroring())
                            getx = (borderA->getArea().getWidth() - 1) - (x - borderA->getOffset());
                            else
                            getx = x - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_270:
                        {
                            getx = (-y) - 1;
                            if (borderA->getMirroring())
                            gety = (borderA->getArea().getHeight() -1) - (x - borderA->getOffset());
                            else
                            gety = x - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_180:
                        {
                            gety = (-y) - 1;
                            if (borderA->getMirroring())
                            getx = x - borderA->getOffset();
                            else
                            getx = (borderA->getArea().getWidth()-1) - (x - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_90:
                        {
                            getx = borderA->getArea().getWidth() + y;
                            if (borderA->getMirroring())
                            gety = x - borderA->getOffset();
                            else
                            gety = (borderA->getArea().getHeight()-1) - (x - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                    }

                }
                case DIRECTION_EAST:
                {
                    switch (borderA->getRotation())
                    {
                        case DEGREE_0:
                        {
                            getx = x - getWidth();
                            if (borderA->getMirroring())
                            gety = (borderA->getArea().getHeight() - 1) - (y - borderA->getOffset());
                            else
                            gety = y - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_270:
                        {
                            gety = x - getWidth();
                            if (borderA->getMirroring())
                            getx = y - borderA->getOffset();
                            else
                            getx = (borderA->getArea().getWidth() - 1) - (y - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_180:
                        {
                            getx = (borderA->getArea().getWidth() - 1) - (x - getWidth());
                            if (borderA->getMirroring())
                            gety = y - borderA->getOffset();
                            else
                            gety = (borderA->getArea().getHeight() - 1) - (y - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_90:
                        {
                            gety = (borderA->getArea().getHeight() - 1) - (x - getWidth());
                            if (borderA->getMirroring())
                            getx = (borderA->getArea().getWidth() - 1) - (y - borderA->getOffset());
                            else
                            getx = y - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                    }

                }
                case DIRECTION_SOUTH:
                {
                    switch (borderA->getRotation())
                    {
                        case DEGREE_0:
                        {
                            gety = y - getHeight();
                            if (borderA->getMirroring())
                            getx = (borderA->getArea().getWidth() - 1) - (x - borderA->getOffset());
                            else
                            getx = x - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_270:
                        {
                            getx = (borderA->getArea().getWidth() - 1) - (y - getHeight());
                            if (borderA->getMirroring())
                            gety = (borderA->getArea().getWidth() - 1) - (x - borderA->getOffset());
                            else
                            gety = x - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_180:
                        {
                            gety = (borderA->getArea().getHeight() - 1) - (y - getHeight());
                            if (borderA->getMirroring())
                            getx = x - borderA->getOffset();
                            else
                            getx = (borderA->getArea().getWidth() - 1) - (x - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_90:
                        {
                            getx = y - getHeight();
                            if (borderA->getMirroring())
                            gety = x - borderA->getOffset();
                            else
                            gety = (borderA->getArea().getWidth() - 1) - (x - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                    }

                }
                case DIRECTION_WEST:
                {
                    switch (borderA->getRotation())
                    {
                        case DEGREE_0:
                        {
                            getx = borderA->getArea().getWidth() + x;
                            if (borderA->getMirroring())
                            gety = (borderA->getArea().getHeight() - 1) - (y - borderA->getOffset());
                            else
                            gety = y - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_270:
                        {
                            gety = (borderA->getArea().getWidth() - 1) + x;
                            if (borderA->getMirroring())
                            getx = y - borderA->getOffset();
                            else
                            getx = (borderA->getArea().getWidth() - 1) - (y - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_180:
                        {
                            getx = (-x) - 1;
                            if (borderA->getMirroring())
                            gety = y - borderA->getOffset();
                            else
                            gety = (borderA->getArea().getHeight() - 1) - (y - borderA->getOffset());
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                        case DEGREE_90:
                        {
                            gety = (-x) - 1;
                            if (borderA->getMirroring())
                            getx = (borderA->getArea().getWidth() - 1) - (y - borderA->getOffset());
                            else
                            getx = y - borderA->getOffset();
                            return borderA->getArea().getTerrain(getx, gety);
                        }
                    }

                }
            }
        }
        else
        return TerrainType('Y');
    }
    return *terrain[y][x];
}

void LocalArea::fillTerrain(const TerrainType& type)
{
    unsigned int i, j;
    for (i = 0; i < terrain.size(); i++)
    {
        for (j = 0; j < terrain[i].size(); j++)
        {
            terrain[i][j] = &type;
        }
    }
}


[Angle]

Also, I really need a better way to upload my project. Any recommendations? I've heard git-hub is good.

Spoiler: LocalAreaBorder.cpp (click to show/hide)

Code: [Select]

#include "LocalArea.h"
#include "Location.h"

void LocalArea::addBorderArea(BorderArea border)
{
    borders.push_back(border);
}



/*
Thus next function is another unholy monster. What it does, is look through the given borders of an area for
*/

LocalArea::BorderArea& LocalArea::getBorder(int x, int y, bool checkborders)
{
    unsigned int i;
    if (x < 0)
    {
        for (i = 0; i < borders.size(); i++)
        {
            if (borders[i].getDirection() == DIRECTION_WEST)
            {
                if (borders[i].getRotation() == DEGREE_90 || borders[i].getRotation() == DEGREE_270)
                {
                    if (borders[i].getOffset() + borders[i].getArea().getWidth() > y && borders[i].getOffset() <= y && borders[i].getArea().getHeight() + x >= 0)
                    return borders[i];
                }
                else
                {
                    if ((borders[i].getOffset() + borders[i].getArea().getHeight()) > y && borders[i].getOffset() <= y && borders[i].getArea().getWidth() + x >= 0)
                    return borders[i];
                }

            }

        }
    }
    if (x >= getWidth())
    {
        for (i = 0; i < borders.size(); i++)
        {
            if (borders[i].getDirection() == DIRECTION_EAST)
            {
                if (borders[i].getRotation() == DEGREE_90 || borders[i].getRotation() == DEGREE_270)
                {
                    if (borders[i].getOffset() + borders[i].getArea().getWidth() > y && borders[i].getOffset() <= y && (x - getWidth()) < borders[i].getArea().getHeight())
                    return borders[i];
                }
                else
                {
                    if (borders[i].getOffset() + borders[i].getArea().getHeight() > y && borders[i].getOffset() <= y && (x - getWidth()) < borders[i].getArea().getWidth())
                    return borders[i];
                }

            }
        }
    }
    if (y < 0)
    {
        for (i = 0; i < borders.size(); i++)
        {
            if (borders[i].getDirection() == DIRECTION_NORTH)
            {
                if (borders[i].getRotation() == DEGREE_90 || borders[i].getRotation() == DEGREE_270)
                {
                    if (borders[i].getOffset() + borders[i].getArea().getHeight() > x && borders[i].getOffset() <= x && borders[i].getArea().getWidth() + y >= 0)
                    return borders[i];
                }
                else
                {
                    if (borders[i].getOffset() + borders[i].getArea().getWidth() > x && borders[i].getOffset() <= x && borders[i].getArea().getHeight() + y >= 0)
                    return borders[i];
                }

            }
        }
    }
    if (y >= getHeight())
    {
        for (i = 0; i < borders.size(); i++)
        {
            if (borders[i].getDirection() == DIRECTION_SOUTH)
            {
                if (borders[i].getRotation() == DEGREE_90 || borders[i].getRotation() == DEGREE_270)
                {
                    if (borders[i].getOffset() + borders[i].getArea().getHeight() > x && borders[i].getOffset() <= x && (y - getHeight()) < borders[i].getArea().getWidth())
                    return borders[i];
                }
                else
                {
                    if (borders[i].getOffset() + borders[i].getArea().getWidth() > x && borders[i].getOffset() <= x && (y - getHeight()) < borders[i].getArea().getHeight())
                    return borders[i];
                }

            }
        }
    }

    throw domain_error("No Border!");
}

Location LocalArea::getBorderingLocation(int x, int y)
{
    BorderArea borderA = getBorder(x, y);
    Location loc(borderA.getArea());
    int getx, gety;
    switch (borderA.getDirection())
    {
        case DIRECTION_NORTH:
        {
            switch (borderA.getRotation())
            {
                case DEGREE_0:
                {
                    gety = borderA.getArea().getHeight() + y;
                    if (borderA.getMirroring())
                    getx = (borderA.getArea().getWidth() - 1) - (x - borderA.getOffset());
                    else
                    getx = x - borderA.getOffset();
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;
                }
                case DEGREE_270:
                {
                    getx = (-y) - 1;
                    if (borderA.getMirroring())
                    gety = (borderA.getArea().getHeight() -1) - (x - borderA.getOffset());
                    else
                    gety = x - borderA.getOffset();
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;
                }
                case DEGREE_180:
                {
                    gety = (-y) - 1;
                    if (borderA.getMirroring())
                    getx = x - borderA.getOffset();
                    else
                    getx = (borderA.getArea().getWidth()-1) - (x - borderA.getOffset());
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;
                }
                case DEGREE_90:
                {
                    getx = borderA.getArea().getWidth() + y;
                    if (borderA.getMirroring())
                    gety = x - borderA.getOffset();
                    else
                    gety = (borderA.getArea().getHeight()-1) - (x - borderA.getOffset());
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;
                }
            }
        }
        case DIRECTION_EAST:
        {
            switch (borderA.getRotation())
            {
                case DEGREE_0:
                {
                    getx = x - getWidth();
                    if (borderA.getMirroring())
                    gety = (borderA.getArea().getHeight() - 1) - (y - borderA.getOffset());
                    else
                    gety = y - borderA.getOffset();
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;;
                }
                case DEGREE_270:
                {
                    gety = x - getWidth();
                    if (borderA.getMirroring())
                    getx = y - borderA.getOffset();
                    else
                    getx = (borderA.getArea().getWidth() - 1) - (y - borderA.getOffset());
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;;
                }
                case DEGREE_180:
                {
                    getx = (borderA.getArea().getWidth() - 1) - (x - getWidth());
                    if (borderA.getMirroring())
                    gety = y - borderA.getOffset();
                    else
                    gety = (borderA.getArea().getHeight() - 1) - (y - borderA.getOffset());
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;;
                }
                case DEGREE_90:
                {
                    gety = (borderA.getArea().getHeight() - 1) - (x - getWidth());
                    if (borderA.getMirroring())
                    getx = (borderA.getArea().getWidth() - 1) - (y - borderA.getOffset());
                    else
                    getx = y - borderA.getOffset();
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;;
                }
            }
        }
        case DIRECTION_SOUTH:
        {
            switch (borderA.getRotation())
            {
                case DEGREE_0:
                {
                    gety = y - getHeight();
                    if (borderA.getMirroring())
                    getx = (borderA.getArea().getWidth() - 1) - (x - borderA.getOffset());
                    else
                    getx = x - borderA.getOffset();
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;;
                }
                case DEGREE_270:
                {
                    getx = (borderA.getArea().getWidth() - 1) - (y - getHeight());
                    if (borderA.getMirroring())
                    gety = (borderA.getArea().getWidth() - 1) - (x - borderA.getOffset());
                    else
                    gety = x - borderA.getOffset();
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;;
                }
                case DEGREE_180:
                {
                    gety = (borderA.getArea().getHeight() - 1) - (y - getHeight());
                    if (borderA.getMirroring())
                    getx = x - borderA.getOffset();
                    else
                    getx = (borderA.getArea().getWidth() - 1) - (x - borderA.getOffset());
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;;
                }
                case DEGREE_90:
                {
                    getx = y - getHeight();
                    if (borderA.getMirroring())
                    gety = x - borderA.getOffset();
                    else
                    gety = (borderA.getArea().getWidth() - 1) - (x - borderA.getOffset());
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;;
                }
            }
        }
        case DIRECTION_WEST:
        {
            switch (borderA.getRotation())
            {
                case DEGREE_0:
                {
                    getx = borderA.getArea().getWidth() + x;
                    if (borderA.getMirroring())
                    gety = (borderA.getArea().getHeight() - 1) - (y - borderA.getOffset());
                    else
                    gety = y - borderA.getOffset();
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;;
                }
                case DEGREE_270:
                {
                    gety = (borderA.getArea().getWidth() - 1) + x;
                    if (borderA.getMirroring())
                    getx = y - borderA.getOffset();
                    else
                    getx = (borderA.getArea().getWidth() - 1) - (y - borderA.getOffset());
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;;
                }
                case DEGREE_180:
                {
                    getx = (-x) - 1;
                    if (borderA.getMirroring())
                    gety = y - borderA.getOffset();
                    else
                    gety = (borderA.getArea().getHeight() - 1) - (y - borderA.getOffset());
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;;
                }
                case DEGREE_90:
                {
                    gety = (-x) - 1;
                    if (borderA.getMirroring())
                    getx = (borderA.getArea().getWidth() - 1) - (y - borderA.getOffset());
                    else
                    getx = y - borderA.getOffset();
                    loc.setX(getx);
                    loc.setY(gety);
                    return loc;;
                }
            }
        }
    }
}

LocalArea::BorderArea::BorderArea(LocalArea& borderArea, Direction dir, int realignment, Rotation rot, bool mirror):
area(&borderArea), direction(dir), offset(realignment), rotation(rot), mirroring(mirror)
{
    //ctor
}

LocalArea::BorderArea::~BorderArea()
{
    //dtor
}