package Launcher;

import javax.swing.JFrame;

public class Launcher extends JFrame implements Runnable{

	private static final long serialVersionUID = 1L;
	
	private final int WIDTH = 810;
	private final int HEIGHT = 670;
	
	private final int MILLIS_PER_TICK = 60;
	private long startTime;
	private long timeTaken;
	
	Display display = new Display();
	
	public Launcher() {
		
		this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		this.setSize(WIDTH,HEIGHT);
		this.setLocationRelativeTo(null);
		this.add(display);
		this.setVisible(true);
	}

	public static void main(String[] args) {
		
		Launcher launcher = new Launcher();
		Thread t = new Thread(launcher);
		t.start();
		
	}

	@Override
	public void run() {
			
		while(true){
			
			startTime = System.currentTimeMillis();
			display.update();
			display.repaint();
			timeTaken = System.currentTimeMillis()-startTime;
			if(timeTaken < MILLIS_PER_TICK){
				try {
					Thread.sleep(MILLIS_PER_TICK-timeTaken);
				} catch (InterruptedException e) {e.printStackTrace();}
			}
			this.setTitle("FPS | " + (MILLIS_PER_TICK-timeTaken));
		}
		
	}

}
package Launcher;

import java.awt.Graphics;
import java.awt.Graphics2D;

import javax.swing.JLabel;

public class Display extends JLabel{

	private static final long serialVersionUID = 1L;

	Player player = new Player();
	Level level = new Level();
	
	public Display() {
		
		this.addMouseListener(new Mouse());
		this.addMouseMotionListener(new Mouse());
		this.setFocusable(true);
		
	}
	
	public void update(){
		
		player.move();
		
	}
	
	public void paintComponent(Graphics g){
		super.paintComponents(g);
		Graphics2D g2 =(Graphics2D) g;
		level.drawTiles(g2);
		player.drawPlayer(g2);
		
	}

}
package Launcher;

import java.awt.Graphics;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class Level {

	private int[][] levelMap;
	private int tilesw;
	private int tilesh;
	private int RASTER;
	private int[] level;
	private int tileNr;
	
	public Level() {
		
		RASTER = 32;
		
		generateMap(1,"gui//map.txt");
		
	}
	
	public void generateMap(int level_nr,String filename){
		
        if(level_nr == 1){
            tilesw=25;
            tilesh=20;
        }
        
        String stringMap = "";

        try {
        	BufferedReader reader = new BufferedReader(new FileReader(filename));
        	String line = null;
		  
        	while ((line = reader.readLine()) != null) {
        		stringMap += line;
			}
        	reader.close();
        } catch (IOException e) {e.printStackTrace();}

        if(stringMap != ""){
			
	        String[] stringarray = stringMap.split(",");
	        level = new int[stringarray.length];
	        
	        for(int i = 0;i<stringarray.length;i++){
	        	level[i] = Integer.parseInt(stringarray[i]);
	        }
			
	        int nr = 0;
			
			levelMap = new int[tilesw][tilesh];
			
			for(int y=0;y<tilesh;y++){
	            for(int x=0;x<tilesw;x++){
	            	levelMap[x][y]= level[nr];
		            nr++;
	            }
			}
        }
    } 
	
	public void drawTiles(Graphics g){
		
		for(int x = 0; x<tilesw*RASTER; x+=RASTER){		
			for(int y = 0; y<tilesh*RASTER; y+=RASTER){
				tileNr = levelMap[x/RASTER][y/RASTER];
				if(tileNr==1){
					g.fillRect(x, y, RASTER, RASTER);
				}
			}
		}	
	}
	
	public int[][] getLevelData(){
		return levelMap;
	}
}
package Launcher;

import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.List;

import javax.imageio.ImageIO;

public class Player extends Level{

	private int playerx;
	private int playery;
	private int startx;
	private int starty;
	private int zielx;
	private int ziely;
	private int speed;
	
	private int[] fx;
	private int[] fy;
	
	private int width;
	private int height;
	
	private boolean[][] grid;
	
	private int figureFrame;
	private int timer;
	
	private int k;
	private double angle;
	private double deltax;
	private double deltay;
	private double w;
	
	private BufferedImage player;
	private boolean stand;
	
	Level level = new Level();
	
	public Player() {
		
		try {
			player = ImageIO.read(new File("gui//circle.png"));
		} catch (IOException e) {e.printStackTrace();}
		
		playerx = 96;
		playery = 128;
		
		startx = playerx;
		starty = playery;
		
		speed = 4;
		
		width = 800;
		height = 640;
		
		k = 1;
		
		stand = true;
		
		fx = new int[width*height];
		fy = new int[width*height];
		
		grid = new boolean[width][height];
		
		for(int y = 0;y<height;y+=32){
			for(int x = 0;x<width;x+=32){
				if(level.getLevelData()[x/32][y/32]==1){
					grid[x][y] = true;
				}
			}
		}
	}
	
	public void move(){
		
		pumpTimer();
		
		if(Mouse.right){
			zielx = (((Mouse.hitmousex/32)%32)*32);
			ziely = (((Mouse.hitmousey/32)%32)*32);
		}
		else{
			zielx = (((playerx/32)%32)*32);
			ziely = (((playery/32)%32)*32);
		}
		
		List<Field> path = AStar.AStaralgorithm(startx,starty,zielx,ziely,grid,width,height);
			
		if(path!=null){
			
			for(int i = 0; i<path.size();i++){
					
				fx[i] = path.get(i).x;
				fy[i] = path.get(i).y;
				
			}
			if(playerx!=zielx||playery!=ziely){
				
				if(fx[k] > playerx && fy[k] == playery){
					angle = 0;
					playerx+=speed;
					stand=false;
					figureFrame = getFrame(figureFrame,10,14,3);
					if(playerx == fx[k] && playery == fy[k]){
						k++;
					}
					if(playerx == zielx && playery == ziely){
						k=1;
						fx[k] = 0;
						fy[k] = 0;
						stand= true;
					}
				}
				else if(fx[k] < playerx && fy[k] == playery){
					angle = 180;
					playerx-=speed;
					stand = false;
					figureFrame = getFrame(figureFrame,15,19,3);
					if(playerx == fx[k] && playery == fy[k]){
						k++;
					}
					if(playerx == zielx && playery == ziely){
						k=1;
						fx[k] = 0;
						fy[k] = 0;
						stand = true;
					}
				}
				else if(fx[k] == playerx && fy[k] > playery){
					angle = 90;
					playery+=speed;
					stand = false;
					figureFrame = getFrame(figureFrame,5,9,3);
					if(playerx == fx[k] && playery == fy[k]){
						k++;
					}
					if(playerx == zielx && playery == ziely){
						k=1;
						fx[k] = 0;
						fy[k] = 0;
						stand = true;
					}
				}
				else if(fx[k] == playerx && fy[k] < playery){
					angle = 270;
					playery-=speed;
					stand = false;
					figureFrame = getFrame(figureFrame,1,4,3);
					if(playerx == fx[k] && playery == fy[k]){
						k++;
					}
					if(playerx == zielx && playery == ziely){
						k=1;
						fx[k] = 0;
						fy[k] = 0;
						stand = true;
					}
				}
				else if(fx[k] > playerx && fy[k] > playery){
					angle = 45;
					playerx+=speed;
					playery+=speed;
					stand = false;
					figureFrame = getFrame(figureFrame,30,34,3);
					if(playerx == fx[k] && playery == fy[k]){
						k++;
					}
					if(playerx == zielx && playery == ziely){
						k=1;
						fx[k] = 0;
						fy[k] = 0;
						stand = true;
					}
				}
				else if(fx[k] < playerx && fy[k] < playery){
					angle = 225;
					playerx-=speed;
					playery-=speed;
					stand = false;
					figureFrame = getFrame(figureFrame,25,29,3);
					if(playerx == fx[k] && playery == fy[k]){
						k++;
					}
					if(playerx == zielx && playery == ziely){
						k=1;
						fx[k] = 0;
						fy[k] = 0;
						stand = true;
					}
				}
				else if(fx[k] > playerx && fy[k] < playery){
					angle = 315;
					playerx+=speed;
					playery-=speed;
					stand = false;
					figureFrame = getFrame(figureFrame,20,24,3);
					if(playerx == fx[k] && playery == fy[k]){
						k++;
					}
					if(playerx == zielx && playery == ziely){
						k=1;
						fx[k] = 0;
						fy[k] = 0;
						stand = true;
					}
				}
				else if(fx[k] < playerx && fy[k] > playery){
					angle = 135;
					playerx-=speed;
					playery+=speed;
					stand = false;
					figureFrame = getFrame(figureFrame,35,39,3);
					if(playerx == fx[k] && playery == fy[k]){
						k++;
					}
					if(playerx == zielx && playery == ziely){
						k=1;
						fx[k] = 0;
						fy[k] = 0;
						stand = true;
					}
				}
			}
			else{
				startx = zielx;
				starty = ziely;
			}
		}
	}
	
	public double rotate(){
		
		deltax = Mouse.rotatemousex - playerx;
		deltay = Mouse.rotatemousey - playery;
		
		if(deltax > 0 && deltay < 0){
			w = Math.toDegrees(Math.atan(deltay/deltax)+((2*Math.PI)));
		}
		else if(deltax > 0 && deltay > 0){
			w = Math.toDegrees(Math.atan(deltay/deltax));
		}
		else if(deltax < 0 && deltay < 0){
			w = Math.toDegrees(Math.atan(deltay/deltax)+(Math.PI));
		}
		else if(deltax < 0 && deltay > 0){
			w = Math.toDegrees(Math.atan(deltay/deltax)+(Math.PI));
		}
		
		if(w >= 337.5 && w <= 360){
			angle = 0;
		}
		else if(w >= 22.5 && w < 67.5){
			angle = 45;
		}
		else if(w >= 67.5 && w < 112.5){
			angle = 90;
		}
		else if(w >= 112.5 && w < 157.5){
			angle = 135;
		}
		else if(w >= 157.5 && w < 202.5){
			angle = 180;
		}
		else if(w >= 202.5 && w < 247.5){
			angle = 225;
		}
		else if(w >= 247.5 && w < 292.5){
			angle = 270;
		}
		else if(w >= 292.5 && w < 337.5){
			angle = 315;
		}
		
		return angle;
	}
	
	public void pumpTimer(){
		
		timer++;
		if(timer>127)timer=0;
	}
	
	public int getFrame(int frame, int min, int max, int step){
		if(frame<min || frame>max){
			frame=min;
		}
		if(step<1){
			step=1;
		}
		if(timer%step==0){
			frame++;
			if(frame>max){
				frame=min;
			}
		}
		return frame;
	}
	
	public void plotFrame(BufferedImage image,int width,int height,int frame, int x,int y,Graphics g){
		Graphics2D g2 = (Graphics2D) g;
		g2.setClip(x, y, width, height);
		g2.drawImage(image,x-(frame%5)*width,y-(frame/5)*height,null);
		g2.setClip(null);
	}

	public void drawPlayer(Graphics g){
		
		Graphics2D g2 =(Graphics2D) g;
		
		if(player != null){
			
			if(stand){
				g2.rotate(Math.toRadians(rotate()),playerx+player.getWidth()/2,playery+player.getHeight()/2);
			}
			else{
				g2.rotate(Math.toRadians(angle),playerx+player.getWidth()/2,playery+player.getHeight()/2);
			}
			plotFrame(player,32,32,0,playerx,playery,g2);
		}
		
	}

}
package Launcher;

import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;

public class Mouse extends MouseAdapter implements MouseMotionListener{

	public static int mousex;
	public static int mousey;
	public static int rotatemousex;
	public static int rotatemousey;
	public static int hitmousex;
	public static int hitmousey;
	public static boolean right;
	public static boolean left;
	
	@Override
	public void mouseMoved(MouseEvent e) {
		
		rotatemousex = e.getX();
		rotatemousey = e.getY();
	
	}
	
	@Override
	public void mousePressed(MouseEvent e) {
		
		mousex = e.getX();
		mousey = e.getY();
		
		
	
	}
	
	@Override
	public void mouseReleased(MouseEvent e) {
		
		mousex = e.getX();
		mousey = e.getY();
	
		if(e.getButton()==MouseEvent.BUTTON1){
			right = false;
		}
	}
	
	@Override
	public void mouseClicked(MouseEvent e) {
		
		hitmousex = e.getX();
		hitmousey = e.getY();
	
		if(e.getButton()==MouseEvent.BUTTON1){
			right = true;
		}
	}

}
package Launcher;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeSet;

public class AStar{
	
	public static List<Field> AStaralgorithm(int xFrom,int yFrom,int xTo,int yTo,boolean[][] grid,int width,int height){
		
		Field[][] fields = new Field[width][height];
		
		for(int x = 0;x<width;x+=32){
			for(int y = 0;y<height;y+=32){
				fields[x][y] = new Field(x,y,grid[x][y]);
			}
		}
		
		for(int x = 0;x<width;x+=32){
			for(int y = 0;y<height;y+=32){
				for(int dx = -32;dx<=32;dx+=32){
					for(int dy = -32;dy<=32;dy+=32){
						if(x+dx<0 || x+dx>=width || y+dy<0 || y+dy>=height){
							continue;
						}
						if(!fields[x+dx][y].blocked && !fields[x][y+dy].blocked){
							fields[x][y].addNeighbor(fields[x+dx][y+dy]);
						}
						
					}
				}
			}
		}
		
		TreeSet<Field> openList = new TreeSet<Field>();
		Set<Field> closedList = new HashSet<Field>();
		
		openList.add(fields[xFrom][yFrom]);
		Field target = fields[xTo][yTo];
		
		while(!openList.isEmpty()){
			
			Field current = openList.first();
			openList.remove(current);
			
			if(current == target){
				List<Field> result = new ArrayList<Field>();
				Field tmp = target;
				while(tmp!=null){
					result.add(0,tmp);
					tmp = tmp.getPredecessor();
				}
				return result;
				
			}
			closedList.add(current);
			expandNode(current,target,openList,closedList);
		}
		return null;
	}
	
	public static void expandNode(Field current,Field target,Set<Field> openList,Set<Field> closedList){
		HashMap<Field, Double> successors = current.getNeighbors();
		Iterator<Entry<Field, Double>> it = successors.entrySet().iterator();
		while(it.hasNext()){
			Map.Entry<Field,Double> pair =  it.next();
			Field successor = pair.getKey();
			if(closedList.contains(successor)){
				continue;
			}
			double tentative_g = current.getG()+pair.getValue();
			if(openList.contains(successor) && tentative_g >= successor.getG()){
				continue;
			}
			successor.setPredecessor(current);
			successor.setG(tentative_g);
			double f = tentative_g + successor.calch(target);
			openList.remove(successor);
			successor.setF(f);
			openList.add(successor);
		}
	}
}
package Launcher;

import java.util.HashMap;

public class Field implements Comparable<Field>{

	public int x;
	public int y;
	private HashMap<Field, Double> neighbors= new HashMap<Field,Double>();
	private double f;
	private double g;
	public boolean blocked;
	private Field predecessor;
	
	public Field(int x,int y,boolean blocked) {
		this.x = x;
		this.y = y;
		this.blocked = blocked;
			
	}
	
	public void addNeighbor(Field neighbor){
		
		if(!neighbor.blocked && this != neighbor){
			neighbors.put(neighbor,Math.sqrt(((this.x-neighbor.x)*(this.x-neighbor.x)) + ((this.y - neighbor.y)*(this.y-neighbor.y))));
		}
	}
	
	public HashMap<Field, Double> getNeighbors(){
		return neighbors;
	}
	
	public double getF(){
		return f;
	}
	
	public void setF(double f){
		this.f = f;
	}
	
	public double getG(){
		return g;
	}
	
	public void setG(double g){
		this.g = g;
	}

	public Field getPredecessor(){
		return predecessor;
	}
	
	public void setPredecessor(Field predecessor){
		this.predecessor = predecessor;
	}
	
	public double calch(Field target){
		double dx = Math.abs(this.x - target.x);
		double dy = Math.abs(this.y - target.y);
		return (Math.sqrt(2)-1)*Math.min(dx,dy) + Math.max(dx,dy);
	}

	@Override
	public int compareTo(Field o) {
		return 4 * (int)Math.signum(this.f-o.f)+2*(int)Math.signum(this.x-o.x)+(int)Math.signum(this.y-o.y);
	}

	@Override
	public String toString(){
		return x +"/" +y;
	}

}