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

// 220x176 pixels.
//New Tastement for Arduino
 
//идея сделать переход к следующему псалму (главе) или к началу и к предыщей главе
//так же линиями обозначить места где касаться тачпаду
//перенос одной буквы на следующую строку
 
#define TRUE 1
#define FALSE 0
#include <SPI.h>
#include <SD.h>
 
#include <UTFT.h>
#include "TouchScreen.h"
//#include <spi.h>
#include <time.h>
 
int A5_init = 0;
int test_touch(int &x, int &y);
char need_write_settings = 0;
 
#define DELAY_ONE_SYMBOL 90
 
#define DEBUG_MODE 0
 
char * FILE_SETTINGS = "sett.dat";
 
 
 
void text_find_prev_stih()
{
  setup_card();
 
  File myFile = SD.open("bible3.txt");
 
  int flg = 0; //счетчик нахождения символа перевода строки
  if (!myFile) return;
 
  setting.pos -= 3;
 
  while (1)
  {
    myFile.seek(setting.pos);
    unsigned char a;
    a = myFile.read();
    setting.pos--;
    if (a == 10)
    {
      flg++;
      if (flg == 2) break;
    }
  }
 
  myFile.close();
  SPI.end();
}
 
void skip_file_to_enter()
{
  setup_card();
 
  File myFile = SD.open("bible3.txt");
 
  if (myFile)
  {
    myFile.seek(setting.pos);
 
    while (1)
    {
 
      unsigned char a;
      a = myFile.read();
 
 
      if (a == 13 || a == 10)
      {
        a = myFile.read();
        setting.pos++;
        break;
      }
      setting.pos++;
    }
 
    myFile.close();
  }
  SPI.end();
}
 
int find_symbol(unsigned char f, unsigned char k=' ')
{
  setup_card();
  unsigned long cnt = 0;
  File myFile = SD.open("bible3.txt");
  unsigned char a,t;
  if (myFile)
  {
    myFile.seek(setting.pos);
 
    while (1)
    {
      a = myFile.read();
      setting.pos++;
      cnt++;
      if (cnt >= 265535.0) break;
 
      if (a == f)
      {
        if (k==' ') break;
        else {
          myFile.read();
          t=myFile.read();
          if (t==k) 
          {
            setting.pos+=2;
            cnt+=2;
            break;
          }
        }
      }
    }
 
    myFile.close();
  }
 
  SPI.end();
  if (a == f) return 1;
  else return 0;
}
 
void read_sd_card()
{
  setup_card();
  //Serial.write("read_sd_card()\n");
  File myFile = SD.open("bible3.txt");
 
  if (myFile)
  {
    //Serial.write("Read file\n");
 
 
    myFile.seek(setting.pos);
 
 
    int p = 0;
    while (1)
    {
 
      unsigned char a;
      a = myFile.read();
      txt2[p] = a;
      txt2[p + 1] = 0;
 
      setting.pos += 1;
 
      if (p >= (BUF_SIZE - 1)) break;
 
      if (a == '(' && (setting.mode & MODE_RND)) flag_rnd = 1;
 
      if (a == 13 || a == 10)
      {
        txt2[p] = ' ';
        myFile.read();
        setting.pos++;
        break;
      }
      p += 1;
    }
 
    myFile.close();
    //rnd_text();
    Serial.write((char*)txt2);
  }
  //else
  //{
    //Serial.write("Can't open file\n");
  //}
 
  SPI.end();
}
 
const int chipSelect = 5;
 
int setup_card()
{
  //Serial.write("setup_card()\n");
  pinMode(5, OUTPUT);
  digitalWrite(5, HIGH);
  int err = SD.begin( chipSelect );
  if ( !err)
  {
    //Serial.println("ini SD-card failed ");
    SPI.end();
    tft.setColor(0, 0, 0);
    //tft.print("SD-card failed", 0, 0);
 
    return FALSE;
  }
  else
  {
    //Serial.println("ini SD-card ok!\n");
    return TRUE;
  }
 
}
 
 
 
int wait_press()
{
  int x, y;
 
  while (1)
  {
    if (test_touch(x, y)) return 1;
 
    delay(1);
  }
 
}
 
void write_settings()
{
 
  setup_card();
 
  if (SD.exists(FILE_SETTINGS))
  {
    SD.remove(FILE_SETTINGS);
  }
 
  File myFile = SD.open(FILE_SETTINGS, FILE_WRITE);
 
  if (myFile)
  {
    int len = sizeof(SETTING);
    myFile.seek(0);
 
    int n = myFile.write((char*)&setting, len);
    myFile.close();
 
    //Serial.write("Write file ");
    //Serial.write(FILE_SETTINGS);
   // Serial.write(" = ");
 
    //Serial.print(n);
    //Serial.print(" ");
 
 
    /*for (int k = 0; k < len; k++)
    {
      int b = ((unsigned char*)&setting)[k];
      Serial.print(b);
      Serial.print(" ");
    }*/
 
    //Serial.write("\n");
  }
 /* else
  {
    Serial.write("Can't open ");
    Serial.write(FILE_SETTINGS);
    Serial.write(" for write\n");
  }
  */
 
  SPI.end();
}
 
void load_settings()
{
  setup_card();
  File myFile = SD.open(FILE_SETTINGS);
 
  if (myFile)
  {
    //Serial.write("Read file ");
    //Serial.write(FILE_SETTINGS);
    //Serial.write(" = ");
 
    int len = sizeof(SETTING);
    int n = myFile.read(&setting, len);
 
    //Serial.print(n);
    //Serial.print(" ");
 
    /*for (int k = 0; k < len; k++)
    {
      int b = ((unsigned char*)&setting)[k];
      Serial.print(b);
      Serial.print(" ");
    }*/
 
    //Serial.write("\n");
 
    myFile.close();
  }
  /*else
  {
    Serial.write("Can't open ");
    Serial.write(FILE_SETTINGS);
    Serial.write("\n");
  }*/
 
  SPI.end();
 
}
 
//влияет на обмен SD-картой
//после Serial.write невозможно записать данные в файл
//void mes(char *m)
//{
//Serial.write(m);
//Serial.write("\n");
//}
 
char buf[16];
 
void pause_fun()
{
  
  
  message("PAUSE", MAX_Y - scaleH - 1, 1);
  //tft.rect(0,0,219,176);
  
  if (setting.mode&MODE_PAUSE) {delay(1000);}
  else
  { 
    setting=old_setting;
    setting.mode|=MODE_PAUSE;
    write_settings();
  }
  
  int x,y;
  while (!test_touch(x, y));
 
  setting.mode^=MODE_PAUSE;
  //tft.line(0,0,100,100);
}
 
 
//проверка, что точка (x,y)  находится в прямоугольнике (x1,y1)-(x1+len,y2+hei)
int test_rect(int x, int y, int x1,int y1,int len,int hei, int draw=0)
{
  if (x>=x1 && x<=(x1+len) && y>=y1 && y<=(y1+hei)) 
  {
    if (draw)
    {
      /*for(int i=0; i<5;i++)
      {
        tft.fillRect(x1, y1, x2-x1, y2-y1, GREEN);
        delay(200);
        tft.fillRect(x1, y1, x2-x1, y2-y1, BLACK);
        delay(200);
      }*/
 
    }
 
    return 1;
  }
  else return 0;
}
 
int pause_pause(int x,int y)
{
        setting.mode |= MODE_PAUSE;
 
 
        bool wr = 1;
 
        while (1)
        {
          setting.mode ^= MODE_RND;
          int f = setting.delay_one_symbol;
          sprintf(buf, "PAUSE %i", f);
          ///itoa(f, buf,10);
          message(buf, 0);
          sprintf(buf, "MODE %i", setting.mode);
          message(buf, 20, 1);
 
          if (setting.mode & MODE_RND)
          {
            message("RND ON", 50, 1);
          }
          else
          {
            char *str = "RND OFF";
            //str[3] = 'O';
            message(str, 50, 1);
          }
 
          while (!test_touch(x, y));
 
 
          #define DELTA_X 60
          
          if (x < DELTA_X && setting.delay_one_symbol >= 1) 
          {
            setting.delay_one_symbol -= 10;
            wr = 1;
          }
          
          if (x > (MAX_X - DELTA_X)) 
          {
            setting.delay_one_symbol += 10;
            wr = 1;
          }
          old_setting=setting;
          
          if (y > (MAX_Y - 50)) break;
 
        }
 
        setting.mode ^= MODE_PAUSE;
        if (setting.delay_one_symbol == 0) 
        {
          message("PAUSE OFF");
        }
        else
        {
          message("SAVE ...");
        }
}
 
void  fun_find_zvezd()
{
          message("FIND *");
          char r = find_symbol('*');
 
          if (r)
          {
            message("FIND * ok");
            delay(500);
 
          }
          
}
 
void print_num(int x,int y,int num)
{
 
  if (num<=9)
  {
      printMyCharWH(x,y,15,16, '0'+num, 0,255,255,true,false);
  }
  else
  {
      printMyCharWH(x,y,15,16, '0'+num/10, 0,255,255,true,false);
      printMyCharWH(x+15,y,15,16, '0'+num%10, 0,255,255,true,false);
  }
      
}
 
//рисует сетку с цифрами и ждет нажатия на клетку
//возвращает номер нажатой клетки
int draw_grid()
{
  int stepx=MAX_X/4;
  int stepy=MAX_Y/4;
  int r=255,g=255,b=255;
  int k=0;
  int x1=0,y1=0, x,y;
 
  char buf[8];
 
  for(x=0; x<MAX_X; x+=stepx)
  {
    for(y=0; y<MAX_Y; y+=stepy)
    {
      r=255.0*y/MAX_Y;
      g=255.0*x/MAX_X;
      b=127.0;
      tft.fillRect(x,y,stepx,stepy, myGetColor(r,g,b));
      print_num(x,y,k);
      //?????
      k++;
    }
  }
  while(1) {
  while (!test_touch(x1, y1))
  {
  }
  
 
  k=0;
  for(x=0; x<MAX_X; x+=stepx)
  {
    for(y=0; y<MAX_Y; y+=stepy)
    {
      
      if (x1>=x && x1<=(x+stepx) && y1>=y && y1<=(y+stepy))
      {
        for(int z=0;z<10;z++)
        {
          tft.fillRect(x,y,stepx,stepy, rand());
          //if (test_touch(x1,y1)) break;
        }
        //if (k==0) 
        return k;
      }
 
      k++;
    }
  }
  
  }
 
  return k;
}
 
void loop()
{
 
  //Serial.write("loop()\n");
 
  while (1)
  {
    old_setting=setting;
    read_sd_card();
    if (strlen(txt2) == 1)
    {
      if (txt2[0] == ' ') continue;
      else break;
    }
    else break;
  }
 
 
  int cnt_ostatok = test_tft();
  int flag_continue = 0;
 
  //220x176 pixels.
  //0      110      220
  /////////////////////
  //       //        //
  //       //        //
  //88/////////////////
  //       //        //
  //176    //        //
  /////////////////////
  for (int k = 0; k < cnt_ostatok; k++)
  {
    delay(setting.delay_one_symbol);
    if (setting.delay_one_symbol == 0) k--;
    int x=-1, y=-1;
    if (setting.mode & MODE_PAUSE)  pause_fun();
    
    if (test_touch(x, y))
    {
      int d = 50;
 
      if (test_rect(x,y, 55,132, 110, 44))   pause_fun();
      if ( test_rect(x,y, 110 - d, 88 - d, d*2, d*2)) 
      {
        pause_pause(x,y); write_settings(); effect();
        cnt_ostatok = test_tft(); k = 0; continue; 
      }
 
      if (test_rect(x,y, 0,MAX_Y-40, 55, 40)){message("RANDOM");rnd_text();}
      
      if (test_rect(x,y, 0,0, 55,44)){fun_find_zvezd();break;}
      
      if (test_rect(x,y, MAX_X-55, 132, 55 ,44)) {flag_continue = 1;break;}
 
      //поиск предыдущей главы
      if (test_rect(x,y, MAX_X-55, 0, 55,44)) {flag_continue = 2;break;}
 
      //поиск предыдущего стиха
      if (test_rect(x,y, MAX_X/2-20, 0, 55,44)) {flag_continue = 3;break;}
 
      if (test_rect(x,y,165,88-15, 30,30, 1))
          {
            for(int i=0; i<3;i++)
            {
              tft.fillRect(165,88-15,55, 30, GREEN);
              delay(20);
              tft.fillRect(165,88-15,55, 30, BLACK);
              delay(20);
              
            }
 
            int n=draw_grid();
            if (n==0)
            {
 
            setting.pos = 0;
            setting.mode = MODE_NORMAL | MODE_RND;
  
            message("RESET");
            find_symbol('*');             
            delay(1000);
            write_settings();
            }
            if (n>=1 && n<=9)
            {
                message("FIND ...");
                setting.pos = 0;
                setting.mode = MODE_NORMAL;
                find_symbol('*', '0'+n);             
            }
              if (n==10)
              {
                scaleW-=2;
                scaleH-=2;
              }
              if (n==11)
              {
                scaleW+=2;
                scaleH+=2;
              }
            
            
          }
 
    }
  }
 
  if (flag_rnd && !flag_continue)
  {
    rnd_text();
    flag_rnd = 0;
  }
 
  if (flag_continue == 2)
  {
      //test_scroll();
      message("P GL");
      text_find_prev();
  }
 
  if (flag_continue == 3)
  {
      //test_scroll();
      message("P ST");
      text_find_prev_stih();
  }
  //
 
}
 
/*void    test_scroll()
{
      cbi(tft.P_CS, tft.B_CS);    
      
      tft.LCD_Write_COM_DATA(0x31,MAX_X);
      tft.LCD_Write_COM_DATA(0x32,0);
      tft.setColor(0);
      for(int i=0; i<=MAX_X;i++)
      {
        cbi(tft.P_CS, tft.B_CS);    
        tft.LCD_Write_COM_DATA(0x33,i);
        
        tft.drawVLine(MAX_X-i,0,MAX_Y);
        sbi(tft.P_CS, tft.B_CS);    
        delay(1);
      }
    
      sbi(tft.P_CS, tft.B_CS);    
}*/
 
int menu(char**str, int c)
{
  tft.clrScr();
  int step_y=20;
  for(int i=0; i<c; i++)
  {
    message(str[i], i*step_y,1);
  }
  wait_press();
  
}

//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

//свойства кубика
    enum box_logic{
        BACKGROUND  =0x8000,    //кирпич есть задний  фон(для всех объектов
                            //он равнозначен пустоте)
        ALIEN       =0x4000,//это не кубик, а код кубика задает номер чужого
        FOREGROUND  =0x2000,//этот кирпич будет поверх всех объектов
        logTRANSP   =BACKGROUND,    //"логически прозрачный"
        TRANSPARENTPIXELS=0x1000,   //кирпич имеет прозрачные пикселы(иначе неимет)
        DESTROYED   =0x0800,    //кирпичик может разрушаться
        COLLAPSE    =0x0400,    //кирпичик обваливается под ногами
        PULL=DESTROYED | FOREGROUND, //кирпичик, когда разрушается, тащит все за собой
        //действительно только для чужих
        //AGAIN=FOREGROUND  //чужой должен появиться снова, если его загасят
    };

bool CopyDoubleBufferToScreen(LPDIRECTDRAWSURFACE pSurface)
{
    //проверка на "потерю" поверхности
    if (pSurface->IsLost())
    {
        //восстанавливаем поверхность в данном случае
        pSurface->Restore();
    }
 
    DDSURFACEDESC ddSDesc={0};
    bool ok=false;
 
    ddSDesc.dwSize=sizeof(DDSURFACEDESC);
 
    //блокируем поверхность, получая указатель на данные
    HRESULT result = pSurface->Lock(NULL, &ddSDesc,
        DDLOCK_SURFACEMEMORYPTR| DDLOCK_NOSYSLOCK,NULL);
 
    if (result==DD_OK)
    {
        UINT hei=ddSDesc.dwHeight;
 
        char *buf= (char*) ddSDesc.lpSurface;
        int z=0;
 
        //исходные данные (буфер 320x200 точек) 1 байт на точку
        BYTE *sourc=scr.DoubleBuffer;
 
        int add_pitch=ddSDesc.lPitch;
 
 
        COLORREF screendata[320*200];
 
        scr.ConvertDoubleBufferToTrueColor(screendata);
 
        //исходные данные - 4 байта на точку
        sourc=(BYTE*) screendata;
 
        //если установлено соотвествующее разрешение
        //корректируем расположение буфера
        if (DISPLAY_HORIZONTAL>= 640 && DISPLAY_VERTICAL>=400)
        {
            int ScaleX=2,ScaleY=2;
 
            //центровка oX
            buf+=(ddSDesc.dwWidth*4-320*4*ScaleX)/2;
            //buf+=WindowRect.left*4;
 
            //центровка oY
            buf+=(ddSDesc.dwHeight-200*ScaleY)/2*add_pitch;
            //buf+=ddSDesc.dwWidth*WindowRect.top;
 
 
            //ВНИМАНИЕ!! верно только для разрешения не ниже 640x400
            for(int i=0; i<200;i++)
            {
                _asm 
                {
                    pusha
                    mov edx,ScaleY
                l2:
                    mov esi,sourc
                    mov edi,buf
                    mov ecx,320
                    cld
                l1:
                    lodsd
                    stosd
                    stosd
                    loop l1
                    mov eax,add_pitch
                    add buf,eax
                    dec edx
                    jnz l2
                    popa
                }
                sourc+=320*4;
            }
 
        }
 
        pSurface->Unlock(ddSDesc.lpSurface);
        ok=true;
    }
 
    return ok;
 
}