ProjectZombie/src/shootergame/entity/Entity.java

package shootergame.entity;

import java.util.Random;

import shootergame.Main;
import shootergame.display.Camera;
import shootergame.display.transparent.ITransparentObject;
import shootergame.display.transparent.TransparentObjects;
import shootergame.init.Entities;
import shootergame.tiles.Tile;
import shootergame.util.math.MathHelpers;
import shootergame.util.math.TileState;
import shootergame.util.math.vec.Vec2d;
import shootergame.util.math.vec.Vec2i;
import shootergame.world.chunk.Chunk;
import shootergame.world.layer.Layer;

public class Entity implements ITransparentObject
{
	public Vec2d pos;
	public double angle;
	public boolean opaqueTile = true;
	public double hitbox = 1;
	public boolean isSolid = false;
	public Chunk chunk;
	private double speed = 1;
	private TileState tile_front;
	private TileState tile_back;
	public boolean crossUnWalkable = true;
	public boolean goThroughSolid = true;
	protected static final Random rand = new Random();
	
	public Entity(Vec2d pos, double angle)
	{
		// Add this entity to the list of entities
		Entities.entities.add(this);
		
		// Store the specified values
		this.angle = angle;
		this.pos = pos;
	}
	
	public Entity() {
		this(new Vec2d(0, 0), 0);
	}
	
	public void tick(Chunk chunk, Layer layer) {
		speed = 1;
		angle = MathHelpers.floor(angle);
		Vec2i tpos = new Vec2i(MathHelpers.floor(pos.x)+0, MathHelpers.floor(pos.y)+0);
		if(chunk == null) chunk = layer.getChunk(pos);
		this.chunk = chunk;
		tile_back = chunk.getBackTile(tpos);
		tile_front = chunk.getFrontTile(tpos);
		
		if(this.isSolid)
		{
			this.addSlowness(tile_back.tile.slowness);
			this.addSlowness(tile_front.tile.slowness);
		}
	}
	
	public void addSlowness(double amount) {
		speed *= (1 - amount);
	}
	
	public void render(Vec2d pos, Camera camera) {
	}
	
	@Override
	public void render(Vec2d pos, Camera camera, TileState state) {
		this.render(pos, camera);
	}
	
	public void doRender(Vec2d pos, Camera camera)
	{
		if(this.opaqueTile) {
			TransparentObjects.register(this, camera, pos, null);
		}
		
		else {
			this.render(pos, camera);
		}
	}

	@Override
	public boolean isOpaqueTile() {
		return this.opaqueTile;
	}
	
	public void moveForward(double speed) {
		this.moveTowards(0, speed);
	}
	
	public void moveBackward(double speed) {
		this.moveTowards(0, -speed);
	}
	
	public void moveTowards(double angle, double speed)
	{
		// Calculate the new position
		speed *= this.speed;
		Vec2d pos = this.pos.add(MathHelpers.moveTowards2(speed, Math.toRadians(this.angle + angle)));
		
		// Check if the new position is legal
		if(this.moveIsLegal(new Vec2d(this.pos.x, pos.y))) this.pos.y = pos.y;
		if(this.moveIsLegal(new Vec2d(pos.x, this.pos.y))) this.pos.x = pos.x;
		
		// Activate stepped on tiles if the entity is "solid"
		if(this.isSolid) activateSteppedOnTile();
	}
	
	public void moveForward() {
		this.moveForward(0.1);
	}
	
	public void moveBackward() {
		this.moveBackward(0.1);
	}
	
	public void moveTowards(double angle) {
		moveTowards(angle, 0.1);
	}
	
	public void kill() {
		chunk.killEntity(this);
	}
	
	public void activateTile()
	{
		// Get the tile position and the layer
		Layer layer = Main.world.getLayer();
		Vec2i tpos = new Vec2i(MathHelpers.floor(pos.x)+0, MathHelpers.floor(pos.y)+0);
		
		// Activate both tiles
		tile_front.tile.onActivated(layer, tpos, this, tile_front);
		tile_back.tile.onActivated(layer, tpos, this, tile_back);
	}
	
	public void activateSteppedOnTile()
	{
		// Get the tile position and the layer
		Layer layer = Main.world.getLayer();
		Vec2i tpos = new Vec2i(MathHelpers.floor(pos.x)+0, MathHelpers.floor(pos.y)+0);
		
		// Activate both tiles
		tile_front.tile.onWalkedOn(chunk, layer, tpos, this, tile_front);
		tile_back.tile.onWalkedOn(chunk, layer, tpos, this, tile_back);
		
	}
	
	public boolean moveIsLegal(Vec2d pos)
	{
		Vec2i t_pos = new Vec2i(MathHelpers.floor(pos.x)+0, MathHelpers.floor(pos.y)+0);
		Chunk chunk = Main.world.getLayer().getChunk(pos);
		tile_back = chunk.getBackTile(t_pos);
		tile_front = chunk.getFrontTile(t_pos);
		
		// Is this entity solid
		if(!goThroughSolid || !crossUnWalkable)
		{
			
			// Check the tile the player is standing on
			Vec2i tpos = new Vec2i(MathHelpers.floor(pos.x)+0, MathHelpers.floor(pos.y)+0);
			
			{
				// Get the tile
				Tile t = tile_back.tile;
				
				// Send false if the tile isn't walkable
				if((!t.tileWalkable) && (!crossUnWalkable)) {
					return false;
				}
				
				// Check the tiles hitbox if the tile is solid
				if((t.tileSolid) && (!goThroughSolid))
				{
					// Is the entity in the tiles hitbox
					if(pos.squareDistance(new Vec2d(tpos.x + 0.5, tpos.y + 0.5)) < t.tileHitbox)
					{
						// Send back false
						return false;
					}
				}
			}
			
			{
				// Get the front tile
				Tile t = tile_front.tile;
				
				// Send false if the tile isn't walkable
				if((!t.tileWalkable) && (!crossUnWalkable)) {
					return false;
				}
				
				// Check the tiles hitbox if the tile is solid
				if((t.tileSolid) && (!goThroughSolid))
				{
					// Is the entity in the tiles hitbox
					if(pos.squareDistance(new Vec2d(tpos.x + 0.5, tpos.y + 0.5)) < t.tileHitbox)
					{
						// Send back false
						return false;
					}
				}
			}
		}
		
		// Send back true if everything passes
		return true;
	}
	
	@Override
	public Vec2d getRenderOffset(TileState state) {
		return new Vec2d(0, 0);
	}
}