V.7

Arbetet går ganska segt framåt pga jul och släkt men lite framåt går det.

Jag har fått ut en gubbe jag kan gå runt med i första staden men har bara hunnit sätta kollision på vattnet och inte huset/staketen. Har även försökt få gubben att vrida sig men lyckas inte få till att den ska byta sprite när man går åt ett annat håll. Ett exempel på vad jag har gjort:

/////////

else if (m_keyboard->IsKeyDown(1))
{
m_y += speed;
if (m_y > 325)
{
m_y = 325;
}
if (m_x > 92 && m_x < 240 && m_y > 260)
{
m_y = 260.0f;
}
}

/////////////

Jag har än så länge bara hårdkodat. Alltså sagt till koden att om den når en viss y-koordinat eller en y-koordinat och en viss x-koordinat så kommer gubben stå helt stilla. Jag ska försöka lösa det på att smidigare sätt nästa gång jag ger mig på det.

V.5

Vad vi lärde oss under denna vecka var: Kollision, hur man sätter in en annan bildtyp (alltså inte bara ”bmp” utan även ”jpg” ”png” etc) och vi blev klara med Arkanoid.

Det vi gjorde klart var: Bollen och Blocken.

Bollen går till att det kommer studsa om den slår i en vägg eller spelaren (som styr det långa blocket längst ner på bilden). Bollen studsar även på blocken men den förstör även blocket den studsar på.

Vi ska göra ett projektarbete då vi ska göra ett klassiskt arkadspel. Jag gick i grupp med David och vi ska göra spelet Pokémon. Pokémon är inte arkadspel men är nära nog och därför tilläts vi att göra spelet.

Programmering v.4

Denna vecka har vi mest live-kodat. Alltså vi har suttit med våra datorer och skrivit av det som skrivits på tavlan. Vi har tillsammans skapat en grund till Arkanoid. Arkanoid är ett gammalt arkad spel som går ut på att studsa en boll på brickor för att tjäna poäng. Allt man styr är en platta som bollen ska studsa mot annars så åker bollen ut och man förlorar.

Det som är nytt för denna vecka är att vi fått lära oss hantera polymorfism.

Vi har lärt oss om en sak som heter Arv. Arv är att om man har flera klasser och att man skickar med värden från klass till klass. Alltså så ”ärver” en klass värden från en annan klass.

Vid klasser så behövs funktioner. Men när funktioner skrivs i klasser kallas det ”Metoder”. Metoder kan beskrivas som: Tänk att man har en matte-formel, och in skickas värden för att senare skicka vidare ett svar. Det stämmer inte riktigt men för dom som inte håller på med programmering så får det duga som förklaring.

Polymorfism är att vid arven så ändras metoderna. Så värdena skickas med men denna ”formel” skrivs om.

Programmering V.2

PONG!!

// main.cpp

// includes
#include <sdl.h>
#include <Windows.h>
#include <math.h>
// Pro+: disable warning(s) that are annoying
#pragma warning(disable:4098)

// pragma directives (can also be linked through project settings)
#pragma comment(lib, ”SDL2.lib”)
#pragma comment(lib, ”SDL2main.lib”)

// structs

struct Paddle
{
float x, y;
bool input[2];
};
struct Ball
{
float x, y, xA,yA;
};
enum EGameState
{
GAME_STATE_PAUSE,
GAME_STATE_PLAY,
};

struct Game
{
SDL_Window* window;
SDL_Renderer* renderer;
int width, height;
unsigned int tick;
EGameState state;
Ball boll;
unsigned int score0, score1;
Paddle left;
Paddle right;
bool start;

};
void initialize_boll(Ball* boll, float x, float y)
{
boll->x = x;// = 502;
boll->y = y;// = 310;
boll->xA = 0.0f; //= 50;
boll->yA = 0.0f; //= -50;
}
void initialize_paddle(Paddle* paddle, float x, float y)
{

paddle->input[0] = false;
paddle->input[1] = false;
paddle->x = x;
paddle->y = y;

}
// functions
bool initialize(Game* game, int width, int height) {
SDL_Log(”initialize()”);
SDL_Init(SDL_INIT_EVERYTHING);
game->window = nullptr;
game->renderer = nullptr;
game->width = width;
game->height = height;
game->tick = SDL_GetTicks();
game->state = GAME_STATE_PAUSE;
game->start = false;
game->score0 = 0;
game->score1 = 0;
//Skapa bollen
initialize_boll(&game->boll, game->width /2 – 10.0f, game->height / 2 – 10.0f);
//Skapa vänster ”paddel”
initialize_paddle(&game->left, 50, game->height / 2 – 50);
//Skapa höger ”paddel”
initialize_paddle(&game->right,game->width -70, game->height / 2 – 50);

/* game.right.input[0] = false;
game.right.input[1] = false;
game.right.x = width – 70;
game.right.y = game.height / 2 – 50;

game.left.input[0] = false;
game.left.input[1] = false;
game.left.x = 50;
game.left.y = game.height / 2 – 50;
*/
// creating a window
game->window = SDL_CreateWindow(”Pong”,
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
game->width,
game->height,
SDL_WINDOW_OPENGL);

// error checking window
if (game->window == nullptr) {
return false;
}

// creating a renderer that we use to draw stuff with
game->renderer = SDL_CreateRenderer(game->window,
-1, SDL_RENDERER_ACCELERATED);

// error checking renderer
if (game->renderer == nullptr) {
return false;
}

// everything went ok!
return true;
}

void shutdown(Game* game) {
// clean up resources
SDL_Log(”shutdown()”);

// check if we have a valid renderer
if (game->renderer != nullptr) {
SDL_DestroyRenderer(game->renderer);
}
game->renderer = nullptr;

// check if we have a valid window
if (game->window != nullptr) {
SDL_DestroyWindow(game->window);
}
game->window = nullptr;

// shut down SDL
SDL_Quit();
}

bool update_input(Game* game) {
// check events for user input
SDL_Event event;
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_KEYDOWN:
switch (event.key.keysym.sym) {
// player 1 keys
case SDLK_w:
game->left.input[0] = true;
break;
case SDLK_s:
game->left.input[1] = true;
break;

// player 2 keys
case SDLK_o:
game->right.input[0] = true;
break;
case SDLK_l:
game->right.input[1] = true;
break;

// space-key
case SDLK_SPACE:
game->start = true;
break;
}
break;

case SDL_KEYUP:
switch (event.key.keysym.sym) {
// player 1 keys
case SDLK_w:
game->left.input[0] = false;
break;
case SDLK_s:
game->left.input[1] = false;
break;

// player 2 keys
case SDLK_o:
game->right.input[0] = false;
break;
case SDLK_l:
game->right.input[1] = false;
break;

// space-key
case SDLK_SPACE:
game->start = false;
break;

// quit-key
case SDLK_ESCAPE:
return false;
break;
}
break;

case SDL_QUIT:
return false;
break;
}
}

return true;
}
bool check(Paddle* paddle, Ball* boll)
{
if (paddle->x + 20.0f <boll->x || paddle->x > boll->x + 20.0f )
{
return false;
}
if (paddle->y + 100.0f < boll->y || paddle->y > boll->y + 20 )
{
return false;
}
return true;
}
bool update(Game* game) {
if (!update_input(game)) {
SDL_Log(”Quit.”);
return false;
}
unsigned int now = SDL_GetTicks();
unsigned int delta = now – game->tick;
game->tick = now;

float deltatime = static_cast<float>(delta)* 0.001f;

switch (game->state)
{
case GAME_STATE_PAUSE:
if (game->start)
{
game->state = GAME_STATE_PLAY;
if (now % 2 == 0)
{
game->boll.xA = 1.0f;
game->boll.yA = 1.0f;
}
else
{
game->boll.xA = -1.0f;
game->boll.yA = – 1.0f;

}
float len = sqrtf(game->boll.xA * game->boll.xA + game->boll.yA * game->boll.yA);

game->boll.xA /= len;
game->boll.yA /= len;

}
break;
case GAME_STATE_PLAY:
float speed = 1000.0f;
if (game->left.input[0])
{
game->left.y -= speed * deltatime;
if (game->left.y < 0)
{
game->left.y = 0;
}
}
if (game->left.input[1])
{
game->left.y += speed * deltatime;
if (game->left.y > 500)
{
game->left.y = 500;
}
}
if (game->right.input[0])
{
game->right.y -= speed * deltatime;
if (game->right.y < 0)
{
game->right.y = 0;
}
}
if (game->right.input[1])
{
game->right.y += speed * deltatime;
if (game->right.y > 500)
{
game->right.y = 500;
}
}
game->boll.x += game->boll.xA * deltatime * 300;
game->boll.y += game->boll.yA * deltatime * 300;
if (game->boll.y >= 580 || game->boll.y <= 0)
{
game->boll.yA *= -1;

}
if (game->boll.x >= 1024)
{
game->score0++;
initialize_paddle(&game->left, 50.0f, game->height / 2 – 50.0f);
initialize_paddle(&game->right, game->width – 70.0f, game->height / 2 – 50.0f);
initialize_boll(&game->boll, game->width / 2 – 10.0f, game->height / 2 – 10.0f);
game->state = GAME_STATE_PAUSE;
SDL_Log(”Player1: %d Player2: %d”, game->score0, game->score1);
}
if (game->boll.x <= 0)
{
game->score1++;
initialize_paddle(&game->left, 50.0f, game->height / 2 – 50.0f);
initialize_paddle(&game->right, game->width – 70.0f, game->height / 2 – 50.0f);
initialize_boll(&game->boll, game->width/2 – 10.0f, game->height / 2 – 10.0f);
game->state = GAME_STATE_PAUSE;
SDL_Log(”Player1: %d Player2: %d”, game->score0, game->score1);
}
if (check(&game->left, &game->boll))
{
game->boll.xA *= -1;
game->boll.xA += 0.25;
}
else if (check(&game->right, &game->boll))
{
game->boll.xA *= -1;
game->boll.xA -= 0.25;
}

/*else if (game->boll.y >= game->left.y && game->boll.x <= game->left.x + 20 && game->boll.y <= game->left.y + 100)
{
game->boll.xA *= -1;
game->boll.xA = game->boll.xA + 0.5;

}
else if (game->boll.y >= game->right.y && game->boll.x >= game->right.x – 20 && game->boll.y <= game->right.y + 100)
{
game->boll.xA *= -1;
game->boll.xA = game->boll.xA – 0.5;

}
*/
break;
}

// here we will be game mechanics

SDL_Delay(10);
return true;
}
void draw(Game* game) {
// alla till fem nollor = svart
SDL_SetRenderDrawColor(game->renderer,
0x00000, 0x00000, 0x00000, 0x00000); //<—
SDL_RenderClear(game->renderer);

// here will be drawing of game Röd/Grön/Blå
SDL_SetRenderDrawColor(game->renderer,
0xfffff, 0x00000, 0xfffff, 0xfffff);
// below an example of drawing left paddle
{
SDL_Rect rect = { game->left.x, game->left.y, 20, 100 };
SDL_RenderFillRect(game->renderer, &rect);
}

// below an example of drawing right paddle
{
SDL_Rect rect = { game->right.x, game->right.y, 20, 100 };
SDL_RenderFillRect(game->renderer, &rect);
}

// below an example of drawing the ball
{
SDL_Rect rect = { game->boll.x, game->boll.y, 20, 20 };
SDL_RenderFillRect(game->renderer, &rect);
}

SDL_RenderPresent(game->renderer);
}
// ,————–.
// | main function |
// `————–´
int main(int argc, char* argv[])
{
// game instance
Game game;

// initialize game
if (initialize(&game, 1024, 600)) {
// game loop
while (update(&game)) {
draw(&game);
}
}
shutdown(&game);

return 0;
}