---
# System prepended metadata

title: 'Labb 2: Klasser - Console Pong'
tags: [inlämningsuppgift]

---

# Labb 2: Klasser - Console Pong

I den här labben ska vi bygga det klassiska spelet Pong i konsolen. Fokus är på att arbeta med klasser och dela upp koden i mindre bitar. 

![image](https://hackmd.io/_uploads/r14gxK53xe.png)

I labben får du ett skal till spelet. Skalet består av tre klasser: `Program` med en main-metod, `Input` som hanterar knapptryckningar och `Game` som hanterar den grundläggande spel-loopen. Det är bara `Game` som du kommer behöva redigera. Utöver det ska du skapa två klasser till:

* `Paddle` som representerar en spelare
* `Ball` som representerar bollen.

`Game`-klassen är den som styr hela spelet. Den har två metoder:

* `StartGame()` som körs i början av spelet. Här kan vi skapa våra andra klasser och sätta inställningar för spelet.
* `Run()` som körs i en loop 10 gånger per sekund. Metoden returnerar en bool: sant om spelet ska fortsätta, falskt om spelet ska avslutas.

### 0. Förberedelse

Använd länken på classroom för att acceptera uppgiften i github-classroom. Då får du ett git-repository som du ska klona i Github desktop och öppna i Visual Studio. Gör det till en vana att commita och pusha i slutet av varje lektion eller efter varje gång du har jobbat på projektet.

### 1. Paddle-klassen

Skapa en ny klass med namn Paddle. Den här klassen ska ha tre stycken egenskaper:

* `x` av typen `int` som representerar spelarens x-position.
* `y` av typen `int` som representerar spelarens y-position.
* `size` av typen `int` som representerar spelarens storlek.

Klassen ska ha en konstruktor som tar in ett argument för varje egenskap och anger ett värde för motsvarande klassvariabel.

Klassen ska ha två metoder:

* `void Move(int yAmount)` som flyttar spelaren i y-led det antal steg som anges i argymentet yAmount.
* `void Draw()` som ritar spelaren i konsolen.

För att rita på en viss plats i konsolen kan vi använda två metoder: `Console.SetCursorPosition(int x, int y)` och `Console.Write()`. Till exempel för att rita ett streck på skärmen, på plats (3,10) kan vi skriva:

```csharp
Console.SetCursorPosition(3, 10);
Console.Write("|"); 
```

### 2. Skapa Paddle-Objekt

När vi har skapat `Paddle`-klassen vill vi skapa två objekt av typen `Paddle` i `Game`-klassen, och anropas deras i metoder i `Run`-metoden.

1. Skapa två objekt av `Paddle`-klassen inut i `Game`-klassen och instansiera dem i metoden `StartGame()`.
2. Anropa `Paddle`-objektens `Draw`-metod inuti `Run`.
3. Anropa `Paddle`-objektens `Move`-metod inuti respektive if-sats i `Run`-metoden.

### 3. Ball-klassen

Skapa en ny klass med namn Ball. Den här klassen har fyra egenskaper:

* `x` av typen `int` som representerar bollens x-position.
* `y` av typen `int` som representerar bollens y-position.
* `xVelocity` av typen `int` som representerar bollens hastighet i x-led.
* `yVelocity` av typen `int` som representerar bollens hastighet i y-led.

Klassen ska ha en konstruktor som tar in ett argument för varje egenskap och anger ett värde för motsvarande klassvariabel.

Klassen ska ha tre metoder.

* `void Move()` som flyttar bollen utifrån xVelocity och yVelocity.
* `void Draw()` som ritar bollen i konsolen. Se ovan för hur man ritar i konsolen!
* `void CheckCollisions(Paddle p1, Paddle p2, int width, int height)` som ska:
    *  kolla om bollen nuddar övre eller undre kanten på skärmen och så fall byta riktning på yVelocity
    *  kolla om bollen nuddar någon av spelarna och i så fall byta riktning på xVelocity
    *  kolla om bollen nuddar högra eller vänstra kanten och i så fall återställas till mitten av skärmen.


### 4. Skapa Ball-objekt

Nu kan vi skapa ett Ball-objekt i Game-klassen

1. Skapa ett objekt av `Ball`-klassen inut i `Game`-klassen och instansiera den i metoden `StartGame()`.
2. Anropa `Ball`-objektets `Move`-metod och sedan `Draw`-metod inuti `Run`.
3. Anropa `Ball`-objektets `CheckCollision`-metod inut `Run` och skicka med `width`, `height` och båda spelarna.


### 5. (Extra) Poängräkning

För att utveckla spelet kan vi nu lägga till poängräkning. För att göra det behövs följande:

1. Lägg till en egenskap `points` i Paddle-klassen. Den representerar spelarens poäng
2. Öka poäng för rätt spelare i `Ball`-klassens `CheckCollisions`-metod
3. Visa poängen genom att skriva det till konsolen på lämplig plats.
4. Kolla om poängen har blivit lika med till exempel 5, och avsluta spelet genom att returnera `false` i `Game`-klassens `Run`-metod.


### 6. Utmaningar

Nu har vi ett fungerande spel. Det finns flera utmanande saker vi kan göra för att utveckla det. Till exempel:

* Olika riktning på bollen beroende på var den träffar paddeln.
* Just nu blinkar skärmen mycket. Det är för att vi använder oss av `Console.Clear()` i början av varje uppdatering. Vi kan fixa det genom att skriva ett blanksteg på bollen respektive spelarens gamla position i början av varje loop. Gör det genom att implementera en metod `UnDraw()` i både `Ball`-klassen och `Paddle`-klassen.
* En nedräkning (t.ex. "3…2…1…") innan spelet startar.
* Möjlighet att ändra paddelns storlek under spelets gång.
* Implementera en AI-spelare som följer bollen
