Facade BackUp

package jumpingalien.facade;


import java.util.Collection;
import java.util.Set;
import be.kuleuven.cs.som.annotate.Raw;
import jumpingalien.facade.IFacade;
//import jumpingalien.internal.gui.painters.GameObjectPainter;
//import jumpingalien.internal.gui.sprites.JumpingAlienSprites;
import jumpingalien.util.ModelException;
import jumpingalien.util.Sprite;
import jumpingalien.model.*;



public class Facade implements IFacade{

    @Override
    public boolean isTeamSolution() {
        return true;
    }

    @Override
    public boolean isLateTeamSplit() {
        //To good of a team
        return false;
    }

    @Override
    public boolean hasImplementedWorldWindow() {
        return true;
    }

    @Override
    public Mazub createMazub(int pixelLeftX, int pixelBottomY, Sprite... sprites) throws ModelException {
        try {Mazub alien = new Mazub(pixelLeftX, pixelBottomY, sprites); return alien;}
        catch (Exception e) {throw new ModelException(e);}
    }

    @Override
    public double[] getActualPosition(Mazub alien) throws ModelException {
        return alien.getActualPosition();
    }

    @Override
    public void changeActualPosition(Mazub alien, double[] newPosition) throws ModelException {
         try {alien.changeActualPosition(newPosition);

        } catch (Exception e) {
            throw new ModelException(e);
        }
    }

    @Override
    public int[] getPixelPosition(Mazub alien) throws ModelException {
        return alien.getPixelPosition();
    }

    @Override
    public int getOrientation(Mazub alien) throws ModelException {
        return alien.getOrientation();
    }

    public Sprite getCurrentSprite(Mazub alien) throws ModelException {
        return alien.getCurrentSprite();
    }

    @Override
    public double[] getVelocity(Mazub alien) throws ModelException {
        return alien.getVelocity();
    }

    @Override
    public double[] getAcceleration(Mazub alien) throws ModelException {
        return alien.getAcceleration();
    }

    @Override
    public boolean isMoving(Mazub alien) throws ModelException {
         return alien.isMoving();
    }

    @Override
    public void startMoveLeft(Mazub alien) throws ModelException {
         if(alien.isMoving()== false) {
                try {
                    ((Entity)alien).startMoveLeft();
                } catch (Exception e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }}
         else if(alien.isMoving()==true){throw new ModelException("Already Moving");}
    }

    @Override
    public void startMoveRight(Mazub alien) throws ModelException {
        if(alien.isMoving()== false) {
            try {
                alien.startMoveRight();
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }}
        else if(alien.isMoving()==true) {throw new ModelException("Already Moving");}
    }

    @Override
    public void endMove(Mazub alien) throws ModelException {
        if(alien.isMoving()==true) {alien.endMove();}
        else if(alien.isMoving()==false){throw new ModelException("Already Stopped Ducking");}
    }

    @Override
    public boolean isJumping(Mazub alien) throws ModelException {
         return alien.isJumping();
    }

    @Override
    public void startJump(Mazub alien) throws ModelException {//Die exception moet denk ik in Mazub zelf. Zelfde in running enz
        if(alien.isJumping() == false) {alien.startJump();}
        else {throw new ModelException("Already Jumping");}
    }

    @Override
    public void endJump(Mazub alien) throws ModelException {
        if(alien.isJumping() ==true) {alien.endJump();}
        else {throw new ModelException("Already Stopped Jumping");}
    }

    @Override
    public boolean isDucking(Mazub alien) throws ModelException {
         return alien.isDucking();
    }

    @Override
    public void startDuck(Mazub alien) throws ModelException {
        if(alien.isDucking() ==false) {alien.startDucking();}
    }

    @Override
    public void endDuck(Mazub alien) throws ModelException {
        alien.endDucking();
    }

    @Override
    public World createWorld(int tileSize, int nbTilesX, int nbTilesY, int[] targetTileCoordinate,
            int visibleWindowWidth, int visibleWindowHeight, int... geologicalFeatures) throws ModelException {
         try {World world= new World(tileSize, nbTilesX, nbTilesY,  targetTileCoordinate, visibleWindowWidth, visibleWindowHeight, geologicalFeatures );
         return world;
        } catch (Exception e) {
            throw new ModelException(e);
        }
    }

    @Override
    public void terminateWorld(World world) throws ModelException {
        world.terminateWorld();
    }

    @Override
    public int[] getSizeInPixels(World world) throws ModelException {
        return world.getSizeInPixels();
    }

    @Override
    public int getTileLength(World world) throws ModelException {
       try {return world.getTileLength();

    } catch (Exception e) {throw new ModelException(e);}
        // TODO: handle exception

    }

    @Override
    public int getGeologicalFeature(World world, int pixelX, int pixelY) throws ModelException {
        return world.getGeologicalFeatures(pixelX, pixelY);

    }

    @Override
    public void setGeologicalFeature(World world, int pixelX, int pixelY, int geologicalFeature) throws ModelException {
        try{world.setGeologicalFeatures(pixelX, pixelY, geologicalFeature);}
        catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public int[] getVisibleWindowDimension(World world) throws ModelException {
        try{return world.getVisibleWindowDimension();}
        catch(Exception e){throw new ModelException(e);}
    }

    public int[] getVisibleWindowPosition(World world) throws ModelException {
        try{return world.getVisibleWindowsPosition();}
        catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public boolean hasAsGameObject(Object object, World world) throws ModelException {
        try{return world.hashAsGameObject(object);}
        catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public Set<? extends Object> getAllGameObjects(World world) throws ModelException {
          try{return world.getAllGameObjects();}
          catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public Mazub getMazub(World world) throws ModelException {
        try{return world.getMazub();}
        catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public void addGameObject(Object object, World world) throws ModelException {
        try{world.addGameObject((Entity)object, world);}
        catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public void removeGameObject(Object object, World world) throws ModelException {
        try{world.terminatedGameObject((Entity)object);}
        catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public int[] getTargetTileCoordinate(World world) throws ModelException {
         return world.getTargetTileCoordinate();
    }

    @Override
    public void setTargetTileCoordinate(World world, int[] tileCoordinate) throws ModelException {
         try {world.setTargetTileCoordinate(tileCoordinate);

        } catch (Exception e) {
            throw new ModelException(e);
        }
    }

    @Override
    public void startGame(World world) throws ModelException {
        try{world.startGame();}
        catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public boolean isGameOver(World world) throws ModelException {
        try{return world.isGameOver();}
        catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public boolean didPlayerWin(World world) throws ModelException {
        try{return world.DidPlayerWin();}
        catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public void advanceWorldTime(World world, double dt) throws ModelException {
        try {
            world.advancedTime(dt);
        } catch (Exception e) {
            Exception d = e;
            // TODO Auto-generated catch block
            throw new ModelException(d);
        }

    }


    @Override
    public Set<School> getAllSchools(World world) throws ModelException {
         try{return world.getAllSchools();}
         catch(Exception e){throw new ModelException(e);}
    }
    /*
     *************
     *GameObjects*
     *************
     */


    @Override
    public void terminateGameObject(Object gameObject) throws ModelException {
         try{if(((Entity)gameObject).getWorld() != null){((Entity)gameObject).getWorld().terminatedGameObject((Entity)gameObject);}
             else {((Entity)gameObject).terminateGameObject();}}
         catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public boolean isTerminatedGameObject(Object gameObject) throws ModelException {
         try{if(((Entity)gameObject).getWorld() != null&&((Entity)gameObject).getWorld().isTerminatedGameObject(gameObject)) {return true;}
         else {
             if(((Entity)gameObject).isTerminatedGameObject()){return true;}else {return false;}}
         }
         catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public boolean isDeadGameObject(Object gameObject) throws ModelException {
         try{return ((Entity)gameObject).isDeadGameObject();}
         catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public double[] getActualPosition(Object gameObject) throws ModelException {
         try{return ((Entity)gameObject).getActualPosition();}
         catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public void changeActualPosition(Object gameObject, double[] newPosition) throws ModelException {
         try{((Entity)gameObject).changeActualPosition(newPosition);}
         catch(Exception e){throw new ModelException(e);}

    }

    @Override
    public int[] getPixelPosition(Object gameObject) throws ModelException {
         try{return ((Entity)gameObject).getPixelPosition();}
         catch(Exception e){throw new ModelException(e);}

    }

    @Override
    public int getOrientation(Object gameObject) throws ModelException {
        try{return ((Entity)gameObject).getOrientation();}
        catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public double[] getVelocity(Object gameObject) throws ModelException {
        try{return ((Entity)gameObject).getVelocity();}
        catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public double[] getAcceleration(Object gameObject) throws ModelException {
         try{return ((Entity)gameObject).getAcceleration();}
         catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public World getWorld(Object object) throws ModelException {
        try{if(object instanceof Entity) {return ((Entity)object).getWorld();}
            else if(object instanceof School) {return ((School)object).getworld();}
            else {World d = null;return d;}}
        catch(Exception e){throw new ModelException(e);}

    }

    @Override
    public int getHitPoints(Object object) throws ModelException {
         try{return ((Entity)object).getHitpoint();}
         catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public Sprite[] getSprites(Object gameObject) throws ModelException {
         try{return ((Entity)gameObject).getSprites();}
         catch(Exception e){throw new ModelException(e);}
    }

    @Override
    public Sprite getCurrentSprite(Object gameObject)throws ModelException{
        try{return ((Entity)gameObject).getCurrentSprite();}
        catch(Exception e){throw new ModelException(e);}
    }


// World AdvencedTime
    @Override
    public void advanceTime(Object gameObject, double dt) throws ModelException {
        try {((Entity)gameObject).advanceTime(dt);}
        catch (Exception e) {throw new ModelException(e);}
    }

// Sneezewort

    @Override
    public Sneezewort createSneezewort(int pixelLeftX, int pixelBottomY, Sprite... sprites) throws ModelException {
        try {Sneezewort Sneeze=new Sneezewort(pixelLeftX, pixelBottomY, sprites);return Sneeze;}
        catch (Exception e) {throw new ModelException(e);}

    }

 // Skullcab

    @Override
    public Skullcab createSkullcab(int pixelLeftX, int pixelBottomY, Sprite... sprites) throws ModelException {
        try {Skullcab Skull=new Skullcab(pixelLeftX, pixelBottomY, sprites);return Skull;}
        catch (Exception e) {throw new ModelException(e);}

    }

// Slime Facade

    @Override
    public Slime createSlime(long id, int pixelLeftX, int pixelBottomY, School school, Sprite... sprites)throws ModelException {
        try {Slime slime=new Slime(id, pixelLeftX, pixelBottomY, school, sprites); return slime;}
        catch (Exception e) {throw new ModelException(e);}
    }

    @Override
    public long getIdentification(Slime slime) throws ModelException {
        try {return slime.getID();}
        catch (Exception e) {throw new ModelException(e);}
    }

    @Override
    public void cleanAllSlimeIds() {
        Slime.CleanIdSet();
    }

 // School Facade

    @Override
    public School createSchool(World world) throws ModelException {
        try {School school= new School(world);return school;}
        catch (Exception e) {throw new ModelException(e);}
    }

    @Override
    public void terminateSchool(School school) throws ModelException {
        try {school.terminateSchool();}
        catch (Exception e) {throw new ModelException(e);}

    }

    @Override
    public boolean hasAsSlime(School school, Slime slime) throws ModelException {
        try {return school.hasAsSlime(slime);}
        catch (Exception e) {throw new ModelException(e);}
    }

    @Override
    public Collection<? extends Slime> getAllSlimes(School school) {
        try {return school.getAllSlimes();}
        catch (Exception e) {throw new ModelException(e);}
    }

    @Override
    public void addAsSlime(School school, Slime slime) throws ModelException {
        try {school.AddAsSlime(slime);}
        catch (Exception e) {throw new ModelException(e);}
    }

    @Override
    public void removeAsSlime(School school, Slime slime) throws ModelException {
        try {school.removeAsSlime(slime);}
        catch (Exception e) {throw new ModelException(e);}
    }

    @Override
    public void switchSchool(School newSchool, Slime slime) throws ModelException {
        try {newSchool.switchSchool(slime);}
        catch (Exception e) {throw new ModelException(e);}
    }

    @Override
    public School getSchool(Slime slime) throws ModelException {
        try {return slime.getSchool();}
        catch (Exception e) {throw new ModelException(e);}
    }

//Shark Facade

    public Shark createShark(int pixelLeftX, int pixelBottomY, Sprite... sprites) throws ModelException {

        try {Shark shark=new Shark(pixelLeftX, pixelBottomY, sprites);return shark;
        } catch (Exception e) {throw new ModelException(e);}
    }

    @Override
    public Sprite[] getSprites(Mazub alien) throws ModelException {
        return alien.getSprites();
    }

}