Игра "Крепс"

ACraps.cpp

/*
	Name: ACraps.cpp
	Copyright: just for study
	Author: beginner
	Date: 24.07.15 10:43
	Description: class ACraps realization
*/

#include "ACraps.h"

#include <cstdlib>  // rand()

// конструктор по умолчанию
ACraps::ACraps()
{
	diceSum = 0;
	myPoint = 0;
	
	for (short i = 0; i < ::playingSides; i++){
		diceSide[i] = 0;
	}
	
	gameStatus = BEGIN;
	
	totalWin = 0;
	totalLose = 0;
}	// end ACraps

// бросить кости
void ACraps::rollDice()
{
    resetSum();
	
	for (short i = 0; i < ::playingSides; i++){
		diceSide[i] = getRandom(1);
		diceSum += diceSide[i];
	}
}   // end rollDice

// проверить статус игры (проиграл, выиграл, продолжить)
void ACraps::checkGameStatus()
{
	switch(diceSum){
		case 2:
        case 3:
        case 12: gameStatus = LOST;
                 myPoint = 0;
                 totalLose++;
            break;
		case 7:
        case 11: gameStatus = WON;
                 myPoint = 0;
				 totalWin++;
            break;
		default: gameStatus = CONTINUE;
				 myPoint = diceSum;
            break;
	}
}	// end checkGameStatus

// проверка игры на продолжение
bool ACraps::checkContinue() const
{
	return CONTINUE == gameStatus;
}	// end controlStatus

// проверить бросок на равенство с "очком"
void ACraps::checkMyPoint()
{
	if (myPoint == diceSum){
		gameStatus = WON;
		totalWin++;
	}
	else if (7 == diceSum){
		gameStatus = LOST;
		totalLose++;
	}
}	// end checkMyPoint

// сумма выпавших костей
int ACraps::getSum() const
{
    return diceSum;
}   // end getSum

// "очко"
int ACraps::getMyPoint() const
{
    return myPoint;
}   // end getMyPoint

// статус игры
Status ACraps::getGameStatus() const
{
    return gameStatus;
}   // end getGameStatus

// установить статус по умолчанию
void ACraps::setDefaultStatus()
{
    gameStatus = BEGIN;
}   // end setDefaultStatus

// общее кол-во побед
int ACraps::getTotalWin() const
{
    return totalWin;
}   // end getTotalWin

// общее кол-во поражений
int ACraps::getTotalLose() const
{
    return totalLose;
}   // end getTotalLose

// значение стороны игровой кости
int ACraps::getDiceSide(int side) const
{
    if (side < 0 && side > 1) {
        return diceSide[0];
    }
    else {
        return diceSide[side];
    }
}   // end getDiceSide

// псевдослучайное значение
int ACraps::getRandom(int fromNumber)
{
    return fromNumber + std::rand() % ::diceSides;
}   // getRandom

ACraps.h

/*
	Name: ACraps.h
	Copyright: just for study
	Author: beginner
	Date: 24.07.15 10:43
	Description: class ACraps
*/

#ifndef CRAPS_H_
#define CRAPS_H_

enum Status{BEGIN, WON, LOST, CONTINUE};	    // статус игры

const int diceSides = 6;            // кол-во сторон кубика
const int playingSides = 2;		    // две игровые стороны кубиков

class ACraps
{
    public:
        
        ACraps();                                   // конструктор
        void rollDice();                            // бросить кости
		void checkGameStatus();                     // проверить статус игры (проиграл, выиграл, продолжить)
		bool checkContinue() const;                 // проверка игры на продолжение
		void checkMyPoint();                        // проверить бросок на равенство с "очком"
        int getSum() const;                         // сумма выпавших костей
        int getMyPoint() const;                     // "очко"
		Status getGameStatus() const;               // статус игры
		void setDefaultStatus();                    // установить статус по умолчанию
		int getTotalWin() const;                    // общее кол-во побед
		int getTotalLose() const;                   // общее кол-во поражений
	    int getDiceSide(int side) const;            // значение стороны игровой кости
	    int getRandom(int fromNumber = 0);          // псевдослучайное значение
		
    private:
        
        void resetSum() { diceSum = 0; }            // сбросить сумму
        
		Status gameStatus;				            // статус игры CONTINUE, WON or LOST
		
		int diceSide[::playingSides];	            // значение двух игровых сторон кубиков
        int diceSum;						        // сумма выпавшая на двух костях
		int myPoint;						        // "point"("очко" -- игра продолжается)
		int totalLose;                              // всего проигрышей
		int totalWin;                               // всего выгрышей
        
};  // end class ACraps

#endif  // end CRAPS_H_

AKeypad.cpp

// реализация класса AKeypad

#include "AKeypad.h"

#include <conio.h>

// конструктор по умолчанию
AKeypad::AKeypad()
{
    state = NO_CMD;
    isMoved = false;
    previousPosition = 0;
    currentPosition = 0;
}   // конец AKeypad

// возвращает предыдущее значение положения курсора
int AKeypad::getPrevPos() const
{
    return previousPosition;
}   // конец функции getPrevPos

// возвращает текущее значение положения курсора
int AKeypad::getCurrPos() const
{
    return currentPosition;
}   // конец функции getCurrPos

// перемещение курсора в четыре стороны
void AKeypad::movement(int size)
{
    state = NO_CMD;
    isMoved = false;
    int input;

    input = _getch();

    if (0xe0 == input){
        input = _getch();
    }

    switch(input){
        case UP:
        case LEFT:
            if (0 == currentPosition){
                previousPosition = currentPosition;
                currentPosition = size - 1;
            }
            else{
                previousPosition = currentPosition;
                currentPosition--;
            }
            isMoved = true;
            break;
        case DOWN:
        case RIGHT:
            if (size - 1 == currentPosition){
                previousPosition = currentPosition;
                currentPosition = 0;
            }
            else{
                previousPosition = currentPosition;
                currentPosition++;
            }
            isMoved = true;
            break;
        case ENTER: state = ENTER; break;
        default: break;
    }
}   // конец функции fourWayMovment

// проверка на ввод клавиши <Enter>
bool AKeypad::isEnter() const
{
    return state == ENTER;
}   // конец функции isEnter

// проверка был ли перемещен курсор
bool AKeypad::isCursMoved() const
{
    return isMoved;
}   // конец функции isMoved

// сброс данных
void AKeypad::resetData()
{
    state = NO_CMD;
    previousPosition = 0;
    currentPosition = 0;
}   // конец функции resetData

AKeypad.h

// определение класса AKeypad

#ifndef AKEYPAD_H_
#define AKEYPAD_H_

class AKeypad
{
public:
    
    AKeypad();                              // конструктор
    int getPrevPos() const;                 // возвращает предыдущее значение положения курсора
    int getCurrPos() const;                 // возвращает текущее значение положения курсора
    void movement(int size = 1);            // перемещение курсора
    bool isEnter() const;                   // проверка на ввод клавиши <Enter>
    bool isCursMoved() const;               // проверка был ли перемещен курсор
    void resetData();                       // сброс данных

private:
    
    enum State {NO_CMD = 0, ENTER = 13, UP = 72, LEFT = 75, RIGHT = 77, DOWN = 80}
         state;
    bool isMoved;
    int previousPosition;
    int currentPosition;

};

#endif	// AKEYPAD_H_

AScreen.cpp

/*
	Name: AScreen.cpp
	Copyright: just for study
	Author: beginner
	Date: 25.07.15 23:30
	Description: class AScreen realization 
*/

#include "AScreen.h"

// конструктор по умолчанию
AScreen::AScreen()
{
    hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);

    GetConsoleCursorInfo(hStdOut, &oldCurInfo);
    curCurInfo.dwSize = oldCurInfo.dwSize;
    curCurInfo.bVisible = oldCurInfo.bVisible;

    CONSOLE_SCREEN_BUFFER_INFO csbi;
    GetConsoleScreenBufferInfo(hStdOut, &csbi);
    oldTextAttr = csbi.wAttributes;
}   // конец AScreen

// деструктор
AScreen::~AScreen()
{
    SetConsoleTextAttribute(hStdOut, oldTextAttr);
    SetConsoleCursorInfo(hStdOut, &oldCurInfo);
}   // конец ~AScreen

// установка позиции курсора
void AScreen::setCursPos(int x, int y)
{
    COORD coord = { static_cast<SHORT>(x), static_cast<SHORT>(y) };
    SetConsoleCursorPosition(hStdOut, coord);
}   // конец функции setCursPos

// установка начального цвета для фона и шрифта
void AScreen::setOldConsTextAttr()
{
    SetConsoleTextAttribute(hStdOut, oldTextAttr);
}   // конец функции setOldConsTextAtrr

// установка цвета для фона и шрифта
void AScreen::setConsTextAttr(WORD attr)
{
    SetConsoleTextAttribute(hStdOut, attr);
}   // конец функции setConsTextAttr

// установка видимости курсора
void AScreen::setCursVisible(bool visible) {
    curCurInfo.bVisible = visible;
    SetConsoleCursorInfo(hStdOut, &curCurInfo);
}   // конец функции setCursVisible

AScreen.h

/*
	Name: AScreen.h
	Copyright: just for study
	Author: beginner
	Date: 25.07.15 23:28
	Description: class AScreen
*/

#ifndef ASCREEN_H_
#define ASCREEN_H_

#include <windows.h>

class AScreen
{
    public:
        
        AScreen();                                      // конструктор
        ~AScreen();                                     // деструктор
        void setCursPos(int x, int y);                  // установка позиции курсора
        void setOldConsTextAttr();                      // установка начального цвета для фона и шрифта
        void setConsTextAttr(WORD attr);                // установка цвета для фона и шрифта
        void setCursVisible(bool visible = false);      // установка видимости курсора
        void cleanScreen() { system("cls"); }           // очистка экрана
    
    private:
        
        HANDLE hStdOut;
        WORD oldTextAttr;
        CONSOLE_CURSOR_INFO oldCurInfo, curCurInfo;
        
};  // конец класса AScreen

#endif  // ASCREEN_H_

AView.cpp

/*
	Name: AView.cpp
	Copyright: just for study
	Author: beginner
	Date: 26.07.15 23:32
	Description: class AView realization
*/

#include "AView.h"

#include <iostream>
#include <cstring>      // strlen
#include <cstdlib>		// rand()
#include <ctime>		// clock()

const int colorsSize = 5;                             // размер массива defaultColors
// цвета
const WORD defaultColors[colorsSize] = { 0x1E,        // 0: фон - синий, шрифт - светло-желтый
                                         0xE0,        // 1: фон - желтый, шрифт - черный
                                         0xF0,        // 2: фон - ярко-белый, шрифт - черный
                                         0x2E,        // 3: фон - зеленый, шрифт - светло-желтый
                                         0xE2 };      // 4: фон - светло-желтый, шрифт - светло-зеленый
                                         
const char spot = 'o';                      // символ для "дырочек" на костях

const int rulesSize = 11;                            // размер массива gameRules
const char* gameRules[::rulesSize] = { "ПРАВИЛА ИГРЫ \"КРЕПС\"\n\n",
                            			" Бросте кубики первый раз. Если при первом броске",
                            			"сумма чисел выпавших на кубиках равна 7 или 11 -\n",
                            			"вы выиграли, если сумма составила 2, 3 или 12 -\n",
                            			"вы проиграли.\n",
                            			" В случае выпадения другой суммы, выпавшая сумма\n",
                            			"становится вашим \"очком\". Вы продолжаете бросать\n",
                            			"кости до тех пор, пока сумма выпавших костей не\n",
                            			"будет равна \"очку\". В этом случае вы выиграли.\n",
                            			"В случае выпадения суммы равной 7 -- вы проиграли.\n",
                            			"УДАЧИ !!!"
                                     };

// конструктор по умолчанию
AView::AView()
{
    workWidth = 0;
    startPosition.x = 0;
    startPosition.y = 0;
}   // end AView

// конструктор
AView::AView(const int xCoord, const int yCoord, int width)
{
    workWidth = width;
    startPosition.x = xCoord;
    startPosition.y = yCoord;
}   // end AView

// заставка
void AView::backdrop(const Coord & c, ACraps & craps, const char* title)
{
    if (WON == craps.getGameStatus()) {
        screen.setConsTextAttr(::defaultColors[3]);
    }
    else if (LOST == craps.getGameStatus()) {
        screen.setConsTextAttr(::defaultColors[4]);
    }
    else {
        screen.setConsTextAttr(::defaultColors[0]);
    }
    
    for (int i = 0; i < 3; i++) {
        screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y + i);
        line(workWidth - 6);
        std::cout << std::endl;
    }
    
    headline(title, startPosition.x + c.x, startPosition.y + c.y + 1);
    
    screen.setOldConsTextAttr();
}   // end backdrop

// главное меню
void AView::menu(Coord & c, const char* menu[], int size)
{
    for (int i = 0; i < size; i++) {
        screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y + i);
        if (!i) {
            screen.setConsTextAttr(::defaultColors[1]);
            line(workWidth - 8);
            screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y + i);
            std::cout << menu[i];
            screen.setOldConsTextAttr();
        }
        else {
            std::cout << menu[i];
        }
    }
}   // end menu

// изменить позицию строки подсветки главного меню
void AView::changeLinePos(const char* menu[], int prevPos, int currPos, const Coord & c)
{
    screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y + prevPos);
    line(workWidth - 8);                                // прорисовка предыдущего положения строки
    screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y + prevPos);
    std::cout << menu[prevPos];
    screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y + currPos);
    screen.setConsTextAttr(::defaultColors[1]);
    line(workWidth - 8);                                // прорисовка текущего положения строки
    screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y + currPos);
    std::cout << menu[currPos];
    screen.setOldConsTextAttr();
}   // end changeLinePos

// инициализация указателя на функции отображения костей
void (*AView::pdice[::diceSides])(const Coord & c, AScreen & screen, int random) = {one, two, three, four, five, six};

// эмуляция вращения костей
void AView::rollingDice(const Coord & c, ACraps & craps)
{
    screen.setConsTextAttr(::defaultColors[2]);
    
    double seconds;
    Coord temp = {startPosition.x + c.x, startPosition.y + c.y};

    // цикл проходит 10 раз на каждом проходе увеличивая время задержки

	for (int i = 1; i < 520; i *= 2){
		dice(c);
		
		(*pdice[craps.getRandom(0)])(temp, screen, craps.getRandom(1));
        temp.x += 8;
		(*pdice[craps.getRandom(0)])(temp, screen, craps.getRandom(1));
		temp.x -= 8;

		seconds = i / 800.0;		// доли секунды увеличиваются на каждом проходе цикла
		
		clock_t dely = static_cast<clock_t>(seconds * CLOCKS_PER_SEC);	// delay
		clock_t start = clock();
		while (clock() - start < dely)
			;
			
		throwResult(c, craps);
	}	// end for (turning dice)
	    
    screen.setOldConsTextAttr();
}   // end rollingDice

// отображение выпавших костей
void AView::throwResult(const Coord & c, ACraps & craps)
{
    screen.setConsTextAttr(::defaultColors[2]);
    
	Coord temp = {startPosition.x + c.x, startPosition.y + c.y};
	
	dice(c);
	
	(*pdice[craps.getDiceSide(0) - 1])(temp, screen, craps.getRandom(1));
	temp.x += 8;
	(*pdice[craps.getDiceSide(1) - 1])(temp, screen, craps.getRandom(1));
	temp.x -= 8;
	
}   // end showThrowResult

// отображение суммы на костях
void AView::sum(const Coord & c, const ACraps & craps)
{
    screen.setOldConsTextAttr();
    screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y);
    line(workWidth);
    screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y);
    
    std::cout << "Sum: " << craps.getSum();
}   // end sum

// отображение значения "очка"
void AView::point(const Coord & c, const ACraps & craps)
{	
    if (craps.getMyPoint()){
	    screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y);
        line(workWidth);
	    screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y);
		std::cout << "Point: " << craps.getMyPoint();		
	}
	
}	// end point

// отображение строки посредине
void AView::string(const char* str, int x, int y)
{
    int strLength = strlen(str);                          // длина строки str
    int whiteLine = (workWidth - strLength) / 2;          // отступ от начала заголовка

    screen.setCursPos(x, y);

    for (int i = 0, j = 0; i < workWidth; i++){
        if (i >= whiteLine && j < strLength){
            std::cout << str[j];                          // отображение строки
            j++;
            continue;
        }
        std::cout << ' ';
    }
}   // end string

// отображение информации
void AView::information(const Coord & c, const char* info, int color)
{
    screen.setConsTextAttr(::defaultColors[checkColor(color)]);
    screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y);
    
    int strLength = strlen(info);                        // длина строки info
    int whiteLine = (workWidth - strLength) / 2;         // отступ от начала заголовка
    
    for (int i = 0, j = 0; i < workWidth; i++){
        if (i >= whiteLine && j < strLength){
            std::cout << info[j];                        // отображение строки
            j++;
            continue;
        }
        std::cout << ' ';
    }
    
    screen.setOldConsTextAttr();
}   // end information

void AView::total(ACraps & craps, const Coord & c)
{
    screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y);
    std::cout << "Wins: " << craps.getTotalWin();
    screen.setCursPos(startPosition.x + c.x - 1, startPosition.y + c.y + 1);
    std::cout << "Loses: " << craps.getTotalLose();
}   // end total

// отображение правил игры
void AView::rules(const Coord & c)
{
    for (int i = 0; i < ::rulesSize; i++) {
        screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y + i);
        std::cout << ::gameRules[i];
    }
}   // end rules

// ------------------- функции-члены private -----------------------------------

// отображение строки заданной длины
void AView::line(int width) const
{
    for (int i = 0; i < width; i++) {
        std::cout << ' ';
    }
}   // end line

// отображение заглавия
void AView::headline(const char* title, int x, int y)
{
    int titleLength = strlen(title);                        // длина строки title
    int whiteLine = (workWidth - 6 - titleLength) / 2;      // отступ от начала заголовка

    screen.setCursPos(x, y);

    for (int i = 0, j = 0; i < workWidth - 6; i++){
        if (i >= whiteLine && j < titleLength){
            std::cout << title[j];                          // отображение строки
            j++;
            continue;
        }
        
        std::cout << ' ';
    }
}   // end headline

// отображение поля для костей
void AView::dice(const Coord & c)
{   
    for (int i = 0; i < 3; i++) {
        screen.setCursPos(startPosition.x + c.x, startPosition.y + c.y + i);
        line(5);
    }
    
    for (int j = 0; j < 3; j++) {
        screen.setCursPos(startPosition.x + c.x + 8, startPosition.y + c.y + j);
        line(5);
    }    
}   // end dice

// проверка на выход за пределы массва defaultColors
int AView::checkColor(int c) const
{
    if (c < 0 && c >= ::colorsSize){
        return 0;
    }
    else {
        return c;
    }
}   // end checkColor

// ------------------- функции отображения "дырочек" на костях -----------------

// отображение единицы
void one(const Coord & c, AScreen & screen, int random)
{
    screen.setCursPos(c.x + 2, c.y + 1);
    std::cout << ::spot;
}   // end one

// отображение двойки
void two(const Coord & c, AScreen & screen, int random)
{
    if (random % 2) {
        screen.setCursPos(c.x, c.y);
        std::cout << ::spot;
        screen.setCursPos(c.x + 4, c.y + 2);
        std::cout << ::spot;
    }
    else {
        screen.setCursPos(c.x + 4, c.y);
        std::cout << ::spot;
        screen.setCursPos(c.x, c.y + 2);
        std::cout << ::spot;
    }
}   // end two

// отображение тройки
void three(const Coord & c, AScreen & screen, int random)
{
    if (random % 2) {
        screen.setCursPos(c.x, c.y);
        std::cout << ::spot;
        screen.setCursPos(c.x + 2, c.y + 1);
        std::cout << ::spot;
        screen.setCursPos(c.x + 4, c.y + 2);
        std::cout << ::spot;
    }
    else {
        screen.setCursPos(c.x + 4, c.y);
        std::cout << ::spot;
        screen.setCursPos(c.x + 2, c.y + 1);
        std::cout << ::spot;
        screen.setCursPos(c.x, c.y + 2);
        std::cout << ::spot;
    }
}   // end three

// отображение четверки
void four(const Coord & c, AScreen & screen, int random)
{
    screen.setCursPos(c.x, c.y);
    std::cout << ::spot;
    screen.setCursPos(c.x + 4, c.y);
    std::cout << ::spot;
    
    screen.setCursPos(c.x, c.y + 2);
    std::cout << ::spot;
    screen.setCursPos(c.x + 4, c.y + 2);
    std::cout << ::spot;
}   // end four

// отображение пятерки
void five(const Coord & c, AScreen & screen, int random)
{    
    screen.setCursPos(c.x, c.y);
    std::cout << ::spot;
    screen.setCursPos(c.x + 4, c.y);
    std::cout << ::spot;
    
    screen.setCursPos(c.x + 2, c.y + 1);
    std::cout << ::spot;
    
    screen.setCursPos(c.x, c.y + 2);
    std::cout << ::spot;
    screen.setCursPos(c.x + 4, c.y + 2);
    std::cout << ::spot;
}   //end five

// отображение шестерки
void six(const Coord & c, AScreen & screen, int random)
{
    if (random % 2) {
        screen.setCursPos(c.x, c.y);
        std::cout << ::spot;
        screen.setCursPos(c.x + 4, c.y);
        std::cout << ::spot;
        
        screen.setCursPos(c.x, c.y + 1);
        std::cout << ::spot;
        screen.setCursPos(c.x + 4, c.y + 1);
        std::cout << ::spot;
        
        screen.setCursPos(c.x, c.y + 2);
        std::cout << ::spot;
        screen.setCursPos(c.x + 4, c.y + 2);
        std::cout << ::spot;
        
    }
    else {
        screen.setCursPos(c.x, c.y);
        std::cout << ::spot;
        screen.setCursPos(c.x + 2, c.y);
        std::cout << ::spot;
        screen.setCursPos(c.x + 4, c.y);
        std::cout << ::spot;
        
        screen.setCursPos(c.x, c.y + 2);
        std::cout << ::spot;
        screen.setCursPos(c.x + 2, c.y + 2);
        std::cout << ::spot;
        screen.setCursPos(c.x + 4, c.y + 2);
        std::cout << ::spot;
    }
}   // end six

AView.h

/*
	Name: AView.h
	Copyright: just for study
	Author: beginner
	Date: 26.07.15 23:32
	Description: class AView
*/

#ifndef AVIEW_H_
#define AVIEW_H_

#include "AConstants.h"
#include "AScreen.h"
#include "ACraps.h"

struct Coord                 // структура для хранения координат вывода на экран
{
    int x;
    int y;
};

class AView
{
    public:
        
        AView();                                                                // конструктор
        // конструктор, параметры: начальные координаты игрового пространства, ширина игрового пространства
        AView(const int xCoord, const int yCoord, int width);
        void backdrop(const Coord & c, ACraps & craps, const char* title);      // заставка
        void menu(Coord & c, const char* menu[], int size);                     // главное меню
        // изменить позицию строки подсветки главного меню
        void changeLinePos(const char* menu[], int prevPos, int currPos, const Coord & c);
        void rollingDice(const Coord & c, ACraps & craps);                      // эмуляция вращения костей
        void sum(const Coord & c, const ACraps & craps);                        // отображение суммы на костях
        void point(const Coord & c, const ACraps & craps);                      // отображение значения "очка"
        void string(const char* str, int x, int y);                             // отображение строки посредине
        // отображение информации
        void information(const Coord & c, const char* info, int color = 0);
        void total(ACraps & craps, const Coord & c);                            // отображение общих результатов игры
        void rules(const Coord & c);                                            // отображение правил игры
	
    private:
        
        void line(int width) const;                                             // отображение строки заданной длины
        void headline(const char* title, int x, int y);                         // заглавие
        void dice(const Coord & c);                                             // отображение поля для костей
        void throwResult(const Coord & c, ACraps & craps);                      // отображение выпавших костей
        int checkColor(int c) const;                                            // проверка на выход за пределы массва defaultColors
        
        // массив указателей на функции отображения костей
        static void (*pdice[diceSides])(const Coord & c, AScreen & screen, int random);
        
        int workWidth;                                                          // ширина игрового пространства
        Coord startPosition;                                                    // начальные координаты
        AScreen screen;
        
};  // end class AView

void one(const Coord & c, AScreen & screen, int random);      // отображение единицы
void two(const Coord & c, AScreen & screen, int random);      // отображение двойки
void three(const Coord & c, AScreen & screen, int random);    // отображение тройки
void four(const Coord & c, AScreen & screen, int random);     // отображение четверки
void five(const Coord & c, AScreen & screen, int random);     // отображение пятерки
void six(const Coord & c, AScreen & screen, int random);      // отображение шестерки

#endif  // end AVIEW_H_

mainACraps.cpp

/*
	Name: mainACraps.cpp
	Copyright: just for study
	Author: beginner
	Date: 26.07.15 23:32
	Description: game craps
*/

#include "AScreen.h"
#include "AView.h"
#include "AKeypad.h"
#include "ACraps.h"

#include <iostream>
#include <clocale>      // setlocale()
#include <cstdlib>		// srand()
#include <ctime>		// time()
#include <windows.h>    // Sleep()

const int menuSize = 3;                                     // размер главного меню
const char* menu[menuSize] = { "Start", "Rules", "Quit" };  // содержание главного меню
const char* copyright = "(c) beginner";                     // копирайт
const char* year = "2015";                                  // год
const char* yesNo[] = { "Yes", "No" };                      // меню выбора

void start(ACraps & craps, AView & view, AScreen & screen);     // приветствие
void end(ACraps & craps, AView & view, AScreen & screen);       // завершение

int main()
{
    setlocale(LC_ALL, "Russian");
    
    // массив структур для координат позиционирования курсора
    Coord coord[] = { {3, 1},       // 0: координаты заставки
                      {4, 5},      // 1: начальные координаты меню
                      {0, 0},       // 2: начальные координаты отображения костей
                      {3, 5},       // 3: начальное положение вывода суммы
                      {2, 6},       // 4: начальное положение вывода "очка"
                      {0, 8},       // 5: начальное положение вывода информации
                      {4, 10},      // 6: начальное отображение меню: да, нет
                      {-17, 0},     // 7: координаты отображения правил игры
                      {3, 5}      // 8: координаты отображения общего результата игры
                    };              
    
    AScreen screen;
    AView view(33, 7, 13);  // инициализация объекта начальными координатами х и у и шириной игрового пространства
    AKeypad keypad;
    ACraps craps;
    
    screen.setCursVisible();                                                    // скрыть курсор

    std::srand(static_cast<unsigned int>(std::time(0)));	                    // засеять время
    
    start(craps, view, screen);             // заставка приветствия
    
    do {
        
        view.backdrop(coord[0], craps, "CRAPS");                                // отображение заставки
        view.menu(coord[1], ::menu, ::menuSize);                                // отображение главного меню
        
        do {                                                                    // перемещение курсора
            keypad.movement(::menuSize);
            if (keypad.isCursMoved()) {
                view.changeLinePos(menu, keypad.getPrevPos(), keypad.getCurrPos(), coord[1]);
            }
        } while (!keypad.isEnter());
        
        if (::menuSize - 1 != keypad.getCurrPos()){
            screen.cleanScreen();                                               // очистка экрана
            switch(keypad.getCurrPos()){
                
                case 0:
                    
                    do {
                        craps.rollDice();                                       // бросок костей
                        
                        view.rollingDice(coord[2], craps);                      // эмуляция вращения костей
                        
                        craps.checkGameStatus();                                // проверка игры (выиграл, проиграл, продолжить)
                        
    			        view.sum(coord[3], craps);                              // отображение суммы броска
                        
                        if (craps.getMyPoint()) {
                            view.point(coord[4], craps);                        // отображение "очка"
                        }          
    			        
                        while (craps.checkContinue()) {	                        // проверка игры на продолжение
            				
            				view.information(coord[5], "THROW AGAIN", 3);
            				                             
            				do {                                                // нажатие клавиши <Enter>
                                keypad.movement();
                            } while (!keypad.isEnter());
            				
            				screen.cleanScreen();                               // очистка экрана
            				
            				view.point(coord[4], craps);                        // отображение "очка"
            				
            				craps.rollDice();                                   // бросок костей
            				
                            view.rollingDice(coord[2], craps);                  // эмуляция вращения костей
                            view.sum(coord[3], craps);                          // отображение суммы броска
            				
            				craps.checkMyPoint();		                        // сравнить "очко" с результатом броска
    			        }
    			        
    			        if (WON == craps.getGameStatus()) {
                            view.backdrop(coord[0], craps, "WIN");
                        }
                        else if (LOST == craps.getGameStatus()) {
                            view.backdrop(coord[0], craps, "LOSE");
                        }
    			        
    			        craps.setDefaultStatus();                               // установить статус игры по умолчанию
    			        
    			        view.information(coord[5], "CONTINUE?");                // запрос на продолжение
    			        view.menu(coord[6], yesNo, menuSize - 1);               // отображение меню
    			        
                        do {                                                    // перемещение курсора

                            keypad.movement(menuSize - 1);
                            if (keypad.isCursMoved()) {
                                view.changeLinePos(yesNo, keypad.getPrevPos(), keypad.getCurrPos(), coord[6]);
                            }
                        } while (!keypad.isEnter());
    			        
                        screen.cleanScreen();                                   // очистка экрана
                        
                    } while (::menuSize - 2 != keypad.getCurrPos());
                    
                    view.backdrop(coord[0], craps, "TOTAL");                    // отображение заставки
                    view.total(craps, coord[8]);
                    
                    do {                                                        // нажатие клавиши <Enter>
                        keypad.movement();
                    } while (!keypad.isEnter());
                    
                    break;
                    
                case 1:
                    view.rules(coord[7]);                                       // отображение заставки
                    
                    do {                                                        // нажатие клавиши <Enter>
                        keypad.movement();
                    } while (!keypad.isEnter());
                    
                    keypad.resetData();                                         // очистка данных клавиатурного ввода
                    screen.cleanScreen();                                       // очистка экрана
                    
                    break;
                case 2: /* Quit */ break;
                default: std::cout << "Unexpected command."; break;
            }            
        }
        
    } while (::menuSize - 1 != keypad.getCurrPos() && ::menuSize != keypad.getCurrPos() + 2);    
                
    screen.cleanScreen();                                                       // очистка экрана
    view.backdrop(coord[0], craps, "BYE");                                      // отображение заставки
    view.string(::copyright, 33, 12);                                           // отображение копирайта
    view.string(::year, 33, 13);                                                // отображение года
    
    do {                                                                        // нажатие клавиши <Enter>
        keypad.movement();
    } while (!keypad.isEnter());

    end(craps, view, screen);
    
    return 0;
}

// заставка запуска программы
void start(ACraps & craps, AView & view, AScreen & screen)
{
    Coord tempBackDrop = {3, 12};
    Coord tempMenu = {4, -7};
    
    Sleep(300);
    for (int i = 0; i < 12; i++) {
        view.backdrop(tempBackDrop, craps, "CRAPS");                            // отображение заставки
        tempBackDrop.y--;
        view.menu(tempMenu, ::menu, ::menuSize);
        tempMenu.y++;
        Sleep(10);
        screen.cleanScreen();
    }
}   // end start

// заставка завершения программы
void end(ACraps & craps, AView & view, AScreen & screen)
{
    Coord tempBackDrop = {3, 1};
    
    for (int i = 0; i < 9; i++) {
        view.backdrop(tempBackDrop, craps, "BYE");
        tempBackDrop.y--;
        view.string(::copyright, 33, 12 + i);                                     // отображение копирайта
        view.string(::year, 33, 13 + i);                                          // отображение года
        Sleep(10);
        screen.cleanScreen();
    }
}