1

I'm making a Roguelike game in C, and I can't get my character to move in the way I want it to. I made a 2D char array with the character on it at point (x, y), drew the array, and changed the x and y values and redrew the array upon input of a direction in which to go (kind of like Zork but with graphics). But this isn't working out how I planned. The code will explain more than I can:

/* game.h (header file for globals) */

#define GAME_H

char character = '@';
//char monster = '&';

int x = 2;
int y = 2;

/* my beginning floor
(will not be implemented, just for testing movement) */
char floor[10][6] = { /* 219 = filled block, 32 = space */
        219, 219, 219, 219, 219, 219, 219, 219, 219, '\n',
        219,  32,  32,  32,  32,  32,  32,  32, 219, '\n',
        219,  32,  32,  32,  32,  32,  32,  32, 219, '\n',
        219,  32,  32,  32,  32,  32,  32,  32, 219, '\n',
        219, 219, 219, 219, 219, 219, 219, 219, 219, '\n'};



/* game.c (main file) */
#include <stdio.h>
#include "game.h"

int main(void){
        system("cls");
        floor[x][y] = character;
        printf("%s", floor);
        char move;

        redo:

        printf("\nTravel which way?\n");
        printf("a = left\ns = down\nd = up\nf = right\n\n>");
        scanf("%s", &move);

        /*
        array oftentimes gets desroyed because the newlines are
        being overwritten by the assignments.
        the if statements should have prevented this.
        why didn't they?
        */

        if (move == 'a'){ /* LEFT */
                if (x < 1){
                        x = 1;}
                x--;
                floor[x][y] = character;
                floor[x+1][y] = ' ';
                system("cls");
                printf("%s", floor);
                goto redo;

        } else if (move == 's'){ /* DOWN (works, but goes right. Sometimes clones itself) */
                if (y > 3){
                        y = 3;} /*bounds may be wrong*/
                y++;
                floor[x][y] = character;
                floor[x][y-1] = ' ';
                system("cls");
                printf("%s", floor);
                goto redo;

        } else if (move == 'd'){ /* UP */
                if (y < 1){
                        y = 1;}
                y--;
                floor[x][y] = character;
                floor[x][y+1] = ' ';
                system("cls");
                printf("%s", floor);
                goto redo;

        } else if (move == 'f'){ /* RIGHT */
                if (x > 7){
                        x = 7;}
                x++;
                floor[x][y] = character;
                floor[x-1][y] = ' ';
                system("cls");
                printf("%s", floor);
                goto redo;}
        else {
                goto done;
        }

        done:
        return 0;
}

Can anyone tell me what I'm doing wrong?

Note: This map setup is simply a draft. I'm going to be doing it completely differently once the mechanics are done, but I'll be planning to move the character along the array in much the same way, so I would rather have help with this specific setup rather than advice on how to do it better/differently. However, relevant answers and source code that show better implementation would still be useful and appreciated, since I myself may be doing it totally wrong in the first place, as this is my first Roguelike game.

Dylan LaCoursiere
  • 493
  • 1
  • 8
  • 18
  • 2
    What's the problem with it? Assume most of us won't bother compiling your code if possible. – Pubby Apr 08 '13 at 23:14
  • Well the problem is that the character will not move, say, left if I tell it to move left. If I put in the command to move the character left, it is supposed to move 1 to the left, but it doesn't do that upon repeated invocations of the command. It moves in zig-zag patterns instead of straight, and sometimes the character shows up in multiple places in the array. – Dylan LaCoursiere Apr 08 '13 at 23:19
  • 2
    Well I'll recommend keeping the player and map separate. Use curses library to draw everything rather than printf. Anyway, a brief look at your code makes me think the bounds check for `'s'` is incorrect. – Pubby Apr 08 '13 at 23:24
  • Ah, I'll check the bounds for s. But even if s were not wrong, the other directions mess up too. For example, if I push the character to the rightmost wall and try to make it go past the wall to test the bounds check, the newline gets erased and the array gets destroyed. I have no experience with curses/ncurses, but I'll check it out. – Dylan LaCoursiere Apr 08 '13 at 23:31
  • 1
    You should probably avoid using `floor` as a name since it's also the name of a standard library math function. – luser droog Apr 09 '13 at 01:51
  • Duly noted, thanks. I've named it different things before, I'll just change it again. – Dylan LaCoursiere Apr 11 '13 at 21:07

3 Answers3

3

Your declaration of floor looks a bit weird to me try doing something like this:

//c arrays are generally array[rows][columns]
int rows = 6, cols = 10;
char floor[rows][cols] = {
    {219, 219, 219, 219, 219, 219, 219, 219, 219, '\n'},
    {219,  32,  32,  32,  32,  32,  32,  32, 219, '\n'},
    {219,  32,  32,  32,  32,  32,  32,  32, 219, '\n'},
    {219,  32,  32,  32,  32,  32,  32,  32, 219, '\n'},
    {219, 219, 219, 219, 219, 219, 219, 219, 219, '\n'}};

Example here http://ideone.com/O7UG8g . I changed 219->35 in that example because I don't think printing extended ascii works on that site.

Also I think the bound checks should be something like:

//move left (go one column left)
//if current position is array[curRow][curCol]
//assuming array[0][0] is top left of map
//check if left is a wall
if((curCol - 1) == charForAWall)
   return;
else
   curCol--;

Right would be +1 column, up -1 row, and down +1 row.

Robert Prior
  • 508
  • 4
  • 14
  • I did change the x and y to `rows` and `cols`, that helped a bit. I didn't know whether C arrays were row dominant or column dominant, so this also helped. I rewrote the array and switched the x and the y around, and after messing around with the bounds-checking, it works :) I'll mark this up, thanks for the help – Dylan LaCoursiere Apr 12 '13 at 17:51
2

Given this code:

char character = '@'; 
int x = 2;
int y = 2;

char floor[10][6] = { /* 219 = filled block, 32 = space */
        219, 219, 219, 219, 219, 219, 219, 219, 219, '\n',
        219,  32,  32,  32,  32,  32,  32,  32, 219, '\n',
        219,  32,  32,  32,  32,  32,  32,  32, 219, '\n',
        219,  32,  32,  32,  32,  32,  32,  32, 219, '\n',
        219, 219, 219, 219, 219, 219, 219, 219, 219, '\n'};


/* game.c (main file) */
#include <stdio.h>
#include "game.h"

int main(void){
        system("cls");
        floor[x][y] = character;
        printf("%s", floor); /* print the map and character */

There are several problems. First, your array is not null terminated; it is not safe to print it like that. There are only 5 * 10 = 50 characters in that array, so it is null terminated after all. I didn't notice the miscounting until later. If you had the sixth line of data, you'd have to use:

       printf("%.*s", (int)sizeof(floor), floor);

The other problem is that you've misunderstood the array; it is 10 rows of 6 characters, not 6 rows of 10 characters. 

char floor[10][6] =
{ /* 219 = filled block, 32 = space */
        { 219,  219, 219,  219, 219,  219, },
        { 219,  219, 219, '\n', 219,   32, },
        {  32,   32,  32,   32,  32,   32, },
        { 219, '\n', 219,   32,  32,   32, },
        {  32,   32,  32,   32, 219, '\n', },
        { 219,   32,  32,   32,  32,   32, },
        {  32,   32, 219, '\n', 219,  219, },
        { 219,  219, 219,  219, 219,  219, },
        { 219, '\n' },
};

and, in fact, your data is short a few characters too. However, it will appear OK because of the way you print it, but if you did fully bracketed initialization, you'd find that you had problems if you put the brackets around each line in your original layout.

I'd be tempted to use names instead of numbers for the characters in the initializatio:

enum { WALL = 219, OPEN = 32, ENDL = '\n' };

These are uniformly 4 letters each, making for a more systematic layout in the initializer.

Note that when you place the character at 2,2, you are modifying the array like this:

char floor[10][6] =
{ /* 219 = filled block, 32 = space */
        { 219,  219, 219,  219, 219,  219, },
        { 219,  219, 219, '\n', 219,   32, },
        {  32,   32, '@',   32,  32,   32, },  // Change here!
        { 219, '\n', 219,   32,  32,   32, },
        {  32,   32,  32,   32, 219, '\n', },
        { 219,   32,  32,   32,  32,   32, },
        {  32,   32, 219, '\n', 219,  219, },
        { 219,  219, 219,  219, 219,  219, },
        { 219, '\n' },
};
Jonathan Leffler
  • 730,956
  • 141
  • 904
  • 1,278
  • Wow! This is exactly the explanation I was hoping for! I was wondering what I was doing wrong. I thought that by making the array in the way I did by separating each element with commas that I would be making a grid that is 10 x across and 6 y down, each element being completely independent, and putting a character on there at point x, y would put it x across from the top-left and y down from there, but apparently not. I haven't gotten a chance to change it yet, but I'll tinker with it tonight, and I'll mark as answered if it works. Thanks for the explanation :) – Dylan LaCoursiere Apr 11 '13 at 21:14
  • I switched the x and the y around and my array works much better. I had to rewrite it and tinker with the bounds checking for like 3 hours last night, but I finally got it to work like it's supposed to :) – Dylan LaCoursiere Apr 12 '13 at 17:39
1

There's nothing wrong with the code that handles the moves, it looks like the problem is to do with the way you allocate your array. For starters, you only have 5 columns, not 6. I grouped the elements like this:

char floor[10][5] = {
    {219,219,219,219,219},
    {219,32,32,32,219},
    {219,32,32,32,219},
    {219,32,32,32,219},
    {219,32,32,32,219},
    {219,32,32,32,219},
    {219,32,32,32,219},
    {219,32,32,32,219},
    {219,219,219,219,219},
    {'\n','\n','\n','\n','\n'}
};

And then I wrote another function to print the array (to replace the printf statement, which will no longer work like this) like so:

int printArray() {
    int i, j;

    for(i=0; i<5; i++) {
        for(j=0; j<10; j++) {
            printf("%c", floor[j][i]);
        }
    }
}

The rest of the code then works fine.

mikeyq6
  • 1,138
  • 13
  • 27
  • Thank you, I will try this tonight and get back to you if it works. 1 thing though, from your second sentence: "you only have 5 columns, not 6". The original code I posted was `floor[10][6]`. The code you posted was `floor[10][5]`. Is this a mistake on your part or a misunderstanding on mine? Or were you demonstrating something different altogether and I'm just not following? – Dylan LaCoursiere Apr 11 '13 at 21:19
  • Your printArray() function works beautifully, except I had to change around the i and the j in the printf statement. I'll be using this function a lot. Thanks :D – Dylan LaCoursiere Apr 12 '13 at 17:40
  • That's great! If you look at your original array declaration, you'll see that you have 10 columns of values, but only 5 rows. That's what I meant when I said that you only have 5 (rows actually, rather than columns). Good luck! – mikeyq6 Apr 12 '13 at 21:56