Game code

struct AnimData
    {
        //compound data types
        Rectangle rec; //The sprite sheet layout?
        Vector2 pos;// The positing in the game's window
        int frame;
        float updatetime;
        float runningtime;

        //Custom variables in a struct are called members
    };

bool isOnGround(AnimData data, int WindowHeight)
{
    return data.pos.y >= WindowHeight - data.rec.height;
}

AnimData UpdateAnimData (AnimData Data, float Deltatime, int maxFrame)
{
    //update running time
    Data.runningtime += Deltatime;

    //Check to see if running time is great or equal then update time
    if (Data.runningtime >= Data.updatetime)
    {
        Data.runningtime = 0.0;

        //Update animation frame
        Data.rec.x = Data.frame * Data.rec.width;
        Data.frame++;
        if(Data.frame > maxFrame)
        {
            Data.frame = 0;
        }
    }
    return Data;
}

int main()
{

//creates an array, of 4 different values starting at 0
double damage [4];
//initilizing each each element with its value
damage [0] = 20.0;
damage [1] = 16.5;
damage [2] = 14.0;
damage [3] = 11.7;

//Size of the window for the game
int WindowDim [2];
WindowDim [0] = 950;//Height
WindowDim [1] = 1000;//Width

//Creating window size
//const makes the variable impossible to change
//const int HeightW {1000};
//const int WidthW {950};

//Gravity by acceleration based on ((pixles/second)second)
const int Gravity {1'212};

InitWindow(WindowDim[0],WindowDim[1],"Run,run, run as fast as you can");

//Animation Frame Tracker
    // int FrameTracker {0};

AnimData scarfyData;




//Custom Variable from raylib. Compound data type
//Loading scarfy variables
Texture2D Scarfy = LoadTexture("dapper-dasher-master-textures/textures/scarfy.png");

//Since there is 6 images in one file we draw from, the width will be divided by 6
    scarfyData.rec.width = Scarfy.width/6;
//The Height is the same as loaded texture
    scarfyData.rec.height = Scarfy.height;
//The starting point on the image to be loaded is 0,0 on the top left of the screen
    scarfyData.rec.x = 0;
    scarfyData.rec.y = 0;
//Putting the center of Scarfy to be in the center of the Window
    scarfyData.pos.x = WindowDim[0]/2 - scarfyData.rec.width/2;
    scarfyData.pos.y = WindowDim[1] - scarfyData.rec.height;
    scarfyData.frame = 0;
//Amount of time before we update Scarfy's animation frame
scarfyData.updatetime = 1.0/12.0;
//Time passed since scarfy's animation frame was updated
    //scarfyData.runningtime = 0.0;

const int SizeofNubulee {6};

//Nebula variables
Texture2D Nebula = LoadTexture("dapper-dasher-master-textures/textures/12_nebula_spritesheet.png");

//Initializing Nebula 2 using a custom variable
//AnimData for Nebula
//Input must be Rectangle, Vector, Int float, and float
//(float)
//(float)
//AnimData nebData {
  //  {0.0,0.0,Nebula.width/8.0,Nebula.height/8.0} , // Rectangle rec (x,y,width,height) ,pos ,frame,update time, running time)
    //{WindowDim[0],WindowDim[1] - Nebula.height/8}, //Vector2 pos (X float, Y Float)
    //0, //Frame (int)
    //1.0/12.0, //UpdateTimeNeb float
    //0// RunningTimeNeb float
   // };

//Initializing Nebula 2 using a custom variable
//AnimData Neb2Data{
//{0.0,0.0,Nebula.width/8.0,Nebula.height/8.0},
//{WindowDim[0]+300, WindowDim[1] - Nebula.height/8},
 //0,
 //1.0/10.0
 //,0
 //};

//Stores each Animdata in an array size of 2
AnimData Nubulee [SizeofNubulee]{};//nebData,Neb2Data};
for (int i = 0; i < SizeofNubulee; i++)
{
    Nubulee[i].rec.x = 0.0;
    Nubulee[i].rec.y = 0.0;
    Nubulee[i].rec.width = Nebula.width/8;
    Nubulee[i].rec.height = Nebula.height/8;
    Nubulee[i].pos.y = WindowDim[1] - Nebula.height/8;
    Nubulee[i].frame = 0;
    Nubulee[i].runningtime = 0.0;
    Nubulee[i].updatetime = 1.0/12.0;
    Nubulee[i].pos.x = WindowDim[0] + (i * 300);
}
//Nubulee[0].pos.x = WindowDim[0];
//Nubulee[1].pos.x = WindowDim[0]+300;
//Nubulee[2].pos.x = WindowDim[0]+600;
//Nubulee[3].pos.x = WindowDim[0]+900;
//Nubulee[4].pos.x = WindowDim[0]+1200;
//Nubulee[5].pos.x = WindowDim[0]+1500;
//Loading in the Nebula sprite sheet which is a 8x8 png sheet
//    Rectangle NebRec {0.0,0.0,(float)(Nebula.width/8.0),(float)(Nebula.height/8.0)};
//    Vector2 nebPos{WidthW,HeightW - NebRec.height};

//Second variables for Nebula
    //Rectangle nebRec2{0.0,0.0,(float)(Nebula.width/8.0),(float)(Nebula.height/8.0)};
    //Vector2 nebPos2{WidthW+300,HeightW - NebRec.height};

//Nebula velocity (pixles per second)
int nevVel {-345};

//Custom variable that will load the a section of the loaded png
//Rectangle ScarfyRec;

//Since there is 6 images in one file we draw from, the width will be divided by 6
//ScarfyRec.width = Scarfy.width/6;

//The Height is the same as loaded texture
//ScarfyRec.height = Scarfy.height;

//The starting point on the image to be loaded is 0,0 on the top left of the screen
//ScarfyRec.x = 0;
//ScarfyRec.y = 0;


//Position for the draw texture pact
    //Vector2 ScarfyPostion;


//Putting the center of Scarfy to be in the center of the Window
//ScarfyPostion.x = WidthW/2 - ScarfyRec.width/2;
//ScarfyPostion.y = HeightW - ScarfyRec.height;

//Jumping velocity pixles per second
const int jump {-600};

//Rectangle Example\/
//const int RectH {25};
//const int rectW {100};

//Velocity and Position Variables
int Velocity {0};
//Position of the rectangle will appear at the Rectangle's height, 100 pixles above the bottom of tg
//int PosY {HeightW - rectW};

bool InAir;
//counter 0-6, of each sprite of scarfy
int FramePos{0};

//Which sprite from the nebula sprite sheet to use
    //int nebFrame {0};

//How much time should pass between animation frames of the nebula
    //const float UpdateTimeNeb (1.0/12.0);

//How much time has passed since we updated the animation fram for the nebula
    //float RunningTimeNeb (0);

//Amount of time before we update animation frame
const float UpdateFPS (1.0/12.0);


    //int neb2frame{0};
    //const float update2timeNeb {1.0/10.0};
    //float nebRunningTime2;


//Time passed since scarfy's animation frame was updated
//float runningtime (0);
Texture2D Background = LoadTexture ("dapper-dasher-master-textures/textures/far-buildings.png");

Texture2D Midground = LoadTexture("dapper-dasher-master-textures/textures/back-buildings.png");

Texture2D Foreground = LoadTexture("dapper-dasher-master-textures/textures/foreground.png");

//Semi global variable used to repeat background
float bgX {0};
float mgX {0};
float fgX {0};

    SetTargetFPS(60);
    //Dont forget that '!' can negate a boolean
    while(!WindowShouldClose())
  {
//delta time (time since last frame)
    float dt{GetFrameTime()};

//if Scarfy is in the air, his sprite would pause
if(!InAir)
{
scarfyData = UpdateAnimData (scarfyData, dt, 5);

      // Point of this part of the code is to make sure that each fram of scarfy loops at a certain pace.
       //We dont want it to run at 60 frames per second so we slow down only scarfy

      //update running time/Animation frames
    //  scarfyData.runningtime += dt;

     // if (scarfyData.runningtime >= scarfyData.updatetime)
    //  {
        //  scarfyData.runningtime = 0.0;
        //update Running time
        //managing framerate and which frame of Sparky to use when running and how fast the sprite goes from one postion to the next
            //  scarfyData.rec.x = scarfyData.frame * scarfyData.rec.width;
            //ScarfyRec.x = FrameTracker * ScarfyRec.width;
            //  scarfyData.frame++;

              //    if (scarfyData.frame > 5)
                  //    {
                   //   scarfyData.frame = 0;
                  //    }
                //  scarfyData.rec.x = FramePos * scarfyData.rec.width;
                //ScarfyRec.x = FramePos*ScarfyRec.width;
                //  FramePos++;

           //    if (FramePos > 5)
                //  {
            //  FramePos = 0;
                //  }

    //  }
}


for (int i = 0; i < SizeofNubulee; i++)
{

Nubulee [i] = UpdateAnimData (Nubulee[i], dt, 7);

//Update Nebula's animation frame //now using a for loop and a const int
//Nubulee[i].runningtime += dt;
//if (Nubulee[i].runningtime>= Nubulee[i].updatetime)
  //  {
    //Nubulee[i].runningtime = 0.0;
    //Nubulee[i].rec.x = Nubulee[i].frame * Nubulee[i].rec.width;
    //Nubulee[i].frame++;
  //  if (Nubulee[i].frame > 7)
        //{
          //  Nubulee[i].frame = 0;
        //}

    //}
}

//Update 2nd Nebula's animation frame
//Nubulee[1].runningtime += dt;
//if (Nubulee[1].runningtime >= Nubulee[1].updatetime)
//{
    //Nubulee[1].runningtime = 0.0;
  //  Nubulee[1].rec.x = Nubulee[1].frame * Nubulee[1].rec.width;
    //Nubulee[1].frame++;
  //  if (Nubulee[1].frame > 7)
    //    {
      //      Nubulee[1].frame = 0;
        //}

//}


    //start drawing
    BeginDrawing();
    //creates the background color
    ClearBackground(BLACK);

    bgX -= 20*dt;

    if (bgX <= -Background.width*2)
    {
        bgX = 0.0;
    }

//Scroll the midground
    mgX -= 40*dt;

    if (mgX <= -Midground.width*2)
    {
        mgX = 0.0;
    }

//Scroll the foreground
    fgX -= 80*dt;

    if (fgX <= -Foreground.width*2)
    {
        fgX = 0.0;
    }



    //The background position changes on a rate of 20*delta time
Vector2 bg1Pos {bgX,0.0};
//Draw the Background
DrawTextureEx(Background,bg1Pos, 0.0, 6.0, PINK);
//The background position changes on a rate of 20*delta time
Vector2 bg2Pos {bgX+Background.width*2, 0.0};
DrawTextureEx(Background,bg2Pos, 0.0, 6.0, PINK);

//Draw the Midground
Vector2 mg1Pos {mgX,0.0};
DrawTextureEx(Midground,mg1Pos,0.0,4,WHITE);
Vector2 mg2Pos {mgX+Midground.width*2, 0.0};
DrawTextureEx(Midground,mg2Pos,0.0,4,WHITE);

//Draw the Background
Vector2 fg1Pos {fgX,0.0};
DrawTextureEx(Foreground,fg1Pos,0.0,5.2,WHITE);
Vector2 fg2Pos {fgX+Foreground.width*2, 0.0};
DrawTextureEx(Foreground,fg2Pos,0.0,5.2,WHITE);


        //have to make sure that the starting position of the rectangle is on the bottom of the window
        //ground height, if the rectangle is sitting on the bottoom of the window
   // if (ScarfyPostion.y >= HeightW - ScarfyRec.width)
   //  if (scarfyData.pos.y >= WindowDim[1] - scarfyData.rec.height)

   //Using a custon function to determine if Scarfy is on the grounds
    if (isOnGround (scarfyData,WindowDim[1]))
    {
        Velocity = 0;
        InAir = false;
    }else
    {
        //Rectangle is in the air
        //apply gravity per each frame of the while loop
        Velocity += Gravity * dt;
        InAir = true;
    }

    //Checking for jumping
    if(IsKeyPressed(KEY_SPACE)&& !InAir)
    {
    Velocity +=jump;
    }

    for (int i = 0; i < SizeofNubulee; i++)
    {
   //update each of nebula's position
    Nubulee[i].pos.x += nevVel * dt;
    }


    //Update second nebula position
   // Nubulee[1].pos.x += nevVel * dt;

    //updating the position of scarfy each instance of the while loop
    scarfyData.pos.y += Velocity * dt;
for (int i = 0; i < SizeofNubulee;i++)
{
    //Draw Nebula
    DrawTextureRec(Nebula,Nubulee[i].rec,Nubulee[i].pos,YELLOW);
}

    //Draw 2nd Nebula
    //DrawTextureRec(Nebula,Nubulee[1].rec,Nubulee[1].pos,YELLOW);

    //Draw scarfy
    //DrawTextureRec(Scarfy,ScarfyRec,ScarfyPostion,PINK);
    DrawTextureRec(Scarfy,scarfyData.rec,scarfyData.pos,PINK);
    //Creating the rectangle
    //DrawRectangle(WidthW/2, PosY, RectH,rectW,WHITE);
    //ends the drawing
    EndDrawing();

    }
   //Closing the texture sheets after the program is done
    UnloadTexture(Scarfy);
    UnloadTexture(Nebula);
    UnloadTexture(Background);
    UnloadTexture(Midground);
    UnloadTexture(Foreground);
    CloseWindow();
}