Using 2D-array as a workspace - c++

Question

I am working on a snake game and made a prototype. I have attached the code. It may not be so good but still it is messy. I could make it move but I don't know why the lower bound region is flickering. How to reduce this overall flickering, which almost makes me dizzy? Also, one more question: How to make the character move (like in the original snake game), not wait until my command? Please help me! Sorry for the language.
#include<iostream.h>
#include<stdlib.h>
#include<windows.h>
int main() {
char a[25][80]={0};
system("Color 0");
int x=40,y=15;
int m=0,n;
a[16][2]='X';
a[y][x]='O';
for(int i=0;i<25;++i) {
for(int j=0;j<80;++j) cout<<a[i][j];
}
while(m!=1000) {
Sleep(70);
if(GetAsyncKeyState(VK_LEFT)) {
a[y][x]=0;
x--;++m;a[y][x]='O';
}
if(GetAsyncKeyState(VK_RIGHT)) {
a[y][x]=0;
x++;
++m;
a[y][x]='O';
}
if(GetAsyncKeyState(VK_UP)) {
a[y][x]=0;
y--;
++m;
a[y][x]='O';
}
if(GetAsyncKeyState(VK_DOWN)) {
a[y][x]=0;
y++;
++m;
a[y][x]='O';
}
system("cls");
for(int i=0;i<25;++i) {
for(int j=0;j<80;++j) cout<<a[i][j];
}
}
}
return 0;
}

Answer 1

Youve chosen a graphics rendering method which nobody ever planned to be flicker-free. You need to draw graphics to a window, or learn how to use the windows console functions. Considering your tight timetable, I suggest you just ignore the flickering.
To make the snake continue to move, remember the last direction the player moved the snake; if there is no key pressed, then move that direction.
Your code doesn't compile as-is. Practice copying and pasting harder (copy it back out of stackoverflow into your compiler to make sure it works)

Answer 2

to overcome on flickering you have to reduce your system ("cls") time. and after one turn, your code is not giving other feed for snake. make it in loop.
and also make boundary wall of your map so that one can understand scope of map. and when you press any movement key, you have to run loop for its movement so that it move continuously .Hope that will help.

Answer 3

You can partially avoid flickering considering that you can draw your "screen" without clearing it before. For example, in the windows console environment (which apparently you are using), this function can be used to clear the screen instead of system("cls"):
void clear_screen ( void ) {
DWORD n; /* Number of characters written */
DWORD size; /* number of visible characters */
COORD coord = {0,0}; /* Top left screen position */
CONSOLE_SCREEN_BUFFER_INFO csbi;
/* Get a handle to the console */
HANDLE h = GetStdHandle ( STD_OUTPUT_HANDLE );
GetConsoleScreenBufferInfo ( h, &csbi );
/* Find the number of characters to overwrite */
size = csbi.dwSize.X * csbi.dwSize.Y;
/* Overwrite the screen buffer with whitespace */
FillConsoleOutputCharacter ( h, TEXT ( ' ' ), size, coord, &n );
GetConsoleScreenBufferInfo ( h, &csbi );
FillConsoleOutputAttribute ( h, csbi.wAttributes, size, coord, &n );
/* Reset the cursor to the top left position */
SetConsoleCursorPosition ( h, coord );
}
Reading the code, you can notice that it overwrites the screen with enough spaces and then resets the cursor position to the top left position. So, instead of blanking the screen and then drawing the strings, we can set the cursor at the origin and then write our string, which already contains spaces.
Moreover, we can use a mono dimensional null terminated array of char, big enough to represent the whole screen. You use a size of 80x25, but in Windows the console is bigger (at least mine is ~100 char wide), so I'll consider a size of 81x25 putting a \n in the extra char of every row. So I end up with this:
void update_screen ( char *buffer )
{
COORD coord = {0,0}; /* Top left screen position */
/* Get a handle to the console */
HANDLE h = GetStdHandle ( STD_OUTPUT_HANDLE );
/* Reset the cursor to the top left position */
SetConsoleCursorPosition ( h, coord );
/* Draw the screen buffer */
cout << buffer;
}
To make your character move you have to update its position every time you draw it and change direction of movement only when a key is pressed. It's better to check for bounds collision too, at least to stop the game:
#include<iostream>
#include<stdlib.h>
#include<windows.h>
#include<string>
using std::cout;
using std::string;
const int scr_rows = 25;
const int scr_cols = 80;
constexpr int buf_rows = scr_rows;
constexpr int buf_cols = scr_cols + 1;
constexpr int buf_size = scr_rows * buf_cols;
void draw( char *buf, int x, int y, char c) {
// warning, unchecked out of bounds;
buf[y * buf_cols + x] = c;
}
char value_at( char *buf, int x, int y ) {
// warning, unchecked out of bounds;
return buf[y * buf_cols + x];
}
int main() {
// initialize buffer
char screen[buf_size + 1];
for ( int i = 0, pos = 0; i < scr_rows; ++i ) {
for ( int j = 0; j < scr_cols; ++j ) {
screen[pos] = ' ';
++pos;
}
screen[pos] = '\n';
++pos;
}
screen[buf_size] = '\0';
clear_screen();
int x = 40, y = 15;
draw(screen, 2, 16,'X');
draw(screen, x, y, 'O');
int vx = -1;
int vy = 0;
bool victory = false;
while( !GetAsyncKeyState(VK_ESCAPE) ) {
Sleep(100);
if (GetAsyncKeyState(VK_LEFT)) {
vx = -1;
vy = 0;
}
if (GetAsyncKeyState(VK_RIGHT)) {
vx = 1;
vy = 0;
}
if (GetAsyncKeyState(VK_UP)) {
vx = 0;
vy = -1;
}
if (GetAsyncKeyState(VK_DOWN)) {
vx = 0;
vy = 1;
}
draw(screen, x, y, ' ');
x += vx;
y += vy;
// check bounds
if ( x < 0 || x >= scr_cols || y < 0 || y >= scr_rows )
break;
if ( 'X' == value_at(screen, x, y) ) {
victory = true;
break;
}
draw(screen, x, y, 'O');
update_screen(screen);
}
if ( victory )
cout << "\n **** You win! ****\n";
else
cout << "\n **** You loose! ****\n";
return 0;
}