NoPaste []

#include <allegro.h>
#include <stdlib.h>
#include <math.h>

#define BUFFSIZE 20
#define WINDOWHEIGHT 480
#define WINDOWWIDTH 640
#define SCALEDETAIL 10

#define CBLACK       makecol (  0,   0,   0)
#define CBALL        makecol (255, 255, 255)
#define CINDICATOR   makecol ( 50, 255,   0)
#define CAUTHOR      makecol ( 50, 255,   0)
#define CPAUSE       makecol (255, 255,   0)
#define CSCALE       makecol (255, 255, 255)
#define CSCALE2      makecol (180, 180, 180)
#define CSCALENUM    makecol (255, 255, 255)
#define CSCALENUM2   makecol (180, 180, 180)
#define CGROUND      makecol (255, 255, 255)
#define CSIMINFO     makecol (255, 255, 255)
#define CMENUINFO    makecol (255, 255, 255)
#define CWHITE       makecol (255, 255, 255)

static short int nLeftMargin   = 20,               \
                 nRightMargin  = 20,               \
                 nTopMargin    = 20,               \
                 nBottomMargin = 20,               \
                 nMargin       = 2,                \
                 nFontHeight   = 8,                \             
                 nFontWidth    = 8,                \
                 nLineInterval = 5,                \
                 nScaleWidth   = 10,               \
                 nScaleMargin  = 100,              \
                 nCircleRadius = 10,               \
                 xCirclePos    = WINDOWWIDTH / 2 ;

char szPauseText[]         = "PAUSE",                                           \
     szAuthorText[]        = "Author: Pawel Guz",                               \
     szInfoText[]          = "\"S\" to start a new simulation, ESC to exit.",   \
     szAltitudeText[]      = "Altitude:",                                       \
     szAccelerationText[]  = "Acceleration:",                                   \
     szMemoryError[]       = "There is not enough memory to create a bitmap!\n" ;

BITMAP *bScreen = NULL;
void Draw (float fAltitude, float fAcceleration, float fScaleStep, float fTime) ;
void GetParameters (float* fAltitude, float* fAcceleration) ;
char* GetNumber (int xPosition, int yPosition) ;

void Initiate() ;
void Deinitiate() ;

volatile int msCounter = 0 ;
void Timer()
{
    msCounter++ ;
}
END_OF_FUNCTION (Timer)
     
int main()
{
    Initiate();
   
    float fAltitude, fAcceleration, fTime, fScaleStep;
     
    while(1)
    {
        clear_bitmap(bScreen);   
        textprintf(bScreen, font, nLeftMargin, nTopMargin, CAUTHOR, szAuthorText) ;
        textprintf(bScreen, font, nLeftMargin, nTopMargin + nFontHeight + nLineInterval, CMENUINFO, szInfoText) ;
        blit(bScreen, screen, 0, 0, 0, 0, WINDOWWIDTH, WINDOWHEIGHT) ;
               
        while(1)
        {
            while (!keypressed()) ;
            if (key[KEY_S])
            {
                readkey() ;
                GetParameters (&fAltitude, &fAcceleration) ;
                fScaleStep = fAltitude * SCALEDETAIL / (WINDOWHEIGHT - (nTopMargin + nBottomMargin)) ;
                break ;             
            }
            else if (key[KEY_ESC])
                Deinitiate() ;
        }   
       
        msCounter = 0 ;
        while (msCounter <= (sqrt (2 * fAltitude / fAcceleration) * 1000))
        {
            Draw (fAltitude, fAcceleration, msCounter * 0.001, fScaleStep) ; 
           
            if(keypressed())
            {
                if (key[KEY_P])
                {
                    readkey();
                    fTime = msCounter;
                   
                    text_mode (CBLACK) ;
                    textout(screen, font, szPauseText, WINDOWWIDTH - nRightMargin - nFontWidth * (sizeof(szPauseText) / sizeof(char) - 1), nTopMargin, CPAUSE);
                    text_mode(-1);
                   
                    while (1)
                    {
                        while (!keypressed());
                        if (key[KEY_P] || key[KEY_ESC])
                        {
                            readkey() ;
                            break ;
                        }
                    }
                    msCounter = fTime;
                }
                else if (key[KEY_ENTER])
                {
                    readkey();
                    break; 
                }
                else if (key[KEY_ESC])
                {
                    readkey();
                    break; 
                }                 
            }       
        }
       
        Draw (fAltitude , fAcceleration, sqrt (2 * fAltitude / fAcceleration), fScaleStep);
        readkey();
    }
}
END_OF_MAIN()

void Draw (float fAltitude, float fAcceleration, float fTime, float fScaleStep)
{
    short int nCurrentStep ;
    int yCurrent, cyDisplacement ;
    float fDisplacement, fVelocity ;
               
       
    clear_bitmap(bScreen) ;
       
    vline(bScreen, nScaleMargin, nTopMargin, WINDOWHEIGHT - nTopMargin, CSCALE) ;
    for (nCurrentStep = 0, yCurrent = WINDOWHEIGHT - nBottomMargin ; yCurrent >= nTopMargin ; yCurrent -= SCALEDETAIL, nCurrentStep++ )
    {
        if (nCurrentStep % 2 == 0)
        {
            textprintf(bScreen, font, nLeftMargin, yCurrent , CSCALENUM, "%0.3f", nCurrentStep * fScaleStep);       
            hline(bScreen, nScaleMargin - nScaleWidth, yCurrent, nScaleMargin + nScaleWidth, CSCALE); 
        }
        else if (nCurrentStep % 2 == 1)
        {
            textprintf(bScreen, font, nLeftMargin, yCurrent , CSCALENUM2, "%0.3f", nCurrentStep * fScaleStep);       
            hline(bScreen, nScaleMargin - nScaleWidth, yCurrent, nScaleMargin + nScaleWidth, CSCALE2); 
        }     
    }
    hline(bScreen, nScaleMargin, WINDOWHEIGHT - nBottomMargin, WINDOWWIDTH - nRightMargin, CGROUND) ;
   
    fDisplacement = fAcceleration * fTime * fTime / 2 ;
    cyDisplacement = fDisplacement / fAltitude * (WINDOWHEIGHT - (nTopMargin + nBottomMargin)) + nTopMargin;
    fVelocity = fAcceleration * fTime;                                                                                   
   
    circle(bScreen, xCirclePos, cyDisplacement, nCircleRadius, CBALL) ;
    hline(bScreen, nScaleMargin, cyDisplacement, xCirclePos - nCircleRadius, CINDICATOR) ;
    textprintf(bScreen, font,  xCirclePos + 2 * nCircleRadius, cyDisplacement - nFontHeight, CSIMINFO, "v=%5.3f h=%0.3f t=%0.3f", fVelocity, (fAltitude - fDisplacement), fTime);

   
    blit(bScreen, screen, 0, 0, 0, 0, WINDOWWIDTH, WINDOWHEIGHT);   
    return; 
}

void GetParameters (float* fAltitude, float* fAcceleration)
{
    clear_bitmap(screen);   
   
    textprintf(screen, font, nLeftMargin, nTopMargin, CWHITE, szAltitudeText) ;
    while(1)
    {
        if ((*fAltitude = atof (GetNumber (nMargin + nLeftMargin + nFontWidth * (sizeof(szAltitudeText) / sizeof(char) - 1), nTopMargin))) == 0)
            continue ;
        else break ;
    }   
   
    textprintf(screen, font, nLeftMargin, nTopMargin + nFontHeight + nLineInterval, CWHITE, szAccelerationText) ;
    while(1)
    {
        if ((*fAcceleration = atof (GetNumber (nMargin + nLeftMargin + nFontWidth * (sizeof(szAccelerationText) / sizeof(char) - 1), nTopMargin + nFontHeight + nLineInterval))) == 0)
            continue ;
        else break ;
    }   
   
    readkey();
    return;   
}

char* GetNumber (int xPosition, int yPosition)
{
    BITMAP* TextBox ;
    char szBuffer[BUFFSIZE], cChar ;
    short int nCaret = 0;
    szBuffer[0] = '\0' ;
   
    if (!(TextBox = create_bitmap (nFontWidth * BUFFSIZE, nFontHeight)))
    {
        set_gfx_mode (GFX_TEXT, 0, 0, 0, 0);
        allegro_message (szMemoryError) ;
        allegro_exit();
        exit(1);
    }
   
    do
    {                         
        if (keypressed())
        {
            cChar = readkey() ;
                       
            if (key[KEY_BACKSPACE])
            {
                if (nCaret > 0)
                    nCaret-- ;
                szBuffer[nCaret] = '\0' ;   
            }                   
            else if (cChar >= '0' && cChar <= '9' || cChar == '.')
            {
                if (nCaret <= BUFFSIZE - 1)
                {
                    szBuffer[nCaret] = cChar ;   
                    nCaret++ ;
                    szBuffer[nCaret] = '\0' ;   
                }
            }
        }
       
        clear_bitmap (TextBox) ;     
        textout (TextBox, font, szBuffer, 0, 0, CWHITE) ;
        blit (TextBox, screen, 0, 0, xPosition, yPosition, TextBox->w, TextBox->h) ;
    }   
    while (!key[KEY_ENTER]) ;
   
    return szBuffer ;     
}

void Initiate()
{   
    allegro_init() ;
    install_keyboard() ;
    set_color_depth(32) ;
   
    set_gfx_mode (GFX_AUTODETECT_WINDOWED, WINDOWWIDTH, WINDOWHEIGHT, 0, 0);

    if (!(bScreen = create_bitmap (WINDOWWIDTH, WINDOWHEIGHT)))
    {
        set_gfx_mode (GFX_TEXT, 0, 0, 0, 0) ;
        allegro_message (szMemoryError) ;
        allegro_exit() ;
        exit(1) ;
    }

    clear_to_color (bScreen, CBLACK) ;

    LOCK_VARIABLE (msCounter) ;
    LOCK_FUNCTION (Timer) ;
    install_int (Timer, 1) ;
   
    return ;
}

void Deinitiate()
{
    readkey() ;
    destroy_bitmap (bScreen);
    allegro_exit();
    exit(1);
}