1. 程式人生 > 實用技巧 >超級瑪麗1.0

超級瑪麗1.0

/*********************************************
               identifier.h
 *********************************************/ 
#define MarioRed        RGB(224,  80,   0)    
#define MarioGreen        RGB(136, 136,   0)    
#define MarioYellow        RGB(255, 160,   0)
#define SkyColor        RGB( 80, 128, 255)

#define
BrickColor11 RGB(192, 112, 0) #define BrickColor12 RGB( 64, 144, 192) #define PipeColor RGB(152, 232, 0) #define FlagpoleColor RGB(152, 232, 0) #define PipeDecColor RGB( 72, 168, 16) #define PoleTopColor RGB( 72, 168, 16) #define FlagColor RGB( 72, 168, 16) IMAGE readyImg;
char imgName[16]; IMAGE levelImg[30]; bool JumpState = false; bool SmallJump = false; bool BigJump = false; bool stillJump = false; bool FirstJump = true; bool Fall = false; bool stillState = true; bool FallCollision = true
; char dir = 'E'; char preDir = 'E'; char stillDir = 'D'; //control the jump direction at the same time char Jump = 'E'; int BigJumpTime = 0; int JumpAnti = 0; double t0 = 0.0; double t = 0.0; bool highState = true; int SMMV = 600; int MMH = 144; int oldSMMV = 0; int preMMH = 0; int jumpCount = 0; int maxWalkDst = 0; int walkState = 0; int bgCount = 0; int bgX = 0; bool bbState[60]; //control the state of the box and brick int i; int j; int k; int m; int n; int x; int y; int bbV[60]; int bbH[60]; int pipeH[6]; int trapH[3]; int stepH[17]; int flagH; int oldFlagHeight = 600-429; char lifeInfo[3]; int lifeCount = 3; bool win = false; int level = 0; void loadBgImg() { for(i=0; i!=15; ++i) { sprintf(imgName, "picture\\%d.bmp", i+15*level); loadimage(&levelImg[i+15*level], imgName); } } void dataInitialization() { PlaySound(TEXT("music\\superMario.wav"), NULL, SND_ASYNC); for(i=0; i!=60; ++i) bbState[i] =false; //initialization of the state of box and bric JumpState = false; SmallJump = false; BigJump = false; stillJump = false; FirstJump = true; Fall = false; stillState = true; FallCollision = true; dir = 'E'; preDir = 'E'; stillDir = 'D'; //control the jump direction at the same time Jump = 'E'; BigJumpTime = 0; JumpAnti = 0; SMMV = 600; MMH = 144; oldSMMV = 0; preMMH = 0; jumpCount = 0; maxWalkDst = 0; walkState = 0; bgCount = 0; bgX = 0; }
/**********************************
        drawElement.h
 **********************************/
#include "identifier.h"

void drawBg()
{
    bgX = -1*(maxWalkDst%768);
    putimage(bgX, 0, &levelImg[bgCount+15*level]);
    putimage(768+bgX, 0, &levelImg[bgCount+1+15*level]);
}

void box11()
{
    setfillcolor(BrickColor11);
    solidrectangle(x-21,y-24,x+21,y+21);
    solidrectangle(x-24,y-21,x-21,y+21);

    setfillcolor(BLACK);
    solidrectangle(x-18,y-18,x-15,y-15);
    solidrectangle(x+15,y-18,x+18,y-15);
    solidrectangle(x-18,y+15,x-15,y+18);
    solidrectangle(x+15,y+15,x+18,y+18);

    solidrectangle(x-6,y-12,x+3,y-9);
    solidrectangle(x-6,y-9,x-3,y);
    solidrectangle(x-9,y-3,x-6,y);

    solidrectangle(x+9,y-9,x+12,y+3);
    solidrectangle(x+3,y,x+9,y+3);
    solidrectangle(x+3,y+3,x+6,y+9);
    solidrectangle(x,y+6,x+3,y+9);

    solidrectangle(x+3,y+12,x+6,y+18);
    solidrectangle(x,y+15,x+3,y+18);

    solidrectangle(x-24,y+21,x+24,y+24);
    solidrectangle(x+21,y-21,x+24,y+21);
}

void brick11()
{
    setfillcolor(WHITE);
    solidrectangle(x-24,y-24,x+24,y-21);

    setfillcolor(BrickColor11);
    solidrectangle(x-24,y-21,x+24,y+24);

    setfillcolor(BLACK);
    solidrectangle(x-24,y-3,x+24,y);
    solidrectangle(x-24,y-15,x+24,y-12);
    solidrectangle(x-24,y+9,x+24,y+12);
    solidrectangle(x-24,y+21,x+24,y+24);

    solidrectangle(x-3,y-21,x,y-15);
    solidrectangle(x+21,y-21,x+24,y-15);
    solidrectangle(x-15, y-12,x-12,y-3);
    solidrectangle(x+9,y-12,x+12,y-3);
    solidrectangle(x-3,y,x,y+9);
    solidrectangle(x+21,y,x+24,y+9);
    solidrectangle(x-15,y+12,x-12,y+21);
    solidrectangle(x+9,y+12,x+12,y+21);
}

void box12()
{
    setfillcolor(BrickColor11);
    solidrectangle(x-21,y-24,x+21,y+21);
    solidrectangle(x-24,y-21,x-21,y+21);

    setfillcolor(BrickColor12);
    solidrectangle(x-18,y-18,x-15,y-15);
    solidrectangle(x+15,y-18,x+18,y-15);
    solidrectangle(x-18,y+15,x-15,y+18);
    solidrectangle(x+15,y+15,x+18,y+18);

    solidrectangle(x-6,y-12,x+3,y-9);
    solidrectangle(x-6,y-9,x-3,y);
    solidrectangle(x-9,y-3,x-6,y);

    solidrectangle(x+9,y-9,x+12,y+3);
    solidrectangle(x+3,y,x+9,y+3);
    solidrectangle(x+3,y+3,x+6,y+9);
    solidrectangle(x,y+6,x+3,y+9);

    solidrectangle(x+3,y+12,x+6,y+18);
    solidrectangle(x,y+15,x+3,y+18);

    solidrectangle(x-24,y+21,x+24,y+24);
    solidrectangle(x+21,y-21,x+24,y+21);
}

void brick12()
{
    setfillcolor(BrickColor12);
    solidrectangle(x-24,y-24,x+24,y+24);

    setfillcolor(BLACK);
    solidrectangle(x-24,y-3,x+24,y);
    solidrectangle(x-24,y-15,x+24,y-12);
    solidrectangle(x-24,y+9,x+24,y+12);
    solidrectangle(x-24,y+21,x+24,y+24);

    solidrectangle(x-3,y-24,x,y-15);
    solidrectangle(x+21,y-24,x+24,y-15);
    solidrectangle(x-15, y-12,x-12,y-3);
    solidrectangle(x+9,y-12,x+12,y-3);
    solidrectangle(x-3,y,x,y+9);
    solidrectangle(x+21,y,x+24,y+9);
    solidrectangle(x-15,y+12,x-12,y+21);
    solidrectangle(x+9,y+12,x+12,y+21);
}

void pipe4()
{
    setfillcolor(PipeColor);
    solidrectangle(x-39,y-144,x+39,y);
    solidrectangle(x-45,y-189,x+45,y-150);

    setfillcolor(PipeDecColor);
    //bottom block decoration
    solidrectangle(x-30,y-144,x-24,y);
    solidrectangle(x-9,y-144,x-6,y);
    solidrectangle(x,y-144,x+24,y);
    //top block decoration
    solidrectangle(x-45, y-186, x-36, y-183);
    solidrectangle(x-12,y-186,x+45,y-183);
    solidrectangle(x-36,y-186,x-30,y-150);
    solidrectangle(x-12,y-183,x-9,y-150);
    solidrectangle(x-3,y-183,x+27,y-150);

    //bottom 3 columns
    for(i=x+24, j=y-141; j!=y+3; j+=6)
        solidrectangle(i,j,i+3,j+3);

    for(i=x+27, j=y-144; j!=y; j+=6)
        solidrectangle(i,j,i+3,j+3);

    for(i=x+30, j=y-141; j!=y+3; j+=6)
        solidrectangle(i,j,i+3,j+3);

    //top 4 columns
    for(i=x+27, j=y-180; j!=y-150; j+=6)
        solidrectangle(i,j,i+3,j+3);

    for(i=x+30, j=y-183; j!=y-147; j+=6)
        solidrectangle(i,j,i+3,j+3);

    for(i=x+33, j=y-180; j!=y-150; j+=6)
        solidrectangle(i,j,i+3,j+3);

    for(i=x+36, j=y-183; j!=y-147; j+=6)
        solidrectangle(i,j,i+3,j+3);

    setfillcolor(BLACK);
    solidrectangle(x-42,y-144,x-39,y);
    solidrectangle(x+39,y-144,x+42,y);
    solidrectangle(x-42,y-147,x+42,y-144);
    solidrectangle(x-48,y-189,x-45,y-150);
    solidrectangle(x+45,y-189,x+48,y-150);
    solidrectangle(x-48,y-192,x+48,y-189);
    solidrectangle(x-48,y-150,x+48,y-147);
}

void pipeL()
{
    m=x;
    n=y;

    x+=48;
    pipe4();

    m-=24;
    n-=48;
    setfillcolor(PipeColor);
    solidrectangle(m-24,n-42,m+36,n+42);
    solidrectangle(m+36,n-33,m+39,n+33);
    solidrectangle(m+39,n-18,m+42,n+18);

    setfillcolor(PipeDecColor);
    solidrectangle(m-24,n-30,m+39,n-24);
    solidrectangle(m-24,n-9,m+42,n-6);
    solidrectangle(m-24,n,m+42,n+27);
    for(i=m-24,j=n+27;i!=m+42;i+=6)
        solidrectangle(i,j,i+3,j+3);
    for(i=m-21,j=n+30;i!=m+39;i+=6)
        solidrectangle(i,j,i+3,j+3);
    for(i=m-24,j=n+33;i!=m+36;i+=6)
        solidrectangle(i,j,i+3,j+3);

    setfillcolor(BLACK);
    solidrectangle(m-24,n-45,m+36,n-42);
    solidrectangle(m-24,n+42,m+36,n+45);
    solidrectangle(m+36,n-42,m+39,n-33);
    solidrectangle(m+36,n+33,m+39,n+42);
    solidrectangle(m+39,n-33,m+42,n-18);
    solidrectangle(m+39,n+18,m+42,n+33);
    solidrectangle(m+42,n-18,m+45,n+18);

    m-=48;
    setfillcolor(PipeColor);
    solidrectangle(m-21,n-45,m+18,n+45);

    setfillcolor(PipeDecColor);
    solidrectangle(m-21,n-33,m+18,n-27);
    solidrectangle(m-21,n-12,m+18,n-9);
    solidrectangle(m-21,n+3,m+18,n+30);
    for(i=m-21,j=n+30;i!=m+21;i+=6)
        solidrectangle(i,j,i+3,j+3);
    for(i=m-18,j=n+33;i!=m+18;i+=6)
        solidrectangle(i,j,i+3,j+3);
    for(i=m-21,j=n+36;i!=m+21;i+=6)
        solidrectangle(i,j,i+3,j+3);

    setfillcolor(BLACK);
    solidrectangle(m-24,n-48,m-21,n+48);
    solidrectangle(m+18,n-48,m+21,n+48);
    solidrectangle(m+21,n-45,m+24,n+45);
    solidrectangle(m-21,n-48,m+18,n-45);
    solidrectangle(m-21,n+45,m+18,n+48);
}

void flag()
{
    //flag
    setfillcolor(WHITE);
    for(i=x-48,j=y-453;i!=x;i+=3,j+=3)
        solidrectangle(i,j,x,j+3);

    setfillcolor(FlagColor);
    solidrectangle(x-21,y-450,x-6,y-447);
    solidrectangle(x-21,y-447,x-18,y-444);
    solidrectangle(x-9,y-447,x-6,y-444);
    solidrectangle(x-24,y-447,x-21,y-438);
    solidrectangle(x-6,y-447,x-3,y-438);
    solidrectangle(x-24,y-438,x-15,y-432);
    solidrectangle(x-12,y-438,x-3,y-432);
    solidrectangle(x-15,y-435, x-12,y-432);
    solidrectangle(x-18,y-432,x-9,y-429);
    solidrectangle(x-18,y-441,x-9,y-438);
    solidrectangle(x-15,y-447,x-12,y-441);
}
/****************************
         drawSmallMario.h
 ****************************/
#include "drawElement.h"

void JumpDetect()
{
    if(GetKeyState('K')<0)
    {
        if(!JumpState)
        {
            JumpState = true;
            if(dir=='E')
                stillJump = true;
            else
                stillJump = false;
            stillState = false;
            oldSMMV = SMMV;
            Jump = 'K';
        }
        else if(Jump=='K')
        {
            ++BigJumpTime;
            if(BigJumpTime>=15 && BigJumpTime<=29)
                SmallJump = true;
            else if(BigJumpTime>=30)
            {
                BigJump = true;
                SmallJump = false;
            }
        }
    }
    else
        Jump = 'E';
}

void DirDetect()
{
    preDir = dir;
    if(GetKeyState('D')<0 || GetKeyState('A')<0)
    {
        if(GetKeyState('D')<0 && GetKeyState('A')<0)
            dir = 'E';
        else if(GetKeyState('D')<0)
            dir = 'D';
        else if(GetKeyState('A')<0)
            dir = 'A';
    }
    else
        dir = 'E';
}

void calculateMMH()
{
    preMMH = MMH;
    switch(dir)
    {
    case 'D':
        if((JumpState && stillDir=='A') || stillJump)
        {    
            if(++JumpAnti==3)
            {
                MMH+=3;
                JumpAnti = 0;
            }
        }
        else if(JumpState)
        {
            if(++JumpAnti==2)
            {
                MMH+=3;
                JumpAnti=0;
            }
        }
        else
            MMH += 3;
        if(!JumpState)
            stillDir = 'D';
        if(MMH>360)
        {
            maxWalkDst += 3;
            if(maxWalkDst%768==0)
                ++bgCount;
        }
        break;
    case 'A':
        if((JumpState && stillDir=='D') || stillJump)
        {    
            if(++JumpAnti==3)
            {
                MMH-=3;
                JumpAnti = 0;
            }
        }
        else if(JumpState)
        {
            if(++JumpAnti==2)
            {
                MMH-=3;
                JumpAnti=0;
            }
        }
        else
            MMH -= 3;
        if(!JumpState)
            stillDir = 'A';
        break;
    default:
        walkState = 0;
        JumpAnti = 0;
        break;
    }
    MMH = max(24, min(MMH, 360));
}

void calculateSMMV()
{
    if(JumpState == true)
    {
        if(FirstJump)
        {
            SMMV -= 3;
            FirstJump = false;
            t0=0.0;
            t=2.006289;
        }
        else
        {
            if(BigJump)            //big jump
            {
                if(Fall==false)   //240 height
                {
                    SMMV -= 3;
                    t0+=t;
                    t=(320-t0-sqrt(pow(320-t0, 2)-1280));
                    if(++jumpCount==79)
                    {
                        Fall=true;
                        t0=0;
                    }
                }
                else if(Fall==true)
                {
                    if(SMMV==oldSMMV)
                    {
                        JumpState = false;
                        Fall = false;
                        FirstJump = true;
                        BigJump = false;
                        BigJumpTime = 0;
                        JumpAnti = 0;
                        stillJump = false;
                        FallCollision = true;
                        jumpCount=0;
                    }
                    else
                        SMMV += 3;
                    t=-t0+sqrt(pow(t0,2)+1280);
                    t0+=t;
                }
            }
            else            //small jump
            {
                if(Fall==false)
                {
                    SMMV -= 3;
                    t0+=t;
                    t=(320-t0-sqrt(pow(320-t0, 2)-1280));
                    if(++jumpCount==35)
                    {
                        Fall=true;
                        t0=237.318;
                    }
                }
                else if(Fall==true)
                {
                    if(SMMV==oldSMMV)
                    {
                        JumpState = false;
                        Fall = false;
                        FirstJump = true;
                        SmallJump = false;
                        BigJumpTime = 0;
                        JumpAnti = 0;
                        stillJump = false;
                        FallCollision = true;
                        jumpCount = 0;
                    }
                    else
                        SMMV += 3;
                    t=(-t0+sqrt(pow(t0,2)+1280));
                    t0+=t;
                }
            }
        }
    }
    else
        stillState = true;
}

void displayTime()
{
    if(JumpState)
        Sleep((unsigned long)t);
    else if(dir == preDir)
        Sleep(10);
    else
        Sleep(100);    
}

void drawStillSmallRightMario()
{
    setfillcolor(MarioGreen);
    POINT greenPts1[] = {{MMH-15, SMMV-15}, {MMH-12, SMMV-15}, {MMH-12, SMMV-18},
                            {MMH+9, SMMV-18}, {MMH+9, SMMV-9}, {MMH+15, SMMV-9},
                            {MMH+15, SMMV-6}, {MMH-15, SMMV-6}};
    POINT greenPts2[] = {{MMH-12, SMMV-3}, {MMH+6, SMMV-3}, {MMH+6, SMMV},
                            {MMH+15, SMMV}, {MMH+15, SMMV+3}, {MMH+18, SMMV+3},
                            {MMH+18, SMMV+9}, {MMH-18, SMMV+9}, {MMH-18, SMMV+3},
                            {MMH-15, SMMV+3}, {MMH-15, SMMV}, {MMH-12, SMMV}};
    POINT greenPts3[] = {{MMH-18, SMMV+21}, {MMH-15, SMMV+21}, {MMH-15, SMMV+18},
                            {MMH-6, SMMV+18}, {MMH-6, SMMV+24}, {MMH-18, SMMV+24}};
    POINT greenPts4[] = {{MMH+18, SMMV+21}, {MMH+15, SMMV+21}, {MMH+15, SMMV+18},
                            {MMH+6, SMMV+18}, {MMH+6, SMMV+24}, {MMH+18, SMMV+24}};
    solidpolygon(greenPts1, 8);
    solidpolygon(greenPts2, 12);
    solidpolygon(greenPts3, 6);
    solidpolygon(greenPts4, 6);

    setfillcolor(MarioRed);
    POINT redPts1[] = {{MMH-12, SMMV-21}, {MMH-9, SMMV-21}, {MMH-9, SMMV-24},
                        {MMH+6, SMMV-24}, {MMH+6, SMMV-21}, {MMH+15, SMMV-21},
                        {MMH+15, SMMV-18}, {MMH-12, SMMV-18}};
    POINT redPts2[] = {{MMH-6, SMMV-3}, {MMH-3, SMMV-3}, {MMH-3, SMMV+3},
                        {MMH+3, SMMV+3}, {MMH+3, SMMV}, {MMH+6, SMMV},
                        {MMH+6, SMMV+6}, {MMH+9, SMMV+6}, {MMH+9, SMMV+12},
                        {MMH+12, SMMV+12}, {MMH+12, SMMV+18}, {MMH+3, SMMV+18},
                        {MMH+3, SMMV+15}, {MMH-3, SMMV+15}, {MMH-3, SMMV+18},
                        {MMH-12, SMMV+18}, {MMH-12, SMMV+12}, {MMH-9, SMMV+12},
                        {MMH-9, SMMV+6}, {MMH-6, SMMV+6}};
    solidpolygon(redPts1, 8);
    solidpolygon(redPts2, 20);

    setfillcolor(MarioYellow);
    POINT yellowPts1[] = {{MMH-3, SMMV-18}, {MMH+3, SMMV-18}, {MMH+3, SMMV-12},
                            {MMH+6, SMMV-12}, {MMH+6, SMMV-9}, {MMH+3, SMMV-9},
                            {MMH+3, SMMV-6}, {MMH+12, SMMV-6}, {MMH+12, SMMV-3},
                            {MMH-9, SMMV-3}, {MMH-9, SMMV-9}, {MMH-3, SMMV-9},
                            {MMH-3, SMMV-12}, {MMH-6, SMMV-12}, {MMH-6, SMMV-15},
                            {MMH-3, SMMV-15}};
    POINT yellowPts2[] = {{MMH+6, SMMV-18}, {MMH+9, SMMV-18}, {MMH+9, SMMV-15},
                            {MMH+15, SMMV-15}, {MMH+15, SMMV-12}, {MMH+18, SMMV-12},
                            {MMH+18, SMMV-9}, {MMH+9, SMMV-9}, {MMH+9, SMMV-12},
                            {MMH+6, SMMV-12}};
    POINT yellowPts3[] = {{MMH-18, SMMV+6}, {MMH-12, SMMV+6}, {MMH-12, SMMV+9},
                            {MMH-9, SMMV+9}, {MMH-9, SMMV+12}, {MMH-12, SMMV+12},
                            {MMH-12, SMMV+15}, {MMH-18, SMMV+15}};
    POINT yellowPts4[] = {{MMH+18, SMMV+6}, {MMH+12, SMMV+6}, {MMH+12, SMMV+9},
                            {MMH+9, SMMV+9}, {MMH+9, SMMV+12}, {MMH+12, SMMV+12},
                            {MMH+12, SMMV+15}, {MMH+18, SMMV+15}};
    solidpolygon(yellowPts1, 16);
    solidpolygon(yellowPts2, 10);
    solidpolygon(yellowPts3, 8);
    solidpolygon(yellowPts4, 8);
    solidrectangle(MMH-12, SMMV-15, MMH-9, SMMV-9);
    solidrectangle(MMH-6, SMMV+6, MMH-3, SMMV+9);
    solidrectangle(MMH+3, SMMV+6, MMH+6, SMMV+9);
}

void drawStillSmallLeftMario()
{
    setfillcolor(MarioGreen);
    POINT greenPts1[] = {{MMH+15, SMMV-15}, {MMH+12, SMMV-15}, {MMH+12, SMMV-18},
                            {MMH-9, SMMV-18}, {MMH-9, SMMV-9}, {MMH-15, SMMV-9},
                            {MMH-15, SMMV-6}, {MMH+15, SMMV-6}};
    POINT greenPts2[] = {{MMH+12, SMMV-3}, {MMH-6, SMMV-3}, {MMH-6, SMMV},
                            {MMH-15, SMMV}, {MMH-15, SMMV+3}, {MMH-18, SMMV+3},
                            {MMH-18, SMMV+9}, {MMH+18, SMMV+9}, {MMH+18, SMMV+3},
                            {MMH+15, SMMV+3}, {MMH+15, SMMV}, {MMH+12, SMMV}};
    POINT greenPts3[] = {{MMH+18, SMMV+21}, {MMH+15, SMMV+21}, {MMH+15, SMMV+18},
                            {MMH+6, SMMV+18}, {MMH+6, SMMV+24}, {MMH+18, SMMV+24}};
    POINT greenPts4[] = {{MMH-18, SMMV+21}, {MMH-15, SMMV+21}, {MMH-15, SMMV+18},
                            {MMH-6, SMMV+18}, {MMH-6, SMMV+24}, {MMH-18, SMMV+24}};
    solidpolygon(greenPts1, 8);
    solidpolygon(greenPts2, 12);
    solidpolygon(greenPts3, 6);
    solidpolygon(greenPts4, 6);

    setfillcolor(MarioRed);
    POINT redPts1[] = {{MMH+12, SMMV-21}, {MMH+9, SMMV-21}, {MMH+9, SMMV-24},
                        {MMH-6, SMMV-24}, {MMH-6, SMMV-21}, {MMH-15, SMMV-21},
                        {MMH-15, SMMV-18}, {MMH+12, SMMV-18}};
    POINT redPts2[] = {{MMH+6, SMMV-3}, {MMH+3, SMMV-3}, {MMH+3, SMMV+3},
                        {MMH-3, SMMV+3}, {MMH-3, SMMV}, {MMH-6, SMMV},
                        {MMH-6, SMMV+6}, {MMH-9, SMMV+6}, {MMH-9, SMMV+12},
                        {MMH-12, SMMV+12}, {MMH-12, SMMV+18}, {MMH-3, SMMV+18},
                        {MMH-3, SMMV+15}, {MMH+3, SMMV+15}, {MMH+3, SMMV+18},
                        {MMH+12, SMMV+18}, {MMH+12, SMMV+12}, {MMH+9, SMMV+12},
                        {MMH+9, SMMV+6}, {MMH+6, SMMV+6}};
    solidpolygon(redPts1, 8);
    solidpolygon(redPts2, 20);

    setfillcolor(MarioYellow);
    POINT yellowPts1[] = {{MMH+3, SMMV-18}, {MMH-3, SMMV-18}, {MMH-3, SMMV-12},
                            {MMH-6, SMMV-12}, {MMH-6, SMMV-9}, {MMH-3, SMMV-9},
                            {MMH-3, SMMV-6}, {MMH-12, SMMV-6}, {MMH-12, SMMV-3},
                            {MMH+9, SMMV-3}, {MMH+9, SMMV-9}, {MMH+3, SMMV-9},
                            {MMH+3, SMMV-12}, {MMH+6, SMMV-12}, {MMH+6, SMMV-15},
                            {MMH+3, SMMV-15}};
    POINT yellowPts2[] = {{MMH-6, SMMV-18}, {MMH-9, SMMV-18}, {MMH-9, SMMV-15},
                            {MMH-15, SMMV-15}, {MMH-15, SMMV-12}, {MMH-18, SMMV-12},
                            {MMH-18, SMMV-9}, {MMH-9, SMMV-9}, {MMH-9, SMMV-12},
                            {MMH-6, SMMV-12}};
    POINT yellowPts3[] = {{MMH+18, SMMV+6}, {MMH+12, SMMV+6}, {MMH+12, SMMV+9},
                            {MMH+9, SMMV+9}, {MMH+9, SMMV+12}, {MMH+12, SMMV+12},
                            {MMH+12, SMMV+15}, {MMH+18, SMMV+15}};
    POINT yellowPts4[] = {{MMH-18, SMMV+6}, {MMH-12, SMMV+6}, {MMH-12, SMMV+9},
                            {MMH-9, SMMV+9}, {MMH-9, SMMV+12}, {MMH-12, SMMV+12},
                            {MMH-12, SMMV+15}, {MMH-18, SMMV+15}};
    solidpolygon(yellowPts1, 16);
    solidpolygon(yellowPts2, 10);
    solidpolygon(yellowPts3, 8);
    solidpolygon(yellowPts4, 8);
    solidrectangle(MMH+9, SMMV-15, MMH+12, SMMV-9);
    solidrectangle(MMH+3, SMMV+6, MMH+6, SMMV+9);
    solidrectangle(MMH-6, SMMV+6, MMH-3, SMMV+9);
}

void drawStillSmallMario()
{
    if(stillDir=='D')
        drawStillSmallRightMario();
    else
        drawStillSmallLeftMario();
    //need isolation of left and right
}

void drawWalkSmallRightMarioFirst()
{
    setfillcolor(MarioGreen);
    POINT greenPts1[] = {{MMH-15, SMMV-15}, {MMH-12, SMMV-15}, {MMH-12, SMMV-18},
                            {MMH+9, SMMV-18}, {MMH+9, SMMV-9}, {MMH+15, SMMV-9},
                            {MMH+15, SMMV-6}, {MMH-15, SMMV-6}};
    POINT greenPts2[] = {{MMH-18, SMMV-3}, {MMH+6, SMMV-3}, {MMH+6, SMMV},
                            {MMH+12, SMMV}, {MMH+12, SMMV+3}, {MMH+15, SMMV+3},
                            {MMH+15, SMMV+6}, {MMH-12, SMMV+6}, {MMH-12, SMMV+3},
                            {MMH-18, SMMV+3}};
    POINT greenPts3[] =    {{MMH-21, SMMV+15}, {MMH-12, SMMV+15}, {MMH-12, SMMV+21},
                            {MMH-9, SMMV+21}, {MMH-9, SMMV+24}, {MMH-18, SMMV+24},
                            {MMH-18, SMMV+21}, {MMH-21, SMMV+21}};
    POINT greenPts4[] = {{MMH+12, SMMV+9}, {MMH+15, SMMV+9}, {MMH+15, SMMV+6},
                            {MMH+18, SMMV+6}, {MMH+18, SMMV+18}, {MMH+12, SMMV+18}};
    solidpolygon(greenPts1, 8);
    solidpolygon(greenPts2, 10);
    solidpolygon(greenPts3, 8);
    solidpolygon(greenPts4, 6);

    setfillcolor(MarioRed);
    POINT redPts1[] = {{MMH-12, SMMV-21}, {MMH-9, SMMV-21}, {MMH-9, SMMV-24},
                        {MMH+6, SMMV-24}, {MMH+6, SMMV-21}, {MMH+15, SMMV-21},
                        {MMH+15, SMMV-18}, {MMH-12, SMMV-18}};
    POINT redPts2[] = {{MMH-6, SMMV-3}, {MMH, SMMV-3}, {MMH, SMMV},
                        {MMH+3, SMMV}, {MMH+3, SMMV+3}, {MMH+9, SMMV+3},
                        {MMH+9, SMMV+9}, {MMH+12, SMMV+9}, {MMH+12, SMMV+18},
                        {MMH+3, SMMV+18}, {MMH+3, SMMV+15}, {MMH-6, SMMV+15},
                        {MMH-6, SMMV+18}, {MMH-15, SMMV+18}, {MMH-15, SMMV+15},
                        {MMH-18, SMMV+15}, {MMH-18, SMMV+12}, {MMH-15, SMMV+12},
                        {MMH-15, SMMV+9}, {MMH-12, SMMV+9}, {MMH-12, SMMV+6},
                        {MMH-6, SMMV+6}};
    solidpolygon(redPts1, 8);
    solidpolygon(redPts2, 22);

    setfillcolor(MarioYellow);
    POINT yellowPts1[] = {{MMH-3, SMMV-18}, {MMH+3, SMMV-18}, {MMH+3, SMMV-12},
                            {MMH+6, SMMV-12}, {MMH+6, SMMV-9}, {MMH+3, SMMV-9},
                            {MMH+3, SMMV-6}, {MMH+12, SMMV-6}, {MMH+12, SMMV-3},
                            {MMH-9, SMMV-3}, {MMH-9, SMMV-9}, {MMH-3, SMMV-9},
                            {MMH-3, SMMV-12}, {MMH-6, SMMV-12}, {MMH-6, SMMV-15},
                            {MMH-3, SMMV-15}};
    POINT yellowPts2[] = {{MMH+6, SMMV-18}, {MMH+9, SMMV-18}, {MMH+9, SMMV-15},
                            {MMH+15, SMMV-15}, {MMH+15, SMMV-12}, {MMH+18, SMMV-12},
                            {MMH+18, SMMV-9}, {MMH+9, SMMV-9}, {MMH+9, SMMV-12},
                            {MMH+6, SMMV-12}};
    POINT yellowPts3[] = {{MMH-24, SMMV}, {MMH-18, SMMV}, {MMH-18, SMMV+3},
                            {MMH-15, SMMV+3}, {MMH-15, SMMV+6}, {MMH-18, SMMV+6},
                            {MMH-18, SMMV+9}, {MMH-24, SMMV+9}};
    POINT yellowPts4[] = {{MMH+12, SMMV}, {MMH+21, SMMV}, {MMH+21, SMMV+6},
                            {MMH+15, SMMV+6}, {MMH+15, SMMV+3}, {MMH+12, SMMV+3}};
    solidpolygon(yellowPts1, 16);
    solidpolygon(yellowPts2, 10);
    solidpolygon(yellowPts3, 8);
    solidpolygon(yellowPts4, 6);
    solidrectangle(MMH-12, SMMV-15, MMH-9, SMMV-9);
    solidrectangle(MMH-3, SMMV+3, MMH, SMMV+6);
}

void drawWalkSmallLeftMarioFirst()
{
    setfillcolor(MarioGreen);
    POINT greenPts1[] = {{MMH+15, SMMV-15}, {MMH+12, SMMV-15}, {MMH+12, SMMV-18},
                            {MMH-9, SMMV-18}, {MMH-9, SMMV-9}, {MMH-15, SMMV-9},
                            {MMH-15, SMMV-6}, {MMH+15, SMMV-6}};
    POINT greenPts2[] = {{MMH+18, SMMV-3}, {MMH-6, SMMV-3}, {MMH-6, SMMV},
                            {MMH-12, SMMV}, {MMH-12, SMMV+3}, {MMH-15, SMMV+3},
                            {MMH-15, SMMV+6}, {MMH+12, SMMV+6}, {MMH+12, SMMV+3},
                            {MMH+18, SMMV+3}};
    POINT greenPts3[] =    {{MMH+21, SMMV+15}, {MMH+12, SMMV+15}, {MMH+12, SMMV+21},
                            {MMH+9, SMMV+21}, {MMH+9, SMMV+24}, {MMH+18, SMMV+24},
                            {MMH+18, SMMV+21}, {MMH+21, SMMV+21}};
    POINT greenPts4[] = {{MMH-12, SMMV+9}, {MMH-15, SMMV+9}, {MMH-15, SMMV+6},
                            {MMH-18, SMMV+6}, {MMH-18, SMMV+18}, {MMH-12, SMMV+18}};
    solidpolygon(greenPts1, 8);
    solidpolygon(greenPts2, 10);
    solidpolygon(greenPts3, 8);
    solidpolygon(greenPts4, 6);

    setfillcolor(MarioRed);
    POINT redPts1[] = {{MMH+12, SMMV-21}, {MMH+9, SMMV-21}, {MMH+9, SMMV-24},
                        {MMH-6, SMMV-24}, {MMH-6, SMMV-21}, {MMH-15, SMMV-21},
                        {MMH-15, SMMV-18}, {MMH+12, SMMV-18}};
    POINT redPts2[] = {{MMH+6, SMMV-3}, {MMH, SMMV-3}, {MMH, SMMV},
                        {MMH-3, SMMV}, {MMH-3, SMMV+3}, {MMH-9, SMMV+3},
                        {MMH-9, SMMV+9}, {MMH-12, SMMV+9}, {MMH-12, SMMV+18},
                        {MMH-3, SMMV+18}, {MMH-3, SMMV+15}, {MMH+6, SMMV+15},
                        {MMH+6, SMMV+18}, {MMH+15, SMMV+18}, {MMH+15, SMMV+15},
                        {MMH+18, SMMV+15}, {MMH+18, SMMV+12}, {MMH+15, SMMV+12},
                        {MMH+15, SMMV+9}, {MMH+12, SMMV+9}, {MMH+12, SMMV+6},
                        {MMH+6, SMMV+6}};
    solidpolygon(redPts1, 8);
    solidpolygon(redPts2, 22);

    setfillcolor(MarioYellow);
    POINT yellowPts1[] = {{MMH+3, SMMV-18}, {MMH-3, SMMV-18}, {MMH-3, SMMV-12},
                            {MMH-6, SMMV-12}, {MMH-6, SMMV-9}, {MMH-3, SMMV-9},
                            {MMH-3, SMMV-6}, {MMH-12, SMMV-6}, {MMH-12, SMMV-3},
                            {MMH+9, SMMV-3}, {MMH+9, SMMV-9}, {MMH+3, SMMV-9},
                            {MMH+3, SMMV-12}, {MMH+6, SMMV-12}, {MMH+6, SMMV-15},
                            {MMH+3, SMMV-15}};
    POINT yellowPts2[] = {{MMH-6, SMMV-18}, {MMH-9, SMMV-18}, {MMH-9, SMMV-15},
                            {MMH-15, SMMV-15}, {MMH-15, SMMV-12}, {MMH-18, SMMV-12},
                            {MMH-18, SMMV-9}, {MMH-9, SMMV-9}, {MMH-9, SMMV-12},
                            {MMH-6, SMMV-12}};
    POINT yellowPts3[] = {{MMH+24, SMMV}, {MMH+18, SMMV}, {MMH+18, SMMV+3},
                            {MMH+15, SMMV+3}, {MMH+15, SMMV+6}, {MMH+18, SMMV+6},
                            {MMH+18, SMMV+9}, {MMH+24, SMMV+9}};
    POINT yellowPts4[] = {{MMH-12, SMMV}, {MMH-21, SMMV}, {MMH-21, SMMV+6},
                            {MMH-15, SMMV+6}, {MMH-15, SMMV+3}, {MMH-12, SMMV+3}};
    solidpolygon(yellowPts1, 16);
    solidpolygon(yellowPts2, 10);
    solidpolygon(yellowPts3, 8);
    solidpolygon(yellowPts4, 6);
    solidrectangle(MMH+9, SMMV-15, MMH+12, SMMV-9);
    solidrectangle(MMH, SMMV+3, MMH+3, SMMV+6);
}

void drawWalkSmallRightMarioSecond()
{
    setfillcolor(MarioGreen);
    POINT greenPts1[] = {{MMH-15, SMMV-15}, {MMH-12, SMMV-15}, {MMH-12, SMMV-18},
                            {MMH+9, SMMV-18}, {MMH+9, SMMV-9}, {MMH+15, SMMV-9},
                            {MMH+15, SMMV-6}, {MMH-15, SMMV-6}};
    POINT greenPts2[] = {{MMH-15, SMMV}, {MMH-12, SMMV}, {MMH-12, SMMV-3},
                            {MMH+6, SMMV-3}, {MMH+6, SMMV}, {MMH+9, SMMV},
                            {MMH+9, SMMV+18}, {MMH+12, SMMV+18}, {MMH+12, SMMV+21},
                            {MMH+3, SMMV+21}, {MMH+3, SMMV+24}, {MMH-9, SMMV+24},
                            {MMH-9, SMMV+12}, {MMH-15, SMMV+12}};
    solidpolygon(greenPts1, 8);
    solidpolygon(greenPts2, 14);

    setfillcolor(MarioRed);
    POINT redPts1[] = {{MMH-12, SMMV-21}, {MMH-9, SMMV-21}, {MMH-9, SMMV-24},
                        {MMH+6, SMMV-24}, {MMH+6, SMMV-21}, {MMH+15, SMMV-21},
                        {MMH+15, SMMV-18}, {MMH-12, SMMV-18}};
    POINT redPts2[] = {{MMH-6, SMMV+3}, {MMH-3, SMMV+3}, {MMH-3, SMMV},
                            {MMH+3, SMMV}, {MMH+3, SMMV+3}, {MMH+12, SMMV+3},
                            {MMH+12, SMMV+12}, {MMH+9, SMMV+12}, {MMH+9, SMMV+15},
                            {MMH-3, SMMV+15}, {MMH-3, SMMV+6}, {MMH-6, SMMV+6}};
    solidpolygon(redPts1, 8);
    solidpolygon(redPts2, 12);
    solidrectangle(MMH-9, SMMV+15, MMH, SMMV+18);
    solidrectangle(MMH-6, SMMV-3, MMH-3, SMMV);
    solidrectangle(MMH-15, SMMV+9, MMH-12, SMMV+12);
    solidrectangle(MMH-12, SMMV+12, MMH-9, SMMV+15);

    setfillcolor(MarioYellow);
    POINT yellowPts1[] = {{MMH-3, SMMV-18}, {MMH+3, SMMV-18}, {MMH+3, SMMV-12},
                            {MMH+6, SMMV-12}, {MMH+6, SMMV-9}, {MMH+3, SMMV-9},
                            {MMH+3, SMMV-6}, {MMH+12, SMMV-6}, {MMH+12, SMMV-3},
                            {MMH-9, SMMV-3}, {MMH-9, SMMV-9}, {MMH-3, SMMV-9},
                            {MMH-3, SMMV-12}, {MMH-6, SMMV-12}, {MMH-6, SMMV-15},
                            {MMH-3, SMMV-15}};
    POINT yellowPts2[] = {{MMH+6, SMMV-18}, {MMH+9, SMMV-18}, {MMH+9, SMMV-15},
                            {MMH+15, SMMV-15}, {MMH+15, SMMV-12}, {MMH+18, SMMV-12},
                            {MMH+18, SMMV-9}, {MMH+9, SMMV-9}, {MMH+9, SMMV-12},
                            {MMH+6, SMMV-12}};
    POINT yellowPts3[] = {{MMH-6, SMMV+9}, {MMH+3, SMMV+9}, {MMH+3, SMMV+12},
                            {MMH, SMMV+12}, {MMH, SMMV+15}, {MMH-6, SMMV+15}};
    solidpolygon(yellowPts1, 16);
    solidpolygon(yellowPts2, 10);
    solidpolygon(yellowPts3, 6);
    solidrectangle(MMH-12, SMMV-15, MMH-9, SMMV-9);
    solidrectangle(MMH, SMMV+3, MMH+3, SMMV+6);
    solidrectangle(MMH+9, SMMV+3, MMH+12, SMMV+6);
}

void drawWalkSmallLeftMarioSecond()
{
    setfillcolor(MarioGreen);
    POINT greenPts1[] = {{MMH+15, SMMV-15}, {MMH+12, SMMV-15}, {MMH+12, SMMV-18},
                            {MMH-9, SMMV-18}, {MMH-9, SMMV-9}, {MMH-15, SMMV-9},
                            {MMH-15, SMMV-6}, {MMH+15, SMMV-6}};
    POINT greenPts2[] = {{MMH+15, SMMV}, {MMH+12, SMMV}, {MMH+12, SMMV-3},
                            {MMH-6, SMMV-3}, {MMH-6, SMMV}, {MMH-9, SMMV},
                            {MMH-9, SMMV+18}, {MMH-12, SMMV+18}, {MMH-12, SMMV+21},
                            {MMH-3, SMMV+21}, {MMH-3, SMMV+24}, {MMH+9, SMMV+24},
                            {MMH+9, SMMV+12}, {MMH+15, SMMV+12}};
    solidpolygon(greenPts1, 8);
    solidpolygon(greenPts2, 14);

    setfillcolor(MarioRed);
    POINT redPts1[] = {{MMH+12, SMMV-21}, {MMH+9, SMMV-21}, {MMH+9, SMMV-24},
                        {MMH-6, SMMV-24}, {MMH-6, SMMV-21}, {MMH-15, SMMV-21},
                        {MMH-15, SMMV-18}, {MMH+12, SMMV-18}};
    POINT redPts2[] = {{MMH+6, SMMV+3}, {MMH+3, SMMV+3}, {MMH+3, SMMV},
                            {MMH-3, SMMV}, {MMH-3, SMMV+3}, {MMH-12, SMMV+3},
                            {MMH-12, SMMV+12}, {MMH-9, SMMV+12}, {MMH-9, SMMV+15},
                            {MMH+3, SMMV+15}, {MMH+3, SMMV+6}, {MMH+6, SMMV+6}};
    solidpolygon(redPts1, 8);
    solidpolygon(redPts2, 12);
    solidrectangle(MMH, SMMV+15, MMH+9, SMMV+18);
    solidrectangle(MMH+3, SMMV-3, MMH+6, SMMV);
    solidrectangle(MMH+12, SMMV+9, MMH+15, SMMV+12);
    solidrectangle(MMH+9, SMMV+12, MMH+12, SMMV+15);

    setfillcolor(MarioYellow);
    POINT yellowPts1[] = {{MMH+3, SMMV-18}, {MMH-3, SMMV-18}, {MMH-3, SMMV-12},
                            {MMH-6, SMMV-12}, {MMH-6, SMMV-9}, {MMH-3, SMMV-9},
                            {MMH-3, SMMV-6}, {MMH-12, SMMV-6}, {MMH-12, SMMV-3},
                            {MMH+9, SMMV-3}, {MMH+9, SMMV-9}, {MMH+3, SMMV-9},
                            {MMH+3, SMMV-12}, {MMH+6, SMMV-12}, {MMH+6, SMMV-15},
                            {MMH+3, SMMV-15}};
    POINT yellowPts2[] = {{MMH-6, SMMV-18}, {MMH-9, SMMV-18}, {MMH-9, SMMV-15},
                            {MMH-15, SMMV-15}, {MMH-15, SMMV-12}, {MMH-18, SMMV-12},
                            {MMH-18, SMMV-9}, {MMH-9, SMMV-9}, {MMH-9, SMMV-12},
                            {MMH-6, SMMV-12}};
    POINT yellowPts3[] = {{MMH+6, SMMV+9}, {MMH-3, SMMV+9}, {MMH-3, SMMV+12},
                            {MMH, SMMV+12}, {MMH, SMMV+15}, {MMH+6, SMMV+15}};
    solidpolygon(yellowPts1, 16);
    solidpolygon(yellowPts2, 10);
    solidpolygon(yellowPts3, 6);
    solidrectangle(MMH+9, SMMV-15, MMH+12, SMMV-9);
    solidrectangle(MMH-3, SMMV+3, MMH, SMMV+6);
    solidrectangle(MMH-12, SMMV+3, MMH-9, SMMV+6);
}

void drawWalkSmallRightMarioThird()
{
    setfillcolor(MarioGreen);
    POINT greenPts1[] = {{MMH-15, SMMV-12}, {MMH-12, SMMV-12}, {MMH-12, SMMV-15},
                            {MMH+9, SMMV-15}, {MMH+9, SMMV-6}, {MMH+15, SMMV-6},
                            {MMH+15, SMMV-3}, {MMH-15, SMMV-3}};
    POINT greenPts2[] = {{MMH-18, SMMV+9}, {MMH-12, SMMV+9}, {MMH-12, SMMV+18},
                            {MMH-18, SMMV+18}, {MMH-18, SMMV+21}, {MMH-21, SMMV+21},
                            {MMH-21, SMMV+15}, {MMH-18, SMMV+15}};
    POINT greenPts3[] = {{MMH-6, SMMV+18}, {MMH+3, SMMV+18}, {MMH+3, SMMV+21},
                            {MMH+6, SMMV+21}, {MMH+6, SMMV+24}, {MMH-6, SMMV+24}};
    solidpolygon(greenPts1, 8);
    solidpolygon(greenPts2, 8);
    solidpolygon(greenPts3, 6);
    solidrectangle(MMH-12, SMMV, MMH+6, SMMV+9);

    setfillcolor(MarioRed);
    POINT redPts1[] = {{MMH-12, SMMV-18}, {MMH-9, SMMV-18}, {MMH-9, SMMV-21},
                        {MMH+6, SMMV-21}, {MMH+6, SMMV-18}, {MMH+15, SMMV-18},
                        {MMH+15, SMMV-15}, {MMH-12, SMMV-15}};
    POINT redPts2[] = {{MMH-12, SMMV+6}, {MMH-9, SMMV+6}, {MMH-9, SMMV+9},
                        {MMH+9, SMMV+9}, {MMH+9, SMMV+15}, {MMH+6, SMMV+15},
                        {MMH+6, SMMV+18}, {MMH-3, SMMV+18}, {MMH-3, SMMV+15},
                        {MMH-6, SMMV+15}, {MMH-6, SMMV+18}, {MMH-15, SMMV+18},
                        {MMH-15, SMMV+12}, {MMH-12, SMMV+12}};
    solidpolygon(redPts1, 8);
    solidpolygon(redPts2, 14);
    solidrectangle(MMH, SMMV, MMH+3, SMMV+3);

    setfillcolor(MarioYellow);
    POINT yellowPts1[] = {{MMH-3, SMMV-15}, {MMH+3, SMMV-15}, {MMH+3, SMMV-9},
                            {MMH+6, SMMV-9}, {MMH+6, SMMV-6}, {MMH+3, SMMV-6},
                            {MMH+3, SMMV-3}, {MMH+12, SMMV-3}, {MMH+12, SMMV},
                            {MMH-9, SMMV}, {MMH-9, SMMV-6}, {MMH-3, SMMV-6},
                            {MMH-3, SMMV-9}, {MMH-6, SMMV-9}, {MMH-6, SMMV-12},
                            {MMH-3, SMMV-12}};
    POINT yellowPts2[] = {{MMH+6, SMMV-15}, {MMH+9, SMMV-15}, {MMH+9, SMMV-12},
                            {MMH+15, SMMV-12}, {MMH+15, SMMV-9}, {MMH+18, SMMV-9},
                            {MMH+18, SMMV-6}, {MMH+9, SMMV-6}, {MMH+9,SMMV-9},
                            {MMH+6, SMMV-9}};
    POINT yellowPts3[] = {{MMH-18, SMMV+6}, {MMH-15, SMMV+6}, {MMH-15, SMMV+3},
                            {MMH-12, SMMV+3}, {MMH-12, SMMV+9}, {MMH-18, SMMV+9}};
    POINT yellowPts4[] = {{MMH+6, SMMV+3}, {MMH+9, SMMV+3}, {MMH+9, SMMV},
                            {MMH+12, SMMV}, {MMH+12, SMMV+3}, {MMH+15, SMMV+3},
                            {MMH+15, SMMV+6}, {MMH+12, SMMV+6}, {MMH+12, SMMV+9},
                            {MMH+6, SMMV+9}};
    solidpolygon(yellowPts1, 16);
    solidpolygon(yellowPts2, 10);
    solidpolygon(yellowPts3, 6);
    solidpolygon(yellowPts4, 10);
    solidrectangle(MMH-12, SMMV-12, MMH-9, SMMV-6);
}

void drawWalkSmallLeftMarioThird()
{
    setfillcolor(MarioGreen);
    POINT greenPts1[] = {{MMH+15, SMMV-12}, {MMH+12, SMMV-12}, {MMH+12, SMMV-15},
                            {MMH-9, SMMV-15}, {MMH-9, SMMV-6}, {MMH-15, SMMV-6},
                            {MMH-15, SMMV-3}, {MMH+15, SMMV-3}};
    POINT greenPts2[] = {{MMH+18, SMMV+9}, {MMH+12, SMMV+9}, {MMH+12, SMMV+18},
                            {MMH+18, SMMV+18}, {MMH+18, SMMV+21}, {MMH+21, SMMV+21},
                            {MMH+21, SMMV+15}, {MMH+18, SMMV+15}};
    POINT greenPts3[] = {{MMH+6, SMMV+18}, {MMH-3, SMMV+18}, {MMH-3, SMMV+21},
                            {MMH-6, SMMV+21}, {MMH-6, SMMV+24}, {MMH+6, SMMV+24}};
    solidpolygon(greenPts1, 8);
    solidpolygon(greenPts2, 8);
    solidpolygon(greenPts3, 6);
    solidrectangle(MMH-6, SMMV, MMH+12, SMMV+9);

    setfillcolor(MarioRed);
    POINT redPts1[] = {{MMH+12, SMMV-18}, {MMH+9, SMMV-18}, {MMH+9, SMMV-21},
                        {MMH-6, SMMV-21}, {MMH-6, SMMV-18}, {MMH-15, SMMV-18},
                        {MMH-15, SMMV-15}, {MMH+12, SMMV-15}};
    POINT redPts2[] = {{MMH+12, SMMV+6}, {MMH+9, SMMV+6}, {MMH+9, SMMV+9},
                        {MMH-9, SMMV+9}, {MMH-9, SMMV+15}, {MMH-6, SMMV+15},
                        {MMH-6, SMMV+18}, {MMH+3, SMMV+18}, {MMH+3, SMMV+15},
                        {MMH+6, SMMV+15}, {MMH+6, SMMV+18}, {MMH+15, SMMV+18},
                        {MMH+15, SMMV+12}, {MMH+12, SMMV+12}};
    solidpolygon(redPts1, 8);
    solidpolygon(redPts2, 14);
    solidrectangle(MMH-3, SMMV, MMH, SMMV+3);

    setfillcolor(MarioYellow);
    POINT yellowPts1[] = {{MMH+3, SMMV-15}, {MMH-3, SMMV-15}, {MMH-3, SMMV-9},
                            {MMH-6, SMMV-9}, {MMH-6, SMMV-6}, {MMH-3, SMMV-6},
                            {MMH-3, SMMV-3}, {MMH-12, SMMV-3}, {MMH-12, SMMV},
                            {MMH+9, SMMV}, {MMH+9, SMMV-6}, {MMH+3, SMMV-6},
                            {MMH+3, SMMV-9}, {MMH+6, SMMV-9}, {MMH+6, SMMV-12},
                            {MMH+3, SMMV-12}};
    POINT yellowPts2[] = {{MMH-6, SMMV-15}, {MMH-9, SMMV-15}, {MMH-9, SMMV-12},
                            {MMH-15, SMMV-12}, {MMH-15, SMMV-9}, {MMH-18, SMMV-9},
                            {MMH-18, SMMV-6}, {MMH-9, SMMV-6}, {MMH-9,SMMV-9},
                            {MMH-6, SMMV-9}};
    POINT yellowPts3[] = {{MMH+18, SMMV+6}, {MMH+15, SMMV+6}, {MMH+15, SMMV+3},
                            {MMH+12, SMMV+3}, {MMH+12, SMMV+9}, {MMH+18, SMMV+9}};
    POINT yellowPts4[] = {{MMH-6, SMMV+3}, {MMH-9, SMMV+3}, {MMH-9, SMMV},
                            {MMH-12, SMMV}, {MMH-12, SMMV+3}, {MMH-15, SMMV+3},
                            {MMH-15, SMMV+6}, {MMH-12, SMMV+6}, {MMH-12, SMMV+9},
                            {MMH-6, SMMV+9}};
    solidpolygon(yellowPts1, 16);
    solidpolygon(yellowPts2, 10);
    solidpolygon(yellowPts3, 6);
    solidpolygon(yellowPts4, 10);
    solidrectangle(MMH+9, SMMV-12, MMH+12, SMMV-6);
}

//need to isolate left and right
void drawWalkSmallMario()
{
    if(walkState>=0 && walkState<=6)
        if(dir=='D')
            drawWalkSmallRightMarioFirst();
        else
            drawWalkSmallLeftMarioFirst();
    else if((walkState>=7 && walkState<=13) || (walkState>=21 && walkState<=27))
        if(dir=='D')
            drawWalkSmallRightMarioSecond();    
        else
            drawWalkSmallLeftMarioSecond();
    else if(walkState>=14 && walkState<=20)
        if(dir=='D')
            drawWalkSmallRightMarioThird();
        else
            drawWalkSmallLeftMarioThird();

    if(++walkState==28)
        walkState=0;
}

void drawJumpSmallRightMario()
{
    setfillcolor(MarioGreen);
    POINT greenPts[] = {{MMH-9, SMMV-15}, {MMH+12, SMMV-15}, {MMH+12, SMMV-12},
                            {MMH+15, SMMV-12}, {MMH+15, SMMV-15}, {MMH+24, SMMV-15},
                            {MMH+24, SMMV-6}, {MMH+21, SMMV-6}, {MMH+21, SMMV-3},
                            {MMH+18, SMMV-3}, {MMH+18, SMMV}, {MMH+15, SMMV},
                            {MMH+15, SMMV+9}, {MMH+21, SMMV+9}, {MMH+21, SMMV+3},
                            {MMH+24, SMMV+3}, {MMH+24, SMMV+18}, {MMH-12, SMMV+18},
                            {MMH-12, SMMV+21}, {MMH-18, SMMV+21}, {MMH-18, SMMV+24},
                            {MMH-21, SMMV+24}, {MMH-21, SMMV+18}, {MMH-18, SMMV+18},
                            {MMH-18, SMMV+15}, {MMH-15, SMMV+15}, {MMH-15, SMMV+12},
                            {MMH-12, SMMV+12}, {MMH-12, SMMV+9}, {MMH-21, SMMV+9},
                            {MMH-21, SMMV+3}, {MMH-18, SMMV+3}, {MMH-18, SMMV},
                            {MMH-9, SMMV}, {MMH-9, SMMV-3}, {MMH-12, SMMV-3},
                            {MMH-12, SMMV-12}, {MMH-9, SMMV-12}};
    solidpolygon(greenPts, 38);

    setfillcolor(MarioRed);
    POINT redPts1[] = {{MMH-9, SMMV-18}, {MMH-6, SMMV-18}, {MMH-6, SMMV-21},
                        {MMH+9, SMMV-21}, {MMH+9, SMMV-18}, {MMH+18, SMMV-18},
                        {MMH+18, SMMV-15}, {MMH-9, SMMV-15}};
    POINT redPts2[] = {{MMH, SMMV+3}, {MMH+3, SMMV+3}, {MMH+3, SMMV+6},
                        {MMH+12, SMMV+6}, {MMH+12, SMMV+3}, {MMH+15, SMMV+3},
                        {MMH+15, SMMV+9}, {MMH+18, SMMV+9}, {MMH+18, SMMV+18},
                        {MMH+9, SMMV+18}, {MMH+9, SMMV+21}, {MMH, SMMV+21},
                        {MMH, SMMV+24}, {MMH-12, SMMV+24}, {MMH-12, SMMV+18},
                        {MMH-9, SMMV+18}, {MMH-9, SMMV+15}, {MMH-12, SMMV+15},
                        {MMH-12, SMMV+9}, {MMH, SMMV+9}};
    solidpolygon(redPts1, 8);
    solidpolygon(redPts2, 20);
    solidrectangle(MMH-3, SMMV, MMH, SMMV+3);
    solidrectangle(MMH+9, SMMV, MMH+12, SMMV+3);

    setfillcolor(MarioYellow);
    POINT yellowPts1[] = {{MMH+15, SMMV-24}, {MMH+24, SMMV-24}, {MMH+24, SMMV-15},
                            {MMH+18, SMMV-15},    {MMH+18, SMMV-18}, {MMH+15, SMMV-18}};
    POINT yellowPts2[] = {{MMH+9, SMMV-15}, {MMH+12, SMMV-15}, {MMH+12, SMMV-12},
                            {MMH+15, SMMV-12}, {MMH+15, SMMV-9}, {MMH+21, SMMV-9}, 
                            {MMH+21, SMMV-6}, {MMH+12, SMMV-6}, {MMH+12, SMMV-9},
                            {MMH+9, SMMV-9}};
    POINT yellowPts3[] = {{MMH, SMMV-15}, {MMH+6, SMMV-15}, {MMH+6, SMMV-9}, 
                            {MMH+9, SMMV-9}, {MMH+9, SMMV-6}, {MMH+6, SMMV-6}, 
                            {MMH+6, SMMV-3}, {MMH+15, SMMV-3}, {MMH+15, SMMV},
                            {MMH-9, SMMV}, {MMH-9, SMMV-3}, {MMH-6, SMMV-3}, 
                            {MMH-6, SMMV-6}, {MMH, SMMV-6}, {MMH, SMMV-9}, 
                            {MMH-3, SMMV-9}, {MMH-3, SMMV-12}, {MMH, SMMV-12}};
    POINT yellowPts4[] = {{MMH-24, SMMV+6}, {MMH-18, SMMV+6}, {MMH-18, SMMV+9},
                            {MMH-15, SMMV+9}, {MMH-15, SMMV+12}, {MMH-18, SMMV+12},
                            {MMH-18, SMMV+15}, {MMH-21, SMMV+15}, {MMH-21, SMMV+12},
                            {MMH-24, SMMV+12}};
    solidpolygon(yellowPts1, 6);
    solidpolygon(yellowPts2, 10);
    solidpolygon(yellowPts3, 18);
    solidpolygon(yellowPts4, 10);
    solidrectangle(MMH-9, SMMV-12, MMH-6, SMMV-6);
    solidrectangle(MMH+3, SMMV+9, MMH+6, SMMV+12);
    solidrectangle(MMH+12, SMMV+9, MMH+15, SMMV+12);
}

void drawJumpSmallLeftMario()
{
    setfillcolor(MarioGreen);
    POINT greenPts[] = {{MMH+9, SMMV-15}, {MMH-12, SMMV-15}, {MMH-12, SMMV-12},
                            {MMH-15, SMMV-12}, {MMH-15, SMMV-15}, {MMH-24, SMMV-15},
                            {MMH-24, SMMV-6}, {MMH-21, SMMV-6}, {MMH-21, SMMV-3},
                            {MMH-18, SMMV-3}, {MMH-18, SMMV}, {MMH-15, SMMV},
                            {MMH-15, SMMV+9}, {MMH-21, SMMV+9}, {MMH-21, SMMV+3},
                            {MMH-24, SMMV+3}, {MMH-24, SMMV+18}, {MMH+12, SMMV+18},
                            {MMH+12, SMMV+21}, {MMH+18, SMMV+21}, {MMH+18, SMMV+24},
                            {MMH+21, SMMV+24}, {MMH+21, SMMV+18}, {MMH+18, SMMV+18},
                            {MMH+18, SMMV+15}, {MMH+15, SMMV+15}, {MMH+15, SMMV+12},
                            {MMH+12, SMMV+12}, {MMH+12, SMMV+9}, {MMH+21, SMMV+9},
                            {MMH+21, SMMV+3}, {MMH+18, SMMV+3}, {MMH+18, SMMV},
                            {MMH+9, SMMV}, {MMH+9, SMMV-3}, {MMH+12, SMMV-3},
                            {MMH+12, SMMV-12}, {MMH+9, SMMV-12}};
    solidpolygon(greenPts, 38);

    setfillcolor(MarioRed);
    POINT redPts1[] = {{MMH+9, SMMV-18}, {MMH+6, SMMV-18}, {MMH+6, SMMV-21},
                        {MMH-9, SMMV-21}, {MMH-9, SMMV-18}, {MMH-18, SMMV-18},
                        {MMH-18, SMMV-15}, {MMH+9, SMMV-15}};
    POINT redPts2[] = {{MMH, SMMV+3}, {MMH-3, SMMV+3}, {MMH-3, SMMV+6},
                        {MMH-12, SMMV+6}, {MMH-12, SMMV+3}, {MMH-15, SMMV+3},
                        {MMH-15, SMMV+9}, {MMH-18, SMMV+9}, {MMH-18, SMMV+18},
                        {MMH-9, SMMV+18}, {MMH-9, SMMV+21}, {MMH, SMMV+21},
                        {MMH, SMMV+24}, {MMH+12, SMMV+24}, {MMH+12, SMMV+18},
                        {MMH+9, SMMV+18}, {MMH+9, SMMV+15}, {MMH+12, SMMV+15},
                        {MMH+12, SMMV+9}, {MMH, SMMV+9}};
    solidpolygon(redPts1, 8);
    solidpolygon(redPts2, 20);
    solidrectangle(MMH, SMMV, MMH+3, SMMV+3);
    solidrectangle(MMH-12, SMMV, MMH-9, SMMV+3);

    setfillcolor(MarioYellow);
    POINT yellowPts1[] = {{MMH-15, SMMV-24}, {MMH-24, SMMV-24}, {MMH-24, SMMV-15},
                            {MMH-18, SMMV-15},    {MMH-18, SMMV-18}, {MMH-15, SMMV-18}};
    POINT yellowPts2[] = {{MMH-9, SMMV-15}, {MMH-12, SMMV-15}, {MMH-12, SMMV-12},
                            {MMH-15, SMMV-12}, {MMH-15, SMMV-9}, {MMH-21, SMMV-9}, 
                            {MMH-21, SMMV-6}, {MMH-12, SMMV-6}, {MMH-12, SMMV-9},
                            {MMH-9, SMMV-9}};
    POINT yellowPts3[] = {{MMH, SMMV-15}, {MMH-6, SMMV-15}, {MMH-6, SMMV-9}, 
                            {MMH-9, SMMV-9}, {MMH-9, SMMV-6}, {MMH-6, SMMV-6}, 
                            {MMH-6, SMMV-3}, {MMH-15, SMMV-3}, {MMH-15, SMMV},
                            {MMH+9, SMMV}, {MMH+9, SMMV-3}, {MMH+6, SMMV-3}, 
                            {MMH+6, SMMV-6}, {MMH, SMMV-6}, {MMH, SMMV-9}, 
                            {MMH+3, SMMV-9}, {MMH+3, SMMV-12}, {MMH, SMMV-12}};
    POINT yellowPts4[] = {{MMH+24, SMMV+6}, {MMH+18, SMMV+6}, {MMH+18, SMMV+9},
                            {MMH+15, SMMV+9}, {MMH+15, SMMV+12}, {MMH+18, SMMV+12},
                            {MMH+18, SMMV+15}, {MMH+21, SMMV+15}, {MMH+21, SMMV+12},
                            {MMH+24, SMMV+12}};
    solidpolygon(yellowPts1, 6);
    solidpolygon(yellowPts2, 10);
    solidpolygon(yellowPts3, 18);
    solidpolygon(yellowPts4, 10);
    solidrectangle(MMH+6, SMMV-12, MMH+9, SMMV-6);
    solidrectangle(MMH-6, SMMV+9, MMH-3, SMMV+12);
    solidrectangle(MMH-15, SMMV+9, MMH-12, SMMV+12);
}

void drawJumpSmallMario()
{
    if(stillDir=='D')
        drawJumpSmallRightMario();
    else
        drawJumpSmallLeftMario();
}

void drawSmallMario()
{
    if(!JumpState && dir=='E')
        drawStillSmallMario();
    else if(!JumpState && dir!='E')
        drawWalkSmallMario();
    else
        drawJumpSmallMario();
}

void drawFallSmallRightMario()
{
    setfillcolor(MarioGreen);
    POINT greenPts1[] = {{MMH-15, SMMV-12}, {MMH-12, SMMV-12}, {MMH-12, SMMV-15},
                            {MMH+9,SMMV-15}, {MMH+9,SMMV-6},{MMH+15,SMMV-6},
                            {MMH+15,SMMV-3}, {MMH-15, SMMV-3}};
    POINT greenPts2[] = {{MMH+15, SMMV+15}, {MMH+18, SMMV+15}, {MMH+18, SMMV+12},
                            {MMH+21, SMMV+12}, {MMH+21, SMMV+24}, {MMH+15,SMMV+24}};
    solidpolygon(greenPts1, 8);
    solidpolygon(greenPts2, 6);
    solidrectangle(MMH-6, SMMV, MMH+12, SMMV+9);

    setfillcolor(MarioRed);
    POINT redPts1[] = {{MMH-12, SMMV-18}, {MMH-9, SMMV-18}, {MMH-9, SMMV-21},
                        {MMH+6,SMMV-21},{MMH+6,SMMV-18},{MMH+15,SMMV-18},
                        {MMH+15,SMMV-15}, {MMH-12,SMMV-15}};
    POINT redPts2[] = {{MMH-9,SMMV}, {MMH-3, SMMV}, {MMH-3,SMMV+3},
                        {MMH-6,SMMV+3},{MMH-6,SMMV+9},{MMH+6,SMMV+9},
                        {MMH+6,SMMV+15},{MMH+15,SMMV+15},{MMH+15,SMMV+24},
                        {MMH-9,SMMV+24},{MMH-9,SMMV+21},{MMH-12,SMMV+21},
                        {MMH-12,SMMV+18},{MMH-15,SMMV+18},{MMH-15,SMMV+6},
                        {MMH-12,SMMV+6},{MMH-12,SMMV+3},{MMH-9,SMMV+3}};
    solidpolygon(redPts1, 8);
    solidpolygon(redPts2, 18);

    setfillcolor(MarioYellow);
    POINT yellowPts1[] = {{MMH-3,SMMV-15}, {MMH+3,SMMV-15},{MMH+3,SMMV-9},
                            {MMH+6,SMMV-9},{MMH+6,SMMV-6},{MMH+3,SMMV-6},
                            {MMH+3,SMMV-3},{MMH+12,SMMV-3},{MMH+12,SMMV},
                            {MMH-9,SMMV},{MMH-9,SMMV-6},{MMH-3,SMMV-6},
                            {MMH-3,SMMV-9},{MMH-6,SMMV-9},{MMH-6,SMMV-12},
                            {MMH-3,SMMV-12}};
    POINT yellowPts2[] = {{MMH+6,SMMV-15}, {MMH+9,SMMV-15},{MMH+9,SMMV-12},
                            {MMH+15,SMMV-12},{MMH+15,SMMV-9},{MMH+18,SMMV-9},
                            {MMH+18,SMMV-6},{MMH+9,SMMV-6},{MMH+9,SMMV-9},
                            {MMH+6,SMMV-9}};
    POINT yellowPts3[] = {{MMH+12,SMMV},{MMH+18,SMMV},{MMH+18,SMMV+3},
                            {MMH+21,SMMV+3},{MMH+21,SMMV+9},{MMH+12,SMMV+9}};
    solidpolygon(yellowPts1, 16);
    solidpolygon(yellowPts2, 10);
    solidpolygon(yellowPts3, 6);
    solidrectangle(MMH-12,SMMV-12,MMH-9,SMMV-6);
    solidrectangle(MMH,SMMV+9,MMH+3,SMMV+12);
}

void drawFallSmallLeftMario()
{
    setfillcolor(MarioGreen);
    POINT greenPts1[] = {{MMH+15, SMMV-12}, {MMH+12, SMMV-12}, {MMH+12, SMMV-15},
                            {MMH-9,SMMV-15}, {MMH-9,SMMV-6},{MMH-15,SMMV-6},
                            {MMH-15,SMMV-3}, {MMH+15, SMMV-3}};
    POINT greenPts2[] = {{MMH-15, SMMV+15}, {MMH-18, SMMV+15}, {MMH-18, SMMV+12},
                            {MMH-21, SMMV+12}, {MMH-21, SMMV+24}, {MMH-15,SMMV+24}};
    solidpolygon(greenPts1, 8);
    solidpolygon(greenPts2, 6);
    solidrectangle(MMH-12, SMMV, MMH+6, SMMV+9);

    setfillcolor(MarioRed);
    POINT redPts1[] = {{MMH+12, SMMV-18}, {MMH+9, SMMV-18}, {MMH+9, SMMV-21},
                        {MMH-6,SMMV-21},{MMH-6,SMMV-18},{MMH-15,SMMV-18},
                        {MMH-15,SMMV-15}, {MMH+12,SMMV-15}};
    POINT redPts2[] = {{MMH+9,SMMV}, {MMH+3, SMMV}, {MMH+3,SMMV+3},
                        {MMH+6,SMMV+3},{MMH+6,SMMV+9},{MMH-6,SMMV+9},
                        {MMH-6,SMMV+15},{MMH-15,SMMV+15},{MMH-15,SMMV+24},
                        {MMH+9,SMMV+24},{MMH+9,SMMV+21},{MMH+12,SMMV+21},
                        {MMH+12,SMMV+18},{MMH+15,SMMV+18},{MMH+15,SMMV+6},
                        {MMH+12,SMMV+6},{MMH+12,SMMV+3},{MMH+9,SMMV+3}};
    solidpolygon(redPts1, 8);
    solidpolygon(redPts2, 18);

    setfillcolor(MarioYellow);
    POINT yellowPts1[] = {{MMH+3,SMMV-15}, {MMH-3,SMMV-15},{MMH-3,SMMV-9},
                            {MMH-6,SMMV-9},{MMH-6,SMMV-6},{MMH-3,SMMV-6},
                            {MMH-3,SMMV-3},{MMH-12,SMMV-3},{MMH-12,SMMV},
                            {MMH+9,SMMV},{MMH+9,SMMV-6},{MMH+3,SMMV-6},
                            {MMH+3,SMMV-9},{MMH+6,SMMV-9},{MMH+6,SMMV-12},
                            {MMH+3,SMMV-12}};
    POINT yellowPts2[] = {{MMH-6,SMMV-15}, {MMH-9,SMMV-15},{MMH-9,SMMV-12},
                            {MMH-15,SMMV-12},{MMH-15,SMMV-9},{MMH-18,SMMV-9},
                            {MMH-18,SMMV-6},{MMH-9,SMMV-6},{MMH-9,SMMV-9},
                            {MMH-6,SMMV-9}};
    POINT yellowPts3[] = {{MMH-12,SMMV},{MMH-18,SMMV},{MMH-18,SMMV+3},
                            {MMH-21,SMMV+3},{MMH-21,SMMV+9},{MMH-12,SMMV+9}};
    solidpolygon(yellowPts1, 16);
    solidpolygon(yellowPts2, 10);
    solidpolygon(yellowPts3, 6);
    solidrectangle(MMH+9,SMMV-12,MMH+12,SMMV-6);
    solidrectangle(MMH-3,SMMV+9,MMH,SMMV+12);
}
/*****************************
        collision.h
 *****************************/
#include "drawSmallMario.h"

void lowOneBBCD()
{
    //height up
    if(bbH[i]<MMH+48 && bbH[i]>MMH-48 && SMMV<=600-192)                
    {
        if(oldSMMV!=600-192)
            oldSMMV=600-192;
    }
    //bottom collision
    else if(bbH[i]<=MMH+24 && bbH[i]>MMH-24)                                
    {
        if(!Fall && SMMV<=600-99 && SMMV>=600-111)
        {
            bbState[i] = true;
            FallCollision = false;
        }
        else if(Fall && SMMV<=600-96 && SMMV>=600-111 && !FallCollision)
            bbState[i] = true;
        if(bbState[i] && SMMV==600-111)
            Fall=true;
    }
    //left collision
    else if(bbH[i]>MMH+24 && bbH[i]<MMH+48)    
    {
        if(SMMV<=600-99 && SMMV>=600-189)
        {
            MMH=bbH[i]-48;
            if(MMH<24)
                MMH=24;
        }
    }
    //right collision
    else if(bbH[i]<=MMH-24 && bbH[i]>MMH-48)
    {
        if(SMMV<=600-99 && SMMV>=600-189)
        {
            if(bbH[i]+48<=360)
                MMH = bbH[i]+48;
            else
            {
                maxWalkDst += bbH[i]+48-360;
                MMH=360;
            }
        }
    }
}

void lowLeftBBCD()
{
    //height up
    if(bbH[i]<MMH+48 && bbH[i]>MMH-48 && SMMV<=600-192)                
    {
        if(oldSMMV!=600-192)
            oldSMMV=600-192;
    }
    //bottom collision
    else if(bbH[i]<=MMH+24 && bbH[i]>MMH-24)            
    {
        if(!Fall && SMMV<=600-99 && SMMV>=600-111)
        {
            bbState[i] = true;
            FallCollision = false;
        }
        else if(Fall && SMMV<=600-96 && SMMV>=600-111 && !FallCollision)
            bbState[i] = true;
        if(bbState[i] && SMMV==600-111)
            Fall=true;
    }
    //left collision
    else if(bbH[i]>MMH+24 && bbH[i]<MMH+48)            
    {
        if(SMMV<=600-99 && SMMV>=600-189)
        {
            MMH=bbH[i]-48;
            if(MMH<24)
                MMH=24;
        }
    }
}

void lowMidBBCD()
{
    //height up
    if(bbH[i]<MMH+48 && bbH[i]>MMH-48 && SMMV<=600-192)                
    {
        if(oldSMMV!=600-192)
            oldSMMV=600-192;
    }
    //bottom collision
    else if(bbH[i]<=MMH+24 && bbH[i]>MMH-24)            
    {
        if(!Fall && SMMV<=600-99 && SMMV>=600-111)
        {
            bbState[i] = true;
            FallCollision = false;
        }
        else if(Fall && SMMV<=600-96 && SMMV>=600-111 && !FallCollision)
            bbState[i] = true;
        if(bbState[i] && SMMV==600-111)
            Fall=true;
    }
}

void lowRightBBCD()
{
    //height up
    if(bbH[i]<MMH+48 && bbH[i]>MMH-48 && SMMV<=600-192)                
    {
        if(oldSMMV!=600-192)
            oldSMMV=600-192;
    }
    //bottom collision
    else if(bbH[i]<=MMH+24 && bbH[i]>MMH-24)            
    {
        if(!Fall && SMMV<=600-99 && SMMV>=600-111)
        {
            bbState[i] = true;
            FallCollision = false;
        }
        else if(Fall && SMMV<=600-96 && SMMV>=600-111 && !FallCollision)
            bbState[i] = true;
        if(bbState[i] && SMMV==600-111)
            Fall=true;
    }
    //right collision
    else if(bbH[i]<=MMH-24 && bbH[i]>MMH-48)
    {
        if(SMMV<=600-99 && SMMV>=600-189)
        {
            if(bbH[i]+48<=360)
                MMH = bbH[i]+48;
            else
            {
                maxWalkDst += bbH[i]+48-360;
                MMH=360;
            }
        }
    }
}

void centerOneBBCD()
{
    //height up
    if(bbH[i]<MMH+48 && bbH[i]>MMH-48 && SMMV<=600-192-192)                
    {
        if(oldSMMV!=600-192-192)
            oldSMMV=600-192-192;
    }
    //bottom collision
    else if(bbH[i]<=MMH+24 && bbH[i]>MMH-24)            
    {
        if(!Fall && SMMV<=600-192-99 && SMMV>=600-192-111)
        {
            bbState[i] = true;
            FallCollision = false;
        }
        else if(Fall && SMMV<=600-192-96 && SMMV>=600-192-111 && !FallCollision)
            bbState[i] = true;
        if(bbState[i] && SMMV==600-192-111)
            Fall=true;
    }
    //left collision
    else if(bbH[i]>MMH+24 && bbH[i]<MMH+48)    
    {
        if(SMMV<=600-192-99 && SMMV>=600-192-189)
        {
            MMH=bbH[i]-48;
            if(MMH<24)
                MMH=24;
        }
    }
    //right collision
    else if(bbH[i]<=MMH-24 && bbH[i]>MMH-48)
    {
        if(SMMV<=600-192-99 && SMMV>=600-192-189)
        {
            if(bbH[i]+48<=360)
                MMH = bbH[i]+48;
            else
            {
                maxWalkDst += bbH[i]+48-360;
                MMH=360;
            }
        }
    }
}

void centerLeftBBCD()
{
    //height up
    if(bbH[i]<MMH+48 && bbH[i]>MMH-48 && SMMV<=600-192-192)                
    {
        if(oldSMMV!=600-192-192)
            oldSMMV=600-192-192;
    }
    //bottom collision
    else if(bbH[i]<=MMH+24 && bbH[i]>MMH-24)            
    {
        if(!Fall && SMMV<=600-192-99 && SMMV>=600-192-111)
        {
            bbState[i] = true;
            FallCollision = false;
        }
        else if(Fall && SMMV<=600-192-96 && SMMV>=600-192-111 && !FallCollision)
            bbState[i] = true;
        if(bbState[i] && SMMV==600-192-111)
            Fall=true;
    }
    //left collision
    else if(bbH[i]>MMH+24 && bbH[i]<MMH+48)            
    {
        if(SMMV<=600-192-99 && SMMV>=600-192-189)
        {
            MMH=bbH[i]-48;
            if(MMH<24)
                MMH=24;
        }
    }
}

void centerMidBBCD()
{
    //height up
    if(bbH[i]<MMH+48 && bbH[i]>MMH-48 && SMMV<=600-192-192)                
    {
        if(oldSMMV!=600-192-192)
            oldSMMV=600-192-192;
    }
    //bottom collision
    else if(bbH[i]<=MMH+24 && bbH[i]>MMH-24)            
    {
        if(!Fall && SMMV<=600-192-99 && SMMV>=600-192-111)
        {
            bbState[i] = true;
            FallCollision = false;
        }
        else if(Fall && SMMV<=600-192-96 && SMMV>=600-192-111 && !FallCollision)
            bbState[i] = true;
        if(bbState[i] && SMMV==600-192-111)
            Fall=true;
    }
}

void centerRightBBCD()
{
    //height up
    if(bbH[i]<MMH+48 && bbH[i]>MMH-48 && SMMV<=600-192-192)                
    {
        if(oldSMMV!=600-192-192)
            oldSMMV=600-192-192;
    }
    //bottom collision
    else if(bbH[i]<=MMH+24 && bbH[i]>MMH-24)            
    {
        if(!Fall && SMMV<=600-192-99 && SMMV>=600-192-111)
        {
            bbState[i] = true;
            FallCollision = false;
        }
        else if(Fall && SMMV<=600-192-96 && SMMV>=600-192-111 && !FallCollision)
            bbState[i] = true;
        if(bbState[i] && SMMV==600-192-111)
            Fall=true;
    }
    //right collision
    else if(bbH[i]<=MMH-24 && bbH[i]>MMH-48)
    {
        if(SMMV<=600-192-99 && SMMV>=600-192-189)
        {
            if(bbH[i]+48<=360)
                MMH = bbH[i]+48;
            else
            {
                maxWalkDst += bbH[i]+48-360;
                MMH=360;
            }
        }
    }
}

void pipe2CD()
{
    //height up
    if(pipeH[i]<MMH+72 && pipeH[i]>MMH-72 && SMMV<=600-96)                
    {
        if(oldSMMV!=600-96)
            oldSMMV=600-96;
    }
    //left collision
    else if(pipeH[i]<MMH+72 && pipeH[i] >=MMH+66)    
    {
        if(SMMV<=600 && SMMV>=600-93)
            MMH=pipeH[i]-72;
    }
    //right collision
    else if(pipeH[i]>MMH-72 && pipeH[i]<=MMH-66)
    {
        if(SMMV<=600 && SMMV>=600-93)
            MMH=pipeH[i]+72;
    }
}

void pipe3CD()
{
    //height up
    if(pipeH[i]<MMH+72 && pipeH[i]>MMH-72 && SMMV<=600-144)                
    {
        if(oldSMMV!=600-144)
            oldSMMV=600-144;
    }
    //left collision
    else if(pipeH[i]<MMH+72 && pipeH[i] >=MMH+66)    
    {
        if(SMMV<=600 && SMMV>=600-141)
            MMH=pipeH[i]-72;
    }
    //right collision
    else if(pipeH[i]>MMH-72 && pipeH[1]<=MMH-66)
    {
        if(SMMV<=600 && SMMV>=600-141)
            MMH=pipeH[i]+72;
    }
}

void pipe4CD()
{
    //height up
    if(pipeH[i]<MMH+72 && pipeH[i]>MMH-72 && SMMV<=600-192)                
    {
        if(oldSMMV!=600-192)
            oldSMMV=600-192;
    }
    //left collision
    else if(pipeH[i]<MMH+72 && pipeH[i] >=MMH+66)    
    {
        if(SMMV<=600 && SMMV>=600-189)
            MMH=pipeH[i]-72;
    }
    //right collision
    else if(pipeH[i]>MMH-72 && pipeH[i]<=MMH-66)
    {
        if(SMMV<=600 && SMMV>=600-189)
            MMH=pipeH[i]+72;
    }
}
/*********************************
        collisionDetect.h
 *********************************/
#include "collision.h"

void coverOldBb11()
{
    setfillcolor(SkyColor);

    if(!Fall && SMMV<=oldSMMV-99)
        bbV[i] = SMMV-45;
    else if(Fall && SMMV<=oldSMMV-96)
        bbV[i] = SMMV-51;
    solidrectangle(bbH[i]-24, bbV[i]-24, bbH[i]+24, bbV[i]+24);
}

void drawNewBox11()
{
    if((!Fall && SMMV<=oldSMMV-99)||(Fall && SMMV<=oldSMMV-96))
        bbV[i] = SMMV-48;
    x= bbH[i];
    y= bbV[i];
    box11();
}

void drawNewBrick11()
{
    if((!Fall && SMMV<=oldSMMV-99)||(Fall&&SMMV<=oldSMMV-96))
        bbV[i] = SMMV-48;
    x= bbH[i];
    y= bbV[i];
    brick11();
}

void coverOldBb12()
{
    setfillcolor(BLACK);

    if(!Fall && SMMV<=oldSMMV-99)
        bbV[i] = SMMV-45;
    else if(Fall && SMMV<=oldSMMV-96)
        bbV[i] = SMMV-51;
    solidrectangle(bbH[i]-24, bbV[i]-24, bbH[i]+24, bbV[i]+24);
}

void drawNewBox12()
{
    if((!Fall && SMMV<=oldSMMV-99)||(Fall && SMMV<=oldSMMV-96))
        bbV[i] = SMMV-48;
    x= bbH[i];
    y= bbV[i];
    box12();
}

void drawNewBrick12()
{
    if((!Fall && SMMV<=oldSMMV-99)||(Fall&&SMMV<=oldSMMV-96))
        bbV[i] = SMMV-48;
    x= bbH[i];
    y= bbV[i];
    brick12();
}

void coverOldFlag()
{
    x=flagH;
    y=oldFlagHeight;
    setfillcolor(SkyColor);
    solidrectangle(x-48,y-24,x,y+24);
}

void coverSmallMario()
{
    setfillcolor(SkyColor);
    solidrectangle(MMH-24,SMMV-24,MMH+24,SMMV+24);
}

void drawMoreNewFlag()
{
    x=flagH;
    y=oldFlagHeight+429;

    setfillcolor(PoleTopColor);
    solidrectangle(x-6,600-477, x+6, 600-459);
    solidrectangle(x-9,600-474, x+9, 600-462);

    setfillcolor(FlagpoleColor);
    solidrectangle(x-3,600-456, x+3, 600-24);
    solidrectangle(x-6,600-477, x-3, 600-474);
    solidrectangle(x-9,600-474, x-6, 600-468);

    setfillcolor(BLACK);
    solidrectangle(x-12,600-474, x-9, 600-462);
    solidrectangle(x+9, 600-474, x+12,600-462);
    solidrectangle(x-9, 600-477, x-6, 600-474);
    solidrectangle(x+6, 600-477, x+9, 600-474);
    solidrectangle(x-9, 600-462, x-6, 600-459);
    solidrectangle(x+6, 600-462, x+9, 600-459);
    solidrectangle(x-6, 600-480, x+6, 600-477);
    solidrectangle(x-6, 600-459, x+6, 600-456);

    flag();
}

void drawLessNewFlag()
{
    x=flagH;
    y=oldFlagHeight+429;

    setfillcolor(FlagpoleColor);
    solidrectangle(x-3,600-456, x+3, 600-24);

    flag();
}
/*******************************
        displayInfo.h
 *******************************/
#include "collisionDetect.h"

void displayReadyInterface()                
{
    loadimage(&readyImg, "picture\\000.bmp");
    putimage(0,0,&readyImg);
}

void displayLevelLifeInfo()
{
    cleardevice();
    //draw Mario
    MMH  = 312;
    SMMV = 360;
    drawStillSmallRightMario();
    //draw *
    setfillcolor(WHITE);
    for(i=0;i!=5;++i)
        solidrectangle(374+i*4,350+i*4,378+i*4,354+i*4);
    for(i=0;i!=5;++i)
        solidrectangle(374+i*4,366-i*4,378+i*4,370-i*4);
    //draw lifeCount
    settextstyle(52, 0, "Fixedsys");
    sprintf(lifeInfo, "%d", lifeCount);
    outtextxy(432, 338, lifeInfo);
    //display time
    Sleep(3000);
}

void displayWinAnimation()
{
    for(i=0;i!=9;++i)
    {
        maxWalkDst+=3;    
        if(maxWalkDst%768==0)
            ++bgCount;
        drawBg();
        Sleep(3);
    }
    flagH = 9528-maxWalkDst;
    while(SMMV<=600-57)
    {
        BeginBatchDraw();
        coverOldFlag();
        coverSmallMario();
        SMMV+=3;
        if(oldFlagHeight<=600-69)
            oldFlagHeight+=3;
        if(SMMV<=600-432)
            drawMoreNewFlag();
        else
            drawLessNewFlag();
        drawFallSmallRightMario();
        EndBatchDraw();
        Sleep(30);
    }
    while(oldFlagHeight<=600-69)
    {
        BeginBatchDraw();
        coverOldFlag();
        oldFlagHeight+=3;
        drawLessNewFlag();
        drawFallSmallRightMario();
        EndBatchDraw();
        Sleep(30);
    }
    for(k=0;k!=12;++k)
    {
        maxWalkDst+=3;    
        if(maxWalkDst%768==0)
            ++bgCount;
        BeginBatchDraw();
        drawBg();
        flagH = 9528-maxWalkDst;
        setfillcolor(SkyColor);
        solidrectangle(flagH-48,600-453,flagH,600-405);
        drawLessNewFlag();
        drawFallSmallRightMario();
        EndBatchDraw();
        Sleep(10);
    }
    BeginBatchDraw();
    coverSmallMario();
    drawLessNewFlag();
    drawFallSmallLeftMario();
    EndBatchDraw();
    Sleep(50);
    for(k=0;k!=2;++k)
    {
        maxWalkDst+=3;
        if(maxWalkDst%768==0)
            ++bgCount;
        BeginBatchDraw();
        drawBg();
        flagH=9528-maxWalkDst;
        setfillcolor(SkyColor);
        solidrectangle(flagH-48,600-453,flagH,600-405);
        drawLessNewFlag();
        drawFallSmallLeftMario();
        EndBatchDraw();
        Sleep(20);
    }
    for(;SMMV!=600;SMMV+=3)
    {
        maxWalkDst+=3;
        if(maxWalkDst%768==0)
            ++bgCount;
        BeginBatchDraw();
        drawBg();
        flagH=9528-maxWalkDst;
        setfillcolor(SkyColor);
        solidrectangle(flagH-48,600-453,flagH,600-405);
        drawLessNewFlag();
        if(SMMV<=600-48)
            drawWalkSmallLeftMarioSecond();
        else
            drawWalkSmallRightMarioSecond();
        EndBatchDraw();
        Sleep(20);
    }
    while(maxWalkDst<=9453)
    {
        maxWalkDst+=3;
        if(maxWalkDst%768==0)
            ++bgCount;
        BeginBatchDraw();
        drawBg();
        flagH=9528-maxWalkDst;
        setfillcolor(SkyColor);
        solidrectangle(flagH-48,600-453,flagH,600-405);
        drawLessNewFlag();
        drawWalkSmallMario();
        EndBatchDraw();
        Sleep(20);
    }
    BeginBatchDraw();
    drawBg();
    flagH=9528-maxWalkDst;
    setfillcolor(SkyColor);
    solidrectangle(flagH-48,600-453,flagH,600-405);
    drawLessNewFlag();
    EndBatchDraw();
    Sleep(3000);
}

void displayBeginAnimation()
{
    dir  = 'D';
    walkState = 0;
    MMH  = 120;
    SMMV = 600;
    while(MMH<=504)
    {
        BeginBatchDraw();
        putimage(0,0,&levelImg[14]);
        drawWalkSmallMario();
        if(MMH>456)
        {
            x=576;
            y=624;
            pipeL();
        }
        EndBatchDraw();
        MMH+=3;
        Sleep(10);
    }
    Sleep(3000);
}

void displayGameOver()
{
    cleardevice();
    settextstyle(52,0,"Fixedsys");
    outtextxy(267,334,"Game Over");
    Sleep(3000);
}

/*********************************
        level1-1.h
 *********************************/
#include "displayInfo.h"

void interactWithBB11()
{
    for(i=0; i!=43; ++i)
        if(bbState[i])
            break;
    if(i!=43)
    {
        switch(i)
        {
        case 0:     case 2:  case 4:  case 6:  case 8: case 21: case 25: case 26:
        case 27: case 28: case 34: case 35: case 41:
            coverOldBb11();
            drawNewBox11();
            bbState[i]=false;
            break;
        case 1:  case 3:  case 5:  case 7:  case 9:  case 10: case 11: case 12:
        case 13: case 14: case 15: case 16: case 17: case 18: case 19: case 20:
        case 22: case 23: case 24: case 29: case 30: case 31: case 32: case 33:
        case 36: case 37: case 38: case 39: case 40: case 42:
            coverOldBb11();
            drawNewBrick11();
            bbState[i]=false;
            break;
        }
    }
}

void CollisionDetect11();
void level11()
{
    loadBgImg();
    displayLevelLifeInfo();
    dataInitialization();
    //main loop
    while(true)
    {
        //Batch Draw
        BeginBatchDraw();
        drawBg();
        interactWithBB11();
        drawSmallMario();
        EndBatchDraw();

        JumpDetect();
        DirDetect();

        calculateMMH();
        calculateSMMV();

        CollisionDetect11();
        //1 trap
        if(maxWalkDst>2928 && maxWalkDst<3408)    //left-24 and left+456  left=2952
        {
            trapH[0] = 3360-maxWalkDst;            //left+408
            if(trapH[0]<=MMH+30 && trapH[0]>=MMH-30 && SMMV>=600)    //height down and game over            
            {
                JumpState = true;
                FirstJump = false;
                BigJump   = true;
                Fall      = true;
                oldSMMV      = 768;
                if(trapH[0]<MMH-24)                //inner right collision
                    MMH=trapH[0]+24;
                else if(trapH[0]>MMH+24)        //inner left collision
                    MMH=trapH[0]-24;
                if(SMMV==768)
                {
                    Sleep(2000);
                    win = false;
                    break;
                }
            }
        }

        //2 trap
        if(maxWalkDst>3744 && maxWalkDst<4272)    //left-24 and left+504  left=3768
        {
            trapH[1] = 4200-maxWalkDst;            //left+432
            if(trapH[1]<=MMH+30 && trapH[1]>=MMH-30 && SMMV>=600)    //height down and game over            
            {
                JumpState = true;
                FirstJump = false;
                BigJump   = true;
                Fall      = true;
                oldSMMV      = 768;
                if(trapH[1]<MMH-24)                //inner right collision
                    MMH=trapH[1]+24;
                else if(trapH[1]>MMH+24)        //inner left collision
                    MMH=trapH[1]-24;
                if(SMMV==768)
                {
                    Sleep(2000);
                    win = false;
                    break;
                }
            }
        }

        //3trap
        if(maxWalkDst>6960 && maxWalkDst<7440)    //left-24 and left+456  left=6984
        {
            trapH[2] = 7392-maxWalkDst;            //left+408
            if(trapH[2]<=MMH+30 && trapH[2]>=MMH-30 && SMMV>=600)    //height down and game over            
            {
                JumpState = true;
                FirstJump = false;
                BigJump   = true;
                Fall      = true;
                oldSMMV      = 768;
                if(trapH[2]<MMH-24)                //inner right collision
                    MMH=trapH[2]+24;
                else if(trapH[2]>MMH+24)        //inner left collision
                    MMH=trapH[2]-24;
                if(SMMV==768)
                {
                    Sleep(2000);
                    win = false;
                    break;
                }
            }
        }

        //flag
        if(maxWalkDst>9120 && maxWalkDst<9552)                //left-24 and left+408 left=9144
        {
            flagH = 9528-maxWalkDst;     //left+384
            //height up
            if(flagH<MMH+48 && SMMV<=600-48)                
            {
                displayWinAnimation();
                win = true;
                ++level;
                break;
            }
            //left collision
            else if(flagH<MMH+48 && flagH >=MMH+42)    
            {
                if(SMMV<=600 && SMMV>=600-45)
                    MMH=flagH-48;
            }
        }

        displayTime();
    }
}

void CollisionDetect11()
{
    /////////////////////////////////////////////////////////////////////////////////
    ////////////////////////////  First Step  ///////////////////////////////////////
    /////////////////////////////////////////////////////////////////////////////////
    if(maxWalkDst>384 && maxWalkDst<2304)
    {
    //0 bb
    if(maxWalkDst>384 && maxWalkDst<816)    //left-24 and left+384+24  left=408
    {
        i=0;
        bbH[i] = 792-maxWalkDst;            //left+384
        lowOneBBCD();
    }

    //1 bb
    if(maxWalkDst>576 && maxWalkDst<1008)    //left-24 and left+384+24  left=600
    {
        i=1;
        bbH[i] = 984-maxWalkDst;            //left+384
        lowLeftBBCD();
    }

    //2 bb
    if(maxWalkDst>624 && maxWalkDst<1056)    //left-24 and left+384+24  left=648
    {
        i=2;
        bbH[i] = 1032-maxWalkDst;            //left+384
        lowMidBBCD();
    }

    //3 bb
    if(maxWalkDst>672 && maxWalkDst<1104)    //left-24 and left+408  left=696
    {
        i=3;
        bbH[i] = 1080-maxWalkDst;            //left+384
        lowMidBBCD();
    }

    //4 bb
    if(maxWalkDst>720 && maxWalkDst<1152)    //left-24 and left+384+24 left=744
    {
        i=4;
        bbH[i] = 1128-maxWalkDst;            //left+384
        lowMidBBCD();
    }

    //5 bb
    if(maxWalkDst>768 && maxWalkDst<1200)    //left-24 and left+408 left=792
    {
        i=5;
        bbH[i] = 1176-maxWalkDst;            //left+384
        lowRightBBCD();
    }

    //6 bb
    if(maxWalkDst>672 && maxWalkDst<1104)    //left-24 and left+408  left=696
    {
        i=6;
        bbH[i] = 1080-maxWalkDst;            //left+384
        centerOneBBCD();
    }

    //0 pipe
    if(maxWalkDst>960 && maxWalkDst<1440)    //left-24 and left+456  left=984
    {
        i=0;
        pipeH[i] = 1392-maxWalkDst;            //left+408
        pipe2CD();
    }

    //1 pipe
    if(maxWalkDst>1440 && maxWalkDst<1920)    //left-24 and left+456  left=1464
    {
        i=1;
        pipeH[i] = 1872-maxWalkDst;            //left+408
        pipe3CD();
    }

    //2 pipe
    if(maxWalkDst>1824 && maxWalkDst<2304)    //left-24 and left+456  left=1848
    {
        i=2;
        pipeH[i] = 2256-maxWalkDst;            //left+408
        pipe4CD();
    }
    }

    ///////////////////////////////////////////////////////////////////////////
    //////////////////////////  Second Step  ///////////////////////////////////
    ///////////////////////////////////////////////////////////////////////////
    if(maxWalkDst>2352 && maxWalkDst<4560)
    {
    //3 pipe
    if(maxWalkDst>2352 && maxWalkDst<2832)    //left-24 and left+456  left=2376
    {
        i=3;
        pipeH[i] = 2784-maxWalkDst;            //left+408
        pipe4CD();
    }

    //7 bb
    if(maxWalkDst>3312 && maxWalkDst<3744)    //left-24 and left+384+24  left=3336
    {
        i=7;
        bbH[i] = 3720-maxWalkDst;            //left+384
        lowLeftBBCD();
    }

    //8 bb
    if(maxWalkDst>3360 && maxWalkDst<3792)    //left-24 and left+384+24  left=3384
    {
        i=8;
        bbH[i] = 3768-maxWalkDst;            //left+384
        lowMidBBCD();
    }

    //9 bb
    if(maxWalkDst>3408 && maxWalkDst<3840)    //left-24 and left+408 left=3432
    {
        i=9;
        bbH[i] = 3816-maxWalkDst;            //left+384
        lowRightBBCD();
    }

    //10 bb
    if(maxWalkDst>3456 && maxWalkDst<3888)    //left-24 and left+408 left=3480
    {
        i=10;
        bbH[i] = 3864-maxWalkDst;            //left+384
        centerLeftBBCD();
    }

    //11-16 bb
    for(j=0; j!=6; ++j)
    {
        if(maxWalkDst>3528+j*48-24 && maxWalkDst<3528+j*48+408)        //left-24 and left+408 left=3528
        {
            i=11+j;
            bbH[i] = 3528+j*48+384-maxWalkDst;                        //left+384
            centerMidBBCD();    
        }
    }

    //17 bb
    if(maxWalkDst>3792 && maxWalkDst<4224)                //left-24 and left+408 left=3816
    {
        i=17;
        bbH[i] = 4200-maxWalkDst;                        //left+384
        centerRightBBCD();
    }

    //18 bb
    if(maxWalkDst>3984 && maxWalkDst<4416)                //left-24 and left+408 left=4008
    {
        i=18;
        bbH[i] = 4392-maxWalkDst;                        //left+384
        centerLeftBBCD();
    }

    //19 bb
    if(maxWalkDst>4032 && maxWalkDst<4464)                //left-24 and left+408 left=4056
    {
        i=19;
        bbH[i] = 4440-maxWalkDst;                        //left+384
        centerMidBBCD();
    }

    //20 bb
    if(maxWalkDst>4080 && maxWalkDst<4512)                //left-24 and left+408 left=4104
    {
        i=20;
        bbH[i] = 4488-maxWalkDst;                        //left+384
        centerMidBBCD();
    }

    //22 bb
    if(maxWalkDst>4128 && maxWalkDst<4560)                //left-24 and left+408 left=4152
    {
        i=22;
        bbH[i] = 4536-maxWalkDst;                        //left+384
        lowOneBBCD();
    }

    //21 bb
    if(maxWalkDst>4128 && maxWalkDst<4560)                //left-24 and left+408 left=4152
    {
        i=21;
        bbH[i] = 4536-maxWalkDst;                        //left+384
        centerRightBBCD();
    }
    }

    ////////////////////////////////////////////////////////////////////////////////
    //////////////////////////// Third Step  //////////////////////////////////////
    ////////////////////////////////////////////////////////////////////////////////
    if(maxWalkDst>4416 && maxWalkDst<6912)
    {
    //23 bb
    if(maxWalkDst>4416 && maxWalkDst<4848)                //left-24 and left+408 left=4440
    {
        i=23;
        bbH[i] = 4824-maxWalkDst;                        //left+384
        lowLeftBBCD();
    }

    //24 bb
    if(maxWalkDst>4464 && maxWalkDst<4896)                //left-24 and left+408 left=4488
    {
        i=24;
        bbH[i] = 4872-maxWalkDst;                        //left+384
        lowRightBBCD();
    }

    //25 bb
    if(maxWalkDst>4704 && maxWalkDst<5136)                //left-24 and left+408 left=4728
    {
        i=25;
        bbH[i] = 5112-maxWalkDst;                        //left+384
        lowOneBBCD();
    }

    //26 bb
    if(maxWalkDst>4848 && maxWalkDst<5280)                //left-24 and left+408 left=4872
    {
        i=26;
        bbH[i] = 5256-maxWalkDst;                        //left+384
        lowOneBBCD();
    }

    //27 bb
    if(maxWalkDst>4848 && maxWalkDst<5280)                //left-24 and left+408 left=4872
    {
        i=27;
        bbH[i] = 5256-maxWalkDst;                        //left+384
        centerOneBBCD();
    }

    //28 bb
    if(maxWalkDst>4992 && maxWalkDst<5424)                //left-24 and left+408 left=5016
    {
        i=28;
        bbH[i] = 5400-maxWalkDst;                        //left+384
        lowOneBBCD();
    }

    //29 bb
    if(maxWalkDst>5280 && maxWalkDst<5712)                //left-24 and left+408 left=5304
    {
        i=29;
        bbH[i] = 5688-maxWalkDst;                        //left+384
        lowOneBBCD();
    }

    //30 bb
    if(maxWalkDst>5424 && maxWalkDst<5856)                //left-24 and left+408 left=5448
    {
        i=30;
        bbH[i] = 5832-maxWalkDst;                        //left+384
        centerLeftBBCD();
    }

    //31 bb
    if(maxWalkDst>5472 && maxWalkDst<5904)                //left-24 and left+408 left=5496
    {
        i=31;
        bbH[i] = 5880-maxWalkDst;                        //left+384
        centerMidBBCD();
    }

    //32 bb
    if(maxWalkDst>5520 && maxWalkDst<5952)                //left-24 and left+408 left=5544
    {
        i=32;
        bbH[i] = 5928-maxWalkDst;                        //left+384
        centerRightBBCD();
    }

    //33 bb
    if(maxWalkDst>5760 && maxWalkDst<6192)                //left-24 and left+408 left=5784
    {
        i=33;
        bbH[i] = 6168-maxWalkDst;                        //left+384
        centerLeftBBCD();
    }

    //37 bb
    if(maxWalkDst>5808 && maxWalkDst<6240)                //left-24 and left+408 left=5832
    {
        i=37;
        bbH[i] = 6216-maxWalkDst;                        //left+384
        lowLeftBBCD();
    }

    //38 bb
    if(maxWalkDst>5856 && maxWalkDst<6288)                //left-24 and left+408 left=5880
    {
        i=38;
        bbH[i] = 6264-maxWalkDst;                        //left+384
        lowRightBBCD();
    }

    //34 bb
    if(maxWalkDst>5808 && maxWalkDst<6240)                //left-24 and left+408 left=5832
    {
        i=34;
        bbH[i] = 6216-maxWalkDst;                        //left+384
        centerMidBBCD();
    }

    //35 bb
    if(maxWalkDst>5856 && maxWalkDst<6288)                //left-24 and left+408 left=5880
    {
        i=35;
        bbH[i] = 6264-maxWalkDst;                        //left+384
        centerMidBBCD();
    }

    //36 bb
    if(maxWalkDst>5904 && maxWalkDst<6336)                //left-24 and left+408 left=5928
    {
        i=36;
        bbH[i] = 6312-maxWalkDst;                        //left+384
        centerRightBBCD();
    }

    //step44 left-0
    if(maxWalkDst>6048 && maxWalkDst<6480)                //left-24 and left+408 left=6072
    {
        stepH[0] = 6456-maxWalkDst;                        //left+384
        //height up
        if(stepH[0]<MMH+48 && stepH[0]>MMH-48 && SMMV<=600-48)                
        {
            if(oldSMMV!=600-48)
                oldSMMV=600-48;
        }
        //left collision
        else if(stepH[0]<MMH+48 && stepH[0] >=MMH+42)    
        {
            if(SMMV<=600 && SMMV>=600-45)
                MMH=stepH[0]-48;
        }
    }

    //step44 left-1
    if(maxWalkDst>6096 && maxWalkDst<6528)                //left-24 and left+408 left=6120
    {
        stepH[1] = 6504-maxWalkDst;                        //left+384
        //height up
        if(stepH[1]<MMH+48 && stepH[1]>MMH-48 && SMMV<=600-96)                
        {
            if(oldSMMV!=600-96)
                oldSMMV=600-96;
        }
        //left collision
        else if(stepH[1]<MMH+48 && stepH[1] >=MMH+42)    
        {
            if(SMMV<=600-48 && SMMV>=600-93)
                MMH=stepH[1]-48;
        }
    }

    //step44 left-2
    if(maxWalkDst>6144 && maxWalkDst<6576)                //left-24 and left+408 left=6168
    {
        stepH[2] = 6552-maxWalkDst;                        //left+384
        //height up
        if(stepH[2]<MMH+48 && stepH[2]>MMH-48 && SMMV<=600-144)                
        {
            if(oldSMMV!=600-144)
                oldSMMV=600-144;
        }
        //left collision
        else if(stepH[2]<MMH+48 && stepH[2] >=MMH+42)    
        {
            if(SMMV<=600-96 && SMMV>=600-141)
                MMH=stepH[2]-48;
        }
    }

    //step44 left-3
    if(maxWalkDst>6192 && maxWalkDst<6624)                //left-24 and left+408 left=6216
    {
        stepH[3] = 6600-maxWalkDst;                        //left+384
        //height up
        if(stepH[3]<MMH+48 && stepH[3]>MMH-48 && SMMV<=600-192)                
        {
            if(oldSMMV!=600-192)
                oldSMMV=600-192;
        }
        //left collision
        else if(stepH[3]<MMH+48 && stepH[3] >=MMH+42)    
        {
            if(SMMV<=600-144 && SMMV>=600-189)
                MMH=stepH[3]-48;
        }
        //right collision
        else if(stepH[3]>MMH-48 && stepH[3]<=MMH-42)
        {
            if(SMMV<=600 && SMMV>=600-189)
                MMH=stepH[3]+48;
        }
    }

    //step44 right-3
    if(maxWalkDst>6480 && maxWalkDst<6912)                //left-24 and left+408 left=6504
    {
        stepH[7] = 6888-maxWalkDst;                        //left+384
        //height up
        if(stepH[7]<MMH+48 && stepH[7]>MMH-48 && SMMV<=600-48)                
        {
            if(oldSMMV!=600-48)
                oldSMMV=600-48;
        }
        //right collision
        else if(stepH[7]>MMH-48 && stepH[7]<=MMH-42)
        {
            if(SMMV<=600 && SMMV>=600-45)
                MMH=stepH[7]+48;
        }
    }

    //step44 right-2
    if(maxWalkDst>6432 && maxWalkDst<6864)                //left-24 and left+408 left=6456
    {
        stepH[6] = 6840-maxWalkDst;                        //left+384
        //height up
        if(stepH[6]<MMH+48 && stepH[6]>MMH-48 && SMMV<=600-96)                
        {
            if(oldSMMV!=600-96)
                oldSMMV=600-96;
        }
        //right collision
        else if(stepH[6]>MMH-48 && stepH[6]<=MMH-42)
        {
            if(SMMV<=600-48 && SMMV>=600-93)
                MMH=stepH[6]+48;
        }
    }

    //step44 right-1
    if(maxWalkDst>6384 && maxWalkDst<6816)                //left-24 and left+408 left=6408
    {
        stepH[5] = 6792-maxWalkDst;                        //left+384
        //height up
        if(stepH[5]<MMH+48 && stepH[5]>MMH-48 && SMMV<=600-144)                
        {
            if(oldSMMV!=600-144)
                oldSMMV=600-144;
        }
        //right collision
        else if(stepH[5]>MMH-48 && stepH[5]<=MMH-42)
        {
            if(SMMV<=600-96 && SMMV>=600-141)
                MMH=stepH[5]+48;
        }
    }

    //step44 right-0
    if(maxWalkDst>6336 && maxWalkDst<6768)                //left-24 and left+408 left=6360
    {
        stepH[4] = 6744-maxWalkDst;                        //left+384
        //height up
        if(stepH[4]<MMH+48 && stepH[4]>MMH-48 && SMMV<=600-192)                
        {
            if(oldSMMV!=600-192)
                oldSMMV=600-192;
        }
        //left collision
        else if(stepH[4]<MMH+48 && stepH[4] >=MMH+42)    
        {
            if(SMMV<=600 && SMMV>=600-189)
                MMH=stepH[4]-48;
        }
        //right collision
        else if(stepH[4]>MMH-48 && stepH[4]<=MMH-42)
        {
            if(SMMV<=600-144 && SMMV>=600-189)
                MMH=stepH[4]+48;
        }
    }
    }

    ///////////////////////////////////////////////////////////////////
    /////////////////////////////// Forth Step  //////////////////////
    ///////////////////////////////////////////////////////////////////
    if(maxWalkDst>6720 && maxWalkDst<9120)
    {
    //step54 left-0
    if(maxWalkDst>6720 && maxWalkDst<7152)                //left-24 and left+408 left=6744
    {
        stepH[8] = 7128-maxWalkDst;                        //left+384
        //height up
        if(stepH[8]<MMH+48 && stepH[8]>MMH-48 && SMMV<=600-48)                
        {
            if(oldSMMV!=600-48)
                oldSMMV=600-48;
        }
        //left collision
        else if(stepH[8]<MMH+48 && stepH[8] >=MMH+42)    
        {
            if(SMMV<=600 && SMMV>=600-45)
                MMH=stepH[8]-48;
        }
    }

    //step54 left-1
    if(maxWalkDst>6768 && maxWalkDst<7200)                //left-24 and left+408 left=6792
    {
        stepH[9] = 7176-maxWalkDst;                        //left+384
        //height up
        if(stepH[9]<MMH+48 && stepH[8]>MMH-48 && SMMV<=600-96)                
        {
            if(oldSMMV!=600-96)
                oldSMMV=600-96;
        }
        //left collision
        else if(stepH[9]<MMH+48 && stepH[9] >=MMH+42)    
        {
            if(SMMV<=600-48 && SMMV>=600-93)
                MMH=stepH[9]-48;
        }
    }

    //step54 left-2
    if(maxWalkDst>6816 && maxWalkDst<7248)                //left-24 and left+408 left=6840
    {
        stepH[10] = 7224-maxWalkDst;                        //left+384
        //height up
        if(stepH[10]<MMH+48 && stepH[10]>MMH-48 && SMMV<=600-144)                
        {
            if(oldSMMV!=600-144)
                oldSMMV=600-144;
        }
        //left collision
        else if(stepH[10]<MMH+48 && stepH[10] >=MMH+42)    
        {
            if(SMMV<=600-96 && SMMV>=600-141)
                MMH=stepH[10]-48;
        }
    }

    //step54 left-3
    if(maxWalkDst>6864 && maxWalkDst<7296)                //left-24 and left+408 left=6888
    {
        stepH[11] = 7272-maxWalkDst;                        //left+384
        //height up
        if(stepH[11]<MMH+48 && stepH[11]>MMH-48 && SMMV<=600-192)                
        {
            if(oldSMMV!=600-192)
                oldSMMV=600-192;
        }
        //left collision
        else if(stepH[11]<MMH+48 && stepH[11] >=MMH+42)    
        {
            if(SMMV<=600-144 && SMMV>=600-189)
                MMH=stepH[11]-48;
        }
    }

    //step54 left-4
    if(maxWalkDst>6912 && maxWalkDst<7344)                //left-24 and left+408 left=6936
    {
        stepH[12] = 7320-maxWalkDst;                        //left+384
        //height up
        if(stepH[12]<MMH+48 && stepH[12]>MMH-48 && SMMV<=600-192)                
        {
            if(oldSMMV!=600-192)
                oldSMMV=600-192;
        }
        //right collision
        else if(stepH[12]>MMH-48 && stepH[12]<=MMH-42)
        {
            if(SMMV<=600 && SMMV>=600-189)
                MMH=stepH[12]+48;
        }
    }

    //step54 right-3
    if(maxWalkDst>7200 && maxWalkDst<7632)                //left-24 and left+408 left=7224
    {
        stepH[13] = 7608-maxWalkDst;                        //left+384
        //height up
        if(stepH[13]<MMH+48 && stepH[13]>MMH-48 && SMMV<=600-48)                
        {
            if(oldSMMV!=600-48)
                oldSMMV=600-48;
        }
        //right collision
        else if(stepH[13]>MMH-48 && stepH[13]<=MMH-42)
        {
            if(SMMV<=600 && SMMV>=600-45)
                MMH=stepH[13]+48;
        }
    }

    //step54 right-2
    if(maxWalkDst>7152 && maxWalkDst<7584)                //left-24 and left+408 left=7176
    {
        stepH[14] = 7560-maxWalkDst;                        //left+384
        //height up
        if(stepH[14]<MMH+48 && stepH[14]>MMH-48 && SMMV<=600-96)                
        {
            if(oldSMMV!=600-96)
                oldSMMV=600-96;
        }
        //right collision
        else if(stepH[14]>MMH-48 && stepH[14]<=MMH-42)
        {
            if(SMMV<=600-48 && SMMV>=600-93)
                MMH=stepH[14]+48;
        }
    }

    //step54 right-1
    if(maxWalkDst>7104 && maxWalkDst<7536)                //left-24 and left+408 left=7128
    {
        stepH[15] = 7512-maxWalkDst;                        //left+384
        //height up
        if(stepH[15]<MMH+48 && stepH[15]>MMH-48 && SMMV<=600-144)                
        {
            if(oldSMMV!=600-144)
                oldSMMV=600-144;
        }
        //right collision
        else if(stepH[15]>MMH-48 && stepH[15]<=MMH-42)
        {
            if(SMMV<=600-96 && SMMV>=600-141)
                MMH=stepH[15]+48;
        }
    }

    //step54 right-0
    if(maxWalkDst>7056 && maxWalkDst<7488)                //left-24 and left+408 left=7080
    {
        stepH[16] = 7464-maxWalkDst;                        //left+384
        //height up
        if(stepH[16]<MMH+48 && stepH[16]>MMH-48 && SMMV<=600-192)                
        {
            if(oldSMMV!=600-192)
                oldSMMV=600-192;
        }
        //left collision
        else if(stepH[16]<MMH+48 && stepH[16] >=MMH+42)    
        {
            if(SMMV<=600 && SMMV>=600-189)
                MMH=stepH[16]-48;
        }
        //right collision
        else if(stepH[16]>MMH-48 && stepH[16]<=MMH-42)
        {
            if(SMMV<=600-144 && SMMV>=600-189)
                MMH=stepH[16]+48;
        }
    }

    //4 pipe
    if(maxWalkDst>7440 && maxWalkDst<7920)                //left-24 and left+456  left=7464
    {
        i=4;
        pipeH[i] = 7872-maxWalkDst;                        //left+408
        pipe2CD();
    }

    //39 bb
    if(maxWalkDst>7680 && maxWalkDst<8112)                //left-24 and left+408  left=7704
    {
        i=39;
        bbH[i] = 8088-maxWalkDst;                        //left+384
        lowLeftBBCD();
    }

    //40 bb
    if(maxWalkDst>7728 && maxWalkDst<8160)                //left-24 and left+408  left=7752
    {
        i=40;
        bbH[i] = 8136-maxWalkDst;                        //left+384
        lowMidBBCD();
    }

    //41 bb
    if(maxWalkDst>7776 && maxWalkDst<8208)                //left-24 and left+408  left=7800
    {
        i=41;
        bbH[i] = 8184-maxWalkDst;                        //left+384
        lowMidBBCD();
    }

    //42 bb
    if(maxWalkDst>7824 && maxWalkDst<8256)                //left-24 and left+408  left=7848
    {
        i=42;
        bbH[i] = 8232-maxWalkDst;                        //left+384
        lowRightBBCD();
    }

    //step90 left-0
    if(maxWalkDst>8304 && maxWalkDst<8736)                //left-24 and left+408 left=8328
    {
        stepH[17] = 8712-maxWalkDst;                    //left+384
        //height up
        if(stepH[17]<MMH+48 && stepH[17]>MMH-48 && SMMV<=600-48)                
        {
            if(oldSMMV!=600-48)
                oldSMMV=600-48;
        }
    }

    //5 pipe
    if(maxWalkDst>8208 && maxWalkDst<8688)                //left-24 and left+456  left=8232
    {
        i=5;
        pipeH[i] = 8640-maxWalkDst;                        //left+408
        pipe2CD();
    }

    //step90 left 1-7
    for(j=0; j!=7; ++j)
    {
        if(maxWalkDst>8352+j*48 && maxWalkDst<8784+j*48)            //left-24 and left+408 left=8376
        {
            stepH[18+j] = 8760+j*48-maxWalkDst;                        //left+384
            //height up
            if(stepH[18+j]<MMH+48 && stepH[18+j]>MMH-48 && SMMV<=600-96-j*48)                
            {
                if(oldSMMV!=600-96-j*48)
                    oldSMMV=600-96-j*48;
            }
            //left collision
            else if(stepH[18+j]<MMH+48 && stepH[18+j] >=MMH+42)    
            {
                if(SMMV<=600-48-j*48 && SMMV>=600-93-j*48)
                MMH=stepH[18+j]-48;
            }
        }
    }

    //step90 left-8
    if(maxWalkDst>8688 && maxWalkDst<9120)                //left-24 and left+408 left=8712
    {
        stepH[25] = 9096-maxWalkDst;                        //left+384
        //height up
        if(stepH[25]<MMH+48 && stepH[25]>MMH-48 && SMMV<=216)                
        {
            if(oldSMMV!=216)
                oldSMMV=216;
        }
        //right collision
        else if(stepH[25]>MMH-48 && stepH[25]<=MMH-42)
        {
            if(SMMV<=600 && SMMV>=219)
                MMH=stepH[25]+48;
        }
    }
    }

    //fall 
    if(SMMV==600-192-192 && !JumpState
        && ((bbH[6]>=MMH+48 || bbH[6]<=MMH-48) && (bbH[10]>=MMH+48 || bbH[10]<=MMH-48)
        && (bbH[11]>=MMH+48 || bbH[11]<=MMH-48)&& (bbH[12]>=MMH+48 || bbH[12]<=MMH-48)
        && (bbH[13]>=MMH+48 || bbH[13]<=MMH-48)&& (bbH[14]>=MMH+48 || bbH[14]<=MMH-48)
        && (bbH[15]>=MMH+48 || bbH[15]<=MMH-48)&& (bbH[16]>=MMH+48 || bbH[16]<=MMH-48)
        && (bbH[17]>=MMH+48 || bbH[17]<=MMH-48)&& (bbH[18]>=MMH+48 || bbH[18]<=MMH-48)
        && (bbH[19]>=MMH+48 || bbH[19]<=MMH-48)&& (bbH[20]>=MMH+48 || bbH[20]<=MMH-48)
        && (bbH[21]>=MMH+48 || bbH[21]<=MMH-48)&& (bbH[27]>=MMH+48 || bbH[27]<=MMH-48)
        && (bbH[30]>=MMH+48 || bbH[30]<=MMH-48)&& (bbH[31]>=MMH+48 || bbH[31]<=MMH-48)
        && (bbH[32]>=MMH+48 || bbH[32]<=MMH-48)&& (bbH[33]>=MMH+48 || bbH[33]<=MMH-48)
        && (bbH[34]>=MMH+48 || bbH[34]<=MMH-48)&& (bbH[35]>=MMH+48 || bbH[35]<=MMH-48)
        && (bbH[36]>=MMH+48 || bbH[36]<=MMH-48)&& (stepH[24]>=MMH+48 || stepH[24]<=MMH-48)
        && (stepH[25]>=MMH+48 || stepH[25]<=MMH-48)))
    {
        JumpState = true;
        FirstJump = false;
        BigJump   = true;
        Fall      = true;
        oldSMMV      = 600;
    }
    else if((SMMV==600-240 && !JumpState && (stepH[21]>=MMH+48 || stepH[21]<=MMH-48))
            ||(SMMV==600-288 && !JumpState && (stepH[22]>=MMH+48 || stepH[22]<=MMH-48))
            ||(SMMV==600-336 && !JumpState && (stepH[23]>=MMH+48 || stepH[23]<=MMH-48)))
    {
        JumpState = true;
        FirstJump = false;
        BigJump   = true;
        Fall      = true;
        oldSMMV      = 600;
    }
    else if(SMMV==600-192 && !JumpState 
            &&((bbH[0]>=MMH+48 || bbH[0]<=MMH-48) && (bbH[1]>=MMH+48 || bbH[1]<=MMH-48)
            && (bbH[2]>=MMH+48 || bbH[2]<=MMH-48) && (bbH[3]>=MMH+48 || bbH[3]<=MMH-48)
            && (bbH[4]>=MMH+48 || bbH[4]<=MMH-48) && (bbH[5]>=MMH+48 || bbH[5]<=MMH-48)
            && (pipeH[2]>=MMH+72 || pipeH[2]<=MMH-72) && (pipeH[3]>=MMH+72 || pipeH[3]<=MMH-72)
            && (bbH[7]>=MMH+48    || bbH[7]<=MMH-48)    && (bbH[8]>=MMH+48    || bbH[8]<=MMH-48)
            && (bbH[9]>=MMH+48    || bbH[9]<=MMH-48)    && (bbH[22]>=MMH+48 || bbH[22]<=MMH-48)
            && (bbH[23]>=MMH+48 || bbH[23]<=MMH-48)    && (bbH[24]>=MMH+48 || bbH[24]<=MMH-48)
            && (bbH[25]>=MMH+48 || bbH[25]<=MMH-48)    && (bbH[26]>=MMH+48 || bbH[26]<=MMH-48)
            && (bbH[28]>=MMH+48 || bbH[28]<=MMH-48)    && (bbH[29]>=MMH+48 || bbH[29]<=MMH-48)
            && (bbH[37]>=MMH+48 || bbH[37]<=MMH-48)    && (bbH[38]>=MMH+48 || bbH[38]<=MMH-48)
            && (stepH[3]>=MMH+48 || stepH[3]<=MMH-48)&& (stepH[4]>=MMH+48 || stepH[4]<=MMH-48)
            && (stepH[11]>=MMH+48 || stepH[11]<=MMH-48)&& (stepH[12]>=MMH+48 || stepH[12]<=MMH-48)
            && (stepH[16]>=MMH+48 || stepH[16]<=MMH-48)&& (stepH[20]>=MMH+48 || stepH[20]<=MMH-48)
            && (bbH[39]>=MMH+48 || bbH[39]<=MMH-48)    && (bbH[40]>=MMH+48 || bbH[40]<=MMH-48)
            && (bbH[41]>=MMH+48 || bbH[41]<=MMH-48)    && (bbH[42]>=MMH+48 || bbH[42]<=MMH-48)))    
    {
        JumpState = true;
        FirstJump = false;
        BigJump   = true;
        Fall      = true;
        oldSMMV   = 600;
    }
    else if(SMMV==600-144 && !JumpState 
            && ((pipeH[1]>=MMH+72 || pipeH[1]<=MMH-72) && (stepH[2]>=MMH+48 || stepH[2]<=MMH-48)
            &&  (stepH[5]>=MMH+48 || stepH[5]<=MMH-48) && (stepH[10]>=MMH+48 || stepH[10]<=MMH-48)
            && (stepH[15]>=MMH+48 || stepH[15]<=MMH-48) && (stepH[19]>=MMH+48 || stepH[19]<=MMH-48)))
    {
        JumpState = true;
        FirstJump = false;
        BigJump   = true;
        Fall      = true;
        oldSMMV      = 600;
    }
    else if(SMMV==600-96 && !JumpState
            && ((pipeH[0]>=MMH+72 || pipeH[0]<=MMH-72) && (stepH[1]>=MMH+48 || stepH[1]<=MMH-48)
            &&  (stepH[6]>=MMH+48 || stepH[6]<=MMH-48) && (stepH[9]>=MMH+48 || stepH[9]<=MMH-48)
            && (stepH[14]>=MMH+48 || stepH[14]<=MMH-48) && (pipeH[4]>=MMH+72 || pipeH[4]<=MMH-72)
            &&  (pipeH[5]>=MMH+72 || pipeH[5]<=MMH-72) && (stepH[18]>=MMH+48 || stepH[18]<=MMH-48)))
    {
        JumpState = true;
        FirstJump = false;
        BigJump   = true;
        Fall      = true;
        oldSMMV      = 600;
    }
    else if(SMMV==600-48 && !JumpState
            && ((stepH[0]>=MMH+48 || stepH[0]<=MMH-48) && (stepH[7]>=MMH+48 || stepH[7]<=MMH-48)
            &&  (stepH[8]>=MMH+48 || stepH[8]<=MMH-48) && (stepH[13]>=MMH+48 || stepH[13]<=MMH-48)
            && (stepH[17]>=MMH+48 || stepH[17]<=MMH-48)))
    {
        JumpState = true;
        FirstJump = false;
        BigJump   = true;
        Fall      = true;
        oldSMMV      = 600;
    }
}


/*******************************
        level1-2.h
 *******************************/
#include "level11.h"

void interactWithBB12()
{
    for(i=0; i!=60; ++i)
        if(bbState[i])
            break;
    if(i!=60)
    {
        switch(i)
        {
        case 0:     case 1:  case 2:  case 3:  case 4:  case 8: case 21: case 25: case 26:
        case 27: case 28: case 34: case 35: case 41:
            coverOldBb12();
            drawNewBox12();
            bbState[i]=false;
            break;
        case 5:  case 6:  case 7:  case 9:  case 10: case 11: case 12:
        case 13: case 14: case 15: case 16: case 17: case 18: case 19: case 20:
        case 22: case 23: case 24: case 29: case 30: case 31: case 32: case 33:
        case 36: case 37: case 38: case 39: case 40: case 42:
            coverOldBb12();
            drawNewBrick12();
            bbState[i]=false;
            break;
        }
    }
}

void CollisionDetect12()
{
    if(maxWalkDst>96 && maxWalkDst<528)        //left-24  left+408        left=120
    {
        i=0;
        bbH[i] = 504-maxWalkDst;            //left+384
        lowLeftBBCD();
    }

    if(maxWalkDst>144 && maxWalkDst<576)    //left-24   left+408    left=168
    {
        i=1;
        bbH[i] = 552-maxWalkDst;            //left+384
        lowMidBBCD();
    }

    if(maxWalkDst>192 && maxWalkDst<624)
    {
        i=2;
        bbH[i] = 600-maxWalkDst;
        lowMidBBCD();
    }

    if(maxWalkDst>240 && maxWalkDst<672)
    {
        i=3;
        bbH[i] = 648-maxWalkDst;
        lowMidBBCD();
    }

    if(maxWalkDst>288 && maxWalkDst<720)
    {
        i=4;
        bbH[i] = 696-maxWalkDst;
        lowRightBBCD();
    }

    if(SMMV==600-192 && !JumpState 
            && ((bbH[0]>=MMH+48 || bbH[0]<=MMH-48) && (bbH[1]>=MMH+48 || bbH[1]<=MMH-48)
            &&  (bbH[2]>=MMH+48 || bbH[2]<=MMH-48) && (bbH[3]>=MMH+48 || bbH[3]<=MMH-48)
            &&    (bbH[4]>=MMH+48 || bbH[4]<=MMH-48)))
    {
        JumpState = true;
        FirstJump = false;
        BigJump   = true;
        Fall      = true;
        oldSMMV   = 600;
    }
}

void level12()
{
    loadBgImg();
    displayLevelLifeInfo();
    displayBeginAnimation();
    dataInitialization();
    //main loop
    while(true)
    {
        //Batch Draw
        BeginBatchDraw();
        drawBg();
        interactWithBB12();
        drawSmallMario();
        EndBatchDraw();

        JumpDetect();
        DirDetect();

        calculateMMH();
        calculateSMMV();

        CollisionDetect12();

        //1 trap
        //2 trap
        //3 trap
        //4 trap
        //5 trap

        //flag
        /*
        if(maxWalkDst>9120 && maxWalkDst<9552)                //left-24 and left+408 left=9144
        {
            flagH = 9528-maxWalkDst;                        //left+384
            //height up
            if(flagH<MMH+48 && SMMV<=600-48)                
            {
                displayWinAnimation();
                win = true;
                ++level;
                break;
            }
            //left collision
            else if(flagH<MMH+48 && flagH >=MMH+42)    
            {
                if(SMMV<=600 && SMMV>=600-45)
                    MMH=flagH-48;
            }
        }
        */

        displayTime();
    }
}
#include <easyx.h>
#include <conio.h>
#include <windows.h>
#include <cstdio>
#include <cmath>
#include "level12.h"

int main()
{
    //initialize graph
    timeBeginPeriod(1);
    initgraph(768,720);

    do
    {    
        level = 0;
        lifeCount = 3;
        displayReadyInterface();    //need to correct, change it into a piture
        while(getch()!='\r');
        do
        {
            switch(level)
            {
            case 0:
                level11();
                break;
            default:
                level12();
                break;
            }
            if(win)
                ++lifeCount;
        }while(--lifeCount!=0);
        displayGameOver();
    }while(true);

    closegraph();
    timeEndPeriod(1);
    return 0;
}