Już od bardzo dawna nic tutaj nie pisałem… Niestety, miałem bardzo mało czasu, a teraz nie mam go wiele więcej, więc częstotliwość zamieszczania postów raczej się u mnie nie zwiększy.

Jeśli kogoś to interesuje, to udało mi się jakimś cudem dostać w tym roku do finału Olimpiady Informatycznej (do której przygotowania kosztowały mnie mnóstwo czasu i wysiłku).

Aby ten post nie zawierał jedynie chwalenia się i narzekania na brak czasu, postanowiłem zamieścić kod pewnej gry, którą tworzyłem w wakacje około 2 godzin. Cechą charakterystyczną tej gry jest to, że cała jej oprawa graficzna składa się ze znaków wyświetlanych w standardowej konsoli Windows’a.

Celem rozgrywki jest dotarcie jak najniżej i zdobycie jak największej ilości punktów. Trzeba unikać przeszkód („kolców”), które pojawiają się na drodze i zabierają cenne HP.

Kod pliku conoleRenderer.h

//Author: lukaszw
#pragma once
#include <Windows.h>
class consoleRenderer
{
private:
 struct elementData
 {
   char c;
   int color;
   bool operator==(const elementData &el)
   {
     return c==el.c&&color==el.color;
   }
   bool operator!=(const elementData &el)
   {
     return !((*this)==el);
   }
   elementData():c(0),color(24)
   {
   }
   elementData &operator=(const elementData &el)
   {
     c=el.c;
     color=el.color;
     return *this;
   }
 };
 HANDLE conOut;
 elementData scr[2][1024][80];
 int w;
 int h;
 int currBuff;
public:
 class sprite
 {
   friend class consoleRenderer;
   private:
   elementData *data;
   int w;
   int h;
   public:
   sprite(int w,int h):data(new elementData[w*h]),w(w),h(h)
   {
   }
   ~sprite()
   {
     delete[] data;
   }
   void setCharAt(int x,int y,char c,int color=24)
   {
    data[y*w+x].c=c;
    data[y*w+x].color=color;
   }
 };
 consoleRenderer(int h):conOut(GetStdHandle(STD_OUTPUT_HANDLE)),w(80),h(h),currBuff(0)
 {
   CONSOLE_CURSOR_INFO ci;
   ci.bVisible=false;
   ci.dwSize=sizeof(ci);
   SetConsoleCursorInfo(conOut,&ci);
 }

 ~consoleRenderer()
 {
 }
 void drawSprite(int x,int y,const sprite &spr)
 {
   const elementData *ptr=spr.data;
   for(int myY=0;myY<min(spr.h,h-y);++myY)
   {
     for(int myX=0;myX<min(spr.w,w-x);++myX)
     {
       if(myY+y<0||myX+x<0)continue;
       scr[currBuff&1][myY+y][myX+x]=*(ptr++);
     }
   }
 }
 void clear(int color=FOREGROUND_INTENSITY)
 {
   for(int y=0;y<h;++y)
   for(int x=0;x<w;++x)
   {
     scr[currBuff&1][y][x].c=' ';
     scr[currBuff&1][y][x].color=color;
   }
 }
 void drawChar(int x,int y,char c,int color=FOREGROUND_INTENSITY)
 {
   if(x<0||y<0)return;
   if(y>=h)return;
   if(x>=w)return;
   scr[currBuff&1][y][x].c=c;
   scr[currBuff&1][y][x].color=color;
 }
 void drawString(int x,int y,const char *str,int color=24)
 {
   while(*str!=0)
   {
     drawChar(x++,y,*str,color);
     ++str;
   }
 }
 void flush()
 {
   for(int y=0;y<h;++y)
   {
     for(int x=0;x<w;++x)
     {
       if(scr[currBuff&1][y][x]!=scr[(currBuff+1)&1][y][x])
       {
         COORD crd={x,y};
         SetConsoleCursorPosition(conOut,crd);
         SetConsoleTextAttribute(conOut,scr[currBuff&1][y][x].color);
         char buff[2]={(scr[currBuff&1][y][x].c),0};
         DWORD ret;
         WriteConsoleA(conOut,buff,1,&ret,0);
     }
   }
 }
 ++currBuff;
 COORD crd={0,0};
 SetConsoleCursorPosition(conOut,crd);
 }
};

Kod gry:

//Author: lukaszw
#include "stdafx.h"
//#include <stdio.h>
//#include <tchar.h>
//
//#include <Windows.h>
//#include <cstdio>
//#include <algorithm>
//#include <vector>
//#include <string>
//#include <fstream>
//#include <ctime>
//#include <conio.h>
//#include <list>
//using namespace std;
#include "consoleRenderer.h"
float g=0.0010f;
consoleRenderer *rndr;
int random(int a,int b)
{
 return rand()%(b-a)+a;
}
static const char platformImg[]={219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219,219};
static const char platformImg2[]={30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30,30};
consoleRenderer::sprite platformSprite(18,1),platformSprite2(18,1);
void initPlatformSprite()
{
 for(int i=0;i<18;++i)
 {
 platformSprite.setCharAt(i,0,platformImg[i],FOREGROUND_BLUE|BACKGROUND_BLUE);
 platformSprite2.setCharAt(i,0,platformImg2[i],FOREGROUND_RED);
 }
}
struct platform
{
 int x,y;
 int w;
 bool dangerous;
 platform(){}
 platform(int x,int y,int w,bool d):x(x),y(y),w(w),dangerous(d)
 {
 }
};
vector<platform> platforms;
struct player
{
 float hp;
 float x,y;
 float vx,vy;
 int lvl;
 float timeToNextLvl;
 float bulletTimeTime;
 int prevY;
 int points;
 player(int x,int y):hp(100),x(x),y(y),lvl(1),timeToNextLvl(100),bulletTimeTime(100),prevY(0),points(0)
 {
 for(int i=platforms.size();i<y+50;++i)
 {
 platforms.push_back(platform(random(-10,80),i,(i%3!=0)?0:18,random(0,10)%4==0));
 }
 }
 void update(float dt)
 {
 if(prevY!=(int)y)
 {
 prevY=(int)y;
 points+=lvl;
 }
 if(platforms.size()<y+40)
 {
 for(int i=platforms.size();i<y+50;++i)
 {
 platforms.push_back(platform(random(-10,80),i,(i%3!=0)?0:18,random(0,10)%4==0));
 }
 }
 if(x>=platforms[y].x&&x<=platforms[y].x+platforms[y].w)
 {
 vy=0;
 if(platforms[y].dangerous)hp-=0.05*dt;
 else if(hp<100)hp+=0.001*dt;
 }
 else
 {
 vy=lvl*0.25*0.0125f;
 if(hp<100)hp+=0.001*dt;
 }
 if(GetAsyncKeyState(VK_RIGHT))
 {
 vx=0.025;
 }
 else if(GetAsyncKeyState(VK_LEFT))
 {
 vx=-0.05;
 }
 else
 {
 vx=0;
 }
 if(GetAsyncKeyState(VK_DOWN))vy*=4;
 else if(GetAsyncKeyState(VK_UP)&&bulletTimeTime>0)
 {
 vy*=0.25;
 bulletTimeTime-=4*0.01f*dt;
 }
 if(hp>100)hp=100;

 x+=vx*dt;
 y+=vy*dt;
 if(x<0)x=0;
 if(x>79-3)x=79-3;

 bulletTimeTime+=0.01f*dt;
 if(bulletTimeTime>100)bulletTimeTime=100;

 timeToNextLvl-=0.01*dt;
 if(timeToNextLvl<0)
 {
 timeToNextLvl=100;
 ++lvl;
 }
 }
 void draw()
 {
 rndr->drawChar(x,8,148,FOREGROUND_GREEN);
 for(int i=max(0,y-8);i<y+20;++i)
 {
 if(platforms[i].w>0)
 {
 if(platforms[i].dangerous)rndr->drawSprite(platforms[i].x,i-(int)y+9,platformSprite2);
 else rndr->drawSprite(platforms[i].x,i-(int)y+9,platformSprite);
 }
 }
 char buff[81];
 sprintf_s(buff,"HP: %3d     Points: %6d     Level: %3d (%d)      Bullet time: %3d",max((int)hp,0),points,lvl,(int)(timeToNextLvl*0.1f),(int)(bulletTimeTime));
 for(int i=strlen(buff);i<80;++i)buff[i]=' ';
 buff[80]=0;
 rndr->drawString(0,0,buff,FOREGROUND_INTENSITY);
 }
};
bool g_tryAgain;
void gameOver(int pts)
{
 while(!GetAsyncKeyState(VK_ESCAPE))
 {
 rndr->clear(0);
 rndr->drawString(30,10,"GAME OVER",FOREGROUND_RED);
 rndr->drawString(30,11,"Your result: ",FOREGROUND_INTENSITY);
 char buff[32];
 sprintf_s(buff,"%6d",pts);
 rndr->drawString(46,11,buff,FOREGROUND_GREEN);
 rndr->drawString(30,13,"Try again? [Y/N]",FOREGROUND_INTENSITY);
 rndr->flush();
 if(GetAsyncKeyState('Y'))
 {
 g_tryAgain=true;
 break;
 }
 else if(GetAsyncKeyState('N'))
 {
 g_tryAgain=false;
 break;
 }
 }
}
int _tmain(int argc, _TCHAR* argv[])
{
 SetConsoleTitleA("Falling down by lukaszw");
 srand(time(0));
 rndr=new consoleRenderer(25);
 do
 {
 g_tryAgain=false;
 platforms.clear();
 platforms.push_back(platform(0,0,18,false));
 initPlatformSprite();
 float accumulator=0.f;
 float dt;
 float timeStep=0.5f;
 float lastUpdateTime=GetTickCount();
 player myPlayer(0,0);
 while(!GetAsyncKeyState(VK_ESCAPE)&&myPlayer.hp>0)
 {
 float currentTime=GetTickCount();
 dt=currentTime-lastUpdateTime;
 accumulator+=dt;
 lastUpdateTime=currentTime;
 while(accumulator>timeStep)
 {
 accumulator-=timeStep;
 myPlayer.update(timeStep);
 }
 rndr->clear();
 myPlayer.draw();
 rndr->flush();
 }
 if(myPlayer.hp<=0)gameOver(myPlayer.points);
 }
 while(g_tryAgain);
 delete rndr;
 return 0;
}

Mam nadzieję, że komuś ten kod się przyda.

Visual C++ 2010 Express x64

Nie było łatwo, ale w końcu udało mi się dojść w jaki sposób uzyskać możliwość tworzenia natywnych aplikacji na platformę x64 w Visual C++ 2010  Express Edition. Jako, że w trakcie moich poszukiwań w sieci nie wpadłem na stronę z rozwiązaniem mojego problemu, postanowiłem teraz je pokrótce przedstawić 🙂

SFML – eventy, ciąg dalszy

Obiecałem ostatnio, że opiszę eventy w SFML. A więc – zaczynamy!

Eventy można podzielić na pewne grupy, dla których struktura Event będzie zawierała określone dane.

Zdarzenie zmiany rozmiaru okna

event.Type=sf::Event::Resized;
event.Size.Width=szerokość w pikselach;
event.Size.Height=wysokość w pikselach;

Zdarzenie wpisania znaku

event.type=sf::Event::TextEntered;
event.Text.Unicode=znak w UTF-32;

Zdarzenia klawiatury

event.type=sf::Event::KeyPressed lub sf::Event::KeyReleased;
event.Key.Code=kod klawisza;
event.Key.Alt=czy alt jest_wciśnięty;
event.Key.Shift=czy shift jest wciśnięty;
event.Key.Control=czy Ctrl jest wciśnięty

Zdarzenia klawisza myszki

event.Type=sf::Event::KeyPressed lub sf::Event::KeyReleased;
event.MouseButton.Button=którego przycisku zdarzenie dotyczy

Zdarzenia przesunięcia kursora myszki

event.Type=sf::Event::MouseMoved;
event.MouseMove.X=współrzędna X kursora;
event.MouseMove.Y=współrzędna Y kursora;

Zdarzenie kółka myszki

event.Type=sf::Event::MouseWheelMoved;
event.MouseWheel.Delta=przesunięcie rolki myszki;

Myślę, że na początek powinno tyle wystarczyć 🙂

SFML – eventy

Kto czytał mój poprzedni wpis zapewne pamięta także, że na jego końcu wspomniałem, że aby ruszyć dalej (tzn. zamknąć okienko) musimy poznać tak zwane eventy.

Co to jest event? Tłumacząc ten wyraz na polski zapewne będzie on oznaczać „zdarzenie”. Co może być zdarzeniem? Właściwie to wiele rzeczy, na przykład kliknięcie myszką, przesunięcie kursora nad okienkiem, naciśnięcie jakiegoś klawisza, czy wreszcie naciśnięcie „krzyżyka” zamykającego okno. Wszystkie typy komunikatów w SFML (przynajmniej w wersji 1.6) opiszę za chwilę. Najpierw zaprezentuję w jaki sposób można ten mechanizm wykorzystać w aplikacji.

Pamiętacie pętlę główną programu z poprzedniej części naszego „tutoriala”? Wyglądała ona tak:

while(true)
{
app.Display();
}

I teraz pojawia się pytanie: co zrobić, aby ta pętla kiedyś się skończyła? Odpowiedź jest oczywista – można użyć w pewnym miejscu pętli instrukcji break, albo po prostu zmienić warunek wykonywania tejże pętli. Ja wolę tę drugą opcję i jej tutaj użyję.

No ale zaraz – zapytasz zapewne jaki powinien być ten warunek zakończenia. Już śpieszę z odpowiedzią. Mianowicie dobrym momentem na zatrzymanie naszej pętli głównej jest moment zamknięcia okienka. Możemy sprawdzić, czy okienko jest aktualnie otwarte, wywołując metodę IsOpened() naszego okna (czyli ‚app’). Oczywiście, jeżeli ktoś chce, to może ustalić jakiś inny warunek zakończenia 🙂

„No dobra – powiesz – wiemy już jak sprawdzić, czy okienko jest otwarte. No ale kiedy je zamknąć?”
No cóż, w sumie to okienko można zamknąć w dowolnej chwili wywołując mu metodę Close(). Fajnie jest  jednak, kiedy istnieje możliwość zamknięcia okna po naciśnięciu „krzyżyka”. Ale żeby to zrobić potrzebna jest informacja, że ktoś tenże przycisk wcisnął. Jak ją uzyskać? Poprzez obsłużenie odpowiedniego eventu 🙂

Teraz już się nie wymigam i muszę wyjaśnić w jaki sposób obsługuje się eventy w SFML 🙂 Otóż jest to zadanie bardzo proste.Potrzebujemy zmiennej typu sf::Event. Za pomocą metody GetEvent() możemy pobrać kolejne zdarzenia z kolejki. Może się w niej znajdować więcej niż jedno zdarzenie, toteż powinniśmy w jakiejś pętli obsłużyć je wszystkie przy każdym obiegu pętli głównej. Przydatną informacją jest fakt, że metoda GetEvent() zwraca true jeżeli zostanie pobrane jakieś zdarzenie do obsłużenia i false w przeciwnym wypadku. Niepobranie komunikatu świadczy oczywiście o tym, że można powrócić do wykonywania dalszych instrukcji w pętli głównej programu 🙂

while(app.IsOpened())
{
sf::Event event;
while(app.GetEvent(Event))
{
if(event.Type==sf::Event::Closed)
{
app.Close();
break;
}
}
app.Display();
}

Powyższy kod jest pętlą główną programu. Pobieramy w każdym przebiegu pętli głównej wszystkie eventy. Jeżeli trafimy po drodze na zdarzenie naciśnięcia „krzyżyka” do zamykania okienka, to zamykamy nasze okno wywołując mu metodę Close().
Widać tutaj, że korzystamy z pola Type naszego eventu. Poniżej przedstawiam listę możliwych wartości tegoż pola i krótki opis danego typu zdarzenia.

W następnej części postaram się przedstawić krótko możliwe typy eventów w SFML.

SFML część 1.

Zainteresowałem się ostatnio biblioteką SFML. Jest to dość prosta w obsłudze biblioteka do obsługi grafiki, dźwięku,sieci… Jest dostępna zarówno na Windowsa, jak i na Linuksa oraz MAC OS X. Stanowi według mnie niezłą konkurencję dla SDL czy Allegro 🙂

Postanowiłem zacząć opisywać co jakiś czas podstawy tej biblioteki. Jak się może łatwo domyślić, na stronie projektu dostępne są tutoriale po angielsku, ale nie każdy musi umieć/chcieć czytać w tym języku. Wśród programistów to raczej powinna występować ta dru… Tfu, co ja plotę – programista gier powinien umieć i chcieć czytać po angielsku 🙂 Ale do rzeczy – będę się mocno wzorował tutorialami ze strony SFML’a, ale postaram się także dorzucać jakieś refleksje od siebie :p

Zaczynajmy więc!

Jako, że każdy szanujący się programista powinien sobie poradzić z odpowiednią konfiguracją swego ulubionego IDE do pracy z SFML, pozwolę sobie ominąć ten jakże nudny z mojego punktu widzenia fragment zabawy ze wszystkimi bibliotekami i przejdę od razu do konkretów – czyli utworzenia pierwszego okienka!

Najpierw musimy dołączyć jeden z nagłówków biblioteki SFML, odpowiadający za utworzenie i obsługę okienka.

#include <SFML/Window.hpp>

Następnie, jak się pewnie już wszyscy domyślili, musimy napisać swoją funkcję main() <- jeżeli czytasz ten artykuł, to zakładam, że wiesz co to jest 😀

int main()
{
return 0;
}

Oczywiście, może to też być funkcja WinMain() jeżeli piszemy pod Windowsa, ale SFML pisze czasem po stderr, więc wygodnie mieć konsolkę 😀
Przykładowe programiki będą zazwyczaj na tyle krótkie i proste, że opakowywanie tego wszystkiego we własne klasy byłoby już znacznym przegięciem.
Moment, w którym napiszemy kod wyświetlający okienko jest coraz bliżej. A właściwie to już nadszedł.

sf::Window app(sf::VideoMode(800, 600, 32), "SFML Window");

Co tutaj robimy? Otóż tworzymy sobie zmienną typu sf::Window. Nazywa się ona app. Konstruktor przyjmuje kilka parametrów, kolejno:
-zmienną typu sf::VideoMode, której kolejne parametry to szerokość, wysokość i ilość bitów na piksel
-tytuł okienka
-opcjonalnie może przyjmować także dodatkowe parametry do ustawienia stylu okienka i innych bardziej zaawansowanych aspektów naszego okienka – na razie nie będziemy się tym przejmować, a chętni mogą poczytać sobie o tych parametrach w dokumentacji, choć o stylach trochę zaraz wspomnę.
Przy okazji od razu widać, że wszystkie funkcje i obiekty SFML znajdują się w przestrzeni nazw sf.

No więc, miałem coś wspomnieć o stylach okienka – otóż możemy podać jako ten parametr kombinację flag sf::Style:

None, Titlebar, Fullscreen, Resize, Close. Domyślny styl to Resize|Close

Pozwolę sobie chwilowo pominąć fullscreen w SFML, gdyż programy podczas uczenia się biblioteki będzie i tak dość wygodnie testować w okienku. Prawdopodobnie jednak kiedyś o tej możliwości napiszę.

Idziemy dalej. Mamy już okienko, ale program zamyka się od razu po uruchomieniu – czy zrobiliśmy błąd, a może kompilator jest popsuty i źle kompiluje program? Albo to jakiś BUG w bibliotece SFML? Otóż nie! Potrzebujemy tak zwanej pętli głównej programu. Czyli, krótko mówiąc, potrzebujemy pętli, w której będziemy co chwila uaktualniać stan okienka, wczytywać dane od użytkownika, albo wykonywać inne czynności związane z aktualnym stanem gry (tudzież innej aplikacji).

while(true)
{
app.Display();
}

Co się dzieje? okienko się pojawia, ale po zamknięciu go krzyżykiem program nadal działa. A właściwie to nawet okienko się nie zamyka.  Czy to jakiś bug w bibliotece? Jak się zapewne domyślasz – nie 🙂 Ale do rozwiązania tego problemu potrzebna jest znajomość tak zwanych eventów – ale to dopiero w następnej części artykułu 😉

Ciekawe sztuczki

Dawno, dawno temu dodałem na Eiobę pewien artykuł o kilku mniej lub bardziej znanych sztuczkach,napotkanych podczas mego koderskiego żywota, do wykorzystania w c/c++ (i nie tylko). Jako, że mój blog świeci na razie pustkami, postanowiłem ten artykuł przenieść tutaj, a dokładniej – zawrzeć go w tym oto wpisie 😀

Latające div-y

Jakiś czas temu miałem okazję zaimplementować z użyciem HTML’a, CSS’a i JavaScriptu animację 3 kwadratów latających po przekątnych pewnego większego kwadratu ruchem jednostajnym (kod na końcu wpisu).

Oczywiści, jak się pewnie łatwo domyślić, opiszę moją implementację w tym oto wpisie 🙂