WIndows Console pong

#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define pAmmount 1 // Określa ilość piłeczek na ekreanie
#define maxForce 1 // Określa maksymalną siłę / prędkość z jaką poruszają się piłeczki

// Definicje
float randomF(int); // Generuje wartość pomiedzy 0.0 a max
float randomD(int); // Generuje wartość pomiedzy 0 a max
void initialisePoints(COORD); // Ustwaia podstawowe wartości piłeczek
void debugPoints(); // Wyświetla statystyki o piłkach
void drawScreen(); // Rysuje plansze gry
void hideCursor(); // Chowa kursor konsoli
void gotoxy(int, int); // Ustala położenie kursora w konsoli
void pointsNext(); // Wykonuje operacje zwiazane z ruchem i kolizjami piłeczek
void checkUserInput(); // Sprawdza działania użytkownia
void initialisePads(); // Ustawia podstawowe wartości paletek
int isPaddle(int, int, int); // Sprawdza czy dany punkt leży na paletce
void movePaddles(); // Porusza paltekami
void resetBall(int); // Przywraca podstawowe wartości piłeczce
void accelerateBall(int, float); // Zmienia szybkość poruszania się wybranej piłeczki

// Struktura opisująca położenie i prędkość piłeczki
struct particle
{
    float x;
    float y;
    float vX;
    float vY;
    float iX;
    float iY;
};

// Struktura opisujaca położenie i wielkość paletki
struct paddle
{
    int x;
    int y;
    int l;
};

// Deklaracja pojemników globalnych
struct particle points[pAmmount]; // Piłeczki
struct paddle pad[2]; // Paletki
COORD score = {0, 0}; // Wynik

COORD size = {60, 15}; // Rozmiar planszy do gry
char endGame;

int main()
{
    srand(time(NULL)); // Zmienia ziarno funkcji pseudolosowej wraz z upływem czasu
    initialisePoints(size);
    initialisePads();
    hideCursor();

    //debugPoints();

    endGame = 0; // Umożliwia wyjście z gry

    // Punkt wejścia do pętli gry
    while(!endGame)
    {
        drawScreen();
    }

    return 0;
}

void drawScreen()
{
    gotoxy(0,0);// Umieszcza kursor na początku konsoli
                // bez konieczności czyszczenia pozostałości
                // poprzedniej klatki

    /*
    Zmienne x i y przechowują wirtualne położenie kursora rusyjącego w konsoli
    ich wartości są ujemne aby wymusić rysowanie obramowania pola gry
    w innym wypadku, trzebaby było dodawać lub odejmować granice pętli for
    w karzdym przypadku, aby nie zmniejszyć pola gry o obramowanie.
    */
    int x = -1;
    int y = -2;
    int i = 0;
    char isPoint = 0;

    // Wykonuje rysowanie planszy linia po linii
    for(; y < size.Y + 1; y++)
    {
        // Rysuje wyniki rozgrywki
        if(y == -2)
        {
            printf("Score: %d - %d\n\n", score.X, score.Y);
        }
        else
        {
            // Rysuje elementy planszy w danej linii
            for(; x < size.X + 1; x++)
            {
                // Sprawdza czy dana pozycja konsoli, to obramowanie
                if(
                   (y == -1) ||
                   (y == size.Y) ||
                   (x == -1) ||
                   (x == size.X)
                   )
                    printf("X"); // Rysuje obramowanie
                else
                {
                    // Sprawdza czy dana pozycja konsoli, to paletka
                    if(isPaddle(0, x, y) || isPaddle(1, x, y))
                    {
                        printf("H"); // Rysuje paletke
                    }
                    else
                    {
                        // Sprawdza czy dana piłeczka nie zostałą już narysowana
                        // dzięki czemu nie trzeba zawsze sprawdzać całej listy piłeczek
                        // i porównywać ich pozycji
                        isPoint = 0;
                        i = 0;
                        for(; i < pAmmount; i++)
                        {
                            // SPrawdza czy dana pozycja w konsoli, to piłeczka
                            if(((int)points[i].x == x) && ((int)points[i].y == y) && !isPoint)
                            {
                                printf("O");
                                isPoint = 1;
                            }
                        }

                        // Rysuje pustą przestrzeń
                        if(!isPoint) printf(" ");
                    }
                }
            }
        }
        x = -1;
        printf("\n"); // Przechodzi do nowej lini
    }

    movePaddles();
    pointsNext();
    //Sleep(10); // Spowalnia działanie gry (do odpluskwiania)
}

void pointsNext()
{
    int i = 0;

    // Iteruje przez wszystkie piłeczki
    for(; i<pAmmount; i++)
    {
        // Sprawdza czy piłeczka nie koliduje z bokami planszy
        if((points[i].x <= 0) || (points[i].x >= size.X))
            points[i].vX = -1 * points[i].vX; // Odwraca kierunek piłeczki

        // Gracz lewy dostaje punkt
        if(points[i].x <= 0)
        {
            score.Y++;
            resetBall(i);
        }
        else if(points[i].x >= size.X) // Gracz prawy dostaje punkt
        {
            score.X++;
            resetBall(i);
        }

        // Sprawdza czy piłeczka nie koliduje z grórą lub dołem planszy
        if((points[i].y <= 0) || (points[i].y >= size.Y))
        {
            points[i].vY = -1 * points[i].vY; // Odwraca kierunek piłeczki
        }

        // Sprawdza kolizje z paletką
        if(isPaddle(0, points[i].x, points[i].y) || isPaddle(1, points[i].x, points[i].y))
        {
            points[i].vX = -1 * points[i].vX; // Odwraca kierunek piłeczki
            accelerateBall(i, 1.1); // Przyspiesza piłeczkę o 10%
        }

        // Porusza piłeczką
        points[i].x += points[i].vX;
        points[i].y += points[i].vY;
    }
}


void debugPoints()
{
    int i = 0;
    for(;i<pAmmount; i++)
    {
        printf("Point id: %d\n", i);
        printf("\t X = %f\n", points[i].x);
        printf("\t Y = %f\n", points[i].y);
        printf("\t vX = %f\n", points[i].vX);
        printf("\t vY = %f\n\n", points[i].vY);
    }
}

void initialisePoints(COORD screenSize)
{
    int i = 0;
    for(;i<pAmmount; i++)
    {
        //points[i].x = randomF(screenSize.X);
        //points[i].y = randomF(screenSize.Y);

        // Nadaje piłeczce pozycję na środku planszy
        points[i].x = screenSize.X/2;
        points[i].y = screenSize.Y/2;

        // Przypisuje losową wartość prędkości piłeczki
        points[i].iX = points[i].vX = randomF(maxForce);
        points[i].iY = points[i].vY = randomF(maxForce);

        // Raz na kilka piłeczek zmienia akcelercję na przeciwnoą w 1 z osi
        randomF(1) > 0.5 ? points[i].vX = -points[i].vX : 0;
        randomF(1) > 0.5 ? points[i].vY = -points[i].vY : 0;
    }
}

float randomF(int max)
{
    float x = (rand()%100)*0.01;
    x *= (float)max;

    return x;
}

float randomD(int max)
{
    return rand()%max;
}

void gotoxy(int x, int y)
{
  COORD coord;
  coord.X = x;
  coord.Y = y;
  // Funkcja tylko dla konsoli windowsa
  SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
}

void hideCursor()
{
    // Funkcje tylko dla konsoli windowsa
    HANDLE consoleHandle = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_CURSOR_INFO info;
    info.dwSize = 100;
    info.bVisible = FALSE;
    SetConsoleCursorInfo(consoleHandle, &info);
}

int inp[5]; // przetrzymuje serię zanków wpisaneych przez użytwkoniaka

void checkUserInput()
{
    int i = 0;

    // Resetuje tablicę znaków
    for(; i < 5; i++)
    {
        inp[i] = -1;
    }

    i=0;

    // Zczytuje dane z stdin
    while(kbhit() && i < 5)
    {
        inp[i] = getch();

        // Wychodzi z gry
        if(inp[i] == 27)
            endGame = 1;

        i++;

    }
}

void initialisePads()
{
    pad[0].l = pad[1].l = 5; // Nadaje długość paletki
    // Ustala pozycję paletki
    pad[1].x = size.X - 5;
    pad[0].x = 4;
    // Ustala rozmiar paletki
    pad[0].y = pad[1].y = (size.Y/2) - (pad[0].l/2);
}

int isPaddle(int i, int x, int y)
{
    if(x == pad[i].x) // Sprawdza czy zadany punkt leży na osi plaetki
        if((y >= pad[i].y) && (y < pad[i].y+pad[i].l)) // Sprawdza czy dany punkt to paletka
            return 1;

    return 0;
}

void movePaddles()
{
    int i = 0;

    checkUserInput();

    for(; i < 5; i++)
    {
        if(inp[i] != -1)
        {
            if(inp[i] == 80) // Porusza prawą paletką w dół
            {
                if(pad[1].y+pad[1].l < size.Y)
                    pad[1].y++;
            }
            else if(inp[i] == 72) // Porusza prawą paletką w górę
            {
                if(pad[1].y > 0)
                    pad[1].y--;
            }

            if(inp[i] == 115) // Porusza lewą paletką w dół
            {
                if(pad[0].y+pad[0].l < size.Y)
                    pad[0].y++;
            }
            else if(inp[i] == 119) // Porusza lewą paletką w górę
            {
                if(pad[0].y > 0)
                    pad[0].y--;
            }
        }
    }
}

void resetBall(int i)
{
    points[i].x = size.X/2;
    points[i].y = size.Y/2;
    points[i].vX = points[i].iX;
    points[i].vY = points[i].iY;
}

void accelerateBall(int i, float ammount)
{
    if(points[i].vY < 1) points[i].vY *= ammount;
    if(points[i].vX < 1) points[i].vX *= ammount;
}