sobota, 30 października 2010

Box2D - Drugie Starcie

Druga próba "dopasowania" Boxa do silnika okazała się sukcesem. Po kilku poprawkach udało mi się wreszcie ruszyć coś na ekranie. Trochę trwało szukanie przyczyn złego dopasowania tego co widzimy na ekranie z tym co
robi box( obraz nie pokrywał się z rzeczywistością, złe pozycje obrazu(różnica 15px)), przyczyną był brak rzutowania na float, wysokości i szerokości podczas definiowania b2Polygona(metoda SetAsBox). Teraz wszystko działa idealnie. Oczywiście były to testy, teraz muszę zrobić kilka klas pomocniczych do tego i może zabiorę się za jakieś demko prezentujące troszeczkę możliwości silnika:)

czwartek, 28 października 2010

Box2D - Pierwsze Starcie

Dzisiaj bawiłem się pudełkiem, czyli silnikiem fizycznym 2D o nazwie Box2D, na razie tylko testowo, ale zanim zacząłem cokolwiek z nim robić musiałem je sobie zbudować( CMAKE i te rzeczy), potem napisałem kilka funkcji: do inicjalizacji świata Boxa, tworzenia Body, rysowania go i itp. Potem próbowałem poruszać obiektem ale coś było nie tak i postanowiłem, rozwiązać to jutro, bo dzisiaj kupiłem nową grę i chciałbym ją przetestować.
Ogólnie to ten Box jest fajny, ale mam problem z tutkami(na stronie głównej box2d jest słaba instrukcja, poza tym widziałem tylko tutki związane z wersją flashową boxa, nic pod c++ :( A może słabo szukałem ??

środa, 27 października 2010

Input Core - Klawiatura i mysz

Napisałem niedawno klasy odpowiedzialne za mysz i klawiaturę, są bardzo proste:
Najpierw klawiatura:




class CKeyboard
{
private:
bool m_Key[512]; // true - wciśnięty, false - nie
public:
CKeyboard()
{
Clear();
}

~CKeyboard()
{
Clear();
}

void Update(int Key, bool Action = true)
{
m_Key[Key] = Action;
}

void Clear()
{
memset(m_Key,0,512*sizeof(bool));
}

bool IsKeyDown(int Key)
{
return m_Key[Key];
}
bool IsKeyUp(int Key)
{
return !(m_Key[Key]);
}

bool operator [] (int Key)
{
return m_Key[Key];
}
};



Teraz klasa myszy:


class CMouse
{
private:
struct{
int x;
int y;
int z;

int dx;
int dy;
int dz;

unsigned int button;
} m_MouseState;

GraphicsCore::ImagePtr m_ImageCursor;

bool m_IsCursorVisible;
protected:
public:
enum EButton{NONE,LEFT, RIGHT, MIDDLE};

CMouse()
{
Clear();
m_IsCursorVisible = true;
}

~CMouse()
{
Clear();
m_IsCursorVisible = true;
al_show_mouse_cursor(al_get_current_display());
}

void Clear()
{
memset(&m_MouseState,0,sizeof(m_MouseState));
}

void Update(ALLEGRO_EVENT& Event)
{
switch (Event.type)
{
case ALLEGRO_EVENT_MOUSE_AXES:

m_MouseState.x = Event.mouse.x;
m_MouseState.y = Event.mouse.y;
m_MouseState.z = Event.mouse.z;

m_MouseState.dx = Event.mouse.dx;
m_MouseState.dy = Event.mouse.dy;
m_MouseState.dz = Event.mouse.dz;
break;

case ALLEGRO_EVENT_MOUSE_BUTTON_DOWN:

m_MouseState.x = Event.mouse.x;
m_MouseState.y = Event.mouse.y;
m_MouseState.z = Event.mouse.z;
m_MouseState.button = Event.mouse.button;
break;

case ALLEGRO_EVENT_MOUSE_BUTTON_UP:

m_MouseState.x = Event.mouse.x;
m_MouseState.y = Event.mouse.y;
m_MouseState.z = Event.mouse.z;
m_MouseState.button = 0;
}
}

unsigned int GetButton()
{
return m_MouseState.button; 
}

void GetXY(int* x, int* y)
{
*x = m_MouseState.x;
*y = m_MouseState.y;
}

void GetZ(int* z)
{
*z = m_MouseState.z;
}

void GetDXDY(int* dx, int* dy)
{
*dx = m_MouseState.dx;
*dy = m_MouseState.dy;
}

void GetDZ(int* dz)
{
*dz = m_MouseState.dz;
}

void VisibleSystemCursor(bool Visible)
{
if (Visible == true)
al_show_mouse_cursor(al_get_current_display());
else al_hide_mouse_cursor(al_get_current_display());
m_IsCursorVisible = Visible;
}

void DrawCursor()
{
m_ImageCursor->Draw(m_MouseState.x,m_MouseState.y);
}

void SetCursorImage(GraphicsCore::ImagePtr& CursorImage)
{
m_ImageCursor = CursorImage;
}
};


W przyszłości będzie oczywiście gamepad oraz obsługa w stylu PS Move(z zastosowaniem kamerki internetowej)

sobota, 23 października 2010

Interfejs GRY

Obecnie pracuję nad klasą, która będzie szkieletowym interfejsem gry. Co to takiego? Otóż będzie to klasa, po której będziemy dziedziczyli podstawowe metody(wirtualne), potem naszą klasę podamy jako parametr do konstruktora klasy CApp(klasa aplikacji- reprezentuje aplikacje to w niej jest pętla główna). Wróćmy jednak do IGame, obecnie ma kilka metod wirtualnych:
- void Update(double step) // aktualizacja gry, parametr krok czasowy;
- void Render() // odrysowanie przebiegu gry;
- bool Init() // inicjalizacja gry;
- bool Uninit() // po zakończeniu gry;
... // jeszcze jakieś można wymyślić.

Ogólnie ta klasa w połączeniu z CApp i innymi  ma pomóc przy tworzeniu gry(nie musimy pisać na przykład pętli głównej od początku itp.)

środa, 20 października 2010

Co już jest w silniku ??

W tym poście chce podsumować te kilka tygodni pracy i pokazać co jeszcze zostało do zrobienia, oraz jak wygląda obecnie silnik(podział na części).

Zacznijmy od podsumowania:
- można wyświetlać obraz(wczytany z pliku lub generowany) i tekst na ekranie;
- jest manager obrazów;
- dostęp do czcionek z plików .ttf;
- można rysować prymitywy;
- można używać klawiatury, myszki;
- dostępny jest wielowyjściowy logger(obecnie wyjscia do pliku i na konsolę dos);
- dostępny timer stałokrokowy;
- animacje z atlasu i manager animacji;
- Sprity(zbiór animacji, graficzna reprezentacjia aktora);
- podstawowa obsługa dźwięku(można załadować muzykę z pliku i odtwarzać ją); 
- i inne drobnostki.

Ogólny zarys silnika:
Podział na 12 podsystemów(w silniku nazywanych rdzeniami), każdy rdzeń odpowiada za odpowiednią funkcjonalność:

  • Graphics Core - odpowiada za to co zobaczymy na ekranie; 
  • Input Core - odpowiada za sterowanie w grze;
  • Sound Core - odpowiada za dźwięk i jego efekty;
  • Physic Core - odpowiada za fizykę oraz systemy cząsteczkowe;
  • System Core - odpowiada za aplikacje, posiada klasy do obsługi maszyny stanów;
  • GUI Core - przyciski, etykiety, okna, czyli GUI i jego obsługa;
  • Effect Core - będą tam szablony różnych efektów np. blur i jego odmiany;
  • Utility Core - Posiada klasy pomocnicze, Manager Zasobów oraz klasy obsługujące VFS i Archiwa( Zip, RAR, itp.);
  • Network Core - odpowiada za komunikacje sieciową
  • Script Core - odpowiada za przetwarzanie skryptów pisanych w specjalnie do tego celu stworzonym języku DarkScript;
  • Artificial Intelligence Core - odpowiada za sztuczną inteligencję w grze;
  • Game Core - odpowiada za całą grę, posiada klasy wyższego poziomu(czytaj: frameworka) które ułatwiają programowanie gier(zawiera klasy reprezentujące poszczególne elementy różnych typów gier).

sobota, 16 października 2010

Co w trawie piszczy ??

W silniku pojawiła się podstawowa obsługa dźwięku. Wreszcie można coś usłyszeć. To na razie tylko tak testowa i atrapowa klasa:



class CSound : public IResource
{
protected:
ALLEGRO_SAMPLE* m_Sound;
ALLEGRO_SAMPLE_ID m_SoundID;
public:
enum EPlayMode {
ONCE = ALLEGRO_PLAYMODE_ONCE,
LOOP = ALLEGRO_PLAYMODE_LOOP,
BIDIR = ALLEGRO_PLAYMODE_BIDIR
};
enum EPanMode {
NONE = -1000,
CENTER = 0,
LEFT = -1,
RIGHT = 1,
};

CSound()
{
m_Type = IResource::RES_TYPE_SOUND;
m_Sound = 0;
memset(&m_SoundID,0,sizeof(m_SoundID));
}
~CSound()
{
Stop();
if (m_Sound != 0)
al_destroy_sample(m_Sound);
}

const CError& LoadFromFile(const std::string & Filename)
{
if (m_Sound == 0)
m_Sound = al_load_sample(Filename.c_str());
if (m_Sound != 0)
{
SetFilename(Filename);
return CError();
}
return CError(CError::TYPE_SYSTEM_ERROR,CError::FILE_LOAD);
}
const CError& Reload()
{
al_destroy_sample(m_Sound);
return LoadFromFile(m_Filename);
}

bool Play(float Gain, float Pan, float Speed = 1.0, int Loop = ONCE)
{
return al_play_sample(m_Sound,Gain,Pan,Speed,Loop,&m_SoundID);
}

void Stop()
{
al_stop_sample(&m_SoundID);
}
};


Jak widać tylko podstawowa funkcjonalność, ale dodam jeszcze miksery i efekty to będzie git. Obsługuje formaty takie jak: .wav, .flac, .ogg, .it, .mod, .s3m, .xm.
Grunt że działa !!!

Angielski is Good !!!

Dzisiaj o nazewnictwie, dlaczego używam i wielu innych programistów języka angielskiego w pracy? Używam go dlatego, że jest wygodniejszy niż ojczysty, w większości przypadków dużo krótszy, a oto przykład:
metdy typu Get i Set, po polsku to Pobierz, Zmien // prawda, że po angielsku łatwiej zapisać i lepiej wygląda.
Ogólnie, rzecz biorąc nasze ogonki nie mogą być wykorzystywane w programowaniu, więc te wyrazy mają orty i zdarzyło mi się kilka razy zapomnieć co dany wyraz oznacza. Może drugi przykład na potwierdzenie tezy, że angielski jest prostszy w zapisie:
int Speed;
int Predkosc;
// Widać różnice ??
Oczywiście są wyjątki od tej reguły np.
int Mass;
int Masa
// ...
Projekty pisane po angielsku są dużo bardziej czytelniejsze niż te po polsku(mimo że w głowie mamy automat korekcji błędów i sami dodajemy ogonki). Jeszcze jeden powód dla którego warto stosować angielskie słownictwo, otóż na świecie jest dużo więcej osób posługujących się angielskim niż polskim i gdyby jakiś anglik chciał skorzystać z naszej pracy to nawet Trans Googla nie pomoże:)

Czekam na uwagi i opinie do tematu.