Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?

Rotate i ustalenie pozycji

Ostatnio zmodyfikowano 2010-01-10 13:33
Autor Wiadomość
JarekKatowice
Temat założony przez niniejszego użytkownika
Rotate i ustalenie pozycji
» 2010-01-09 11:41:25
Mam pewien problem. Załóżmy, że ustawiamy sprita w pozycji x=50 y=50. jego lewy gorny rog znajduje sie dokaldnie w tej pozycji. Teraz funcja rotate przekrecamy go w ktoras strone no o 35 stopni w lewo. Jak ustalic w jakiej pozycji znajduje sie jego lewy gorny rog (tego sprita)?? Do czego mi to potrzebne? Powiedzmy ze mamy jakies dzialo do strzelania na daleka odleglosc. Jesli bedziemy krecic dzialem o 90 stoni to zadnen problem w ktorym miejscu znajduje sie wylot z lufy( no bo z ktoregos miejsca musi wyleciec pocisk - nasz kolejny sprite). Ale jesli damy uzytkownikowi mozliwosc wsobodnego ustawienia dziala? Oczywiscie zakladam ze dzialo bedzie przekrecane za pomoca funkcji rotate. A moze jest lepszy sposob?
pozdr
P-12834
szyx_yankez
» 2010-01-09 14:16:32
Robilem kiedyś podobno grę jednak projekt zostal porzucony.
Projekt czolgi pobierz
Musialem pokombinować z funkcjami trygonometrycznymi.
Jezeli chcodzi ci  o taki efekt to moge wrzucic kod.
P-12840
JarekKatowice
Temat założony przez niniejszego użytkownika
» 2010-01-09 23:32:59
Domyslam sie ze chodzi wlasnie o funkcje trygoometryczne.... ale szkole srednia skonczylem ....nie pamietam kiedy :) a na studiach o tym nie bylo :)
JAk bys mogl podeslac kawalek kodu ktory by mi wyjasnil problem to bylbym ci "dźwięczny" :)
P-12864
szyx_yankez
» 2010-01-10 13:05:35
do usuniecia
P-12876
szyx_yankez
» 2010-01-10 13:10:14
do usnuniecia
P-12877
szyx_yankez
» 2010-01-10 13:33:29
C/C++
Domyslam sie ze chodzi wlasnie o funkcje trygoometryczne....ale szkole srednia skonczylem....nie pamietam kiedy a na studiach o tym nie bylo
Ja jeszcze gimnazjum nie skończyłem (2 klasa gimnazjum)a jakoś problem rozwiązałem .Wystarczyły google.

OK ale przejdźmy do rzeczy
a więc naipierw piszemy taką malutką funkcję z sinusami i cosinusami.
C/C++
double tab_sin[ 360 ];
double tab_cos[ 360 ];

void laduj_sin_cos()
{
    for( int i = 0; i < 360; i++ )
    {
        tab_sin[ i ] = sin(( M_PI *( i ) ) / 180 );
        tab_cos[ i ] = cos(( M_PI *( i ) ) / 180 );
    }
}
następnie.pamiętajmy o wcześniejszym stworzeniu zmiennych
C/C++
dx[ k ] += v[ k ] * tab_cos[ kierunek[ k ] ];
dy[ k ] += v[ k ] * tab_sin[ kierunek[ k ] ];

if( dx[ k ] >= 1 || dx[ k ] <= - 1 ) { x[ k ] += int( dx[ k ] ); dx[ k ] = dx[ k ] - int( dx[ k ] ); }
if( dy[ k ] >= 1 || dy[ k ] <= - 1 ) { y[ k ] += int( dy[ k ] ); dy[ k ] = dy[ k ] - int( dy[ k ] ); }

stop_x[ k ] = int( mnoznik[ k ] * kol_x[ k ] * tab_cos[ kierunek[ k ] ] - kol_y[ k ] * tab_sin[ kierunek[ k ] ] ) + x[ k ];
stop_y[ k ] = int( mnoznik[ k ] * kol_x[ k ] * tab_sin[ kierunek[ k ] ] + kol_y[ k ] * tab_cos[ kierunek[ k ] ] ) + y[ k ];

stop_x_lewy[ k ] = int( 0.14 * kol_x_lewy[ k ] * tab_cos[ nowykierunek[ k ] ] - kol_y_lewy[ k ] * tab_sin[ nowykierunek[ k ] ] ) + x[ k ];
stop_y_lewy[ k ] = int( 0.14 * kol_x_lewy[ k ] * tab_sin[ nowykierunek[ k ] ] + kol_y_lewy[ k ] * tab_cos[ nowykierunek[ k ] ] ) + y[ k ];

stop_x_prawy[ k ] = int( 0.14 * kol_x_lewy[ k ] * tab_cos[ nowykierunek2_[ k ] ] - kol_y_prawy[ k ] * tab_sin[ nowykierunek2_[ k ] ] ) + x[ k ];
stop_y_prawy[ k ] = int( 0.14 * kol_x_lewy[ k ] * tab_sin[ nowykierunek2_[ k ] ] + kol_y_prawy[ k ] * tab_cos[ nowykierunek2_[ k ] ] ) + y[ k ];

strzal_x[ k ] = int( promienstrzalu[ k ] * kol_strzal_x[ k ] * tab_cos[ kierunekstrzalu[ k ] ] - kol_strzal_y[ k ] * tab_sin[ kierunekstrzalu[ k ] ] ) + xs[ k ];
strzal_y[ k ] = int( promienstrzalu[ k ] * kol_strzal_x[ k ] * tab_sin[ kierunekstrzalu[ k ] ] + kol_strzal_y[ k ] * tab_cos[ kierunekstrzalu[ k ] ] ) + ys[ k ];
k==coż u mnie jest tak ze gracz jet numerem 0 np  stop_x[0]
a przeciwnicy są powyzej zero np stop_x[1]

nastepnie ograniczenia;
C/C++
if( x[ k ] > 1024 ) { x[ k ] = x[ k ] - 5; kierunek[ k ] = kierunek[ k ] - 5; }
if( x[ k ] < 0 ) { x[ k ] = x[ k ] + 5; kierunek[ k ] = kierunek[ k ] - 5; }
if( y[ k ] > 768 ) { y[ k ] = y[ k ] - 5; kierunek[ k ] = kierunek[ k ] - 5; }
if( y[ k ] < 0 ) { y[ k ] = y[ k ] + 5; kierunek[ k ] = kierunek[ k ] - 5; }

if( strzelaj[ 0 ] == 1 )
     promienstrzalu[ 0 ] = promienstrzalu[ 0 ] + szybkoscstrzalu[ 0 ];


if( kierunekstrzalu[ k ] > 359 ) kierunekstrzalu[ k ] = 0;

if( kierunekstrzalu[ k ] < 0 ) kierunekstrzalu[ k ] = 359;

if( kierunek[ k ] > 359 ) kierunek[ k ] = 0;

if( kierunek[ k ] < 0 ) kierunek[ k ] = 359;

nowykierunek[ k ] = kierunek[ k ] - 60;
nowykierunek2_[ k ] = kierunek[ k ] + 60;

for( int i = 0; i < 60; i++ )
{
    if( nowykierunek[ k ] ==- 60 + i )
         nowykierunek[ k ] = 300 + i;
   
}
for( int i = 0; i < 61; i++ )
{
    if( nowykierunek2_[ k ] == 359 + i )
         nowykierunek2_[ k ] = i;
   
}
no i oczywiście sterownie
C/C++
if( key[ KEY_LEFT ] ) kierunek[ 0 ] = kierunek[ 0 ] - 2;

if( key[ KEY_RIGHT ] ) kierunek[ 0 ] = kierunek[ 0 ] + 2;

if( key[ KEY_UP ] ) v[ 0 ] = v[ 0 ] + 0.1;

if( key[ KEY_DOWN ] ) v[ 0 ] = 0;

if( key[ KEY_SPACE ] )
{ kierunekstrzalu[ 0 ] = kierunek[ 0 ]; strzelaj[ 0 ] = 1; promienstrzalu[ 0 ] = 0; xs[ k ] = x[ k ]; ys[ k ] = y[ k ]; }
następnie wyświetl sobie czołga na buforze rotate_sprite...
w miejcsu na kąt wpisz kierunek[k]*100/256.

coż kod jest długi gdyż uwzględnilem kolizje
jak pkazano na na rysunku
     x
     ||
x__||__x
|         |
|         |    x-kolizja
|_____|
 
Z tym kodem wyzej to musisz pokombinowac.

jak bys chcial tom jeszcze masz kolizje
C/C++
if( getpixel( mapa, stop_x[ k ], stop_y[ k ] ) == makecol( 1, 1, 1 ) )
{
    if( losowaskretu > 10 )
         kierunek[ k ] = kierunek[ k ] - 3;
   
    if( losowaskretu < 10 )
         kierunek[ k ] = kierunek[ k ] + 3;
   
}

if( getpixel( mapa, stop_x_prawy[ k ], stop_y_prawy[ k ] ) == makecol( 1, 1, 1 ) )
{
   
    kierunek[ k ] = kierunek[ k ] - 3;
   
}
if( getpixel( mapa, stop_x_lewy[ k ], stop_y_lewy[ k ] ) == makecol( 1, 1, 1 ) )
{
   
    kierunek[ k ] = kierunek[ k ] + 3;
   
}


tak patrze i myslw ze dam ci moje zmienne
C/C++
int cc = 2; //ilosc graczy(przeciwników tez)


int kierunek[ cc ];
for( int i = 0; i < cc; i++ )
     kierunek[ i ] = random( 0, 360 );

int x[ cc ], y[ cc ];
x[ 0 ] = 600; y[ 0 ] = 200;
for( int s = 100, i = 1; i < cc; i++, s = s + 10 )
     x[ i ] = s, y[ i ] = 100;

double dx[ cc ], dy[ cc ];
for( int i = 0; i < cc; i++ )
     dx[ i ] = 0, dy[ i ] = 0;

int kol_x[ cc ], kol_y[ cc ];
int stop_x[ cc ], stop_y[ cc ];
double mnoznik[ cc ];
mnoznik[ 0 ] = 0.25;
for( int i = 1; i < cc; i++ )
     mnoznik[ i ] = 0.44;

for( int i = 0; i < cc; i++ )
     kol_x[ i ] = 200, kol_y[ i ] = 0;


int stop_x_lewy[ cc ], stop_y_lewy[ cc ];
int kol_x_lewy[ cc ], kol_y_lewy[ cc ];
for( int i = 0; i < cc; i++ )
     kol_x_lewy[ i ] = 200, kol_y_lewy[ i ] = 0;


int stop_x_prawy[ cc ], stop_y_prawy[ cc ];
int kol_x_prawy[ cc ], kol_y_prawy[ cc ];
for( int i = 0; i < cc; i++ )
     kol_x_prawy[ i ] = 200, kol_y_prawy[ i ] = 0;


int nowykierunek[ cc ], nowykierunek2_[ cc ];
for( int i = 0; i < cc; i++ )
     nowykierunek[ i ] =- 10, nowykierunek2_[ i ] = 10;

double v[ cc ];
for( int i = 0; i < cc; i++ )
     v[ i ] = 1;


int kol_strzal_x[ cc ], kol_strzal_y[ cc ];
int strzal_x[ cc ], strzal_y[ cc ];
for( int i = 0; i < cc; i++ )
     kol_strzal_x[ i ] = 200, kol_strzal_y[ i ] = 0;

int kierunekstrzalu[ cc ];
for( int i = 0; i < cc; i++ )
     kierunekstrzalu[ i ] = 0;

int xs[ cc ];
int ys[ cc ];

double promienstrzalu[ cc ];

int strzelaj[ cc ];

double szybkoscstrzalu[ cc ];
szybkoscstrzalu[ 0 ] = 0.01;

int losowaskretu = 0;
int losowaskretu_n = 0;

int k = 0;



laduj_sin_cos();


ok dam caly kod teraz
C/C++
#include <allegro.h> 
#include <cmath>
#include <ctime>
#include <iostream>
#include <string>

using namespace std;



///////////////////////////////////
volatile long sekunda = 0;
void increment_sekunda()
{
    sekunda++;
}
END_OF_FUNCTION( increment_sekunda );
LOCK_VARIABLE( sekunda );
LOCK_FUNCTION( increment_sekunda );

volatile long speed = 0;
void increment_speed()
{
    speed++;
}
END_OF_FUNCTION( increment_speed );
LOCK_VARIABLE( speed );
LOCK_FUNCTION( increment_speed );

volatile long szybkosc = 0;
void increment_szybkosc()
{
    szybkosc++;
}
END_OF_FUNCTION( increment_szybkosc );
LOCK_VARIABLE( szybkosc );
LOCK_FUNCTION( increment_szybkosc );
///////////////////////////////////wczytywanie textu
void wczytaj( string & wyraz, int pozycja_x, int pozycja_y )
{
    wyraz.clear();
    string::iterator iter = wyraz.begin();
    int caret = 0;
    bool insert = true;
    do
    {
       
        while( keypressed() )
        {
            int newkey = readkey();
            char ASCII = newkey & 0xff;
            char scancode = newkey >> 8;
            if( ASCII >= 32 && ASCII <= 126 )
            {
                if( insert || iter == wyraz.end() )
                     iter = wyraz.insert( iter, ASCII );
                else
                     wyraz.replace( caret, 1, 1, ASCII );
               
                caret++;
                iter++;
            } else
            switch( scancode )
            {
            case KEY_BACKSPACE:
                if( iter != wyraz.begin() )
                {
                    caret--;
                    iter--;
                    iter = wyraz.erase( iter );
                }
                break;
               
            }
        }
        textout_ex( screen, font, wyraz.c_str(), pozycja_x, pozycja_y, makecol( 0, 0, 0 ), - 1 );
       
    } while( !key[ KEY_ENTER ] );
   
}
/////////////////////////////////////
/////////////////////////////////////
double tab_sin[ 360 ];
double tab_cos[ 360 ];

void laduj_sin_cos()
{
    for( int i = 0; i < 360; i++ )
    {
        tab_sin[ i ] = sin(( M_PI *( i ) ) / 180 );
        tab_cos[ i ] = cos(( M_PI *( i ) ) / 180 );
    }
}
/////////////////////////////////////wczytywanie textu
int random( int nMin, int nMax ) { return rand() %( nMax - nMin + 1 ) - nMin; }





int main()
{
    srand( time( NULL ) );
    string text;
   
   
   
    allegro_init();
    install_keyboard();
    set_color_depth( 32 );
    set_gfx_mode( GFX_AUTODETECT_WINDOWED, 1024, 768, 0, 0 );
   
    install_timer();
    install_int_ex( increment_speed, BPS_TO_TIMER( 100 ) );
    install_int_ex( increment_szybkosc, BPS_TO_TIMER( 75 ) );
    install_int_ex( increment_sekunda, BPS_TO_TIMER( 1 ) );
   
   
   
    BITMAP * bufor = NULL;
    bufor = create_bitmap( 1024, 768 );
   
    BITMAP * czolg = NULL;
    czolg = load_bmp( "czolg.bmp", default_palette );
    BITMAP * mapa = NULL;
    mapa = load_bmp( "mapa.bmp", default_palette );
    BITMAP * a = NULL;
    a = load_bmp( "a.bmp", default_palette );
    BITMAP * wybuch = NULL;
    wybuch = load_bmp( "wybuch.bmp", default_palette );
    int cc = 2;
   
   
    int kierunek[ cc ];
    for( int i = 0; i < cc; i++ )
         kierunek[ i ] = random( 0, 360 );
   
    int x[ cc ], y[ cc ];
    x[ 0 ] = 600; y[ 0 ] = 200;
    for( int s = 100, i = 1; i < cc; i++, s = s + 10 )
         x[ i ] = s, y[ i ] = 100;
   
    double dx[ cc ], dy[ cc ];
    for( int i = 0; i < cc; i++ )
         dx[ i ] = 0, dy[ i ] = 0;
   
    int kol_x[ cc ], kol_y[ cc ];
    int stop_x[ cc ], stop_y[ cc ];
    double mnoznik[ cc ];
    mnoznik[ 0 ] = 0.25;
    for( int i = 1; i < cc; i++ )
         mnoznik[ i ] = 0.44;
   
    for( int i = 0; i < cc; i++ )
         kol_x[ i ] = 200, kol_y[ i ] = 0;
   
   
    int stop_x_lewy[ cc ], stop_y_lewy[ cc ];
    int kol_x_lewy[ cc ], kol_y_lewy[ cc ];
    for( int i = 0; i < cc; i++ )
         kol_x_lewy[ i ] = 200, kol_y_lewy[ i ] = 0;
   
   
    int stop_x_prawy[ cc ], stop_y_prawy[ cc ];
    int kol_x_prawy[ cc ], kol_y_prawy[ cc ];
    for( int i = 0; i < cc; i++ )
         kol_x_prawy[ i ] = 200, kol_y_prawy[ i ] = 0;
   
   
    int nowykierunek[ cc ], nowykierunek2_[ cc ];
    for( int i = 0; i < cc; i++ )
         nowykierunek[ i ] =- 10, nowykierunek2_[ i ] = 10;
   
    double v[ cc ];
    for( int i = 0; i < cc; i++ )
         v[ i ] = 1;
   
   
    int kol_strzal_x[ cc ], kol_strzal_y[ cc ];
    int strzal_x[ cc ], strzal_y[ cc ];
    for( int i = 0; i < cc; i++ )
         kol_strzal_x[ i ] = 200, kol_strzal_y[ i ] = 0;
   
    int kierunekstrzalu[ cc ];
    for( int i = 0; i < cc; i++ )
         kierunekstrzalu[ i ] = 0;
   
    int xs[ cc ];
    int ys[ cc ];
   
    double promienstrzalu[ cc ];
   
    int strzelaj[ cc ];
   
    double szybkoscstrzalu[ cc ];
    szybkoscstrzalu[ 0 ] = 0.01;
   
    int losowaskretu = 0;
    int losowaskretu_n = 0;
   
    int k = 0;
   
   
   
    laduj_sin_cos();
    ///////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////////////////////////////////////////
    //////////////////////////////////////////////pętla nieskończoności
   
   
    while( !key[ KEY_ESC ] )
    {
        while( szybkosc > 0 )
        {
            clear_to_color( bufor, makecol( 255, 255, 255 ) );
            szybkosc--;
        }
        ////////////////////////////////////////////////////////////////////////////
        ////////////////////////////////////////////////obsluga klawiszy  
        if( key[ KEY_LEFT ] ) kierunek[ 0 ] = kierunek[ 0 ] - 2;
       
        if( key[ KEY_RIGHT ] ) kierunek[ 0 ] = kierunek[ 0 ] + 2;
       
        if( key[ KEY_UP ] ) v[ 0 ] = v[ 0 ] + 0.1;
       
        if( key[ KEY_DOWN ] ) v[ 0 ] = 0;
       
       
       
        ////////////////////////////////////////////////obsluga klawiszy
        ////////////////////////////////////////////////////////////////////////////  
        while( sekunda > 0 )
        {
            losowaskretu_n++;
            sekunda--;
        }
        if( losowaskretu_n > 3 ) losowaskretu_n = 0;
       
        if( losowaskretu_n == 3 )
             losowaskretu = random( 1, 20 );
       
       
        while( speed > 0 )
        {
           
            for( int k = 0; k < cc; k++ )
            {
               
               
                if( x[ k ] > 1024 ) { x[ k ] = x[ k ] - 5; kierunek[ k ] = kierunek[ k ] - 5; }
                if( x[ k ] < 0 ) { x[ k ] = x[ k ] + 5; kierunek[ k ] = kierunek[ k ] - 5; }
                if( y[ k ] > 768 ) { y[ k ] = y[ k ] - 5; kierunek[ k ] = kierunek[ k ] - 5; }
                if( y[ k ] < 0 ) { y[ k ] = y[ k ] + 5; kierunek[ k ] = kierunek[ k ] - 5; }
               
               
                if( key[ KEY_SPACE ] )
                { kierunekstrzalu[ 0 ] = kierunek[ 0 ]; strzelaj[ 0 ] = 1; promienstrzalu[ 0 ] = 0; xs[ k ] = x[ k ]; ys[ k ] = y[ k ]; }
               
               
               
               
                /////////////////////////////////////////////////////////////////////////////
                /////////////////////////////////////////////wszystkie funkcje ruchu gracza
                if( strzelaj[ 0 ] == 1 )
                     promienstrzalu[ 0 ] = promienstrzalu[ 0 ] + szybkoscstrzalu[ 0 ];
               
               
                if( kierunekstrzalu[ k ] > 359 ) kierunekstrzalu[ k ] = 0;
               
                if( kierunekstrzalu[ k ] < 0 ) kierunekstrzalu[ k ] = 359;
               
                if( kierunek[ k ] > 359 ) kierunek[ k ] = 0;
               
                if( kierunek[ k ] < 0 ) kierunek[ k ] = 359;
               
                nowykierunek[ k ] = kierunek[ k ] - 60;
                nowykierunek2_[ k ] = kierunek[ k ] + 60;
               
                for( int i = 0; i < 60; i++ )
                {
                    if( nowykierunek[ k ] ==- 60 + i )
                         nowykierunek[ k ] = 300 + i;
                   
                }
                for( int i = 0; i < 61; i++ )
                {
                    if( nowykierunek2_[ k ] == 359 + i )
                         nowykierunek2_[ k ] = i;
                   
                }
               
                dx[ k ] += v[ k ] * tab_cos[ kierunek[ k ] ];
                dy[ k ] += v[ k ] * tab_sin[ kierunek[ k ] ];
               
                if( dx[ k ] >= 1 || dx[ k ] <= - 1 ) { x[ k ] += int( dx[ k ] ); dx[ k ] = dx[ k ] - int( dx[ k ] ); }
                if( dy[ k ] >= 1 || dy[ k ] <= - 1 ) { y[ k ] += int( dy[ k ] ); dy[ k ] = dy[ k ] - int( dy[ k ] ); }
               
                stop_x[ k ] = int( mnoznik[ k ] * kol_x[ k ] * tab_cos[ kierunek[ k ] ] - kol_y[ k ] * tab_sin[ kierunek[ k ] ] ) + x[ k ];
                stop_y[ k ] = int( mnoznik[ k ] * kol_x[ k ] * tab_sin[ kierunek[ k ] ] + kol_y[ k ] * tab_cos[ kierunek[ k ] ] ) + y[ k ];
               
                stop_x_lewy[ k ] = int( 0.14 * kol_x_lewy[ k ] * tab_cos[ nowykierunek[ k ] ] - kol_y_lewy[ k ] * tab_sin[ nowykierunek[ k ] ] ) + x[ k ];
                stop_y_lewy[ k ] = int( 0.14 * kol_x_lewy[ k ] * tab_sin[ nowykierunek[ k ] ] + kol_y_lewy[ k ] * tab_cos[ nowykierunek[ k ] ] ) + y[ k ];
               
                stop_x_prawy[ k ] = int( 0.14 * kol_x_lewy[ k ] * tab_cos[ nowykierunek2_[ k ] ] - kol_y_prawy[ k ] * tab_sin[ nowykierunek2_[ k ] ] ) + x[ k ];
                stop_y_prawy[ k ] = int( 0.14 * kol_x_lewy[ k ] * tab_sin[ nowykierunek2_[ k ] ] + kol_y_prawy[ k ] * tab_cos[ nowykierunek2_[ k ] ] ) + y[ k ];
               
                strzal_x[ k ] = int( promienstrzalu[ k ] * kol_strzal_x[ k ] * tab_cos[ kierunekstrzalu[ k ] ] - kol_strzal_y[ k ] * tab_sin[ kierunekstrzalu[ k ] ] ) + xs[ k ];
                strzal_y[ k ] = int( promienstrzalu[ k ] * kol_strzal_x[ k ] * tab_sin[ kierunekstrzalu[ k ] ] + kol_strzal_y[ k ] * tab_cos[ kierunekstrzalu[ k ] ] ) + ys[ k ];
               
               
               
               
               
                if( getpixel( mapa, stop_x[ k ], stop_y[ k ] ) == makecol( 1, 1, 1 ) )
                {
                    if( losowaskretu > 10 )
                         kierunek[ k ] = kierunek[ k ] - 3;
                   
                    if( losowaskretu < 10 )
                         kierunek[ k ] = kierunek[ k ] + 3;
                   
                }
               
                if( getpixel( mapa, stop_x_prawy[ k ], stop_y_prawy[ k ] ) == makecol( 1, 1, 1 ) )
                {
                   
                    kierunek[ k ] = kierunek[ k ] - 3;
                   
                }
                if( getpixel( mapa, stop_x_lewy[ k ], stop_y_lewy[ k ] ) == makecol( 1, 1, 1 ) )
                {
                   
                    kierunek[ k ] = kierunek[ k ] + 3;
                   
                }
               
               
                if( getpixel( mapa, strzal_x[ k ], strzal_y[ k ] ) == makecol( 1, 1, 1 ) )
                {
                    masked_blit( wybuch, mapa, 0, 0, strzal_x[ 0 ] -( wybuch->w / 2 ), strzal_y[ 0 ] -( wybuch->h / 2 ), wybuch->w, wybuch->h );
                    strzelaj[ 0 ] = 0;
                    promienstrzalu[ 0 ] = 0.0;
                }
                //////////////////////////////////////////////////////////////wszystkie funkcje ruchu gracza   
                ///////////////////////////////////////////////////////////////////////////////////////////   
               
               
               
               
                //////////////////////////////////////////////////////////////////////////////////////////////// 
                //////////////////////////////////////////////////////////////////////////////////////////////// 
               
               
               
            }
            speed--;
        }
        //////////////////////////////////////////////////////////////////////////////////////////////
        /////////////////////////////////////////////////////////////////////wyswietlanie 
        set_color_blender( 128, 128, 128, 66 );
        blit( mapa, bufor, 0, 0, 0, 0, mapa->w, mapa->h );
       
       
        for( int i = 0; i < cc; i++ )
       
             rotate_sprite( bufor, czolg, x[ i ] -( czolg->w / 2 ), y[ i ] -( czolg->h / 2 ), itofix( kierunek[ i ] * 256 / 360 ) );
       
       
        if( strzelaj[ 0 ] == 1 )
             rotate_sprite( bufor, a, strzal_x[ 0 ] -( a->w / 2 ), strzal_y[ 0 ] -( a->h / 2 ), itofix( kierunekstrzalu[ 0 ] * 256 / 360 ) );
       
       
       
       
       
        while( szybkosc > 0 )
        {
           
            blit( bufor, screen, 0, 0, 0, 0, 1024, 768 );
            szybkosc--;
        }
       
        /////////////////////////////////////////////////////////////////////wyswiatlanie
        ///////////////////////////////////////////////////////////////////////////////////////////////    
    }
   
   
   
    destroy_bitmap( bufor );
    destroy_bitmap( czolg );
    destroy_bitmap( a );
    destroy_bitmap( wybuch );
   
    readkey();
    allegro_exit();
    return 0;
}
END_OF_MAIN();
P-12878
« 1 »
  Strona 1 z 1