for disch - Snake beta - graphical

[zwA4jE8b]

Here is the graphic version. beta obviously
just remove line 6 and 32 if you want to compile and test


snakemain.cpp

//////////////////////////////////////////////////////////////////////////////////////////////////////////
//Michael Ervin - Windows based graphical snake game - 7/29/2011
//////////////////////////////////////////////////////////////////////////////////////////////////////////

#include <Windows.h>
#include "resource.h"
#include "snakengine.h"

HWND hWnd;
HDC hDC;

//////////////////
game _game;
//////////////////

LRESULT CALLBACK MessageProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);

int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR lpCmdLine,
                   int nCmdShow)
{
	WNDCLASSEXA wc;

	ZeroMemory(&wc, sizeof(WNDCLASSEX));

	wc.cbSize = sizeof(WNDCLASSEX);
	wc.style = CS_HREDRAW | CS_VREDRAW;
	wc.lpfnWndProc = MessageProc;
	wc.hInstance = hInstance;
	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
	wc.hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1)); 
	wc.lpszClassName = "SNAKE";

	RegisterClassExA(&wc);

	hWnd = CreateWindowExA(NULL,
                          "SNAKE", "Snake",
                          WS_SYSMENU | WS_BORDER,
                          0, 45,
                          screen_width, screen_height,
                          NULL, NULL,
                          hInstance,
                          NULL);

	ShowWindow(hWnd, nCmdShow);
	hDC = GetDC(hWnd);

	MSG msg;

	_game.game_init(hDC, hWnd);

	while(TRUE)
	{
		if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
		{
			if(msg.message == WM_QUIT)
				break;
			TranslateMessage(&msg);
			DispatchMessage(&msg);
		}
		else
		{
			_game.game_play();
			Sleep(75);
		}
	}
	return msg.wParam;
}

LRESULT CALLBACK MessageProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch(message)
	{
		case WM_DESTROY:
		{
			PostQuitMessage(0);
			return 0;
		} break;
		case WM_KEYDOWN:
		{
			switch (wParam)
			{
			case _up:
			case _down:
			case _left:
			case _right:
				_game.game_input(wParam);
				break;
			case _pause:
				_game.game_pause();
				break;
			}
			return 0;
		} break;
		case 2345:
			_game.game_over();
			break;
		case 1234:
			_game.game_init(hDC, hWnd);
			break;
     }
     return DefWindowProcA(hWnd, message, wParam, lParam);
 }

[zwA4jE8b]

snakengine.h

//Snake object header
#ifndef H_snakengine
#define H_snakengine

#define screen_width 800
#define screen_height 600

#include <vector>
#include <ctime>

#include <sstream>
#include <string>
std::string convstr(const int& t){std::stringstream itoa; itoa << t; return itoa.str();}

COLORREF _blue = RGB(0,0,255);
COLORREF _red = RGB(255,0,0);
COLORREF _white = RGB(255,255,255);
COLORREF _black = RGB(0,0,0);
COLORREF _green = RGB(0,255,0);
const int _rectwidth = 10, _rectheight = 10, _bordertop = 5, _borderleft = 5,
		  _borderbottom = screen_height - 65, _borderright = screen_width - 9;
const DWORD _up = 0x57, _down = 0x53, _left = 0x41, _right = 0x44, _pause = 0x50;
HBRUSH _bluebrush = CreateSolidBrush(_blue);
HBRUSH _whitebrush = CreateSolidBrush(_white);
HBRUSH _blackbrush = CreateSolidBrush(_black);
HBRUSH _greenbrush = CreateSolidBrush(_green);

std::vector<RECT> _foodgrid, _obstaclegrid;

class level
{
public:
	int _numfood, _numobstacle;

	level(HDC _hDC, int _lvl, int _scr):hDC(_hDC), _level(_lvl), _score(_scr){}

	void init_level()
	{
		draw_level();
		fill_foodobstaclegrid();
	}
	void update_info(int& _score)
	{
		std::string _slevel = convstr(_level);
		std::string _sscore = convstr(_score);
		TextOut(hDC, 60, screen_height - 55, _slevel.c_str(), _slevel.length());
		TextOut(hDC, 145, screen_height - 55, convstr(_score).c_str(), _sscore.length());
	}
private:
	int _level, _score;
	const HDC hDC;
	void draw_level()
	{
		RECT _back = {0,0,screen_width - 6,screen_height - 60};
		RECT _front = {10,10,screen_width - 10,screen_height - 70};
		FillRect(hDC, &_back, _blackbrush);
		FillRect(hDC, &_front, _whitebrush);
	}
	void fill_foodobstaclegrid()
	{
		_numfood = _level * 4;
		_numobstacle = _level * 3;
		int _top, _left, i;
		srand(time(0));

		for(i = 0; i < _numfood; i++)
		{
			_top = 10 + (rand() % (_borderbottom - 20));
			if(_top % 10 != 0)
				_top -= _top % 10;
			_left = 10 + (rand() % (_borderright - 20));
			if(_left % 10 != 0)
				_left -= _left % 10;
			RECT _food = {_left, _top, _left + 10, _top + 10};
			if(_foodgrid.empty())
				_foodgrid.push_back(_food);
			else
				for(int j = 0; j < _foodgrid.size(); j++)
					if(_top == _foodgrid[j].top && _left == _foodgrid[j].left)
					{
						i--;
						break;
					}
					else
					{
						_foodgrid.push_back(_food);
						break;
					}
			FillRect(hDC, &_food, _greenbrush);
		}

		for(i = 0; i < _numobstacle; i++)
		{
			_top = 10 + (rand() % (_borderbottom - 20));
			if(_top % 10 != 0)
				_top -= _top % 10;
			_left = 10 + (rand() % (_borderright - 21));
			if(_left % 10 != 0)
				_left -= _left % 10;
			RECT _obstacle = {_left, _top, _left + 10, _top + 10};
			if(_obstaclegrid.empty())
				_obstaclegrid.push_back(_obstacle);
			else
				for(int j = 0; j < _obstaclegrid.size(); j++)
					if(_top == _obstaclegrid[j].top && _left == _obstaclegrid[j].left)
					{
						i--;
						break;
					}
					else
					{
						_obstaclegrid.push_back(_obstacle);
						break;
					}
			FillRect(hDC, &_obstacle, _blackbrush);
		}
		TextOut(hDC, 15, screen_height - 55, "Level: ", 7);
		TextOut(hDC, 100, screen_height - 55, "Score: ", 7);
	}
	void end_game()
	{

	}
};

class snake
{
	int _lvl, _length, _counter;
	RECT _old;
	std::vector<RECT> _segments;
	
public:
	char _direction;
	snake(int _level):_lvl(_level), _length(_lvl*4), _direction(NULL), _counter(0){}

	void init_snake(int _ystart)
	{
		_segments.resize(0);
		for(int i = 0; i < _length; i++)
		{
			RECT _newseg = {390, _ystart, 390 + _rectwidth, _ystart + _rectheight};
			_segments.push_back(_newseg);
		}
	};
	void add_seg(int _x, int _y)
	{
		RECT _newseg = {_x, _y, _rectwidth, _rectheight};
		_segments.push_back(_newseg);
	}
	void show_head(const HDC& hDC)
	{
			FillRect(hDC, &_segments[0], _bluebrush); 
	}
	void next_pos()
	{
		int i;
		_old = _segments.back();

		for(i = _length - 1; i > 0; i--)
			_segments[i] = _segments[i - 1];
		
		switch (_direction)
		{
		case _right:
			_segments[0].left += _rectwidth;
			_segments[0].right += _rectwidth;
			break;
		case _left:
			_segments[0].left -= _rectwidth;
			_segments[0].right -= _rectwidth;
			break;
		case _up:
			_segments[0].top -= _rectheight;
			_segments[0].bottom -= _rectheight;
			break;
		case _down:
			_segments[0].top += _rectheight;
			_segments[0].bottom += _rectheight;
			break;
		}
	}
	void animate_snake(const HDC& hDC)
	{
		FillRect(hDC, &_segments[0], _bluebrush);

		if (_counter == (4 * _lvl) - 1)
			FillRect(hDC, &_old, _whitebrush);
		else
			_counter++;
	}
	void add_seg()
	{
		RECT _newseg = _segments[_length - 1];
		_segments.push_back(_newseg);
		_length++;
	}
	char collisions()
	{
		int i;
		char _ret = 'n';

		switch (_direction)
		{
		case _up:
			if(_segments[0].top <= _bordertop)
			_ret = 'o';
			break;
		case _down:
			if(_segments[0].bottom >= _borderbottom)
			_ret = 'o';
			break;
		case _left:
			if(_segments[0].left <= _borderleft)
			_ret = 'o';
			break;
		case _right:
			if(_segments[0].right >= _borderright)
			_ret = 'o';
			break;
		}

		for(i = 0; i < _foodgrid.size(); i ++)
			if(_segments[0].top == _foodgrid[i].top && _segments[0].left ==_foodgrid[i].left)
			{
				_ret = 'f';
				break;
			}

		for(i = 0; i < _obstaclegrid.size(); i ++)
			if(_segments[0].top == _obstaclegrid[i].top && _segments[0].left ==_obstaclegrid[i].left)
			{
				_ret = 'o';
				break;
			}

		for(i = 1; i < _length; i++)
			if(_segments[0].top == _segments[i].top && _segments[0].left ==_segments[i].left)
			{
				_ret = 'o';
				break;
			}

		return _ret;
	}
};

class game
{
	level* _LVL;
	snake* _SNK;
	HDC hDC;
	int _level, _score, _foodeaten;
	char _collision;
	HWND _hWnd;

public:
	game():_level(1), _score(0){}
	
	void game_init(HDC _hDC, HWND hWnd)
	{
		_hWnd = hWnd;
		hDC = _hDC;
		
		_foodeaten = 0;

		_LVL = new level(hDC, _level, _score);
		_LVL->init_level();
		_LVL->update_info(_score);

		_SNK = new snake(_level);
		_SNK->init_snake(300);
		_SNK->show_head(hDC);
	}
	void game_input(WPARAM _direction)
	{
		switch (_direction)
		{
		case _up:
			_SNK->_direction = _up;
			break;
		case _down:
			_SNK->_direction = _down;
			break;
		case _left:
			_SNK->_direction = _left;
			break;
		case _right:
			_SNK->_direction = _right;
			break;
		}
	}
	void game_play()
	{
		if(_SNK->_direction != NULL)
		{
				_SNK->next_pos();
				_SNK->animate_snake(hDC);
				switch (_SNK->collisions())
				{
				case 'f':
					_foodeaten++;
					_SNK->add_seg();
					_score += _level * 5;
					break;
				case 'o':
					PostMessage(_hWnd, 2345, 0, 0);
					break;
				case 'n':
					break;
				}
				_LVL->update_info(_score);
				if(_foodeaten == _LVL->_numfood)
				{
					_level++;
					_foodgrid.resize(0);
					_obstaclegrid.resize(0);
					delete _SNK;
					delete _LVL;
					PostMessage(_hWnd, 1234, 0, 0);
				}
		}
	}
	void game_pause()
	{
		
	}
	void game_over()
	{
		PostQuitMessage(0);
	}
};
#endif