Na zaliczenie jednego przedmiotu musiałem zrobić jakiś projekt, no i postanowiłem sobie zrobić coś na wzór haxballa... wyszło to średnio, bardzo średnio... ale zaliczyłem
Do działania wymaga biblioteki allegro (z resztą, widać w inkludach)

Kod jest na tyle krótki, że mogę go wrzucić od razu w znacznikach:
//1.tworzyc bitmape (create_bitmap) w load
//2.rysowac (draw_sprite) w draw
//boisko: 838x412
#include "allegro.h"
#include <math.h>
#define WIDTH 1000
#define HEIGHT 700

BITMAP *bufor;
BITMAP *tlo;
char* const sciezka = "C:\\Users\\Albert\\Desktop\\In_progres\\code\\Game2\\Release\\obraz2.bmp";
int ticks = 0;
bool wyjscie = false;

//gracz1 - czerwony
BITMAP *gracz1;
int r1 = 210, g1 = 17, b1 = 17;
float x1 = 250, y11 = 430;
int punkty1 = 0;

//gracz2 - niebieski
BITMAP *gracz2;
int r2 = 38, g2 = 122, b2 = 165;
float x2 = 750, y2 = 430;
int punkty2 = 0;

//pilka
BITMAP *pilka;
float x3 = 504, y3 = 430;
float wektor1 = 0, wektor2 = 0;

void timerproc(){
ticks++;
}

void init(){
allegro_init();
install_keyboard();
set_color_depth(32);
set_gfx_mode(GFX_AUTODETECT_WINDOWED, WIDTH, HEIGHT, 0,0);
install_int(timerproc, 30);
}

void load(){
bufor = create_bitmap(WIDTH, HEIGHT);
if(!bufor)
allegro_message("Blad przy tworzeniu bufora");

tlo = load_bitmap(sciezka, NULL);
if(!tlo)
allegro_message("Blad przy otwarciu obrazu!");

//gracz1
gracz1 = create_bitmap(27,27);
clear_to_color(gracz1, makecol(11,37,0));
circlefill(gracz1, 13, 13, 13, makecol(r1,g1,b1));

//gracz2
gracz2 = create_bitmap(27,27);
clear_to_color(gracz2, makecol(11,37,0));
circlefill(gracz2, 13, 13, 13, makecol(r2,g2,b2));

//pilka
pilka = create_bitmap(13,13);
clear_to_color(pilka, makecol(11,37,0));
circlefill(pilka, 6, 6, 6, makecol(255,255,255));
}

void draw(){
clear_to_color(bufor, makecol(0,0,0));

draw_sprite(bufor, tlo, 0, 0);

draw_sprite(bufor, gracz1, x1, y11);
draw_sprite(bufor, gracz2, x2, y2);
draw_sprite(bufor, pilka, x3, y3);

textout_ex(bufor, font, "Wcisnij ESC zeby zakonczyc", 680, 670, makecol(60,60,60), -1);
textout_ex(bufor, font, "Wcisnij P zeby zresetowac pozycje pilki", 640, 680, makecol(60,60,60), -1);
textout_ex(bufor, font, "Czerwony", 420, 160, makecol(240,60,60), -1);
textprintf_ex(bufor, font, 450, 180, makecol(240,60,60), -1, "%d", punkty1);
textout_ex(bufor, font, "Niebieski", 540, 160, makecol(60,60,240), -1);
textprintf_ex(bufor, font, 570, 180, makecol(60,60,240), -1, "%d", punkty2);

blit(bufor, screen, 0, 0, 0, 0, WIDTH, HEIGHT);
}

void logic(){
//gracz1
if(key[KEY_A] && x1>=90) x1-=3.3;
if(key[KEY_D] && x1<=908) x1+=3.3;
if(key[KEY_W] && y11>= 228) y11-=3.3;
if(key[KEY_S] && y11<=621) y11+=3.3;

//gracz2
if(key[KEY_LEFT] && x2>=90) x2-=3.3;
if(key[KEY_RIGHT] && x2<=908) x2+=3.3;
if(key[KEY_UP] && y2>=228) y2-=3.3;
if(key[KEY_DOWN] && y2<=621) y2+=3.3;


//pilka
wektor1 = sqrt(pow(x3-x1,2)+pow(y3-y11,2));
if(wektor1>16 && wektor1<18){
if(key[KEY_A]) x3-=3.3;
if(key[KEY_D]) x3+=3.3;
if(key[KEY_W]) y3-=3.3;
if(key[KEY_S]) y3+=3.3;
//strzal gracz1
if(key[KEY_E]) x3+=100;
}
wektor2 = sqrt(pow(x3-x2,2)+pow(y3-y2,2));
if(wektor2>16 && wektor2<18){
if(key[KEY_LEFT]) x3-=3.3;
if(key[KEY_RIGHT]) x3+=3.3;
if(key[KEY_UP]) y3-=3.3;
if(key[KEY_DOWN]) y3+=3.3;
//strzal gracz2
if(key[KEY_M]) x3-=100;
}

//punkty
if(x3<79 && y3>368 && y3<487){
++punkty2;
x3 = 504; y3 = 430;
x1 = 250; y11 = 430;
x2 = 750; y2 = 430;
allegro_message("GOOOOOOOLLLLL!!!!!!!!!!");
}
if(x3>926 && y3>368 && y3<487){
++punkty1;
x3 = 504; y3 = 430;
x1 = 250; y11 = 430;
x2 = 750; y2 = 430;
allegro_message("GOOOOOOOLLLLL!!!!!!!!!!");
}

//rozny_aut_1
if((x3<79 && (y3<368 || y3>487)) || (y3>621 || y3<228)){
x1 = 100; y11 = 430;
x2 = 500; y2 = 430;
x3 = 120; y3 = 430;
allegro_message("Pilka opuscila linie boiska!");
}

//rozny_aut_2
if((x3>926 && (y3<368 || y3>487)) || (y3>621 || y3<228)){
x1 = 500; y11 = 430;
x2 = 900; y2 = 430;
x3 = 880; y3 = 430;
allegro_message("Pilka opuscila linie boiska!");
}

//reset
if(key[KEY_P]){x3 = 504; y3 = 430;}
//wyjscie
if(key[KEY_ESC]) wyjscie = true;
}

void release(){
destroy_bitmap(tlo);
destroy_bitmap(gracz1);
destroy_bitmap(gracz2);
destroy_bitmap(pilka);
destroy_bitmap(bufor);
allegro_exit();
}

//int _tmain(int argc, _TCHAR* argv[])
#undef main
int main()
{
init();
load();
while(!wyjscie){
draw();
while(ticks>0){
logic();
ticks--;
}
}
release();
return 0;
}
//END_OF_MAIN()
Wygląda to tak po uruchomieniu:


sterowanie czerwonego WASD + E (strzał), niebieskiego strzałki + M (strzał), ESC żeby wyjść i P żeby umieścić piłkę na środku boiska

drugą częścią zaliczenia będzie zrobienie drugiej wersji gry w C#, więc parę rzeczy może uda się poprawić i rozwinąć, to wam też pokażę

działał też na względnym. miałem tylko problemy z załadowaniem tego obrazu to dla bezpieczeństwa zrobiłem na sztywno

exe jest, tylko potrzebne są do niego pliki biblioteki allegro, ale jutro jedno i drugie podrzucę

No to bym bardzo chciał zrobić, ale raczej w C# bo tam nieco łatwiej
tylko jeśli bym się za to wziął to i tak w wakacje bo na razie nie mam aż tyle czasu, a za mało sockety ogarniam żeby szybko z nimi pisać

http://www.allegro.cc/files/4.2.2/allegro-msvc80-4.2.2.zip tu jest link do allegro
a tu exe: http://www.fileserve.com/file/hVxC9RX
żeby działał to trzeba to rozpakować na C: bezpośrednio bo jednak nie działa mi jak daję względny adres, a nie chce mi się tego poprawiać... w następnej wersji będę mógł się takim szczegółami lepiej zająć

i z tego gameplaya na pewno nie będę robić bo nie ma się czym chwalić, jeśli w c# wyjdzie to tak jakbym chciał to wtedy mogę się o gameplaya pokusić

zupełnie zapomniałem jeszcze o tej c# wersji

using System;
using System.Timers;
using System.Windows.Forms;
using AllegNet;

namespace Game4{
class Obiekt{ //klasa wszelkich obiektow w grze
public double x, y;
public int punkty, r, g, b, promien;
public Obiekt(double x, double y, int r, int g, int b, int promien){
this.r = r; this.g = g; this.b = b;
this.x = x; this.y = y; this.promien = promien;
punkty = 0;
}
public BITMAP bitmapa;
public int getColor(){
return API.Makecol(r,g,b);
}
public void reset(double x, double y){
this.x = x;
this.y = y;
}
}
class MainClass:API{
int ticks = 0;
System.Timers.Timer Zegar;
bool wyjscie = false;

BITMAP bufor;
BITMAP tlo;
string sciezkaTlo = "C:\\Users\\Albert\\Desktop\\In_progres\\code\\Game4\\bin\\Debug\\obraz2.bmp";

int kolor = API.Makecol(11,37,0);
//x, y, R, G, B, r
Obiekt gracz1 = new Obiekt(250, 430, 210, 17, 17, 13);
Obiekt gracz2 = new Obiekt(750, 430, 38, 122, 165, 13);
Obiekt pilka = new Obiekt(504, 430, 255, 255, 255, 6);
double wektor1, wektor2;
KEY klawisz = new KEY();

//zwiekszanie zegarka
public void timerproc(object source, ElapsedEventArgs e){
++ticks; //Console.WriteLine(ticks); //tylko do testow
}
//inicjalizacja biblioteki
public void init(){
Allegro_init();
Install_keyboard();
Set_color_depth(COLOR_DEPTH.BITS_32);
Set_gfx_mode(GFX_MODES.GFX_AUTODETECT_WINDOWED, 1000, 700);
//ustawienia zegara
Zegar = new System.Timers.Timer(30); //Zegar.Interval = 30; //w razie jakby wartosc z konstruktora nie dzialala
Zegar.Elapsed += new ElapsedEventHandler(timerproc);
Zegar.Enabled = true;
}
//ladowanie zasobow
public void load(){
bufor = Create_bitmap(1000, 700); //tworzenie bufora grafiki
if(bufor.BitmapPointer == null) Console.WriteLine("Nie mozna stworzyc bufora!");

tlo = Load_bitmap(sciezkaTlo); //ladowanie grafiki tla
if(tlo.BitmapPointer == null) Console.WriteLine("Nie mozna zaladowac tla!");

gracz1.bitmapa = Create_bitmap(27,27); //grafika gracza1
Clear_to_color(gracz1.bitmapa, kolor);
Circlefill(gracz1.bitmapa, gracz1.promien, gracz1.promien, gracz1.promien, gracz1.getColor());

gracz2.bitmapa = Create_bitmap(27,27); //grafika gracza2
Clear_to_color(gracz2.bitmapa, kolor);
Circlefill(gracz2.bitmapa, gracz2.promien, gracz2.promien, gracz2.promien, gracz2.getColor());

pilka.bitmapa = Create_bitmap(13,13); //grafika pilki
Clear_to_color(pilka.bitmapa, kolor);
Circlefill(pilka.bitmapa, pilka.promien, pilka.promien, pilka.promien, pilka.getColor());
}
//rysowanie grafiki
void draw(){
Clear_to_color(bufor, 0);
//wyswietlenie calej grafiki
Blit(tlo, bufor, 0, 0, 0, 0, 1000, 700); //Jak cos nie podziala, to: Blit(bufor, Screen, 0, 0, 0, 0, 800, 600);
Blit(gracz1.bitmapa, bufor, 0, 0, (int)gracz1.x, (int)gracz1.y, 1000, 700);
Blit(gracz2.bitmapa, bufor, 0, 0, (int)gracz2.x, (int)gracz2.y, 1000, 700);
Blit(pilka.bitmapa, bufor, 0, 0, (int)pilka.x, (int)pilka.y, 1000, 700);
//wszystkie napisy
Textout_ex(bufor, Font, "Wcisnij ESC zeby zakonczyc", 680, 670, Makecol(60,60,60), -1);
Textout_ex(bufor, Font, "Wcisnij P zeby zresetowac pozycje pilki", 640, 680, Makecol(60,60,60), -1);
Textout_ex(bufor, Font, "Czerwony", 420, 160, Makecol(240,60,60), -1);
Textout_ex(bufor, Font, gracz1.punkty.ToString(), 450, 180, Makecol(240,60,60), -1);
Textout_ex(bufor, Font, "Niebieski", 540, 160, Makecol(60,60,240), -1);
Textout_ex(bufor, Font, gracz2.punkty.ToString(), 570, 180, Makecol(60,60,240), -1);
//bufor na ekran
Blit(bufor, Screen, 0, 0, 0, 0, 1000, 700);
}
//mechanika
void logic(){
if(klawisz[ALL_KEYS.KEY_ESC]) wyjscie = true; //wyjscie z gry
if(klawisz[ALL_KEYS.KEY_P]) pilka.reset(504, 430); //reset pilki
//gracz1
if(klawisz[ALL_KEYS.KEY_A] && gracz1.x>=90) gracz1.x-=3.3;
if(klawisz[ALL_KEYS.KEY_D] && gracz1.x<=908) gracz1.x+=3.3;
if(klawisz[ALL_KEYS.KEY_W] && gracz1.y>= 228) gracz1.y-=3.3;
if(klawisz[ALL_KEYS.KEY_S] && gracz1.y<=621) gracz1.y+=3.3;
//gracz2
if(klawisz[ALL_KEYS.KEY_LEFT] && gracz2.x>=90) gracz2.x-=3.3;
if(klawisz[ALL_KEYS.KEY_RIGHT] && gracz2.x<=908) gracz2.x+=3.3;
if(klawisz[ALL_KEYS.KEY_UP] && gracz2.y>=228) gracz2.y-=3.3;
if(klawisz[ALL_KEYS.KEY_DOWN] && gracz2.y<=621) gracz2.y+=3.3;
//pilka
wektor1 = Math.Sqrt(Math.Pow(pilka.x-gracz1.x,2)+Math.Pow(pilka.y-gracz1.y,2));
if(wektor1>16 && wektor1<18){
if(klawisz[ALL_KEYS.KEY_A]) pilka.x-=3.3;
if(klawisz[ALL_KEYS.KEY_D]) pilka.x+=3.3;
if(klawisz[ALL_KEYS.KEY_W]) pilka.y-=3.3;
if(klawisz[ALL_KEYS.KEY_S]) pilka.y+=3.3;
//strzal gracz1
if(klawisz[ALL_KEYS.KEY_E]) pilka.x+=100;
}
wektor2 = Math.Sqrt(Math.Pow(pilka.x-gracz2.x,2)+Math.Pow(pilka.y-gracz2.y,2));
if(wektor2>16 && wektor2<18){
if(klawisz[ALL_KEYS.KEY_LEFT]) pilka.x-=3.3;
if(klawisz[ALL_KEYS.KEY_RIGHT]) pilka.x+=3.3;
if(klawisz[ALL_KEYS.KEY_UP]) pilka.y-=3.3;
if(klawisz[ALL_KEYS.KEY_DOWN]) pilka.y+=3.3;
//strzal gracz2
if(klawisz[ALL_KEYS.KEY_M]) pilka.x-=100;
}
//punkty
if(pilka.x<79 && pilka.y>368 && pilka.y<487){
++gracz2.punkty;
pilka.reset(504, 430);
gracz1.reset(250, 430);
gracz2.reset(750,430);
Console.WriteLine("GOOOLLLLLL!!!!!!!");
}
if(pilka.x>926 && pilka.y>368 && pilka.y<487){
++gracz1.punkty;
pilka.reset(504, 430);
gracz1.reset(250, 430);
gracz2.reset(750,430);
Console.WriteLine("GOOOLLLLLL!!!!!!!");
}
//rozny_aut_1
if((pilka.x<79 && (pilka.y<368 || pilka.y>487)) || (pilka.y>621 || pilka.y<228)){
gracz1.reset(100, 430);
gracz2.reset(500, 430);
pilka.reset(120, 430);
Console.WriteLine("Pilka opuscila linie boiska!");
}
//rozny_aut_2
if((pilka.x>926 && (pilka.y<368 || pilka.y>487)) || (pilka.y>621 || pilka.y<228)){
gracz1.reset(500, 430);
gracz2.reset(900, 430);
pilka.reset(880, 430);
Console.WriteLine("Pilka opuscila linie boiska!");
}
}
//zwolnienie zasobow
void release(){
Destroy_bitmap(tlo);
Destroy_bitmap(gracz1.bitmapa);
Destroy_bitmap(gracz2.bitmapa);
Destroy_bitmap(pilka.bitmapa);
Destroy_bitmap(bufor);
}

public static void Main(){
MainClass gra = new MainClass();
gra.init();
gra.load();
while(!gra.wyjscie){
gra.draw();
while(gra.ticks>0){
gra.logic();
gra.ticks--;
}
}
gra.release();
}
}
}od strony kodu trochę się różni, jest bardziej obiektowo bo sam c# kładzie większy nacisk na obiektowość no i dotnetowa wersja allegro czyli allegnet, też trochę bardziej stawia na obiektowość
od strony tego jak gra działa nie ma praktycznie żadnej różnicy poza tym, że w wersji c++ komunikaty były w messageboxie, a tutaj są w konsoli, reszta jest dokładnie identyczna