//This source code has been extremely badly done!!!
//This is my first project with C++ and SDL.
//Don't laugh.

#include <SDL/SDL.h>
#include <SDL/SDL_gfxPrimitives.h>
#include <SDL/SDL_rotozoom.h>
#include <SDL/SDL_image.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_mixer.h>
#include <fstream>
#include <iostream>
#include <time.h>
#include <string.h>
using namespace std;

//globaalit
int fps_asdf;
char bfr[50];
bool kaksinpeli=0;
int screen_leveys=500;
int screen_korkeus=500;

void text(SDL_Surface *taso, int x, int y, char teksti[], TTF_Font *fontti)
{               //väri
                SDL_Color fntcolor = {0,0,0, 255};
                //renderöidään teksti
                SDL_Surface *temp = TTF_RenderText_Blended(fontti, teksti, fntcolor);
                //määritetään paikka
                SDL_Rect alue;
                alue.x=x;
                alue.y=y;
                //yhdistetään tasot
                SDL_BlitSurface(temp, NULL, taso, &alue);
		SDL_FreeSurface(temp);
		SDL_FreeSurface(taso);
}
void text(SDL_Surface *taso, int x, int y, int teksti, TTF_Font *fontti)
{               //väri
                SDL_Color fntcolor = {0,0,0, 255};
                //renderöidään teksti
		snprintf(bfr, 50, "%d", teksti);
                SDL_Surface *temp = TTF_RenderText_Blended(fontti, bfr, fntcolor);
                //määritetään paikka
                SDL_Rect alue;
                alue.x=x;
                alue.y=y;
                //yhdistetään tasot
                SDL_BlitSurface(temp, NULL, taso, &alue);
		SDL_FreeSurface(temp);
		SDL_FreeSurface(taso);
}
void text(SDL_Surface *taso, int x, int y, double teksti, TTF_Font *fontti)
{               //väri
                SDL_Color fntcolor = {0,0,0, 255};
                //renderöidään teksti
		snprintf(bfr, 50, "%G", teksti);
                SDL_Surface *temp = TTF_RenderText_Blended(fontti, bfr, fntcolor);
                //määritetään paikka
                SDL_Rect alue;
                alue.x=x;
                alue.y=y;
                //yhdistetään tasot
                SDL_BlitSurface(temp, NULL, taso, &alue);
		SDL_FreeSurface(temp);
		SDL_FreeSurface(taso);
}
void text2(SDL_Surface *taso, int x, int y, char teksti[], TTF_Font *fontti)
{               //väri
                SDL_Color fntcolor = {255,255,255, 255};
                //renderöidään teksti
                SDL_Surface *temp = TTF_RenderText_Blended(fontti, teksti, fntcolor);
                //määritetään paikka
                SDL_Rect alue;
                alue.x=x;
                alue.y=y;
                //yhdistetään tasot
                SDL_BlitSurface(temp, NULL, taso, &alue);
		SDL_FreeSurface(temp);
		SDL_FreeSurface(taso);
}
void textv(SDL_Surface *taso, int x, int y, char teksti[], TTF_Font *fontti)
{               //väri
                SDL_Color fntcolor = {252,206,251 ,255};
                //renderöidään teksti
                SDL_Surface *temp = TTF_RenderText_Blended(fontti, teksti, fntcolor);
                //määritetään paikka
                SDL_Rect alue;
                alue.x=x;
                alue.y=y;
                //yhdistetään tasot
                SDL_BlitSurface(temp, NULL, taso, &alue);
		SDL_FreeSurface(temp);
		SDL_FreeSurface(taso);
}

void nappula(SDL_Surface *taso, int x, int y, char teksti[], int valinta, int id, TTF_Font *fontti)
{
	if (valinta!=id) boxRGBA(taso, x,y,x+140,y+20, 245,126,241 ,170);
	else boxRGBA(taso, x,y,x+140,y+20, 175,40,170 ,255);
	rectangleRGBA(taso, x,y,x+140,y+20, 252,206,251 ,255);
	textv (taso, x+3,y+3, teksti, fontti);
	SDL_FreeSurface(taso);
}

//funktioiden prototyypit
int distance(int, int, int, int);
int FPS(void);
float absf(float);
int prt(int);
int prt(double);
int kulmaf(int, int, int, int);

int main(int argc, char *argv[])
{

//initialisoidaan SDL
SDL_Init(SDL_INIT_AUDIO|SDL_INIT_VIDEO);

Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, 2, 1024);

bool soitto=1;

Mix_Chunk *music;
music=Mix_LoadWAV_RW(SDL_RWFromFile("filut/musa.ogg", "rb"), 0);

Mix_PlayChannel(0, music, -1);

SDL_Surface *screen = SDL_SetVideoMode(screen_leveys,screen_korkeus,32, SDL_HWSURFACE|SDL_DOUBLEBUF);
SDL_Surface *screen2 = SDL_CreateRGBSurface(SDL_SWSURFACE, 400, 500, 32, 0, 0, 0, 0);
if (kaksinpeli==1)screen = SDL_SetVideoMode(screen_leveys*2,screen_korkeus,32, SDL_HWSURFACE|SDL_DOUBLEBUF);

SDL_Surface *scr = SDL_CreateRGBSurface(SDL_SWSURFACE, 800, 500, 32, 0, 0, 0, 0);

//muuttujat
int i;
int k;
int m;
int n;
int t;

const int x=0;
const int y=1;
const int kulma=2;
const int tyyppi=3;
const int kulmato=4;

const int p1=0;
const int p2=1;
const int p3=2;

int pituus[3];
pituus[0]=7;
pituus[1]=2;
pituus[2]=5;

float pallo[10][5][3];
int kierros[3];
bool tsek[500][3];
for (i=0;i<3;i++){
	kierros[i]=0;
	for (k=0;k<100;k++){
		tsek[k][i]=0;
	}
}

int chp[50][3];
int chp_pituus=0;

float vauhti=0;
float tmp_pituus;
float kitka=0.8;
float kiihtyvyys=1.1;

float vauhti2=0;
float vauhti3=0;
float kiihtyvyys2=0.9;
float kiihtyvyys3=1.05;

if (kaksinpeli==1){
	kiihtyvyys2=kiihtyvyys;
}

char ax;
int pointer=0;
int pointer2=0;
int fps;
int wait;
char tmp_leveys[4];
int camx=0;
int camy=0;
int cam2x=0;
int cam2y=0;
int tmp_tmp=0;
int tmp_kulma=0;
int tieta=0;
int tieta2=0;
int tie_laskuri=0;
int mouse_x=0;
int mouse_y=0;
int mouse_state=0;
int lahto;
int run=1;
bool pause=0;
int maalix=0;
int maaliy=0;

Uint8 *key;

int laps=3;
int level_valinta=0;
int r;
int g;
int b;
int asdf_m=2000;
int valinta=0;
//ladataan levelien nimet
char nimi[500][50];
int levels=0;

int level[500][500];
int leveys;

int kmuutos=0;
int osallistujia=0;

for (k=0;k<500;k++){
for (i=0;i<50;i++){
nimi[k][i]=0;
}}
ifstream inFile;
inFile.open("filut/levelit/all_levels.txt");

while (inFile >> ax) {
	if (ax=='#'){pointer++;pointer2=0;levels++;}
	else {nimi[pointer][pointer2]=ax;pointer2++;}
}
levels--;

inFile.close();

//initialisoidaan TTF
TTF_Init();
//ladataan fontti
TTF_Font *fontti = TTF_OpenFont("filut/VeraMoBd.ttf", 12);
TTF_Font *fontti2 = TTF_OpenFont("filut/VeraMoBd.ttf", 36);

srand(time(NULL));

SDL_Rect alue;
SDL_Rect alue2;
SDL_Rect alueb;

	//cout << "rivi: 1\n";

int suunta=3;
int mato_x=int(maalix/50);
int mato_y=int(maaliy/50);
int mato_matka=0;

int way=tieta2;
int wayp2=0;
int wayp3=0;
int wp[1000][2];

int antibug=0;

tie_laskuri=0;
int wp_laskuri=0;

int leveysb;
int voittaja;

//ladataan kuvat
SDL_Surface *pallura1=IMG_Load("filut/pallura1.png");
SDL_Surface *pallura2_t=IMG_Load("filut/pallura2.png");
SDL_Surface *pallura3_t=IMG_Load("filut/pallura3.png");
SDL_Surface *pallura4_t=IMG_Load("filut/pallura4.png");
SDL_Surface *palkki=IMG_Load("filut/palkki.png");
SDL_Surface *donut=IMG_Load("filut/donut.png");
SDL_Surface *donut2=IMG_Load("filut/donut2.png");
SDL_Surface *maali=IMG_Load("filut/maali.png");
SDL_Surface *set=IMG_Load("filut/set.png");
SDL_Surface *kuva=IMG_Load("filut/pp.png");

alue.x=0;
alue.y=0;

SDL_Surface *nurmi = SDL_CreateRGBSurface(SDL_SWSURFACE, 50, 50, 32, 0, 0, 0, 0);
alue2.x=0;
alue2.y=0;
alue2.w=50;
alue2.h=50;
SDL_BlitSurface(set, &alue2, nurmi, &alue);
SDL_Surface *kukka1 = SDL_CreateRGBSurface(SDL_SWSURFACE, 50, 50, 32, 0, 0, 0, 0);
alue2.w=50;
alue2.h=50;
alue2.x=50*1;
alue2.y=50*0;
SDL_BlitSurface(set, &alue2, kukka1, &alue);
SDL_Surface *kukka2 = SDL_CreateRGBSurface(SDL_SWSURFACE, 50, 50, 32, 0, 0, 0, 0);
alue2.w=50;
alue2.h=50;
alue2.x=50*2;
alue2.y=50*0;
SDL_BlitSurface(set, &alue2, kukka2, &alue);
SDL_Surface *kukka3 = SDL_CreateRGBSurface(SDL_SWSURFACE, 50, 50, 32, 0, 0, 0, 0);
alue2.w=50;
alue2.h=50;
alue2.x=50*3;
alue2.y=50*0;
SDL_BlitSurface(set, &alue2, kukka3, &alue);
SDL_Surface *kivi1 = SDL_CreateRGBSurface(SDL_SWSURFACE, 50, 50, 32, 0, 0, 0, 0);
alue2.w=50;
alue2.h=50;
alue2.x=50*0;
alue2.y=50*1;
SDL_BlitSurface(set, &alue2, kivi1, &alue);
SDL_Surface *kivi2 = SDL_CreateRGBSurface(SDL_SWSURFACE, 50, 50, 32, 0, 0, 0, 0);
alue2.w=50;
alue2.h=50;
alue2.x=50*3;
alue2.y=50*1;
SDL_BlitSurface(set, &alue2, kivi2, &alue);
SDL_Surface *tie1 = SDL_CreateRGBSurface(SDL_SWSURFACE, 50, 100, 32, 0, 0, 0, 0);
alue2.w=50;
alue2.h=100;
alue2.x=50*4;
alue2.y=50*0;
SDL_BlitSurface(set, &alue2, tie1, &alue);
SDL_Surface *tie2 = SDL_CreateRGBSurface(SDL_SWSURFACE, 100, 50, 32, 0, 0, 0, 0);
alue2.w=100;
alue2.h=50;
alue2.x=50*1;
alue2.y=50*1;
SDL_BlitSurface(set, &alue2, tie2, &alue);
SDL_Surface *mutka1 = SDL_CreateRGBSurface(SDL_SWSURFACE, 100, 100, 32, 0, 0, 0, 0);
alue2.w=100;
alue2.h=100;
alue2.x=50*7;
alue2.y=50*0;
SDL_BlitSurface(set, &alue2, mutka1, &alue);
SDL_Surface *mutka2 = SDL_CreateRGBSurface(SDL_SWSURFACE, 100, 100, 32, 0, 0, 0, 0);
alue2.w=100;
alue2.h=100;
alue2.x=50*9;
alue2.y=50*0;
SDL_BlitSurface(set, &alue2, mutka2, &alue);
SDL_Surface *mutka3 = SDL_CreateRGBSurface(SDL_SWSURFACE, 100, 100, 32, 0, 0, 0, 0);
alue2.w=100;
alue2.h=100;
alue2.x=50*11;
alue2.y=50*0;
SDL_BlitSurface(set, &alue2, mutka3, &alue);
SDL_Surface *mutka4 = SDL_CreateRGBSurface(SDL_SWSURFACE, 100, 100, 32, 0, 0, 0, 0);
alue2.w=100;
alue2.h=100;
alue2.x=50*5;
alue2.y=50*0;
SDL_BlitSurface(set, &alue2, mutka4, &alue);

	//cout << "2\n";

SDL_FreeSurface(set);

SDL_Surface *pallura[360];
for (i=0;i<360;i++)
{
	pallura[i]=rotozoomSurface(pallura1, i,1,0);
}
SDL_FreeSurface(pallura1);

SDL_Surface *pallura2[360];
for (i=0;i<360;i++)
{
	pallura2[i]=rotozoomSurface(pallura2_t, i,1,0);
}
SDL_FreeSurface(pallura2_t);

SDL_Surface *pallura3[360];
for (i=0;i<360;i++)
{
	pallura3[i]=rotozoomSurface(pallura3_t, i,1,0);
}
SDL_FreeSurface(pallura3_t);

SDL_Surface *pallura4[360];
for (i=0;i<360;i++)
{
	pallura4[i]=rotozoomSurface(pallura4_t, i,1,0);
}
SDL_FreeSurface(pallura4_t);

int mittari=SDL_GetTicks();

	//cout << "3\n";

SDL_Event event;

//pääluuppi
while (run){
//-->run alkaa

//valikot------------------------------------------------------------->
while (run==1)
	{
	fps=FPS();
	SDL_FillRect(screen, NULL, 0);

	for (i=0;i<=500;i++)
	{
	for (k=0;k<=500;k++)
	{
		r=int(k*i+(asdf_m*100))/500;
		g=int(k*i+(asdf_m*100))/450;
		b=int(k*i+(asdf_m*100))/400;
		r= r-(int(r/255)*255);
		g= g-(int(g/255)*255);
		b= b-(int(b/255)*255);
		
		//kontrasti
		if (r<128) {r-=15;}
		if (r>128) {r+=15;}

		if (g<128) {g-=15;}
		if (g>128) {g+=15;}

		if (b<128) {b-=15;}
		if (b<128) {b+=15;}
		
		r+=90;
		g+=90;
		b+=90;
		if (r>255) {r=255;}
		if (g>255) {g=255;}
		if (b>255) {b=255;}
		if (r+g+b>720){r=200;g=200;b=255;}

		if (i>1 && k>1){
		}

		pixelRGBA(screen, i, k, r,g,b, 255);
	}
	}

	asdf_m+=2;
	alue.x=68;
	alue.y=50;
	SDL_BlitSurface(kuva, NULL, screen, &alue);
	
	nappula (screen, 180,150, "Start 1 player", valinta, 0, fontti);
	nappula (screen, 180,180, "Start 2 players", valinta, 1, fontti);
	nappula (screen, 180,210, "Settings", valinta, 2, fontti);
	nappula (screen, 180,240, "Quit", valinta, 3, fontti);

	SDL_Flip(screen);

	while(SDL_PollEvent(&event))
	{
		if (event.type==SDL_QUIT) run=0;
		if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_ESCAPE)run=0;
		if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_UP)valinta--;
		if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_DOWN)valinta++;
		if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_RETURN){
			if (valinta==0){run=5;kaksinpeli=0;}
			if (valinta==1){run=5;kaksinpeli=1;}
			if (valinta==2)run=4;
			if (valinta==3)run=0;
		}
	}

	if (valinta>3)valinta=0;
	if (valinta<0)valinta=3;

	SDL_Delay(10);
	wait=10-(SDL_GetTicks()-fps_asdf);
	if (wait>0) SDL_Delay(wait);
}

while (run==4)
	{
	fps=FPS();
	SDL_FillRect(screen, NULL, 0);

	for (i=0;i<=500;i++)
	{
	for (k=0;k<=500;k++)
	{
		r=int(k*i+(asdf_m*100))/500;
		g=int(k*i+(asdf_m*100))/450;
		b=int(k*i+(asdf_m*100))/400;
		r= r-(int(r/255)*255);
		g= g-(int(g/255)*255);
		b= b-(int(b/255)*255);
		
		//kontrasti
		if (r<128) {r-=15;}
		if (r>128) {r+=15;}

		if (g<128) {g-=15;}
		if (g>128) {g+=15;}

		if (b<128) {b-=15;}
		if (b<128) {b+=15;}
		
		r+=90;
		g+=90;
		b+=90;
		if (r>255) {r=255;}
		if (g>255) {g=255;}
		if (b>255) {b=255;}
		if (r+g+b>720){r=200;g=200;b=255;}

		if (i>1 && k>1){
		}

		pixelRGBA(screen, i, k, r,g,b, 255);
	}
	}

	asdf_m+=2;
	alue.x=68;
	alue.y=50;
	SDL_BlitSurface(kuva, NULL, screen, &alue);

	text (screen, 100,100, "Use arrow keys to change values. Length: 0 = disable.", fontti);

	snprintf(bfr, 50, "Player1 Length: %d", pituus[0]);
	nappula (screen, 180,150, bfr, valinta, 0, fontti);
	snprintf(bfr, 50, "Player2 Length: %d", pituus[1]);
	nappula (screen, 180,180, bfr, valinta, 1, fontti);
	snprintf(bfr, 50, "Player3 Length: %d", pituus[2]);
	nappula (screen, 180,210, bfr, valinta, 2, fontti);
	snprintf(bfr, 50, "Laps: %d", laps);
	nappula (screen, 180,240, bfr, valinta, 3, fontti);
	nappula (screen, 180,270, "Level:", valinta, 4, fontti);
	textv(screen, 230,273, nimi[level_valinta], fontti);
	if (soitto==1) nappula (screen, 180,300, "Stop music", valinta, 5, fontti);
	else nappula (screen, 180,300, "Play music", valinta, 5, fontti);
	nappula (screen, 180,330, "Done", valinta, 6, fontti);

	SDL_Flip(screen);

	//Lopetus
	while(SDL_PollEvent(&event))
	{
		if (event.type==SDL_QUIT) run=0;
		if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_ESCAPE)run=1;
		if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_UP)valinta--;
		if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_DOWN)valinta++;
		if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_RETURN){
			if (valinta==5){
				if (soitto==1){soitto=0;Mix_HaltChannel(0);}
				else {soitto=1;Mix_PlayChannel(0, music, -1);}
			}
			else run=1;
		}
		if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_RIGHT){
			if (valinta<3){if (pituus[valinta]<10)pituus[valinta]++;}
			if (valinta==3)laps++;
			if (valinta==4)level_valinta++;
		}
		if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_LEFT){
			if (valinta<3 && valinta!=0){if (pituus[valinta]>0)pituus[valinta]--;}
			if (valinta<3 && valinta==0){if (pituus[valinta]>1)pituus[valinta]--;}
			if (valinta==3)laps--;
			if (valinta==4)level_valinta--;
		}
	}

	if (valinta>6)valinta=0;
	if (valinta<0)valinta=6;

	if (laps<1)laps=1;

	if (level_valinta>levels)level_valinta=0;
	if (level_valinta<0)level_valinta=levels;

	SDL_Delay(10);
	wait=10-(SDL_GetTicks()-fps_asdf);
	if (wait>0) SDL_Delay(wait);
}
//peli---------------------------------------------------------------->
while (run==2)
	{
	fps=FPS();
	SDL_FillRect(screen, NULL, 0);
	SDL_FillRect(screen2, NULL, 0);

	SDL_GetMouseState(&mouse_x, &mouse_y);

	key = SDL_GetKeyState(NULL);
	//p1	
	//näppäimistösyötteet
	if (key[SDLK_LEFT]) pallo[0][kulma][p1]+=5;
	if (key[SDLK_RIGHT]) pallo[0][kulma][p1]-=5;
	if (key[SDLK_UP]) vauhti-=kiihtyvyys;
	if (key[SDLK_DOWN]) vauhti+=kiihtyvyys;

	pallo[0][kulma][p1] = prt(pallo[0][kulma][p1]);//-(int(pallo[0][kulma][p1]/360)*360);
	if (pallo[0][kulma][p1]<0) pallo[0][kulma][p1]=360+pallo[0][kulma][p1];
	pallo[0][x][p1]+=sin(pallo[0][kulma][p1]/(180/3.14159265))*vauhti;
	pallo[0][y][p1]+=cos(pallo[0][kulma][p1]/(180/3.14159265))*vauhti;

	//p2
	if (pituus[p2]>0){
		if (kaksinpeli==1){
			//näppäimistösyötteet
			if (key[SDLK_a]) pallo[0][kulma][p2]+=5;
			if (key[SDLK_d]) pallo[0][kulma][p2]-=5;
			if (key[SDLK_w]) vauhti2-=kiihtyvyys;
			if (key[SDLK_s]) vauhti2+=kiihtyvyys;
		
			pallo[0][kulma][p2] = prt(pallo[0][kulma][p2]);
			if (pallo[0][kulma][p2]<0) pallo[0][kulma][p2]=360+pallo[0][kulma][p2];
			pallo[0][x][p2]+=sin(pallo[0][kulma][p2]/(180/3.14159265))*vauhti2;
			pallo[0][y][p2]+=cos(pallo[0][kulma][p2]/(180/3.14159265))*vauhti2;
	
		}
		else {
			pallo[0][kulmato][p2] = kulmaf(int(pallo[0][x][p2]+(screen_leveys/2)),int(pallo[0][y][p2]+(screen_korkeus/2)),wp[wayp2][x],wp[wayp2][y])+180;
		
			if (distance(int(pallo[0][x][p2]+(screen_leveys/2)),int(pallo[0][y][p2]+(screen_korkeus/2)),wp[wayp2][x], wp[wayp2][y])<50) wayp2++;
			if (wayp2>=wp_laskuri)wayp2=0;
			pallo[0][kulma][p2]=prt(pallo[0][kulma][p2]);
			kmuutos=int(prt(pallo[0][kulmato][p2])-pallo[0][kulma][p2]);
			if (prt(pallo[0][kulmato][p2]-pallo[0][kulma][p2]) > 10 ){
					if (kmuutos<0 && kmuutos > -180 ) pallo[0][kulma][p2]-=5;
					if (kmuutos>0 && kmuutos < 180 ) pallo[0][kulma][p2]+=5;
					if (kmuutos > 180 ) pallo[0][kulma][p2]-=5;
					if (kmuutos < -180 ) pallo[0][kulma][p2]+=5;
			}
			vauhti2-=kiihtyvyys2;
			pallo[0][x][p2]+=sin(prt(pallo[0][kulma][p2])/(180/3.14159265))*vauhti2;
			pallo[0][y][p2]+=cos(prt(pallo[0][kulma][p2])/(180/3.14159265))*vauhti2;
		}
	}
	
	if (pituus[p3]>0){
		pallo[0][kulmato][p3] = kulmaf(int(pallo[0][x][p3]+(screen_leveys/2)),int(pallo[0][y][p3]+(screen_korkeus/2)),wp[wayp3][x],wp[wayp3][y])+180;
	
		if (distance(int(pallo[0][x][p3]+(screen_leveys/2)),int(pallo[0][y][p3]+(screen_korkeus/2)),wp[wayp3][x], wp[wayp3][y])<50) wayp3++;
		if (wayp3>=wp_laskuri)wayp3=0;
		pallo[0][kulma][p3]=prt(pallo[0][kulma][p3]);
		kmuutos=int(prt(pallo[0][kulmato][p3])-pallo[0][kulma][p3]);
		if (prt(pallo[0][kulmato][p3]-pallo[0][kulma][p3]) > 10 ){
				if (kmuutos<0 && kmuutos > -180 ) pallo[0][kulma][p3]-=5;
				if (kmuutos>0 && kmuutos < 180 ) pallo[0][kulma][p3]+=5;
				if (kmuutos > 180 ) pallo[0][kulma][p3]-=5;
				if (kmuutos < -180 ) pallo[0][kulma][p3]+=5;
		}
		vauhti3-=kiihtyvyys3;
		pallo[0][x][p3]+=sin(prt(pallo[0][kulma][p3])/(180/3.14159265))*vauhti3;
		pallo[0][y][p3]+=cos(prt(pallo[0][kulma][p3])/(180/3.14159265))*vauhti3;
	}

	//kitka
	vauhti*=kitka;
	vauhti2*=kitka;
	vauhti3*=kitka;
	if (vauhti<0.5 && vauhti>0) vauhti=0;
	if (vauhti>-0.5 && vauhti<0) vauhti=0;
	
	camx=-int(pallo[0][x][p1]);
 	camy=-int(pallo[0][y][p1]);
	if (camx>0) camx=0;
	if (camy>0) camy=0;
	if (camx<-(50*leveys-screen_leveys)) camx=-(50*leveys-screen_leveys);
	if (camy<-(50*leveys-screen_korkeus)) camy=-(50*leveys-screen_korkeus);

	if (kaksinpeli==1){
		cam2x=-int(pallo[0][x][p2]);
		cam2y=-int(pallo[0][y][p2]);
		if (cam2x>0) cam2x=0;
		if (cam2y>0) cam2y=0;
		if (cam2x<-(50*leveys-screen_leveys)) cam2x=-(50*leveys-screen_leveys);
		if (cam2y<-(50*leveys-screen_korkeus)) cam2y=-(50*leveys-screen_korkeus);
	}

	for (m=0;m<3;m++){
		if (pallo[0][x][m] > (50*leveys)-(screen_leveys/2)) pallo[0][x][m]=(50*leveys)-(screen_leveys/2);
		if (pallo[0][y][m] > (50*leveys)-(screen_korkeus/2)) pallo[0][y][m]=(50*leveys)-(screen_korkeus/2);
		if (pallo[0][x][m] < -(screen_leveys/2)) pallo[0][x][m]=-(screen_leveys/2);
		if (pallo[0][y][m] < -(screen_korkeus/2)) pallo[0][y][m]=-(screen_korkeus/2);
	}

	tie_laskuri=0;

	for (i=0;i<leveys;i++)
	{
	for (k=0;k<leveys;k++)
	{	
		alue.x=i*50+camx;
		alue.y=k*50+camy;

		alueb.x=i*50+cam2x;
		alueb.y=k*50+cam2y;
		switch (level[i][k]){
			case 0:
				SDL_BlitSurface(nurmi, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(nurmi, NULL, screen2, &alueb);
				break;
			case 1:
				SDL_BlitSurface(kukka1, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(kukka1, NULL, screen2, &alueb);
				break;
			case 2:
				SDL_BlitSurface(kukka2, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(kukka2, NULL, screen2, &alueb);
				break;
			case 3:
				SDL_BlitSurface(kukka3, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(kukka3, NULL, screen2, &alueb);
				break;
			case 4:
				SDL_BlitSurface(kivi1, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(kivi1, NULL, screen2, &alueb);
				break;
			case 5:
				SDL_BlitSurface(kivi2, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(kivi2, NULL, screen2, &alueb);
				break;
			case 6:
				SDL_BlitSurface(tie1, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(tie1, NULL, screen2, &alueb);
				tie_laskuri++;
				break;
			case 7:
				SDL_BlitSurface(tie2, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(tie2, NULL, screen2, &alueb);
				tie_laskuri++;
				break;
			case 8:
				if (level[i+1][k+1]==8){
				SDL_BlitSurface(mutka1, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(mutka1, NULL, screen2, &alueb);
				tie_laskuri++;}
				break;
			case 9:
				if (level[i+1][k+1]==9){
				SDL_BlitSurface(mutka2, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(mutka2, NULL, screen2, &alueb);
				tie_laskuri++;}
				break;
			case 10:
				if (level[i+1][k+1]==10){
				SDL_BlitSurface(mutka3, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(mutka3, NULL, screen2, &alueb);
				tie_laskuri++;}
				break;
			case 11:
				if (level[i+1][k+1]==11){
				SDL_BlitSurface(mutka4, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(mutka4, NULL, screen2, &alueb);
				tie_laskuri++;}
				break;
			case 12:
				SDL_BlitSurface(maali, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(maali, NULL, screen2, &alueb);
				tie_laskuri++;
				break;
		}
		if (level[i][k]==1 || level[i][k]==2 || level[i][k]==3 || level[i][k]==4 || level[i][k]==5){
		
		for (t=0;t<pituus[p1];t++){
		if (int(pallo[t][x][p1]+(screen_leveys/2))>(i*50) && int(pallo[t][x][p1]+(screen_leveys/2))<((i*50)+50) && int(pallo[t][y][p1]+(screen_korkeus/2))>(k*50) && int(pallo[t][y][p1]+(screen_korkeus/2))<((k*50)+50) ){
			vauhti*=0.05;
		}
		}

		for (t=0;t<pituus[p2];t++){
		if (int(pallo[t][x][p2]+(screen_leveys/2))>(i*50) && int(pallo[t][x][p2]+(screen_leveys/2))<((i*50)+50) && int(pallo[t][y][p2]+(screen_korkeus/2))>(k*50) && int(pallo[t][y][p2]+(screen_korkeus/2))<((k*50)+50) ){
			vauhti2*=0.05;
		}
		}

		for (t=0;t<pituus[p3];t++){
		if (int(pallo[t][x][p3]+(screen_leveys/2))>(i*50) && int(pallo[t][x][p3]+(screen_leveys/2))<((i*50)+50) && int(pallo[t][y][p3]+(screen_korkeus/2))>(k*50) && int(pallo[t][y][p3]+(screen_korkeus/2))<((k*50)+50) ){
			vauhti3*=0.05;
		}
		}

		}
	}
	}
	for (m=0;m<3;m++){
	//maaliviiva
	if (pallo[0][x][m]+(screen_leveys/2) > maalix && pallo[0][x][m]+(screen_leveys/2) < maalix+100 && pallo[0][y][m]+(screen_korkeus/2) > maaliy && pallo[0][y][m]+(screen_korkeus/2) < maaliy+20){
		tmp_tmp=0;
		for(i=0;i<=chp_pituus;i++){
		if (tsek[i][m])tmp_tmp++;
		}
		if (tmp_tmp==chp_pituus){
			for(i=0;i<=chp_pituus;i++){
				tsek[i][m]=0;
			}
			kierros[m]++;
		}
	}
	for (i=0;i<pituus[m];i++){
		if (i>0 && distance(int(pallo[i][x][m]),int(pallo[i][y][m]), int(pallo[i-1][x][m]),int(pallo[i-1][y][m]))>27 ){
			pallo[i][kulma][m]= atan( ((pallo[i][x][m]-pallo[i-1][x][m])/(pallo[i][y][m]-pallo[i-1][y][m])) );
			pallo[i][kulma][m]*=(180/3.14159265);
			if (pallo[i][y][m] < pallo[i-1][y][m]) pallo[i][kulma][m]+=180;
			//pyöräytetään
			tmp_tmp=prt(pallo[i][kulma][m]);
			while (distance(int(pallo[i][x][m]),int(pallo[i][y][m]), int(pallo[i-1][x][m]),int(pallo[i-1][y][m]))>27){
				pallo[i][x][m]+=sin(tmp_tmp/(180/3.14159265))*-2;
				pallo[i][y][m]+=cos(tmp_tmp/(180/3.14159265))*-2;
			}
		}
		//törmäystarkistus itsensä kanssa
		for (n=0;n<3;n++){
		for (k=0;k<pituus[n];k++){
			if (k != i || m!=n ){
			if (distance(int(pallo[k][x][n]),int(pallo[k][y][n]), int(pallo[i][x][m]),int(pallo[i][y][m]))<25){
				tmp_tmp= int(atan( ((pallo[k][x][n]-pallo[i][x][m])/(pallo[k][y][n]-pallo[i][y][m])) )*(180/3.14159265));
				if (pallo[k][y][n] < pallo[i][y][m]) tmp_tmp+=180;
				if (distance(int(pallo[k][x][n]),int(pallo[k][y][n]), int(pallo[i][x][m]),int(pallo[i][y][m]))<24){
					pallo[k][x][n]+=sin(tmp_tmp/(180/3.14159265))*3;
					pallo[k][y][n]+=cos(tmp_tmp/(180/3.14159265))*3;
				}
			}}
		}
		}

		alue.x=screen_leveys/2+int(camx+pallo[i][x][m])-13;
		alue.y=screen_korkeus/2+int(camy+pallo[i][y][m])-13;
		alueb.x=screen_leveys/2+int(cam2x+pallo[i][x][m])-13;
		alueb.y=screen_korkeus/2+int(cam2y+pallo[i][y][m])-13;

		if (int (pallo[i][kulma][m])>=0 && int (pallo[i][kulma][m])<360){
			if (pallo[i][tyyppi][m]==0)SDL_BlitSurface(pallura[int(pallo[i][kulma][m])], NULL, screen, &alue);
			if (pallo[i][tyyppi][m]==1)SDL_BlitSurface(pallura2[int(pallo[i][kulma][m])], NULL, screen, &alue);
			if (pallo[i][tyyppi][m]==2)SDL_BlitSurface(pallura3[int(pallo[i][kulma][m])], NULL, screen, &alue);
			if (pallo[i][tyyppi][m]==3)SDL_BlitSurface(pallura4[int(pallo[i][kulma][m])], NULL, screen, &alue);

			if (kaksinpeli==1){
				if (pallo[i][tyyppi][m]==0)SDL_BlitSurface(pallura[int(pallo[i][kulma][m])], NULL, screen2, &alueb);
				if (pallo[i][tyyppi][m]==1)SDL_BlitSurface(pallura2[int(pallo[i][kulma][m])], NULL, screen2, &alueb);
				if (pallo[i][tyyppi][m]==2)SDL_BlitSurface(pallura3[int(pallo[i][kulma][m])], NULL, screen2, &alueb);
				if (pallo[i][tyyppi][m]==3)SDL_BlitSurface(pallura4[int(pallo[i][kulma][m])], NULL, screen2, &alueb);
			}
		}
		else{
			//pyöräytys
			tmp_tmp = prt(int(pallo[i][kulma][m]));

			if (pallo[i][tyyppi][m]==0)SDL_BlitSurface(pallura[tmp_tmp], NULL, screen, &alue);
			if (pallo[i][tyyppi][m]==1)SDL_BlitSurface(pallura2[tmp_tmp], NULL, screen, &alue);
			if (pallo[i][tyyppi][m]==2)SDL_BlitSurface(pallura3[tmp_tmp], NULL, screen, &alue);
			if (pallo[i][tyyppi][m]==3)SDL_BlitSurface(pallura4[tmp_tmp], NULL, screen, &alue);

			if (kaksinpeli==1){
				if (pallo[i][tyyppi][m]==0)SDL_BlitSurface(pallura[tmp_tmp], NULL, screen2, &alueb);
				if (pallo[i][tyyppi][m]==1)SDL_BlitSurface(pallura2[tmp_tmp], NULL, screen2, &alueb);
				if (pallo[i][tyyppi][m]==2)SDL_BlitSurface(pallura3[tmp_tmp], NULL, screen2, &alueb);
				if (pallo[i][tyyppi][m]==3)SDL_BlitSurface(pallura4[tmp_tmp], NULL, screen2, &alueb);
			}
		}
	}
	}

	//Donitsit
	for(i=0;i<chp_pituus;i++){
		if (chp[i][2]<30){
			alue.x=int(chp[i][x]+camx+5);
			alue.y=int(chp[i][y]+camy+5);
			alueb.x=int(chp[i][x]+cam2x+5);
			alueb.y=int(chp[i][y]+cam2y+5);
			if (chp[i][2]){
				SDL_BlitSurface(donut2, NULL, screen, &alue);chp[i][2]=0;
				if (kaksinpeli==1) SDL_BlitSurface(donut2, NULL, screen2, &alueb);
			}
			else {
				SDL_BlitSurface(donut, NULL, screen, &alue);
				if (kaksinpeli==1) SDL_BlitSurface(donut, NULL, screen2, &alueb);
			}
		}
		for(m=0;m<3;m++){
			if (distance(int(pallo[0][x][m]+(screen_leveys/2)),int(pallo[0][y][m]+(screen_korkeus/2)),chp[i][x]+50,chp[i][y]+50)<55){
			chp[i][2]=1;
			tsek[i][m]=1;}
		}
	}

	//Blitataan palkki
	alue.x=10;
	alue.y=10;
	SDL_BlitSurface(palkki, NULL, screen, &alue);

		//renderöidään teksti
		snprintf(bfr, 50, "Lap: %d", kierros[0]);
		text(screen, 15,13, bfr, fontti);
		snprintf(bfr, 50, "/%d", laps);
		text(screen, 85,13, bfr, fontti);
	if (kaksinpeli==1){
		alue.x=10;
		alue.y=10;
		SDL_BlitSurface(palkki, NULL, screen2, &alue);
	}
	if (kaksinpeli==1){
		alue.x=screen_leveys;
		alue.y=0;
		SDL_BlitSurface(screen2, NULL, screen, &alue);
		lineRGBA(screen, screen_leveys,screen_korkeus,screen_leveys,0, 0,0,0,255);
		snprintf(bfr, 50, "Lap: %d", kierros[1]);
		text(screen, 15+screen_leveys,13, bfr, fontti);
		snprintf(bfr, 50, "/%d", laps);
		text(screen, 85+screen_leveys,13, bfr, fontti);
	}

	//Lähtölaskenta----------------------->
	if ((SDL_GetTicks()-lahto) < 4000){
		alue.x=0;
		alue.y=0;
		SDL_BlitSurface(screen, NULL, scr, &alue);
	}
	while ((SDL_GetTicks()-lahto) < 4000)
	{
		fps=FPS();
		SDL_FillRect(screen, NULL, 0);

		SDL_BlitSurface(scr, NULL, screen, &alue);
		
		boxRGBA(screen, 0,0,screen_leveys*2,screen_korkeus, 0,0,0,125);
		if (kaksinpeli==1)tmp_tmp=370;
		else tmp_tmp=230;
		if (SDL_GetTicks()-lahto<1000) text2(screen, tmp_tmp,240, " 3", fontti2);
		if (SDL_GetTicks()-lahto>=1000 && SDL_GetTicks()-lahto<2000 ) text2(screen, tmp_tmp,240, " 2", fontti2);
		if (SDL_GetTicks()-lahto>=2000 && SDL_GetTicks()-lahto<3000 ) text2(screen, tmp_tmp,240, " 1", fontti2);
		if (SDL_GetTicks()-lahto>=3000 && SDL_GetTicks()-lahto<4000 ) text2(screen, tmp_tmp,240, "GO!", fontti2);
		
		SDL_Flip(screen);
		//Lopetus
		while(SDL_PollEvent(&event))
		{
			if (event.type==SDL_QUIT) {run=0;lahto=SDL_GetTicks()+4000;}
			if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_ESCAPE) {run=1;lahto=SDL_GetTicks()+4000;SDL_SetVideoMode(500,500,32, SDL_HWSURFACE|SDL_DOUBLEBUF);}
		}
		wait=10-(SDL_GetTicks()-fps_asdf);
		if (wait>0) SDL_Delay(wait);
	}
	//Lähtölaskenta----------------------->
	//pause----------------------->
	if (key[SDLK_LCTRL] || key[SDLK_RCTRL]){
		while(SDL_PollEvent(&event))
		{
			if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_p) {
				alue.x=0;
				alue.y=0;
				SDL_BlitSurface(screen, NULL, scr, &alue);
				pause=1;
			}
		}
	}
	while (pause)
	{
		fps=FPS();
		SDL_FillRect(screen, NULL, 0);
		SDL_BlitSurface(scr, NULL, screen, &alue);
		
		boxRGBA(screen, 0,0,screen_leveys*2,screen_korkeus, 0,0,0,125);
		if (kaksinpeli==1)tmp_tmp=390;
		else tmp_tmp=240;
		text2(screen, tmp_tmp-50,240, "Pause", fontti2);
		text(screen, tmp_tmp-40,280, "p to continue", fontti);
		
		SDL_Flip(screen);
		//Lopetus
		while(SDL_PollEvent(&event))
		{
			if (event.type==SDL_QUIT) {run=0;pause=0;}
			if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_ESCAPE) {pause=0;}
			if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_p)pause=0;
		}

		wait=10-(SDL_GetTicks()-fps_asdf);
		if (wait>0) SDL_Delay(wait);
	}
	//pause----------------------->
	//voittaja-------------------->

	if (kierros[0]>=laps && voittaja==0)voittaja=1;
	if (kierros[1]>=laps && voittaja==0)voittaja=2;
	if (kierros[2]>=laps && voittaja==0)voittaja=3;

	osallistujia=0;
	if (pituus[0]>0) osallistujia++;
	if (pituus[1]>0) osallistujia++;
	if (pituus[2]>0) osallistujia++;
	tmp_tmp=0;
	if (kierros[0]>=laps) tmp_tmp++;
	if (kierros[1]>=laps) tmp_tmp++;
	if (kierros[2]>=laps) tmp_tmp++;

	if(tmp_tmp>=osallistujia){
		alue.x=0;
		alue.y=0;
		SDL_BlitSurface(screen, NULL, scr, &alue);
	}

	while(tmp_tmp>=osallistujia){
		fps=FPS();
		SDL_FillRect(screen, NULL, 0);
		SDL_BlitSurface(scr, NULL, screen, &alue);
		
		boxRGBA(screen, 0,0,screen_leveys*2,screen_korkeus, 0,0,0,125);

		nappula (screen, 180,150, "Level:", valinta, 0, fontti);
		nappula (screen, 180,180, "Ok", valinta, 1, fontti);
		nappula (screen, 180,210, "Menu", valinta, 2, fontti);

		textv(screen, 230,153, nimi[level_valinta], fontti);

		if (voittaja==1) text2 (screen, 125,50, "Player 1 won!" ,fontti2);
		if (voittaja==2) text2 (screen, 125,50, "Player 2 won!" ,fontti2);
		if (voittaja==3) text2 (screen, 125,50, "Player 3 won!" ,fontti2);
	
		SDL_Flip(screen);
	
		//Lopetus
		while(SDL_PollEvent(&event))
		{
			if (event.type==SDL_QUIT) run=0;
			if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_ESCAPE){run=1;SDL_SetVideoMode(500,500,32, SDL_HWSURFACE|SDL_DOUBLEBUF);tmp_tmp=0;}
			if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_UP)valinta--;
			if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_DOWN)valinta++;
			if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_RETURN){
				if (valinta==1){run=5;tmp_tmp=0;}
				if (valinta==2){run=1;SDL_SetVideoMode(500,500,32, SDL_HWSURFACE|SDL_DOUBLEBUF);tmp_tmp=0;}
			}
			if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_LEFT){
				if (valinta==0)level_valinta--;
			}
			if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_RIGHT){
				if (valinta==0)level_valinta++;
			}
		}
	
		if (valinta>2)valinta=0;
		if (valinta<0)valinta=2;
	
		if (laps<0)laps=0;
	
		if (level_valinta>levels)level_valinta=0;
		if (level_valinta<0)level_valinta=levels;
	
		SDL_Delay(10);
		wait=10-(SDL_GetTicks()-fps_asdf);
		if (wait>0) SDL_Delay(wait);
	}
	//voittaja-------------------->

	//Lopetus
	while(SDL_PollEvent(&event))
	{
		if (event.type==SDL_QUIT) run=0;
		if (event.type==SDL_KEYDOWN && event.key.keysym.sym== SDLK_ESCAPE){run=1;SDL_SetVideoMode(500,500,32, SDL_HWSURFACE|SDL_DOUBLEBUF);}
	}

	wait=20-(SDL_GetTicks()-fps_asdf);
	if (wait>0) SDL_Delay(wait);

	SDL_Flip(screen);
}

if (run==5){
	screen_leveys=500;
	if (kaksinpeli==1){screen_leveys=400;}
	screen_korkeus=500;
	
	if (kaksinpeli==1)SDL_SetVideoMode(screen_leveys*2,screen_korkeus,32, SDL_HWSURFACE|SDL_DOUBLEBUF);
	else SDL_SetVideoMode(screen_leveys,screen_korkeus,32, SDL_HWSURFACE|SDL_DOUBLEBUF);
	
	for (i=0;i<3;i++){
		kierros[i]=0;
		for (k=0;k<500;k++){
			tsek[k][i]=0;
		}
	}
	if (kaksinpeli==1){
		kiihtyvyys2=kiihtyvyys;
	}
	
	for (i=0;i<50;i++){
		bfr[i]=0;
	}

	strcat(bfr, "filut/levelit/");
	strcat(bfr, nimi[level_valinta]);
	strcat(bfr, ".txt");

	inFile.open(bfr);
	
	//kentän leveys 4 ekaa numeroa.
	ax=0;
	for (i=0;i<=3;i++)
	{
		inFile >> ax;
		tmp_leveys[i]=ax;
	}
	
	leveysb=atoi(tmp_leveys);
	
	if (leveysb>50){
		for (i=0;i<20;i++){
			leveysb=atoi(tmp_leveys);
			if (leveysb<=50) break;
			cout << "Leveys # :" << leveysb <<"\n";
		}
	}
	
	leveys=leveysb;
	
	for (k=0;k<leveys+1;k++){
	for (i=0;i<leveys+1;i++){
	level[i][k]=0;
	}}
	
	voittaja=0;
	pointer=0;
	pointer2=0;
	tieta=0;
	tieta2=0;
	voittaja=0;
	while (inFile >> ax) {
		switch (ax){
			case 'x':
				level[pointer][pointer2]=rand()%3+1;
				if ((rand()%3+1)==1)level[pointer][pointer2]=rand()%5+1;
				break;
			case '=':
				level[pointer][pointer2]=6;
				tieta++;tieta2++;break;
			case 'T':
				level[pointer][pointer2]=7;
				tieta++;tieta2++;break;
			case '1':
				level[pointer][pointer2]=8;tieta2++;break;
			case '2':
				level[pointer][pointer2]=9;tieta2++;break;
			case '3':
				level[pointer][pointer2]=10;tieta2++;break;
			case '4':
				level[pointer][pointer2]=11;tieta2++;break;
			case 'M':
				level[pointer][pointer2]=12;maalix=pointer*50;maaliy=pointer2*50;tieta2++;break;
			case '.':
				level[pointer][pointer2]=0;break;
			case '#':
				level[pointer][pointer2]=999;break;
		}
	
		pointer++;
		if (pointer>leveys-1){pointer2++;pointer=0;}
	}
	
	inFile.close();

	for (i=0;i<1000;i++){
		wp[i][0]=5000;
		wp[i][1]=5000;
	}

	for (i=0;i<50;i++){
		chp[i][0]=0;
		chp[i][1]=0;
		chp[i][2]=0;
	}

	suunta=3;
	mato_x=int(maalix/50);
	mato_y=int(maaliy/50);
	mato_matka=0;
	
	way=tieta2;
	wayp2=0;
	wayp3=0;
	
	antibug=0;
	
	tie_laskuri=0;
	wp_laskuri=0;
	chp_pituus=0;
	while(mato_matka<tieta){
	
		if (level[mato_x][mato_y]==12){maalix=mato_x*50;maaliy=mato_y*50;}
	
		if (level[mato_x][mato_y]==8 && level[mato_x+1][mato_y+1]==8 && suunta==3) suunta=0;
		if (level[mato_x][mato_y]==8 && level[mato_x+1][mato_y+1]==8 && suunta==2) suunta=1;
		if (level[mato_x][mato_y]==9 && level[mato_x+1][mato_y+1]==9 && suunta==0) suunta=1;
		if (level[mato_x][mato_y]==9 && level[mato_x+1][mato_y+1]==9 && suunta==3) suunta=2;
		if (level[mato_x][mato_y]==10 && level[mato_x+1][mato_y+1]==10 && suunta==1) suunta=2;
		if (level[mato_x][mato_y]==10 && level[mato_x+1][mato_y+1]==10 && suunta==0) suunta=3;
		if (level[mato_x][mato_y]==11 && level[mato_x+1][mato_y+1]==11 && suunta==1) suunta=0;
		if (level[mato_x][mato_y]==11 && level[mato_x+1][mato_y+1]==11 && suunta==2) suunta=3;
	
		if (level[mato_x][mato_y]>=6 && level[mato_x][mato_y]<=12 ){
			//waypointit
			wp[wp_laskuri][x]=(mato_x*50)+50;
			wp[wp_laskuri][y]=(mato_y*50)+50;
			wp_laskuri++;
		}
	
		if (level[mato_x][mato_y]>=6 && level[mato_x][mato_y]<=7){
			if (tie_laskuri>=10) {chp[chp_pituus][x]=mato_x*50;chp[chp_pituus][y]=mato_y*50;chp_pituus++;tie_laskuri=0;chp[chp_pituus][2]=0;}
			tie_laskuri++;
			mato_matka++;
		}
	
			if (suunta==0) mato_x++;
			if (suunta==1) mato_y++;
			if (suunta==2) mato_x--;
			if (suunta==3) mato_y--;
		if (mato_x>leveys-1) {mato_x=0;mato_y++;}
		if (mato_x<0) mato_x=0;
		if (mato_y<0) mato_y=0;
		if (mato_y>leveys-1) mato_y=leveys-1;
	
		antibug++;
		if (antibug>(leveys*leveys))break;
	}
	
	//asetetaan pallurat siisteihin riveihin maaliviivalle ja arvotaan värit
	for (m=0;m<3;m++){
	for (i=0;i<pituus[m];i++){
		pallo[i][tyyppi][m]=int((rand()%4000)/1000);
		pallo[i][x][m]=maalix+23+(m*27)-screen_leveys/2;
		pallo[i][y][m]=maaliy+35+(i*27)-screen_korkeus/2;
		pallo[i][kulma][m]=0;
	}
	}
	
	lahto=SDL_GetTicks();

	run=2;
}

//-->run loppuu
}

SDL_FreeSurface(screen2);
SDL_FreeSurface(scr);

for (i=0;i<360;i++)
{
SDL_FreeSurface(pallura[i]);
}
for (i=0;i<360;i++)
{
SDL_FreeSurface(pallura2[i]);
}
for (i=0;i<360;i++)
{
SDL_FreeSurface(pallura3[i]);
}
for (i=0;i<360;i++)
{
SDL_FreeSurface(pallura4[i]);
}

SDL_FreeSurface(nurmi);
SDL_FreeSurface(kukka1);
SDL_FreeSurface(kukka2);
SDL_FreeSurface(kukka3);
SDL_FreeSurface(kivi1);
SDL_FreeSurface(kivi2);

SDL_FreeSurface(tie1);
SDL_FreeSurface(tie2);

SDL_FreeSurface(mutka1);
SDL_FreeSurface(mutka2);
SDL_FreeSurface(mutka3);
SDL_FreeSurface(mutka4);

SDL_FreeSurface(palkki);
SDL_FreeSurface(maali);

SDL_FreeSurface(donut);
SDL_FreeSurface(donut2);

//vapautetaan musiikki
Mix_FreeChunk(music);
music = NULL;

SDL_Quit();

return EXIT_SUCCESS;
}
//funktiot
int FPS(void)
{
float fp=1000/(SDL_GetTicks()-fps_asdf);
fps_asdf=SDL_GetTicks();
return int(fp);
}

float absf(float a)
{
if (a<0)a*=-1;
return a;
}

int distance(int x1, int y1, int x2, int y2)
{
return abs(int(sqrt(pow(abs(x1-x2),2)+pow(abs(y1-y2),2))));
}

int prt(int kulma)
{
if (kulma < -360) kulma = kulma-(int(kulma/360)*360);
if (kulma < 0) kulma=(360+kulma);
kulma= kulma-(int(kulma/360)*360);
return kulma;
}

int prt(double kulma)
{
return prt(int (kulma));
}

int kulmaf(int x, int y, int x2, int y2)
{
if (x-x2!=0 && y-y2!=0) return int(atan2( (x-x2),(y-y2) )*(180/3.14159265))+180;
else return 180;
}
