import java.awt.*;
import java.applet.Applet;
import java.io.*;


public class Applet1 extends Applet implements Runnable
{
	Image buffer;
	Graphics bufferg;
	Thread main;
	
	
	Image back, mtns, drift;					// background images
	Image skb, skbFAKIE, skbSIDE, skbJump;		// skiboarder image
	Image skbLandForward, skbLandFakie;
	Image skbTrick[][] = new Image[8][5];
	Image controls;								// control board image
	
	Image trickObjects[] = new Image[2];		// trick objects
	String trickObjectType[] = new String[2];	// trick object type
	int trickObjectX = 5000;					// trick object pos.
	int trickObjectIndex = 0;					// the trick object array index
	
	
	String stance = "forward";					// sprite data
	String skbName = "kirk";					// more...
	String skbMode = "riding";					// riding, jumping, grinding...
	String gameMode = "intro";					// mode set
		
	String trickNames[] = new String[8];		// trick names
    int trickDifficulty[] = new int[8];			// trick diff. (20 = easy, 5 = impossible)
	boolean trickFakie[] = new boolean[8];		// is it fakie?
    String trickType[] = new String[8];			// grinding or jumping
	String endStance[] = new String[8];
	int trickPoints[] =  new int[8];
	
    int mtnx = 0, drftx = 0;					// image loop ints
	int sideCount = 0;							// sideways ticks
	int skbx = 75, skby = 120;					// skiboarder's position
	int checked = 1, checkx = 112, checky = 382;	//the trick boxes...
	int skbHeight = 0, skbV =0;					// the height of the skiboarder
	int skbPoints = 0;							// lets think here...
	int trickStage = 0, jumpH = 0;				// stage of the trick...
	
	int focusCount = 0;							// hmm...
	int focusX = 0, focusY = 0;					// where the target is...
	boolean focusLanded = false;				// focus meter work...
	
	
    public void init()
	{       
		main=new Thread(this);
        main.start();
        
        buffer=createImage(getSize().width,getSize().height);
        
		bufferg=buffer.getGraphics();
		
		back = getImage(getCodeBase(), "sprites\\sky2.jpg");
		mtns = getImage(getCodeBase(), "sprites\\mtns.gif");
		drift = getImage(getCodeBase(), "sprites\\drift.gif");
		controls = getImage(getCodeBase(), "sprites\\controls.gif");
	
		trickObjects[0] = getImage(getCodeBase(), "sprites\\objects\\rail.gif");
		trickObjects[1] = getImage(getCodeBase(), "sprites\\objects\\jump.gif");
		
		trickObjectType[0] = "grinding";
		trickObjectType[1] = "jumping";
		
		skb = getImage(getCodeBase(), "sprites\\" + skbName + "\\forward.gif");
		skbFAKIE = getImage(getCodeBase(), "sprites\\" + skbName + "\\fakie.gif");
		skbSIDE = getImage(getCodeBase(), "sprites\\" + skbName + "\\side.gif");
		skbJump = getImage(getCodeBase(), "sprites\\" + skbName + "\\jump1.gif");
		skbLandForward = getImage(getCodeBase(), "sprites\\" + skbName + "\\lforward.gif");
		skbLandFakie = getImage(getCodeBase(), "sprites\\" + skbName + "\\lfakie.gif");
		
		initTrickImages();
		
		loadTrickNames();
	}

	public void initTrickImages()
	{
		for(int tck = 0; tck < 1; tck++)
		{
			for(int i = 0; i <5; i++)
			{
				skbTrick[tck][i] = getImage(getCodeBase(), "sprites\\" + skbName + "\\t" + Integer.toString(tck+1) + "\\img" + Integer.toString(i+1) + ".gif");
			}
		}
		
		for(int tck = 4; tck < 8; tck++)
		{
			for(int i = 0; i <5; i++)
			{
				skbTrick[tck][i] = getImage(getCodeBase(), "sprites\\" + skbName + "\\t" + Integer.toString(tck+1) + "\\img" + Integer.toString(i+1) + ".gif");
			}
		}
	}
	
	
    public void run()
	{
		try{Thread.sleep(15000);}catch(Exception e){}
	
		gameMode = "game";
		
		repaint();
		
		try{Thread.sleep(5000);}catch(Exception e){}
		
        while(main!=null)
		{
            try
			{
                Thread.sleep(50);
            }
            catch(Exception e){}
            
		    repaint();
            
			/////animate background//////////////
            mtnx--;
			if(mtnx == -640) mtnx = 0;
			
			drftx -= 10;
			if(drftx == -640) drftx = 0;
			/////////////////////////////////////
			
			/////rider's random err//////////////
			if(skbMode == "riding")
			{
				skbx += (Math.random() * 3)-1;
				if(skbx < 70)skbx = 70;
				if(skbx > 80)skbx = 80;
			
				skby += (Math.random() * 3)-1;
				if(skby < 115) skby = 115;
				if(skby > 125) skby = 125;
			}
			/////////////////////////////////////
        
			//////// Gravity with jumping.../////
			if(skbV > 0 || skbHeight != 0)
			{
				skbHeight += skbV;
				skbV -= 2;
				if(skbHeight == 0) skbV =0;
			}
			/////////////////////////////////////
			
			/////////// Trick Object Motion	/////
			
			if(trickObjectX >= 5000)
				trickObjectX++;
			
			if(trickObjectX >= 5025)
				initTrickObject();
			
			if(trickObjectX < 1000)
				trickObjectX -= 10;
			
			if(trickObjectX < -800)
				trickObjectX = 5000;
			
			///////// Doing Tricks //////////////
			if(trickObjectX == 120)
				startTrick();
			/////////////////////////////////////
			
			///////// Focus Deal ////////////////
			if(focusCount > 0)
				focusCount--;
			
			if(trickObjectX == 300)
				beginFocus();
			/////////////////////////////////////
		}
    }
    
	
    public void stop()
	{
        if(main!=null){main.stop();}
    }
    
	
    public void paint(Graphics g)
	{
		update(g);
    }
	
	
    public void update(Graphics g)
	{	
		if(gameMode == "intro")
			drawIntro();
		else if(gameMode == "game")
			drawGame();
		
		g.drawImage(buffer,0,0,this);
    }
	
	
	public void drawIntro()
	{
		bufferg.drawImage(back, 0, 0, this);
		bufferg.drawImage(mtns,0, 0,this);
		bufferg.drawImage(drift, 0, 0, this);
		bufferg.drawImage(controls, 300, 0, this);
		
		bufferg.fillRect(1, 1, 640, 480);
		
		bufferg.drawImage(skb, 0, 0, this);
		bufferg.drawImage(skbJump, 0, 0, this);
		bufferg.drawImage(skbSIDE, 200, 0, this);
		bufferg.drawImage(skbFAKIE, 400, 0, this);
		bufferg.drawImage(skbLandFakie, 400, 0, this);
		bufferg.drawImage(skbLandForward, 400, 0, this);
		
		for(int i = 1; i >=0; i--)
			bufferg.drawImage(trickObjects[i], 0, 300, this);

		for(int tck = 0; tck < 1; tck++)
		{
			for(int i = 0; i < 5; i++)
			{
				bufferg.drawImage(skbTrick[tck][i], 0 + 100*i, 100, this);
			}
		}
				
		for(int tck = 4; tck < 8; tck++)
		{
			for(int i = 0; i < 5; i++)
			{
				bufferg.drawImage(skbTrick[tck][i], 0 + 100*i, 100, this);
			}
		}
	
		
		bufferg.setColor(Color.black);
		bufferg.drawString("Loading..." + trickNames[0], 280,20);
		bufferg.setColor(Color.gray);
	}
	
	public void drawGame()
	{
		bufferg.setColor(Color.black);
		
        bufferg.fillRect(0,0,getSize().width,getSize().height);
		
		/////////////////Draw backgrouds///////////////////
		bufferg.drawImage(back, 0,0,this);
		
		bufferg.drawImage(mtns, mtnx, skbHeight/5, this);
		bufferg.drawImage(mtns, mtnx + 640, skbHeight/5, this);
		
		bufferg.drawImage(drift, drftx, skbHeight, this);
		bufferg.drawImage(drift, drftx + 640, skbHeight, this);
		///////////////////////////////////////////////////
		
		/////////////////Draw Trick Object/////////////////
		
		if(trickObjectX < 1000)
		{
			bufferg.drawImage(trickObjects[trickObjectIndex], trickObjectX, skbHeight + 200, this);
		}
		
		
		/////////////////Draw Skiboarder///////////////////
		if(skbMode == "riding")
		{
			if(sideCount > 0)
			{
				bufferg.drawImage(skbSIDE, skbx, skby, this);
				sideCount--;
			}
			else if(stance == "forward")
				bufferg.drawImage(skb, skbx, skby, this);
			else
				bufferg.drawImage(skbFAKIE, skbx, skby, this);
		}
		else if(skbMode == "grinding")
		{
			if(trickStage == 1)
			{
				bufferg.drawImage(skbTrick[checked-1][0], skbx, 15-jumpH, this);
				jumpH+=3;
				if(trickObjectX <= 0) trickStage = 2;
			}
			else if(trickStage == 2)
			{
				bufferg.drawImage(skbTrick[checked-1][1], skbx, 0 - jumpH, this);
				jumpH += (trickObjectX+50)/10;
				if(trickObjectX <= -50) trickStage = 3;
			}
			else if(trickStage == 3)
			{
				bufferg.drawImage(skbTrick[checked-1][2], skbx, 0-jumpH, this);
				jumpH += (trickObjectX+50)/10;
				if(trickObjectX <= -100) 
				{
					trickStage = 4;
					jumpH = 0;
				}
			}
			else if(trickStage == 4)
			{
				bufferg.drawImage(skbTrick[checked-1][3], skbx, 0, this);
				if(trickObjectX <= -500) trickStage = 5;
			}
			else if(trickStage == 5)
			{
				bufferg.drawImage(skbTrick[checked-1][4], skbx, jumpH, this);
				jumpH += 4;
				if(trickObjectX <= -600) 
				{
					trickStage = 0;
					skbMode = "riding";
					stance = endStance[checked-1];
					focusLanded = false;
				}
			}
		}
		else if(skbMode == "jumping")
		{
			if(trickStage == 1)
			{
				bufferg.drawImage(skbJump, skbx, 15-jumpH, this);
				jumpH+=3;
				if(trickObjectX <= 30) trickStage = 2;
			}
			else if(trickStage == 2)
			{
				bufferg.drawImage(skbTrick[checked-1][0], skbx-20, -jumpH, this);
				jumpH+=10;
				if(trickObjectX <= -50)
				{
					trickStage = 3;
					jump();
				}
			}
			else if(trickStage == 3)
			{
				bufferg.drawImage(skbTrick[checked-1][1], skbx, 15-jumpH, this);

				if(trickObjectX <= -125) trickStage = 4;
			}
			else if(trickStage == 4)
			{
				bufferg.drawImage(skbTrick[checked-1][2], skbx, 15-jumpH, this);

				if(trickObjectX <= -200) trickStage = 5;
			}
			else if(trickStage == 5)
			{
				bufferg.drawImage(skbTrick[checked-1][3], skbx, 15-jumpH, this);

				if(trickObjectX <= -275) trickStage = 6;
			}
			else if(trickStage == 6)
			{
				bufferg.drawImage(skbTrick[checked-1][4], skbx, 15-jumpH, this);

				if(trickObjectX <= -340) trickStage = 7;
			}
			else if (trickStage == 7)
			{
				if(endStance[checked-1] == "forward")
					bufferg.drawImage(skbLandForward, skbx, 45-jumpH, this);
				else
					bufferg.drawImage(skbLandFakie, skbx, 45-jumpH, this);
				
				if(jumpH>5)	jumpH -= 5;
				
				if(trickObjectX <= -550) 
				{
					trickStage = 0;
					skbMode = "riding";
					stance = endStance[checked-1];
					focusLanded = false;
				}
			}
		}
		///////////////////////////////////////////////////
  
		
		////////////// Controls Output ////////////////////
		bufferg.drawImage(controls, 0, 360, this);
		
		for(int i = 0; i < 8; i++)
			bufferg.drawString(trickNames[i], 127 + (i/4) * 144, 391 + (21 * i) - (i/4)*84);
		
		bufferg.drawString(Integer.toString(skbPoints), 20, 400);
		
		bufferg.setColor(Color.red);
		bufferg.fillRect(checkx, checky, 11, 11);
		
		bufferg.drawString(String.valueOf(focusLanded), 550, 380);
		///////////////////////////////////////////////////
		
		////////////// Focus Output ///////////////////////
		if(focusCount > 0)
		{
			bufferg.setColor(Color.blue);
			bufferg.fillRect(focusX, focusY, trickDifficulty[checked - 1], trickDifficulty[checked - 1]);
		}
		///////////////////////////////////////////////////
	}
	
	
	
	
	public boolean mouseDown(Event evt,int x,int y)
	{	
		if(x>=103 && x<=405 && y>=372 && y<=466 && skbMode == "riding")
			trickCheck(x, y);
		else if(x>=12 && x <=100 && y>=372 && y <= 466 && skbMode == "riding")
			revert();
		else if(y <=100) 
			jump();	
		else if(x>=416 && x <= 528 && y >=395 && y <= 459)
			/*if(focusCount == 0)
				beginFocus();
			else*/ if(x>= focusX && x <= (focusX + trickDifficulty[checked-1]) &&
					y>= focusY && y <= (focusY + trickDifficulty[checked-1]))
				initTrick();
					
		return true;
	}
	
	public void revert()
	{
		sideCount = 3;
		
		if(stance == "forward")
			stance = "fakie";
		else
			stance = "forward";
	}
	
	public void jump()
	{
		if(skbHeight == 0)
			skbV = 28;
	}
	
	public void beginFocus()
	{
		focusCount = 13;
		focusLanded = false;
		focusX = (int)(416 + Math.random() * (112 - trickDifficulty[checked - 1]));
		focusY = (int)(395 + Math.random() * (64 - trickDifficulty[checked - 1]));
	}
	
	//// Makes sure trick is in proper stance (forward/fakie)//
	public void initTrick()
	{
		if(trickFakie[checked-1] && stance == "fakie" ||
		   !trickFakie[checked-1] && stance == "forward")
		{
			focusLanded = true;
			focusCount = 0;
		}
	}
	////////////////////////////////////////////////////////////
	
	
	//  Checks the box of the trick selected w/ coordinates//
	public void trickCheck(int x, int y)
	{
		if(x>=111 && x<=123)
		{
			if(y>=381 && y<=393)
			{
				checked = 1;
				checkx = 112;
				checky = 382;
			}
			else if(y>=402 && y<=414)
			{
				checked = 2;
				checkx = 112;
				checky = 403;
			}
			else if(y>=423 && y<=435)
			{
				checked = 3;
				checkx = 112;
				checky = 424;
			}
			else if(y>=444 && y <=456)
			{
				checked = 4;
				checkx = 112;
				checky = 445;
			}
		}
		else if(x >=255 & x <=267)
		{
			if(y>=381 && y<=393)
			{
				checked = 5;
				checkx = 256;
				checky = 382;
			}
			else if(y>=402 && y<=414)
			{
				checked = 6;
				checkx = 256;
				checky = 403;
			}
			else if(y>=423 && y<=435)
			{
				checked = 7;
				checkx = 256;
				checky = 424;
			}
			else if(y>=444 && y <=456)
			{
				checked = 8;
				checkx = 256;
				checky = 445;
			}
		}
	}
	/////////////////////////////////////////////////////
	
	
	//	Loads trick data for selected rider		//
	public void loadTrickNames()
	{
		if(skbName == "kirk")
		{
			trickNames[0] = "Safety 540";
			trickNames[1] = "Lui Kang Frontflip";
			trickNames[2] = "Fly Fish 180";
			trickNames[3] = "Fakie 540";
			trickNames[4] = "Backslide";
			trickNames[5] = "Lui Kang Disaster Frontside";
			trickNames[6] = "Fakie 270 Backside";
			trickNames[7] = "Kind Grind";
			
			trickDifficulty[0] = 12;
			trickDifficulty[1] = 7;
			trickDifficulty[2] = 20;
			trickDifficulty[3] = 15;
			trickDifficulty[4] = 15;
			trickDifficulty[5] = 20;
			trickDifficulty[6] = 10;
			trickDifficulty[7] = 5;
			
			trickPoints[0] = 1000;
			trickPoints[1] = 1500;
			trickPoints[2] = 500;
			trickPoints[3] = 800;
			trickPoints[4] = 800;
			trickPoints[5] = 500;
			trickPoints[6] = 1200;
			trickPoints[7] = 2000;
				
			trickFakie[0] = false;
			trickFakie[1] = false;
			trickFakie[2] = false;
			trickFakie[3] = true;
			trickFakie[4] = false;
			trickFakie[5] = false;
			trickFakie[6] = true;
			trickFakie[7] = false;
			
			trickType[0] = "jumping";
			trickType[1] = "jumping";
			trickType[2] = "jumping";
			trickType[3] = "jumping";
			trickType[4] = "grinding";
			trickType[5] = "grinding";
			trickType[6] = "grinding";
			trickType[7] = "grinding";
			
			endStance[0] = "fakie";
			endStance[1] = "forward";
			endStance[2] = "fakie";
			endStance[3] = "forward";
			endStance[4] = "fakie";
			endStance[5] = "forward";
			endStance[6] = "forward";
			endStance[7] = "fakie";
		}
	}
	/////////////////////////////////////////////////////
	
	
	//	determines what object will appear to trick on	//
	public void initTrickObject()
	{
		trickObjectIndex = (int)(Math.random() * 2);
		
		trickObjectX = 650;	
	}
	//////////////////////////////////////////////////////
		
	
	// starts the trick by initializing trick data	//
	public void startTrick()
	{
		if(focusLanded == true && trickType[checked-1] == trickObjectType[trickObjectIndex] && (checked > 4 || checked ==1))
		{
			skbMode = trickType[checked-1];			// sets skb mode to jumping/grinding
			trickStage = 1;							// first part of the trick
			jumpH = 0;								// sets the jump height to 0
			
			//// give points...	////////
			skbPoints += trickPoints[checked - 1];
			trickPoints[checked-1] /= 2;
			////////////////////////////
		}
	}
	//////////////////////////////////////////////////
}