/*
  Test of a platform game with gravity
  Copyright 2008 Andrea Micheloni

  This program is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 3 of the License, or
  (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
  
  See <http://www.gnu.org/licenses/gpl.txt> for details.
  
 */

import java.awt.*;
import java.awt.event.*;

public class FirstGame extends Frame implements KeyListener{

	public boolean keys[] = {false, false, false, false};
	public Player player;
	public Map map;
	public boolean invisible = false;
	private int speed = 40;
	Thread t;
	boolean won=false;

	public FirstGame(){
		map = new Map();
		player = new Player(map);
		setTitle("Java Test Game");
		setBounds(100,100,400,400);
		addKeyListener(this);
		addWindowListener(new WindowAdapter() {
				public void windowClosed(WindowEvent evt){
					System.exit(0);
				}
				public void windowClosing(WindowEvent evt){
					evt.getWindow().dispose();
				}
			});
		setVisible(true);
		
		t = new Thread(new Motion(this));
		t.start();
	}

	public int getSpeed(){
		return speed;
	}

	public void getPoints(){
		if (map.allPoints()){
				map=null;
				player=null;
				won=true;
				t.interrupt();
				t=null;
			}
	}

	public void paint(Graphics g) {
		getPoints();
		g.drawString("Level f'(n) + o-piccolo(x^"+speed+")",40,40);
		if(won){
			g.drawString("Level cleared in theta(n*lg(n)), greetings!",40,60);
			g.drawString("Press any key to exit.",40,80);
		} else {
			player.draw(g);
			map.draw(g,invisible);
		}
	}

  public void keyReleased(KeyEvent e) {
		switch(e.getKeyCode()){
		case KeyEvent.VK_LEFT: keys[0] = false; break;
		case KeyEvent.VK_RIGHT: keys[1] = false; break;
		case KeyEvent.VK_UP: keys[2] = false; break;
		case KeyEvent.VK_DOWN: keys[3] = false; break;
		}
		e.consume();
  }

	public void keyPressed(KeyEvent e) {
		switch(e.getKeyCode()){
		case KeyEvent.VK_LEFT: keys[0] = true; break;
		case KeyEvent.VK_RIGHT: keys[1] = true; break;
		case KeyEvent.VK_UP: keys[2] = true; break;
		case KeyEvent.VK_DOWN: keys[3] = true; break;
		case KeyEvent.VK_ESCAPE: System.exit(0); break;
		}
		e.consume();
	}

  public void keyTyped(KeyEvent e) {
	  if(won)
		  System.exit(0);
	  else
		  switch(e.getKeyChar()){
		  case 'i':
			  invisible = !invisible;
			  repaint();
			  break;
		  case '+':
			  if(speed>10)
				  speed-=5;
			  repaint();
			  break;
		  case '-':
			  speed+=5;
			  repaint();
			  break;
		  }
	  // make sure the key isn't processed for anything else
	  e.consume();
  }
	public static void main(String a[]){FirstGame x = new FirstGame();}
}

class Motion implements Runnable{
	private FirstGame win;

	public void run(){
		while(true)
			{
				boolean move = win.player.gravity();
				move = move | (win.keys[0] && win.player.left());
				move = move | (win.keys[1] && win.player.right());
				move = move | (win.keys[2] && win.player.jump());
				move = move | (win.keys[3] && win.player.down());
				try{
					if(move){
						win.repaint();
						Thread.currentThread().sleep(win.getSpeed());
					}
					else
						Thread.currentThread().sleep(200);
				} catch(InterruptedException e){}
			}

	}
	public Motion(FirstGame w){
		win = w;
	}
}

class Map{
	private int jumps = 0;
	private int[][] vert = {{60,260,300},
							{100,300,340},
							{140,300,340},
							{260,300,340},
							{340,260,300},
							{300,220,260},
							{100,180,220},
							{60,140,180},
							{300, 60,140}};
	private int[][] horz = {{20,60,340},
							{60,100,300},
							{100,140,340},
							{140,180,300},
							{260,340,340},
							{260,300,300},
							{340,380,300},
							{220,300,260},
							{20,60,180},
							{60,100,220},
							{260,340,180},
							{100,180,100},
							{340,380,140},
							{260,340,100},
							{340,380,60},
							{300,380,20}};

	private int[][] points = {{35,355},
							  {35,235},
							  {35,155},
							  {355,275},
							  {275,75},
							  {155,75}};
	private int pointnum = 0;

	public int getX(){return 65;}
	public int getY(){return 350;}

	public void addJump(){jumps++;}

	public boolean isCollidingPoint(int[] xy){
		boolean res = false;
		for(int i=0; !res && i<points.length; i++)
				if(points[i][0]!=-42 &&
				   xy[0]+9>points[i][0] &&
				   xy[0]-19<points[i][0] &&
				   xy[1]+5>points[i][1] &&
				   xy[1]-33<points[i][1]){
					points[i][0] = -42;
					pointnum++;
					res=true;
				}
		return res;
	}

	public boolean isCollidingLeft(int[] xy){
		boolean res = (xy[0]<20+6);
		for(int i=0; !res && i<vert.length; i++){
			if(xy[1] > vert[i][1] && 
			   xy[1] < vert[i][2]+18 &&
			   (xy[0] == vert[i][0]+6 || 
				(vert[i][0]+6 > xy[0] && xy[0] > vert[i][0]+3))){
				res=true;
				xy[0] = vert[i][0]+6;
			}
		}
		for(int i=0; !res && i<horz.length; i++){
			if(xy[1] > horz[i][2] && 
			   xy[1] < horz[i][2]+18 &&
			   (xy[0] == horz[i][1]+6 || 
				(xy[0] > horz[i][1]+3 && xy[0] <= horz[i][1]+6))){
				res=true;
				xy[0] = horz[i][1]+6;
			}
		}

		return res;
	}

	public boolean isCollidingRight(int[] xy){
		boolean res = (xy[0]>380-6);
		for(int i=0; !res && i<vert.length; i++){
			if(xy[1] > vert[i][1] && 
			   xy[1] < vert[i][2]+18 &&
			   (xy[0] == vert[i][0]-6 || 
				(vert[i][0]-6 < xy[0] && xy[0] <= vert[i][0]-3))){
				res=true;
				xy[0] = vert[i][0]-6;
			}
		}
		
		for(int i=0; !res && i<horz.length; i++){
			if(xy[1] > horz[i][2] && 
			   xy[1] < horz[i][2]+18 &&
			   (xy[0] == horz[i][0]-6 || 
				(horz[i][0]-6 < xy[0] && xy[0] <= horz[i][0]-3))){
				res=true;
				xy[0] = horz[i][0]-6;
			}
		}

		return res;
	}

	public boolean isCollidingDownVert(int[] xy, int vy){
		boolean res = false;
			for(int i=0; !res && i<vert.length; i++){
			if(xy[0]>vert[i][0]-4 && 
			   xy[0]<vert[i][0]+4 &&
			   (xy[1]==vert[i][1] || 
				(xy[1]<vert[i][1] && xy[1]+vy>=vert[i][1]))){
				res=true;
				xy[1] = vert[i][1];
			}
		}
		return res;
	}

	public boolean isCollidingDown(int[] xy, int vy){
		boolean res = isCollidingBase(xy,vy);
		for(int i=0; !res && i<horz.length; i++){
			if(xy[0]>horz[i][0]-4 && 
			   xy[0]<horz[i][1]+4 &&
			   (xy[1]==horz[i][2] || 
				(xy[1]<horz[i][2] && xy[1]+vy>=horz[i][2]))){
				res=true;
				xy[1] = horz[i][2];
			}
		}
		res = res || isCollidingDownVert(xy,vy);
		return res;
	}

	public boolean isCollidingUp(int[] xy, int vy){
		boolean res = false;
		for(int i=0; !res && i<horz.length; i++){
			if(xy[0]>horz[i][0]-4 && 
			   xy[0]<horz[i][1]+4 &&
			   xy[1]>horz[i][2]+18 && 
			   xy[1]+vy<=horz[i][2]+18){
				res=true;
				xy[1] = horz[i][2]+18;
			}
		}
		//		res = res || isCollidingDownVert(xy,vy);
		return res;
	}

	public boolean isCollidingBase(int[] xy, int vy){
		if(xy[1]>=380 || (xy[1]<380 && xy[1]+vy>380)){
			xy[1]=380;
			return true;
		} else
			return false;
	}

	public boolean allPoints(){
		return pointnum==points.length;
	}

	public void draw(Graphics g, boolean invisible){
		
		g.drawString("points:"+pointnum+"/"+points.length+" jumps:" 
					 + jumps,40,60);
		
		g.drawLine(20,20,380,20);
		g.drawLine(20,20,20,380);
		g.drawLine(20,380,380,380);
		g.drawLine(380,20,380,380);
		
		g.setColor(Color.yellow);
		
		for(int i=0; i<points.length; i++)
			if(points[i][0]!=-42)
				g.fillOval(points[i][0],points[i][1],10,10);
		
		g.setColor(Color.red);

		for(int i=0; i<points.length; i++)
			if(points[i][0]!=-42)
				g.drawOval(points[i][0],points[i][1],10,10);
		
		g.setColor(Color.red);
		if(invisible)
			g.drawString("Invisible mode enabled",40,80);
		else{
			for(int i=0; i<horz.length; i++)
				g.drawLine(horz[i][0],horz[i][2],horz[i][1],horz[i][2]);
			for(int i=0; i<vert.length; i++)
				g.drawLine(vert[i][0],vert[i][1],vert[i][0],vert[i][2]);
		}
	}
}

class Player{
	private int[] xy;
	private int vy;
	private Map map;
	private boolean jumping;

	public Player(Map map){
		this.map = map;
		xy = new int[2];
		xy[0] = map.getX();
		xy[1] = map.getY();
		vy=0;
		jumping = true;
	}


	public boolean left(){
		if(map.isCollidingLeft(xy))
			return false;
		else{
			xy[0]-=3;
			return true;
		}
	}

	public boolean right(){
		if(map.isCollidingRight(xy))
			return false;
		else{
			xy[0]+=3;
			return true;
		}
	}

	public boolean jump(){
		if(!jumping){
			vy = -11;
			xy[1]-=15;
			jumping = true;
			map.addJump();
		}
		return true;
	}

	public boolean down(){
		if(!jumping && !map.isCollidingBase(xy,vy) 
		   && !map.isCollidingDownVert(xy,vy)){
			xy[1]++;
			vy++;
			jumping = true;
		}
		return jumping;
	}

	public boolean gravity(){
		map.isCollidingPoint(xy);
		if(map.isCollidingDown(xy,vy)){
			vy = 0;
			jumping = false;
		} else if(map.isCollidingUp(xy,vy)){
			vy = 0;
		}
		else {
			xy[1] += ++vy;
			jumping = true;
		}
		return true;
	}

	public void draw(Graphics g){
		g.drawLine(xy[0]-3,xy[1],xy[0]-1,xy[1]-5);
		g.drawLine(xy[0]+3,xy[1],xy[0]+1,xy[1]-5);
		g.drawLine(xy[0],xy[1]-12,xy[0],xy[1]-5);
		g.drawLine(xy[0]-4,xy[1]-7,xy[0],xy[1]-13);
		g.drawLine(xy[0]+4,xy[1]-7,xy[0],xy[1]-13);
		g.drawOval(xy[0]-3,xy[1]-18,6,6);
	}
}