Messages

1

General / Re: How to determine/display possible movements in turn-based grid game

« on: March 08, 2015, 06:43:44 am »

I've got it solved now using recursion. Thanks guys 

2

General / Re: How to determine/display possible movements in turn-based grid game

« on: March 06, 2015, 05:31:38 pm »

If you need speed you could do a geometric approach..........................

Thank you for the descriptive answer. However, I must admit that I do not have the faintest idea on how to actually go about implementing that. Mathematics has not been my strong point. Can you please provide a small example of this?

If I understand what you want, what you need is a flood fill algorithm

You start at the player position, and collect all its non-occupied adjacent cells (there should be max 4).................

Thanks for the idea. I have looked into wiki and have tried different ways of implementing this. But I still can't seem to get it to work correctly.


Once again, thank you both for your help. I cannot even fathom how a geometric approach to this would be. So I've went and redone the function several times trying to  to implement a recursive function akin to what a flood fill algorithm may be like (except of course, mine doesn't work). My current code follows this logic (or at least I think it does!)

(click to show/hide)

I pass the player' gridposition and the player's movementPoints into this function...

showPossibleGridMoves(GridPosition, int movementPoints)
1. If grid north to the player is out of bonds, return.
2. If grid north to the player is occupied, return.
3. If the northern grid is not already added to the drawing container of pointers for grids, then:
   Add the northern grid to the drawing container for grids.
4. Step 1-3 is repeated using loop for east/south/west.

5. Subtract 1 from movementPoints
6. if movementPoints is greater than zero, then:
     showPossibleGridMoves(north grid, movementPoints)
     showPossibleGridMoves(east grid, movementPoints)
      showPossibleGridMoves(south grid, movementPoints)
      showPossibleGridMoves(west grid, movementPoint)

My actual code is

(click to show/hide)

void TurnBasedBattle::showPossibleGridMoves(std::string ref_gridId, int ref_moves)
{

    GridStatus * ptr_grid;
    ptr_grid = &gridMap[ref_gridId];
    sf::Vector2i tmp_gridPosition(ptr_grid->getGridPositionX(),ptr_grid->getGridPositionY());

    std::string tmp_gridKey;
    bool isOverLimit;

    for (int i = 1; i <= 4; ++i)
    {
        //std::cout<<i<<std::endl;
        switch (i)
        {
        case 1:
            tmp_gridKey = formGridId(tmp_gridPosition.x, tmp_gridPosition.y - 1);
            isOverLimit = ((tmp_gridPosition.y - 1) < 1);
            break;
        case 2:
            tmp_gridKey = formGridId(tmp_gridPosition.x, tmp_gridPosition.y + 1);
            isOverLimit = ((tmp_gridPosition.y + 1) > 9);
            break;
        case 3:
            tmp_gridKey = formGridId(tmp_gridPosition.x + 1, tmp_gridPosition.y);
            isOverLimit = ((tmp_gridPosition.x + 1) > 14);
            break;
        case 4:
            tmp_gridKey = formGridId(tmp_gridPosition.x - 1, tmp_gridPosition.y);
            isOverLimit = ((tmp_gridPosition.x - 1) < 1);
            break;
        }

        if (isOverLimit) return;
        else if (gridMap[tmp_gridKey].isBlocked() == true) return;
        else if (gridIsDrawn(tmp_gridKey) == false)//gridMap[tmp_gridKey].isDrawn == false)
        {

            std::cout<<"Checking adjacent cells of "<<ref_gridId<<std::endl;
            std::cout<<"Obstacles check at "<<tmp_gridKey<<" is clear!\n";

            if (gridExists(tmp_gridKey) == true)
            {
                std::cout<<tmp_gridKey<<" is within the gridmap, so it is safe to add to drawing list.";
               // gridMap[tmp_gridKey].isDrawn = true;
                gridDrawList.push_back(&gridMap[tmp_gridKey]);
            }
            else if (gridExists(tmp_gridKey) == false)
            {
                std::cout<<"Error: "<<tmp_gridKey<<" was not found in the initialized gridMap";
            }
            std::cout<<std::endl<<std::endl;
        }

    }
    --ref_moves;
    if (ref_moves > 0)
    {
        tmp_gridKey = formGridId(tmp_gridPosition.x, tmp_gridPosition.y - 1);
        showPossibleGridMoves(tmp_gridKey, ref_moves);

        tmp_gridKey = formGridId(tmp_gridPosition.x, tmp_gridPosition.y + 1);
        showPossibleGridMoves(tmp_gridKey, ref_moves);

        tmp_gridKey = formGridId(tmp_gridPosition.x + 1, tmp_gridPosition.y);
        showPossibleGridMoves(tmp_gridKey, ref_moves);

        tmp_gridKey = formGridId(tmp_gridPosition.x - 1, tmp_gridPosition.y);
        showPossibleGridMoves(tmp_gridKey, ref_moves);
    }

}

This sorts of works...

(click to show/hide)

But not perfectly.

(click to show/hide)

Actually it doesn't work at all.

(click to show/hide)

Inconsistent too.

(click to show/hide)

Is there something wrong with my underlying code logic or am I making some major mistakes in coding? Or both? I feel like I have difficulties with trying to come up with the a working algorithm  Is there something very obvious that I am missing?

3

General / How to determine/display possible movements in turn-based grid game

« on: March 05, 2015, 02:58:56 pm »

Hi,

I'm still quite a newb when it comes to C++ (or programming in general) and SFML so this is a project more for my personal learning and interest than anything else.

I've been stumped for a while now on how to implement a way to properly determine the possible movements in a turn-based grid game.

At first, I've implemented possible movements to be something like this:

(click to show/hide)

Basically what happens is that when you click the banana button (just testing for now), the possible grids you can click on to move to gets filled with the colour yellow. After you click on one of those grids, the grids will stop showing and the sprite on the left will move to that grid (always x first, then y; I don't intend to make diagonal movements possible for now; also note that the sprite on the right doesn't do anything other than occupy a grid at the moment). Once the sprite finishes the movement, the banana button will appear again.

I threw in a check so that you cannot move to a grid already occupied by another entity and thought it was fine until I realised that while you cannot move to an occupied grid, you can still move through them:

(click to show/hide)

However, before I start working on trying to make it so it moves around the occupied grids instead of right through them, I needed to make sure the possible grid movement being shown is correct. There shouldn't be a yellow grid on the right of the non-moving stick entity since it would take more than 3 grids to get there (that is if you dont move through him or diagonally).

I've been stumped on this for a long time, tried multiple different ways to implement this logic but I cannot come up with anything that works properly or consistently. I've tried to write nests and nests of IF statements instead of using loops , but it got way too messy to manage and I feel that there has to be an easier way.

Eventually, I've stripped it all down to movement in a straight line. If the grid is blocked, further grids beyond no longer gets shown:

(click to show/hide)

This works fine, but obviously I want to also display grids beyond just a straight line. What would be a simple solution to implement this logic?

For reference, below are my current code for implementing the grids. I apologise in advance if they lack clarity, since I'm still quite a newb and may adopt practices and conventions that are not optimal. However, I've inserted comments and tried to explain what I did.

(click to show/hide)

#include "TurnBasedBattle.hpp"
void TurnBasedBattle::drawGrid()
{
    if (displayMoveGrid)
    {
        std::string tGridKey = gridMap[playerDrawList[0]->gridPosition].id; //player's current grid id

        int tGridX = gridMap[playerDrawList[0]->gridPosition].getGridPositionX(); //grab player's artificial grid x-coordinate 1~14
        int tGridY = gridMap[playerDrawList[0]->gridPosition].getGridPositionY(); //grab player's artificial grid y-coordinate 1~9
        //std::cout<<"Position: "<<tGridX << ","<<tGridY<<std::endl;

        int movePoints = 5;
        int gridWidth = 14;
        int gridHeight = 9;

        int northLimit = movePoints;
        int eastLimit = movePoints;
        int southLimit = movePoints;
        int westLimit = movePoints;

        /***To make sure you do not move off the Gridboard***/
        while ((tGridY - northLimit) < 1) --northLimit;
        while ((tGridX + eastLimit) > gridWidth) --eastLimit;
        while ((tGridY + southLimit) > gridHeight) --southLimit;
        while ((tGridX - westLimit) < 1) --westLimit;


        showPossibleGridMoves(eastLimit, "east");
        showPossibleGridMoves(westLimit, "west");
        showPossibleGridMoves(southLimit, "south");
        showPossibleGridMoves(northLimit, "north");

    }
}

void TurnBasedBattle::showPossibleGridMoves
(int & ref_dirLimit, std::string ref_dir)
{
    GridStatus * ptr_gridstatus;
    ptr_gridstatus = &gridMap[playerDrawList[0]->gridPosition]; //pointing to the the grid the player is on
    for (int i = 0; i < ref_dirLimit; ++i) //ref_dirLimit is the number of movement in that direction possible
    {
        /**
         *  grabDir() allows access to grids next to the grid itself (north/east/south/west)
         *  every GridStatus contains pointers to north/east/south/west of the grid itself
         *  with nullptr assigned when there is no grid in that direction
         **/
        if (ptr_gridstatus->grabDir(ref_dir)->isBlocked() == false) //if not blocked, show next grid;
        {
            ptr_gridstatus = ptr_gridstatus->grabDir(ref_dir);
            showGrid(*ptr_gridstatus);
        }

    }
}

void TurnBasedBattle::showGrid(GridStatus & ref_gridstatus)
{
    ptr_mainWindow->draw(ref_gridstatus.mark);
    mouse_position = sf::Mouse::getPosition(*ptr_mainWindow);
    if (ref_gridstatus.checkMouse(mouse_position)) //if clicked
    {
        displayMoveGrid = false; //stops showing the display grids
        gridMap[playerDrawList[0]->gridPosition].clear(); //gridPosition no longer occupied by player

        //change the player's new gridPosition so that he gets moved in another cpp file...
        playerDrawList[0]->gridPosition = ref_gridstatus.id;
    }
}

 

Thanks for anyone who can help me this.

-Sine