Rotate i ustalenie pozycji

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();

#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();