//13.1 - The Random Color Program -Dirk Henkemans
#include <windows.h>
#include <cstdlib>
#include <ctime>
#include <ddraw.h>

LRESULT CALLBACK WndProc(HWND hWnd, UINT nMsg, WPARAM wParam,
          LPARAM lParam);

LPDIRECTDRAW7 g_pdd; //the DirectDraw object
LPDIRECTDRAWSURFACE7 g_pddsprimary; //the primary surface
LPDIRECTDRAWSURFACE7 g_pddsback; //the back buffer
LPDIRECTDRAWSURFACE7 g_pddsone; //a temporary surface
DDSURFACEDESC2 ddsd; //used to store surface descriptions
DDSCAPS2 ddsc; //stores the capabilities of a surface
HRESULT hRet; //used to temporarily store the result of a function

int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPreInst,
        LPSTR lpszCmdLine, int nCmdShow)
{
  HWND  hWnd;
  MSG   msg;
  WNDCLASSEX    wc;

  //fill the WNDCLASSEX structure with the appropriate values
  wc.cbSize = sizeof(WNDCLASSEX);
  wc.style = CS_HREDRAW | CS_VREDRAW;
  wc.lpfnWndProc = WndProc;
  wc.cbClsExtra = 0;
  wc.cbWndExtra = 0;
  wc.hInstance = hInst;
  wc.hIcon = LoadIcon(NULL, IDI_EXCLAMATION);
  wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  wc.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
  wc.lpszMenuName = NULL;
  wc.lpszClassName = "RandomColor";
  wc.hIconSm = LoadIcon(NULL, IDI_EXCLAMATION);

  //register the new class
  RegisterClassEx(&wc);

  //create a window
  hWnd = CreateWindowEx(
   NULL,
   "RandomColor",
   "The Random Color Program",
   WS_VISIBLE,
   CW_USEDEFAULT,
   CW_USEDEFAULT,
   CW_USEDEFAULT,
   CW_USEDEFAULT,
   NULL,
   NULL,
   hInst,
   NULL
  );

  //event loop - handle all messages
  while(GetMessage(&msg, NULL, 0, 0))
  {
   TranslateMessage(&msg);
   DispatchMessage(&msg);
  }

  //standard return value
  return (msg.wParam);
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT nMsg, WPARAM wParam,
          LPARAM lParam)
{
   
  //find out which message is being sent
  switch(nMsg)
  {
   case WM_CREATE:
    //create the timer (3 seconds)
    SetTimer(hWnd, 1, 3000, NULL);
    //create the DirectDraw object
    hRet = DirectDrawCreateEx(NULL, (void**)&g_pdd,IID_IDirectDraw7, NULL);
    if(hRet != DD_OK)
     MessageBox(hWnd, "DirectDrawCreateEx Failed", "Error", NULL);
    //Set the Cooperative Level
    hRet = g_pdd->SetCooperativeLevel(hWnd, DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE);
    if(hRet != DD_OK)
     MessageBox(hWnd, "SetCooperativeLevel Failed", "Error", NULL);;
    //Set the display mode: 800x600 with 16 bits per pixel
    hRet = g_pdd->SetDisplayMode(800, 600, 16,0,0);
    if(hRet != DD_OK)
     MessageBox(hWnd, "SetDisplayMode Failed", "Error", NULL);;
     
    //prepare primary surface info
    ZeroMemory(&ddsd,sizeof(ddsd));
    ddsd.dwSize = sizeof(ddsd);
    ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
    ddsd.dwBackBufferCount = 1;
    ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
   
    //create the surface
    hRet = g_pdd->CreateSurface(&ddsd, &g_pddsprimary, NULL);
    if (hRet != DD_OK)
     MessageBox(hWnd, "CreateSurface Failed", "Error", NULL);
   
    //prepare the back buffer info
    ZeroMemory(&ddsc,sizeof(ddsc));
    ddsc.dwCaps = DDSCAPS_BACKBUFFER;
     
    //get a pointer to the back buffer
    hRet = g_pddsprimary->GetAttachedSurface(&ddsc,&g_pddsback);
    srand(time(0));
    break;
   
   case WM_TIMER: //when the timer goes off (only one)
    DDBLTFX ddbltfx;
    ZeroMemory(&ddbltfx,sizeof(ddbltfx));
    ddbltfx.dwSize = sizeof(ddbltfx);
    ddbltfx.dwFillColor = rand()%16;
    g_pddsback->Blt(NULL,NULL,NULL, DDBLT_COLORFILL, &ddbltfx);
    g_pddsprimary->Flip(NULL,0);
    break;

   case WM_DESTROY:
    //destroy the timer
    KillTimer(hWnd, 1);
    //end the program
    PostQuitMessage(0);
    break;
   
   default:
    //let Windows handle every other message
    return(DefWindowProc(hWnd, nMsg, wParam, lParam));
  }

  return 0;
}

/*==========================================================================
  *
  *  Copyright (C) 1998-1999 Microsoft Corporation. All Rights Reserved.
  *
  *  File:       ddutil.cpp
  *  Content:    Routines for loading bitmap and palettes from resources
  *
  ***************************************************************************/

#ifdef __cplusplus
extern "C" {            /* Assume C declarations for C++ */
#endif    /* __cplusplus */

extern IDirectDrawPalette  *DDLoadPalette(IDirectDraw7 *pdd, LPCSTR szBitmap);
extern IDirectDrawSurface7 *DDLoadBitmap(IDirectDraw7 *pdd, LPCSTR szBitmap, int dx, int dy);
extern HRESULT              DDReLoadBitmap(IDirectDrawSurface7 *pdds, LPCSTR szBitmap);
extern HRESULT              DDCopyBitmap(IDirectDrawSurface7 *pdds, HBITMAP hbm, int x, int y, int dx, int dy);
extern DWORD                DDColorMatch(IDirectDrawSurface7 *pdds, COLORREF rgb);
extern HRESULT              DDSetColorKey(IDirectDrawSurface7 *pdds, COLORREF rgb);

#ifdef __cplusplus
}
#endif    /* __cplusplus */

#include <windows.h>

LRESULT CALLBACK WndProc(HWND hWnd,UINT nMsg,WPARAM WParam,LPARAM lParam);
int WINAPI WinMain(HINSTANCE hInst,HINSTANCE hPreints,
        LPSTR lpszCmdLine, int nCmdShow)
{
  HWND hWnd;
  MSG msg;
  WNDCLASSEX wc;
wc.cbSize=sizeof(WNDCLASSEX);
wc.style=CS_HREDRAW|CS_VREDRAW;
wc.lpfnWndProc=WndProc;
wc.cbClsExtra=0;
wc.cbWndExtra=0;
wc.hInstance=hInst;
wc.hIcon=LoadIcon(NULL,IDI_EXCLAMATION);
wc.hCursor=LoadCursor(NULL,IDC_ARROW);
wc.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH);
wc.lpszMenuName=NULL;
wc.lpszClassName="BouncingBall";
wc.hIconSm=LoadIcon(NULL,IDI_EXCLAMATION);

RegisterClassEx(&wc);

hWnd=CreateWindowEx(
        NULL,
        "BouncingBall",
        "Рекошитирующий Мяч",
        WS_OVERLAPPEDWINDOW|WS_VISIBLE,
        CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
                       CW_USEDEFAULT,
        NULL,
        NULL,
        hInst,
        NULL
    );

while(GetMessage(&msg,NULL,0,0))
{
  TranslateMessage(&msg);
  DispatchMessage(&msg);
}
return(msg.wParam);
}
LRESULT CALLBACK WndProc(HWND hWnd,UINT nMsg,WPARAM wParam,
        LPARAM lParam)
{

static int dX=5,dY=5;
static int x=0,y=0,oldX=0,oldY=0;
HDC hDC;
HBRUSH brush;
switch(nMsg)
{
case WM_CREATE:
  SetTimer(hWnd,1,20,NULL);
  break;
case WM_TIMER:
  hDC=GetDC(hWnd);
  brush=(HBRUSH)SelectObject(hDC,GetStockObject(WHITE_BRUSH));

RECT temp;
temp.left=oldX;
temp.top=oldY;
temp.right=oldX+30;
temp.bottom=oldY+30;

FillRect(hDC,&temp,brush);
brush=(HBRUSH)SelectObject(hDC,GetStockObject(GRAY_BRUSH));
Ellipse(hDC,x,y,30+x,30+y);
oldX=x;
oldY=y;
x+=dX;
y+=dY;

RECT rect;
GetClientRect(hWnd,&rect);
if(x+30>rect.right||x<0)
{
  dX=-dX;
}
if(y+30>rect.bottom||y<0)
{
  dY=-dY;
}
SelectObject(hDC,brush);
ReleaseDC(hWnd,hDC);
break;
case WM_DESTROY:
      KillTimer(hWnd,1);
   PostQuitMessage(0);
   break;
default:
  return(DefWindowProc(hWnd,nMsg,wParam,lParam));
}
return 0;
}

#include <iostream>
#include <conio.h>

int main(void)
{
cout<<"Добро пожаловать.Три испытания чести."
      "\nзлой маг похител девицу,и"
   "её судьба в твоих руках"
   "\nон предлогает пройти тебе 3 испытания"
   "чести в его роковом лабиринте";
   bool goldTaken,diamondsTaken,killedByDragon;
cout<<"\n\nТы входишь в первую комнату."
      "\nЗдесь столько золота что ты едва веришь своим глазам"
   "\nВозмёшь ли ты золото(1-да,0-нет)?";
cin>>goldTaken;
if(goldTaken)
cout<<"\nЗолото остаётся тебе,но"
      "ты провалил первое испытание"
   "\nИгра окончена.\n\n";
else
{
cout<<"\n\nПоздравляем ты прошол первое испытание чести !"
      "\nТы переходишь во вторую комнату."
   "она полна брилиантов"
   "\nВозмёшь ли ты брилианты"
   "(1-да,0-нет)?";
    
cin>>diamondsTaken;
if(diamondsTaken)  
cout<<"Брилианты достаются тебе,"
       "но ты провалил второе испытание"
    "\nЕвоя жадность очивидна."
    "\nИгра окончена.\n\n";
else
{
cout<<"Поздравляем ,ты"
       "прошол первые два испытания чести"
    "\n\nТы входишь в третью комнату."
    "\nНа несчаствонго крестянина напал дракон !"
    "\nДвигатся дальше не обращая на них внимания "
    "(1-да,0-нет)?";
     
cin>>killedByDragon;
if(killedByDragon)
cout<<"\nТы пиытаешся проскользнуть мимо"
       "и дракон тебя замечает"
    "\nОдним огненым дуновением "
    "он превращает тебя в пепел. Ты мёртв"
    "\nИгра окончена\n\n";
     
else
cout<<"Поздравляем ты прошол все 3 испытания!\n\n"
       "Конец.\n\n";
}
}
getch();
return 0;
}

//Dragon.cpp
#include <string>
#include <ctime>
#include <cstdlib>
#define MAX(a,b) a>b? a:b
using namespace std;
class Dragon
{
       private:
               int speed;
               string name;
               int hitPoints;
               int armour;
               int treasure;
               int clawDamage;
               int size;
       protected:
                 Dragon(int theSize);
                 int getArmour(){return armour;}
                 int& getHitPoints(){return hitPoints;}
                 int getClawDamage(){return clawDamage;}
                 int getSize(){return size;}
                 virtual int attack(int targetArmour,int specialDamage);
       public:
              virtual int attack(int targetArmour)=0;
              virtual void defend(int damage)=0;
              int getTreasure(){return treasure;}
              virtual string getName(){return name;}
              int getSpeed(){return speed;}
              bool isAlive(){return hitPoints>0;}
       };
Dragon::Dragon(int theSize):
                    size(theSize)
{
      if(size<1||size>4)
      size=3;
      clawDamage=2*size;
      speed=3*size;
      hitPoints=4*size;
      armour=size;
      treasure=1000*size;
      srand(time(0));
}
int Dragon::attack(int targetArmour,int specialDamage)
{
     int useSpecial=rand()%2;//0 или 1
     int damage;
     if (useSpecial)
       damage = specialDamage;
     else damage = getClawDamage();
     return MAX(damage - targetArmour,0);
}
     

//RedDragon.cpp
class RedDragon:public Dragon
{
       private:
               int fireDamage;
       public:
              RedDragon(int theSize);
              int attack(int targetArmour);
              void defend(int damage);
              string getName(){return "Красный дракон";}
};
RedDragon::RedDragon(int theSize):
                          Dragon(theSize)
{
    fireDemage=4*getSize();
}
int RedDragon::attack(int targetArmour)
{
     return Dragon::attack(targetArmour,fireDamage);
}
void RedDragon::defend(int damage)
{
      getHitPoints()-=(damage-getArmour())/3;
}

//BlackDragon
class BlackDragon:public Dragon
{
       private:
               int fireDamage;
       public:
              BlackDragon(int theSize);
              int attack(int targetArmour);
              void defend(int damage);
              string getName(){return "Чёрный дракон";}
};
BlackDragon::BlackDragon(int theSize):
                          Dragon(theSize)
{
    poisonDemage=getSize();
}
int RedDragon::attack(int targetArmour)
{
     return Dragon::attack(targetArmour,poisonDamage);
}
void BlackDragon::defend(int damage)
{
      getHitPoints()-=damage-getArmour();
}

//BlueDragon
class BlueDragon:public Dragon
{
       private:
               int iceDamage;
       public:
              RedDragon(int theSize);
              int attack(int targetArmour);
              void defend(int damage);
              string getName(){return "Синий дракон";}
};
BlueDragon::BlueDragon(int theSize):
                          Dragon(theSize)
{
    fireDemage=3*getSize();
}
int BlueDragon::attack(int targetArmour)
{
     return Dragon::attack(targetArmour,iceDamage);
}
void BlueDragon::defend(int damage)
{
      getHitPoints()-=(damage-getArmour())/2;
}

//DragonLord.cpp
#include <iostream>
#include <ctime>
#include <cstdlib>
#include "Dragon.cpp"
#include "RedDragon.cpp"
#include "BlueDragon.cpp"
#include "BlackDragon.cpp"

using namespace std;
int menuChoise();
int main(void)
{
     srand(time(0));
     Dragon*dragons[3];
     int hp=15;
     int armour=2;
     int tempArmour;
     int tempAttack;
     dragons[0]=new RedDragon(rand()%4+1);
     dragons[1]=new BlackDragon(rand()%4+1);
     dragons[2]=new BlueDragon(rand()%4+1);
     Dragons*d=dragons[rand()%3];
     cout<<"Добро пожаловать благородный рыцарью\n"
         <<"Ты должен спасти принцессу."
         <<"Её похитил "
         <<d->getName()<<".\n"
         <<"Ты должен победить дракона.\n";
     cout<<"воя сила: "<<hp<<endl;
     while (d->isAlive()&& hp>0)
     {
          int choise=menuChoise();
          int (choise==3)goto RUN;
          else if (choise==1)
          {
               tempAttack=rand()%16+5;
               tempArmour=armour;
          }
          else
          {
             tempAttack=rand()%11;
             tempArmour=armour+4;
          }
          hp-=d->attack(armour);
          d->defend(rand()%16-5);
          cout<<"\nТы наносишь мощьный удар и ущерб"
              <<tempAttack<<" damage.\n";
          cout<<"Твоя сила: "<<hp;
}
if(d->isAlive())
     cout<<"\nТы побеждён"
         <<"могущественным драконом.\n";
else
     cout<<"\n\nТы победил дракона !"
         <<"Поздравляем\n"
         <<"принцесса спасена.\n";
return 0;
}
int menuChoise()
{
     int choise;
     do{
         cout<<endl
             <<"[1]Атаковать\n"
             <<"[2]Оборонятся\n"
             <<"[3]Бежать\n";
         cin>>choise;
}while(choise<1 && choise>3);
return choise;
}
          

// pirateTawn.cpp
#include <iostream>
#include <string>
#include "MenuUtility.h"
#include "pirateTown.h"
using namespace std;

using menuNamespace::menu;

namespace wharf
{
     void menu()
{
        string options[]=
        {"ïðûãíóòü â âîäó",
        "âçÿòü ãðåáíóþ øëþïêó è óïëûòü â çâêàò.",
        "âçîéòè íà áîðò êðîâàâîãî âåòðà.",
        "îòïðàâèòñÿ â ãîðîä"};
        int userResponse=::menu(options,4);
          
        switch(userResponse)
        {
          case 1:
               cout<<"Òû ïðûãàåøü â âîäó."
                   <<"Âíåçàïíî òû ñëûøèøü"
                   <<"ñìåõ,è òóò æå\n"
                   <<"îñîçíà¸øü ÷òî çàáûë"
                   <<"ñíÿòü îäåæäó."
                   <<"Òû âûëàçèåøü èç âîäû"
                   <<"ïðîìîêøèé íàñêâîçü\n";
                   menu();
                   break;
          case 2:
               cout<<"Òû õâàòàåøü íå áîëüøóþ êðàñíóþ ëîäêó "
                   <<"è óïëûâàåøü â çàêàò"
                   <<"Àõ,ñëàâà."<<endl;
                   break;
          case 3:
               cout<<"Òû âîçâðàùàåøñÿ íà áîðò êðîâàâîãî âåòðâ"
                   <<"è æä¸øü êîãäà âåðíóòñÿ òâîè äðóçüÿ,"
                   <<"âäîâîëü íàâåñåëèâøèñü. \n";
                   break;
          case 4:
               street::menu();
               break;
}
}
}
//îáðàáîòêà ñîáûòèé â òàâåðíå
namespace tavern
{
   void menu(void)
   {
      string options[]=
      {"Çôêàçàòü âûïèâêó"
      "Íà÷àòü øóìíóþ äðàêó"
      "Âûòè íà óëèöó."};
      int userResponse=::menu(options,3);
        
      switch(userResponse)
      {
       case 1:
              cout<<"Òû çàêàçàë êîêòåéëü"
                  <<"\"ËÅÍÒßÉ\"\n";
                  menu();
                  break;
       case 2:
            cout<<"Òû íà÷àë øóìíóþ äðàêó\n";
            menu();
            break;
       case 3:
            street::menu();
            break;
       }
}
}
//îáðàáîòêà ñîáûòèé ïðîèñõîäÿøèõ íà óëèöå
namespace street
{
    void menu(void)
    {
        string options[]=
        {"Äâèíóòñÿ ê ïðè÷àëó",
        "Âîéòè â òàâåðíó",
        "Âîéòèâ îðóæåéíûé ìàãàçèí",
        "Íà÷àòü äðàêó."};
        int userResponse=::menu(options,4);
        switch(userResponse)
        {
          case 1:
               wharf::menu();
               break;
          case 2:
               tavern::menu();
               break;
          case 3:
                weaponShop::menu();
                break;
          case 4:
               cout<<"Òû íà÷àë îòëè÷íóþ äðàêó íà óëèöå\n";
               street::menu();
               break;
        }
}
}
//ïîêóïêà îðóæèÿ
namespace weaponShop
{
            void menu(void)
            {
                 string options[]=
                 {"Êóïèòü êèíæàë èíõðóñòèðîâàííûé äðàãîöåííûìè êàìíÿìè çà 300",
                 "Êóïèòü êðåìíåâûé ìóøêåò çà 300 ",
                 "Êóïèòü ñòàíäàðòíóþ áîåâóþ ñàáëþ çà 100 ",
                 "Óéòèèç ìàãàçèíà."};
                 int userResponse=::menu(options,4);
                 switch(userResponse)
                 {
                   case 1:
                        cout<<"Òû êóïèë êèíæàë"
                            <<"è ñïðÿòàë åãî â êàðìàí\n"   
                            <<"óïëàòèâ êîñòëÿâîìó ìóæ÷èíå "   
                            <<"çà ïðèëàâêîì\n";
                        menu();
                        break;
                   case 2:
                        cout<<"Çàïëàòèâ çàìóøêåò,"
                            <<"òû ñðàçó îöåíèë åãî."   
                            <<"Îí ïðåâîñõîäíî äåéñòâóåò !!!\n";
                        menu();
                        break;
                   case 3:
                        cout<<"Âçìàõíóâ ñàáëåé ïàðó ðàç òû ïîíèìàåøü\n"
                            <<"÷òî îíà íå ñòîèò"
                            <<"ïîòðà÷åííîãî çîëîòà\n";
                        menu();
                        break;
                   case 4:
                        street::menu();
                        break;
                   }
}
}
// íà÷àëî èãðû
int main(void)
{
      cout<<"Òâîé êîðàáûëü êðîâàâûé âåòåð âîøîë â äîêè"
          <<"Òû ñîøîë ñ\n"
          <<"êîðîáëÿ è ñòîèøü íà ïðè÷àëåþ\n\n";
      wharf::menu();
      return 0;
}              

// pirateTawn.h
#include <iostream>
#include <string>
#include "MenuUtility.h"
using namespace std;
//îáÿâëåíèÿ ôóíêöèé
namespace street
{
            void menu(void);
}
namespace weaponShop
{
            void menu(void);
}
namespace wharf
{
          void menu(void);
}
namespace tavern
{
            void menu(void);
}        

// MenuUtility.h
#include <iostream>
#include <string>
using namespace std;
namespace menuNamespace
{
            int menu(string* strArray,int size);
}