Игра "SUPER MARIO" или "SOLDIR OF MARIO"

//Mario.cpp
//примечание:
//в проекте перед файлом mario.cpp должен быть включены файлы KEYBOARD, TIMER
//чтобы создались предопределенные объекты
 
#include "stdafx.h"
//=================хедеры стандартных библиотек=================
#include <fcntl.H>
 
//======================мои хедеры==================
#include "Sound.h"
#include "IDSound.h"
#include "Keyboard.h"
#include "Timer.h"
#include "Mario.h"
#include "IDSprite.h"
#include "Mouse.h"
#include "SpriteEditor.h"
#include "Total.h"
//==================================================================
#include <fstream.h>
 
CString _S="";
 
/*******************************************
/**         Глобальные переменные       /**/
/******************************************/
/**/    SOUND   Sound;                  /**/    //цифровой звук
/**/    SPRITE  Sprite(&scr,110);       /**/    //обычные спрайты
/**/    SPRITE  LvSpr(&scr,112);        /**/    //чем строится картинка
/**/    SPRITE  BigFont(&scr,28);       /**/    //большие буквы
/**/    LEVEL   Level(100,50,&LvSpr);   /**/    //уровень
/**/    SUPERMARIO Supermario;          /**/    //все об игре
/**/    MOUSE   Mouse;                  /**/    //мышка
/******************************************/
 
int random(int n)
{
    return rand()%n;
}
 
int SUPERMARIO::InitForStartGame(int param)
{
//LevelNumber=0;
 
    //это randomize - инициализация генератора случайных чисел
    srand(GetTickCount());
 
    char str[7]="SOLDIR";
 
    /*int 
            LevelNumber,    //уровень, на который следует переместиться
            x,              //код кубика, который нужно искать на уровне
            Status;         //флаги
    */
    //создаем таблицу перемещений
    SHUFFLE ShuffleTable[]=
    {
            {0,0,   SHUFFLE::ALWAYS},   //0
            {0,17,  SHUFFLE::CHGLEVEL}, //1
            {0,5,   SHUFFLE::ALWAYS},   //2
            {0,15,  SHUFFLE::ALWAYS},   //3
            {0,3,   SHUFFLE::ALWAYS},   //4
            {0,2,   SHUFFLE::ALLMAP},   //5
            {0,16,  SHUFFLE::ALWAYS},   //6
            {0,6,   SHUFFLE::ALWAYS},   //7
            {10,15, SHUFFLE::CHGLEVEL}, //8
            {10,15, SHUFFLE::BOSSLIVE | SHUFFLE::CHGLEVEL},//9
            {0,0,  SHUFFLE::ALWAYS}, //10
            {0,0,  SHUFFLE::ALWAYS}, //11
            {0,0,  SHUFFLE::ALWAYS}, //12
            {0,0,  SHUFFLE::ALWAYS}, //13
            {0,0,  SHUFFLE::ALWAYS}, //14
            {0,0,  SHUFFLE::ALWAYS}, //15
            {0,0,  SHUFFLE::ALWAYS}, //16
            {0,0,  SHUFFLE::ALWAYS}, //17
            {0,0,  SHUFFLE::ALWAYS}, //18
            {0,0,  SHUFFLE::NEXTLEVEL} //19
    };
 
    //2 -> 5
    //3 -> 15
    //4 -> 3
    //5 -> 2
    //6 -> 16
    //7 -> 6
    //8 -> 15 (с изменением уровня на 10)
    //9 -> 15 (с изменением уровня на 10 и флаг "BOSSLIVE")
    //10 -> 0
    //11 -> 0
 
    //как можно сделать
    // (1) <-> (2)
    // (3) -> (4)
    // (4) -> нельзя
 
 
    for(int i=0; i<SHUFFLE_COUNT; i++)
      Shuffle[i]=ShuffleTable[i];
 
    ManymoneyCounter=0; //счечик для многих монеток
 
    //устанавливаем атрибуты вывода текста
    {
        scr.setbkcolor(0);
        scr.setcolor(15);
    }
 
    //инициализируем классовые переменные
    {
        OldMarioX=0, OldMarioY=0;   //старые координаты марио
                    //(используется при рестарте уровня)
 
        DoorOpenCounter=0,
        GAMECYCLE=TRUE;     //если GAME=FALSE, игра прекращается
 
        LevelStatus=LEVEL_UNDERWATER;
        BossLive=TRUE;      //босс пока жив
        MapCounter=0;       //число собранных карт
        Arms=ARROW;         //оружие - кегли
        ArrowPower=1;       //сила стрелы - 1
        DaggerPower=2;      //сила ножичка - 2
        AxePower=3;         //сила топорика - 3
        SalivaPower=20;     //сила сопел
        ArmsPower=ArrowPower;//сила оружия - как у стрелы
        ProtectedCounter=0; //счетчик, используем для организации защиты
        Lives=20;           //начальное число жизней
        Score=0;            //число набранных очков
        MoneyCounter=0;     //число собранных монеток (кристаллов)
        Time=Level.Time;    //текущее время
        GameMode=GAMEMODE_RESTARTLEVEL | GAMEMODE_LOADLEVEL;
        GAMEEXIT=FALSE;
 
        Timer1=0,
        Timer2=0;
 
        ShowExit=0;     //не показывать ексит
    }
 
    // идея - объединить все супервизоры в цепочку
    //создаем объекты-супервизоры чужих
    //{
        Rick.MakeSupervisor(&Sprite);       //марио
        Bullet.MakeSupervisor(&Sprite);     //оружие
        HeadSaliva.MakeSupervisor(&Sprite); //кегли, которые пускает башка
        Toothflower.MakeSupervisor(&Sprite);//цветки
        Lift.MakeSupervisor(&Sprite);       //лифты
        Door.MakeSupervisor(&Sprite);       //двери
        Door1.MakeSupervisor(&Sprite);      //дверь перед Марио
        Different.MakeSupervisor(&Sprite);  //разное, никак не обрабатываемое
        Cleverobj.MakeSupervisor(&Sprite);  //дескриптор клевых объектов
        CleverAlien.MakeSupervisor(&Sprite);//умные чужие
        Boss.MakeSupervisor(&Sprite);       //босс (голова)
        Skeleton.MakeSupervisor(&Sprite);   //скелеты
        Movetxt.MakeSupervisor(&Sprite);
        Answer.MakeSupervisor(&LvSpr);
        SCORES.MakeSupervisor(&Sprite);
        Brick.MakeSupervisor(&Sprite);
        Money.MakeSupervisor(&Sprite);
        Prize.MakeSupervisor(&Sprite);
        Alien.MakeSupervisor(&Sprite);
        FireLine.MakeSupervisor(&Sprite);
 
    //}
    //создаем Mario
    {
        //уничтожаем рика
        Rick.DelAll();
 
        MARIO  ob;
//      PERSON  ob;
 
        ob.FrameFirst=SPRITE_RICKSTART;
        ob.FrameLast=SPRITE_RICKEND;
 
        ob.FrameSpeed=0.4;
        ob.SpriteIndex=SPRITE_RICKSTART;
        ob.RenewFrame();
        ob.x=Level.MarioX;
        ob.y=Level.MarioY;
        ob.Hot.Set(3,0,21,23);
        ob.Movement=PERSON::RIGHT;
 
        //создаем марио
        for(UINT TT=0;TT<PlayerCounter;TT++)
        {
            Rick += ob;
            ob.x+=20;
        }
    }
 
    //запускаем таймер
    {
        //Timer.Restart(50);
    }
 
    return 0;
}
 
void SUPERMARIO::prPuziri()
{
    //Марио пускают пузыри если флаг уровня - подводный
    if (LevelStatus & LEVEL_UNDERWATER)
    for(int i=0; i<Rick.Counter; i++)
    {
        ANIM &mr=Rick[i];
        if (mr.Status & MARIO_DEATH) continue;
        if ( random(30+int(abs(mr.Speedx)*2) ) > 28 )
        {
            MINDOBJ ob;
            MINDOBJ::GOING go[]=
            {
                {1,0,5+random(5)},
                {-1,0,5+random(5)}
            };
 
            MINDOBJ::FRAMING fr[]=
            {
                {SPRITE_BUBBLE1+random(3), 4},
                {SPRITE_BUBBLE1+random(3), 4},
                {SPRITE_BUBBLE1+random(3), 4}
            };
 
            ob.x=mr.x+5+random(10);
            ob.y=mr.y+7;
            ob.SpriteIndex=SPRITE_BUBBLE1+random(3);
            ob.Speedy=-1;
            ob.Acceleraty=-0.01-0.01*random(5);
            ob.AlwaysAnimate=TRUE;
            ob.TimeLive=200;
            CleverAlien.Add(ob, 2, go, 3, fr);
        }
    }
}
 
void SUPERMARIO::BirdsOtSten()
{
for(int i=0; i<CleverAlien.Counter; i++)
{
    MINDOBJ &br=CleverAlien[i];
    if  (br.SpriteIndex != SPRITE_BIRD1) continue;
    int c=0;    //была ли коллизия
    if (!chk_left(br,0)) br.Speedx=2+0.1*random(10),c=1;
    else if (!chk_right(br,0)) br.Speedx=-2-0.1*random(10),c=1;
 
    int x=int(br.x+12);
    int y1=int(br.y+br.Hot.Top-3);
    int y2=int(br.y+br.Hot.Bottom+3);
    if (Level.ReadXY(x,y1)) br.Speedy=0.7+0.1*random(10),c=1;
    else if (Level.ReadXY(x,y2)) br.Speedy=-0.7-0.1*random(10) ,c=1;
 
    if (br.x<0) br.Speedx=3.4,c=1;
    if (br.y<0) br.Speedy=1.7,c=1;
    if (br.x>Level.MaxX+320) br.Speedx=-3.4,c=1;
    if (br.y>Level.MaxY+200) br.Speedy=-1.7;
 
    //если была коллизия
    //if (c)
    //{
    //  if ( !random(6) ) br.Acceleraty=0.2;
    //else
 
    br.Acceleraty=0;
    //}
 
    if (br.Speedy>0)
    {
        br.SpriteIndex=SPRITE_BIRD1;
        br.FrameSpeed=0;
        //br.frame_num=0;
        br.Frame=br.framing[br.frame_num];
    }
    else
    {
        br.FrameSpeed=0;
    }
}
}
 
void SUPERMARIO::prMarioDeathOnShipah()
{
    for(int i=0; i<Rick.Counter; i++)
    {
        ANIM &rk=Rick[i];
        if (rk.Status & MARIO_DEATH) continue;
        if (chk_down(rk, PRICKLES))
        {
            //гасим марио
            rk.Speedx=0;
            rk.Speedy=-5;
            rk.Acceleratx=0;
            rk.Acceleraty=0.2;
            rk.FrameSpeed=0;
            rk.Status|=MARIO_DEATH;
            Sound.play(SND_EXORCISM);
            //Sound.play(SND_LAUGHT);
        }
    }
}

//============= 'game' это, собственно, сама игра ==================
void SUPERMARIO::Game()
{
    InitForStartGame(0);
    //music(NORMAL_MUSIC);
    while (GAMECYCLE)   //цикл игры
    {
    //I. построение изображения 
    MOVEOBJ::TotalAnimatedObject=0;
    prMonetsChangePhase();
    prPuziri();
    prBuildGamePicture();
    prShowDebugInfo();
    //II. логика игры
    BirdsOtSten();          //птички отталкиваются от стен
    SkeletonCollect();      //собираем скелетов
    prCleverobjRefresh();   //обновляем все у умных объектов
    prMarioDeathOnShipah(); //марио гасится на шипах
    prForMarioProtected();  //чтобы марио был защищенным
    prPrizeCatch(Rick, Prize);//призы не проходят сквозь стенки и марио ловит призы
    prBricksNudgePrize();   //кирпичи могут подталкивать призы
    prBricksRestore();      //восстанавливаем кирпичи
    prTurtleCikAlien();     //черепаха сбивает других чужих
    prMonetsTimeEndTimeLiveAndScoreCreate();//надо создать очки когда монетка пропадает
    prIfGameOver();         //если конец игры 
    prBossSalivaDeathMario();// кегли башки гасят марио и не пролетают через стены
    prBossSendSaliveAndKeepAtMario();//башка пускает "кегли" и находится вблизи от марио
    ArmsKillAlien();        // оружие убивает чужих
    prLiftUpDown();         //меняем направление лифта и обновляем его координаты
    prMarioDeathOnFlower();//марио гасится на зубастых цветках
    prFlowersUpDown();      //поднимаем и опускаем зубастые цветки
    MindobjFunctions(Rick, Cleverobj);//различные функции
    MindobjFunctions(Rick, CleverAlien);//предусмотренные для Mindobj
    prMarioFlyDownCleverobj();  //марио слетает с клевых объектов
    prMarioPositionerOnCleverobject();//позиционируем Mario  на клевый объект
    prMarioRenewXY();//обновляем координаты Mario
    //если ноги марио близко к лифту, марио падает
    prMarioClammyToLift();  //на лифт и его ускорение приравнять к нулю
    prMarioDownsBrickDestroy();//обрушиваем кирпичи под ногами у марио
    prArmsCollisionWithWall();//оружие сталкивается со стенами *
    prRememberOldMarioCoordinates();//запоминаем старые координаты Mario
    prKeyboardProcess();        //обработка НАЖАТИЙ клавиш 
    GameModesTreat();       //обрабатываем ситуацию загрузки и рестарта уровня режимы игры
    if (DoorOpenCounter) DoorOpenCounter--; //чтобы дверь успела открыться
    prScrollBricks();       //двигается фон (спрайты воды и огня)
    prChangeEffect();       //эффект перехода на другой экран
    prShowFPS();            //показать FPS
    prSynhronization();     //синхронизируемся (ждем когда таймер станет равным 1)
    
    ShowLevelNumberTimeCounter++;
 
    if (ShowLevelNumberTimeCounter<100)
    {
        
        Msg("  УРОВЕНЬ    ", 9, MSG_NOUPDATE);
        
 
        /*if (LevelNumber<40)
        {
            scr.putNumb(LevelNumber/4+1,1);
            scr<< '-';
            scr.putNumb(LevelNumber%4+1,1);
        }
        else
        {
            scr.putNumb(LevelNumber);
        }*/
        scr.putNumb(LevelNumber);
 
    }
    
    static int ShowLog=0;
    //выводим изображение на экран из DoubleBuffer
    if (Keyb[KEY_L] && Keyb[KEY_LEFTCTRL]) 
    {
        Keyb^KEY_L;
        ShowLog^=1;
    }
    
    if (ShowLog) 
    {
        //сжимаем картинку
        for(int i=0; i<100; i++)
        {
            memcpy(scr.DoubleBuffer+i*320, scr.DoubleBuffer+i*2*320,320);
        }
        
        scr.rectangle(0,100,320,100,0);
        Log.Show();
    }
    scr.update();           
    } //конец цикла while
}//конец функции game

//вывод прямоугольника
void SCREEN::rectangle(int x,int y,int len,int hei, int color)
{
    int x1=x+len-1, y1=y+hei-1;
    if (x1<0 || y1<0 || x>319 || y>199) return;
 
    if (y<0 || x<0 || x1>319 || y1>199)
    {
        MYRECT rt1(0,0,319,199),
        rt2(x,y,x+len-1,y+hei-1),
        rt3;
 
        if (DetermineSystem(rt1,rt2,rt3))
        rectangle(rt3,color);
        //Debug("SCREEN::rectangle - parametrs erorr!");
        return;
    }
 
    unsigned char far * vb=DoubleBuffer;
    unsigned addr=320*y+x;
    _asm {
        cld
        mov edi,vb
        add edi,addr
        mov al,byte ptr color
        mov ah,al
        mov bx,ax
        shl eax,16  //shl eax,16
        mov ax,bx
 
        mov ebx,len
        and ebx,3
 
        mov edx,len
        shr edx,1
        shr edx,1
        cld
    }
    m:
    _asm{ 
        mov ecx,edx
        rep stosd
        mov ecx,ebx
        rep stosb
        add edi,320
        sub edi,len
        dec hei
        jnz m
    }
}

struct Color
{   byte r, g, b, a=0;
};
 
struct ConfigWorld
{  ... 
    Color sky{0,0,200};
    ...
};

//Level.h
#ifndef __WIZLEVEL_H
#define __WIZLEVEL_H
 
#include "sprite.h"
#include "rects.h"
 
//класс LEVEL предназначен для описания уровня
class LEVEL
{
// !!! ВНИМАНИЕ !!! При добавлении новых данных их можно дописывать
// ТОЛЬКО в конец текущего описания. В противном случае
// чтение прежних файлов level???.dat станет невозможным
// не меняйте порядок следования и тип данных, если хотите читать старые файлы уровней
//************************ ЗАГОЛОВОК ФАЙЛА УРОВНЯ *********************
private:
    unsigned long SIGNATURE;//сигнатура структуры
    WORD sizeofLevel;   //размер структуры в байтах
    SPRITE *spr;        //указатель на используемый класс спрайтов
public:
    WORD x,y;           //координаты окна показа уровня
    WORD MaxX,MaxY;     //максимальные координаты показа уровня
    WORD Len;           //ширина уровня в кубиках
    WORD Hei;           //высота уровня в кубиках
    WORD BoxLen;        //ширина кубика в пикселях
    WORD BoxHei;        //высота кубика в пикселях
private:
    WORD *Data;         //указатель на данные
public:
    WORD MarioX,MarioY; //координаты марио
    WORD BackgroundColor;//цвет заднего плана в данном уровне и флаги
    WORD Time;           //время, за которое надо пройти этот уровень
//************************ КОНЕЦ ЗАГОЛОВКА ФАЙЛА УРОВНЯ ***************
 
//************************** МЕТОДЫ ****************************
public:
    void ConvertNumber(int num, char width, char far * dest);
    int  Editor(int n);         //редактор уровня n
    LEVEL(int len, int hei,SPRITE *spr); //конструктор создание уровня
    ~LEVEL();                   //деструктор
    int  Load(int n);           //загрузка уровня n
    void New(int len,int hei);  //создание нового уровня
    int  Read(int x,int y);     //считать один кубик из уровня
    int  ReadXY(int x,int y)    //считать из уровня кубик (точность до пикселя)
    {
        return Read(x/BoxLen,y/BoxHei);
    }
    int  Save(int n);           //запись уровня  n
    void Show();                //нарисовать уровень
    void Show(int x,int y,char=SHOW_BACKGROUND|SHOW_FOREGROUND);    //нарисовать уровень с заданной позиции
    void Write(int x,int y,int what);//записать в уровень
    
    //записать в уровень кубик
    //x,y - пиксельные координаты
    //what - код кубика вместе с атрибутами
    void WriteXY(int x,int y,int what)
    {
        Write(x/BoxLen, y/BoxHei,what);
    };
 
public:
    enum {
        MASK=0x1ff
    };
 
    //свойства кубика
    enum box_logic{
        BACKGROUND  =0x8000,    //кирпич есть задний  фон(для всех объектов
                            //он равнозначен пустоте)
        ALIEN       =0x4000,//это не кубик, а код кубика задает номер чужого
        FOREGROUND  =0x2000,//этот кирпич будет поверх всех объектов
        logTRANSP   =BACKGROUND,    //"логически прозрачный"
        TRANSPARENTPIXELS=0x1000,   //кирпич имеет прозрачные пикселы(иначе неимет)
        DESTROYED   =0x0800,    //кирпичик может разрушаться
        COLLAPSE    =0x0400,    //кирпичик обваливается под ногами
        PULL=DESTROYED | FOREGROUND, //кирпичик, когда разрушается, тащит все за собой
        //действительно только для чужих
        //AGAIN=FOREGROUND  //чужой должен появиться снова, если его загасят
    };
 
    //как показывать уровень
    enum {
        SHOW_DEBUG      =0x01,  //показывать отладку
        SHOW_BACKGROUND =0x02,  //показать задний план
        SHOW_FOREGROUND =0x04   //показать передний план
    };
 
    enum {
        FLAG_UNDERWATER=0x8000   //этот уровень - подводный
    };
}; //class LEVEL
 
#endif

//Screen.h
#ifndef __SCREEN_H
#define __SCREEN_H
 
#include "rects.h"
 
/*
    Класс SCREEN предназначен для вывода информации во внутренний буфер,
копию экранного буфера. Когда кадр сформирован, вызывается функция update(),
и изображения из внутреннего буфера копируется в видеопамять (на экран)
    Примечание: такие понятия, как 'вывод на экран', 'очистка экрана'
относятся не к физической VRAM, а к теневому экрану (DoubleBuffer, дублирующиц буфер)
    Чтобы информация появилась на экране необходимо вызвать функцию update() 
    Настоящая реализация поддерживает размер экрана 320x200
*/
class SCREEN {
 
// ********************** ДАННЫЕ-ЧЛЕНЫ ******************************
public:
 
    BYTE    DoubleBuffer[320*200];  //теневой экран
 
public:
 
    char    bkcolor;        //цвет заднего фона (при выводе текста)
    char    color;          //цвет рисования
    int     x,y;            //координаты курсора
 
    //хранит копию экрана 
    BYTE    SavedDoubleBuffer[320*200]; 
 
// ********************** ФУНКЦИИ-ЧЛЕНЫ *************************
public:
    void ConvertDoubleBufferToTrueColor(COLORREF * TrueColorBuffer);
    
    //значение State для bitblt
    enum {
        FLIP_HORZ=0x01, //перевернуть спрайт по горизонтали
        FLIP_VERT=0x02, //перевернуть спрайт по вертикали
        TRANSP=0x04 //есть прозрачные пикселы
    };
 
    enum {
        ONLY_DIGIT=0x01 //фунция InputString будет вводить только цифры
    };
 
    void bitblt(int X,int Y,int Len,int Hei, char far* Data, char State);
    void bitblt_part(int x,int y,int x_in, int y_in,int Len, int Hei,
                    int FactLen,int FactHei, char far* Data, char State);
    void border(int x,int y,int len,int hei, int color);    
    void center(int y, char far*);  
    void clear(int=0);              
    void CreatePalette();           
    void DecrementPalette();        
    void IncrementPalette();        
 
    void LoadPaletteFromFile(char *fname);  //восстанавливает палитру из файла
    void SavePaletteToFile(char *fname);    //записывает текущую палитру в файл
 
    //получить массив цветовых регистров
    //void GetColorRegisters(int startReg, int count, RGB * values);
    
    //установить массив цветовых регистров
    //void SetColorRegisters(int startReg, int count, RGB * values);
 
    //получение одного цветового регистра
    void GetColorRegister(unsigned char nReg,char&r,char&g,char&b);
 
    //установка одного цветового регистра
    void SetColorRegister(unsigned char nReg,char r,char g,char b);
 
    
    unsigned long InputNumber(unsigned int DigitCounter);   
    void InputString(int len, char far * str,int flag=0);
    void locate(int x,int y);   
    void locateXY(int x,int y); 
    void line(int x1,int y1,int x2,int y2, char color); 
    void lineright(int x,int y,int len, char color);    
    void linedown(int x,int y,int hei, char color);     
 
    SCREEN& operator << (char*);
    SCREEN& operator << (DWORD);
    SCREEN& operator << (unsigned);
    SCREEN& operator << (int);
    SCREEN& operator << (char);
    SCREEN& operator<< (SCREEN& (*_f)(SCREEN&))
    {
        return (*_f)(*this);
    }
 
    void pause(int n);
    void putpixel(int x,int y,int color); 
    void putpixel();                     
 
    void putSymbol(BYTE s);             
    void putSymbol(int x,int y, unsigned char s);   
    void putText(char far *);       
    void putNumb(unsigned long num);    
    void putNumb(unsigned long num,char width); 
    void rectangle(int x,int y,int len,int hei,int color);
    void rectangle(MYRECT &rt,int color);
    void setbkcolor(char c){bkcolor=c;};    //установка цвета вывода
    void setcolor(char c){color=c;};    //установка цвета вывода
    
    void Set320x240Mode();          //установить режим 320*240, 256 цветов
    void update(void);          //обновление экрана
    void update(RECT);          //обновление экрана
//  void wait(void);            //ждет обратного хода луча
    void SaveScreen();          //сохраняет экран во внутреннем буфере
 
    SCREEN(void);               
    ~SCREEN(void);              
 
};
//================== end of class 'SCREEN' ==============================
 
inline        SCREEN& endl(SCREEN& ob) { return ob; }
 
class MANIPMY {
public:
    SCREEN& (*fun) (SCREEN& , int);
    int ag;
 
public:
    MANIPMY ( SCREEN& (*_f)(SCREEN&, int) , int _a)
    {
        fun=_f;
        ag=_a;
    }
 
        friend SCREEN& operator<< (SCREEN& obj, MANIPMY& _f)
        {
            (_f.fun) (obj, _f.ag);
            return obj;
        }
};
 
MANIPMY& setcolor(int);
MANIPMY& cur(int,int);
 
 
//extern SCREEN scr;
 
 
/*
class FONT
{
    //возможные перечеслиния размеров фонта
    enum {
        FONT8x8,
        FONT8x14,
        FONT8x16
    };
 
    char * FontAddres;      //адрес фонта
    char SymHigh;           //высота одного символа
 
public:
    FONT(int size=FONT8x8); //конструктор size - размер фонта
    ~FONT();    //деструктор
 
    //показать на экране символ с дополнительным цветом color
void    Show(int x,int y, int symbol, char color);
};
 
  */
 
 
#endif

//Moveobj.h
#ifndef __MOVEOBJ_H
#define __MOVEOBJ_H
 
#include "rects.h"
#include "debug.h"
 
 
class SPRITE;       //предварительное объявление класса
 
class MOVEOBJ 
{
 
    void NullAllData();
    //YES - значит супервизор, NO - значит объект
public: enum { YES=1, NO=-1 };  //значение переменной Supervisor
 
//*********************** ЧЛЕНЫ-ДАННЫЕ ************************
protected:
static  int SupervisorCounter;//число созданных объектов-супервизоров
    SPRITE* Sprite;     //указатель на объект типа SPRITE
    int Supervisor; //флаг супервизора
    MOVEOBJ* First;     //указатель на первый обьект cписка
    MOVEOBJ* Last;      //указатель на последний объект списка
public:
static  int TotalAnimatedObject;
    double  Acceleratx; //ускорение по осям
    double  Acceleraty;
    int Counter;    //число созданных объектов в списке
    MYRECT  Hot;        //определяет горячее пятно спрайта
       MOVEOBJ* Next;       //указатель на следующий обьект. Если это последний обект Next=NULL
       MOVEOBJ* Prev;       //указатель на предыдущий обект.Если это первый обьект Prev=NULL
    int Link;       //привязка объекта
static  MYRECT  Lim;        //границы, выйдя за которые объекты удаляются
    MYRECT  Rect;       //определяет объект на экране
    double  Speedx;     //проекции скорости на оси
    double  Speedy;
    int SpriteIndex;    //индекс спрайта
    double  Speed;      //модуль вектора скорости
    int Status;     //состояние обьекта
static  double  SPEED_UNIT; //единица скорости
static  int WindowX;    //координата X окна вывода
static  int WindowY;    //координата Y окна вывода
    double  x,y;        //текущие координаты обьекта
    int ShootCounter;   //число выстрелов, после чего объект
    int AlwaysAnimate;  //всегда ли надо анимировать объекты ?
                //убивается
//********************** ФУНКЦИИ-ЧЛЕНЫ ***************************
//(пометка YES - значит функция предназначена только для супервизора
// NO - функция не предназначена для супервизора, то есть предназначена
// только для объекта)
public:
    void Animate();             //YES анимация обектов
virtual void Del (MOVEOBJ *Obj);        //YES удаление обьекта из списка по его адресу,
    void Del (int n) { Del(&operator[](n));}//YES удаление объекта с номером n
    void DelAll();              //YES удаление всех объектов
virtual void Destroy(int who) {}        //вызывается когда объект кто-то убивает
    void MakeSupervisor(SPRITE*spr)     //делает объект супервизором
    {
        Supervisor=YES;
        Sprite=spr;
    }
         MOVEOBJ(SPRITE *Sprite);       //YES конструктор супервизора
         MOVEOBJ();             //NO конструктор move-объекта
        ~MOVEOBJ();                         //YES, NO деструктор
    int  New( MOVEOBJ *Obj, int size);  //YES создание нового объекта
    MOVEOBJ& operator[] (int i);        //YES получить ссылку на объект i
    void operator+= (MOVEOBJ &);        //YES добавить объект в список
virtual void RenewFrame() {}
    void RenewRect();           //NO  обновить структуру Rect
virtual int RenewTimeLive() {return 1;}
virtual void RenewXY();             //NO  обновить координаты X,Y
    void Set(double x=0,double y=0,double sx=0,double sy=0,double acx=0,double acy=0);    //NO установить наиболее важные переменные
virtual void Show();                //NO показываем объект
    void ShowAll();             //YES показать все объекты
};
 
 
//****************************************************
//************* class ANIM - анимация объектов *******
//****************************************************
//класс надстривает MOVEOBJ таким образом, что новый объекты
//могут самоуничтожаться (переменная TimeLive) и изменять
//последовательно c нужной скоростью номера спрайтов (в определенном
//отрезке значений)
 
class ANIM: public MOVEOBJ
{
public:
    int FrameFirst, FrameLast;
    double FrameSpeed, FrameCurrent;
    int TimeLive;
 
public:
    ANIM ();
    ANIM(SPRITE *s) : MOVEOBJ(s) {;}
    //перегружаем [] для правильного преобразования типа
    ANIM & operator[] (int i) {return (ANIM&) MOVEOBJ::operator[](i); }
    //заметьте, MOVEOBJ & operator+= также остается !
    void operator+= (ANIM& ob) { New(&ob, sizeof(ob)); };
    void Animate(void);
virtual void RenewFrame();
    int RenewTimeLive()
    {
            if (TimeLive>3)
        {
            TimeLive--;
                    return 1;
                }
                else if (!TimeLive) return 1;
                else return 0;
    }
 
};
 
 
//************************************************************
//************* class MINDOBJ - умные, разумные объекты *******
//************************************************************
//класс ANIM позволяет создавать простейшую анимацию. Если вас не устраивают
//возможности класса ANIM, используйте класс MINDOBJ
 
//0,-1,10, 0,1,10, 0    мостик вверх, вниз
//
 
class MINDOBJ : public ANIM
{
public:
        //структура "хотьба" (кому? - ясно,что не мне)
        struct GOING
    {
        double Speed_x,Speed_y; //перемещение по осям за один шаг
//                  Accelerat_x,Accelerat_y;
        int  Time;      //время этого передвижения(число шагов)
                       //если Time==0, значит этот шаг последний
        };
        //как должны меняться фазы
        struct FRAMING
        {
            int Fase,   //какая фаза
                Time;   //сколько времение она будет держаться
                            //аналогично GOING, если Time==0 - на начало
    };
 
    GOING  * going;     //указатель на способ движения
    FRAMING * framing;        //указатель на способ смены фазов
 
        int go_num, frame_num;  //текущие элементы
        int go_max, frame_max;  //число элементов
 
public:
    GOING  Go;      //текущие элементы
    FRAMING Frame;
 
 
    //команды
    enum {
        SET_SPEED       = -1,   //установить скорость
        SET_ACCELERAT   = -2,   //установить ускорение
        SET_INDEX       = -3    //перепрыгнуть на другой элемент
    };
 
        enum {
             PERSON=0x01,      //объект всегда смотрит в сторону перемещения
                               //(иначе отображается так, как нарисован)
             DANGER=0x02,   //объект опасный
                    //(иначе неопасный)
             SOLID=0x04,    //объект твердый(нельзя пройти через него)
                        //(иначе прозрачный)
             LIFT=0x08,     //объект может переносить на себе(мостик,
                        //тележка, лифт)
                            //(иначе не может)
        };
 
        unsigned State;     //состояние элемента
 
        void Add(MINDOBJ&, int NumGo,GOING *go_ptr, int NumFrame,
    FRAMING *frame_ptr,int StartGo=0, int StartFrame=0);
 
 
    void Del (MOVEOBJ *Obj);    //удаление объекта из списка
    MINDOBJ(SPRITE *s) : ANIM(s) {;}
        MINDOBJ();
        ~MINDOBJ();         //деструктор
    void operator+=(MINDOBJ&);
        MINDOBJ& operator[](int i) { return (MINDOBJ&) MOVEOBJ::operator[](i); }
        void RenewFrame();
        void RenewXY();
        void Show();
 
};
 
 
 
//перемещающийся текст
class MOVETXT : public ANIM
{
public:
    char* Message;      //сообщение
    char Color;         //цвет сообщения
    MOVETXT (SPRITE* spr) : ANIM(spr), Message(0) {}
    MOVETXT () : Message(0), Color(15) {;}
    void Animate();
    void operator+= (MOVETXT& ob) { New(&ob, sizeof(ob)); };
    void Show();
};
 
#endif

void SUPERMARIO::BirdsOtSten()
{
for(int i=0; i<CleverAlien.Counter; i++)
{
    MINDOBJ &br=CleverAlien[i];
    if  (br.SpriteIndex != SPRITE_BIRD1) continue;
    int c=0;    //была ли коллизия
    if (!chk_left(br,0)) br.Speedx=2+0.1*random(10),c=1;
    else if (!chk_right(br,0)) br.Speedx=-2-0.1*random(10),c=1;
 
    int x=int(br.x+12);
    int y1=int(br.y+br.Hot.Top-3);
    int y2=int(br.y+br.Hot.Bottom+3);
    if (Level.ReadXY(x,y1)) br.Speedy=0.7+0.1*random(10),c=1;
    else if (Level.ReadXY(x,y2)) br.Speedy=-0.7-0.1*random(10) ,c=1;
 
    if (br.x<0) br.Speedx=3.4,c=1;
    if (br.y<0) br.Speedy=1.7,c=1;
    if (br.x>Level.MaxX+320) br.Speedx=-3.4,c=1;
    if (br.y>Level.MaxY+200) br.Speedy=-1.7;
 
    //если была коллизия
    //if (c)
    //{
    //  if ( !random(6) ) br.Acceleraty=0.2;
    //else
 
    br.Acceleraty=0;
    //}
 
    if (br.Speedy>0)
    {
        br.SpriteIndex=SPRITE_BIRD1;
        br.FrameSpeed=0;
        //br.frame_num=0;
        br.Frame=br.framing[br.frame_num];
    }
    else
    {
        br.FrameSpeed=0;
    }
}
}