import greenfoot.*;  // (World, Actor, GreenfootImage, Greenfoot and MouseInfo)

/**
 * Eigenschaften der Tower werden hier gesteuert, verwaltet und initialisiert
 * 
 * @author Marek Parucha, Felix Pfeffer
 * @version 2.0_24.02.2014
 */
public class Monsters extends Actor
{
    /** falls true --> erster durchlauf der act() Methode
     */
    boolean firstRun = true; 
    boolean barFirstRun = true;
    /** Geldertrag des Monsters
     */
    protected int monsterMoney; 
    /**Scoreertrag des Monsters
     */
    protected int monsterScore; 
    /**Bild des Monsters
     */
    protected GreenfootImage monsterImage; 
    /**Bild des Monsters
     */
    protected GreenfootImage monsterImageSet; 
    /**Geschwindigkeit des Monsters
     */
    protected int monsterSpeed;
    /**die jetzige Geschwindigkeit des Monsters 
     */
    public int monsterCurSpeed;
     /**Das Anfangsleben des Monsters
     */
    protected int monsterLife; 
    /**Das jetzige Leben des Monsters
     */
    public int monsterCurLife;   
    /**Lebensabzeige
     */
    Bar bar;                        
    boolean barInWorld = false;
    private static boolean canMove = true;
    boolean clicked = false;
    static boolean oneMonsterIsSelected = false;
    boolean thisMonsterIsSelected = false;
    /**
     * act() Methode regelt die einzelnen Methoden, sowie das entfernen der Lebensanzeige und des Monsters selbst
     */
    public void act() 
    {
        if(firstRun)
        {
            setRotation(90);
            
            firstRun = false;
        }
        
        
        if(Greenfoot.mouseClicked(this) && !clicked && !oneMonsterIsSelected) 
        {
            Towers.selectMonster(this,false);
            clicked=true;
            oneMonsterIsSelected = true;
            thisMonsterIsSelected = true;
            this.setImage(monsterImageSet);
        }
        else if(Greenfoot.mouseClicked(this) && clicked && oneMonsterIsSelected)
        {
            Towers.selectMonster(this,true);
            clicked=false;
            oneMonsterIsSelected = false;
            thisMonsterIsSelected = false;
            this.setImage(monsterImage);
        }
            
        if(monsterLife != monsterCurLife && barFirstRun)
        {
            bar= new Bar("","", 100, 100);
            getWorld().addObject(bar,getX(),getY()-25);
            barInWorld = true;
            barFirstRun = false;
        }
        
        if(getWorld()!=null && barInWorld) 
        {
            bar.setLocation(getX(),getY()-25);
            bar.setValue(100/monsterLife * monsterCurLife);
        }
        

        if(monsterCurSpeed <=0)
        {
            monsterCurSpeed=1;
        }
        
       
        if(setMonsterRotation(getX(),getY()))
        {
                move(monsterCurSpeed);
        }
        else
        {
            move(0);
            
            if (thisMonsterIsSelected)
            {
                //Towers.selectMonster(this,true);
                oneMonsterIsSelected = false;
                thisMonsterIsSelected = false;
            }
            
            getWorld().removeObject(bar);
            getWorld().removeObject(this);
        }
        
        if(kurvenMitteErreicht( this.getX() , this.getY() ) && TeD_World.SPIELEVERWALTUNG.map0.getMap( TeD_World.pixToCell(getX())-1,TeD_World.pixToCell(getY())-1) == 8)
        {
            
            
            if (thisMonsterIsSelected)
            {
                Towers.selectMonster(this,true);
                oneMonsterIsSelected = false;
                thisMonsterIsSelected = false;
            }
            getWorld().removeObject(bar);
            Spieleverwaltung.removeLife();
            getWorld().removeObject(this);
        }
        
        if(monsterCurLife <=0)
        {
           
            
            if (thisMonsterIsSelected)
            {
                Towers.selectMonster(this,true);
                oneMonsterIsSelected = false;
                thisMonsterIsSelected = false;
            }
            getWorld().removeObject(bar);
            Spieleverwaltung.addMoney(monsterMoney);
            Spieleverwaltung.addScore(monsterScore);
            getWorld().removeObject(this);
            
            
        }
    }
    
    
    /**
     * Rotation des Monsters
     * 
     * @param 'X': X-koordinate des Monsters
     * @param 'Y': Y-koordinate des Monsters
     * 
     */
    public boolean setMonsterRotation(int X, int Y)
    {
        int hilf = 0;
        int spalte = TeD_World.pixToCell(X);
        int zeile  = TeD_World.pixToCell(Y);
        
       
        if(spalte < 0 || zeile < 0)
        {
            canMove = false;
        }
        
        hilf = TeD_World.SPIELEVERWALTUNG.map0.getMap(spalte-1,zeile-1);
        int aktR = this.getRotation();
        //System.out.println(TeD_World.pixToCell(X)+" "+TeD_World.pixToCell(Y)+" "+hilf);
        
        if(canMove)
        {
            if((hilf == 3 && aktR == 90) || (hilf == 5 && aktR == 0) || (hilf == 4 && aktR == 180) || (hilf == 6 && aktR == 270))
            {
                if (kurvenMitteErreicht(X,Y))
                {
                    this.setRotation( getRotation()-90 );
                }
            }
            else if( (hilf == 4 && aktR == 270) || (hilf == 6 && aktR == 0) || (hilf == 5 && aktR == 90) || (hilf == 3 && aktR == 180))
            {
                if (kurvenMitteErreicht(X,Y))
                {
                    this.setRotation( getRotation()+90 );
                }   
            }
            /*else if( hilf == 7 )
            {
                canMove = false;
            }*/
        }
        
        return canMove;
    }
    /**
     * true falls kurvenmitte errreicht
     * 
     * @param 'X': X-koordinate des Monsters
     * @param 'Y': Y-koordinate des Monsters
     * 
     */
    private boolean kurvenMitteErreicht(int X , int Y)
    {
        boolean jetzt = false;
        boolean gefunden = false;
        
        int mPixX        = TeD_World.cellToPixM( TeD_World.pixToCell(X) );
        int mPixY        = TeD_World.cellToPixM( TeD_World.pixToCell(Y) );
        final int mV     = (monsterCurSpeed - 1);                //Mögliche Verschiebung
        int rot          = this.getRotation();
        int[] mPix       = new int[((2*mV)+1)];
        
        if( rot == 180 || rot == 0)
        {
            for(int i = 0,j = -mV; i < ((2*mV)+1); ++i, ++j )
            {
                mPix[i] = mPixX + j;
            }
            for(int i = 0,j = -mV; i < ((2*mV)+1); ++i, ++j )
            {
                if(mPix[i] == X)
                {
                    gefunden = true;
                    break;
                }
            }
        }
        else if( rot == 270 || rot == 90)
        {
            for(int i = 0,j = -mV; i < ((2*mV)+1); ++i, ++j )
            {
                mPix[i] = mPixY + j;
            }
            for(int i = 0,j = -mV; i < ((2*mV)+1); ++i, ++j )
            {
                if(mPix[i] == Y)
                {
                    gefunden = true;
                    break;
                }
            }
        }
        
        if(gefunden)
        {
            jetzt = true;
        }
        
        
        return jetzt;
    }
    /**
     * gibt GEschwindigkeit des Monsters aus
     */
    public int getSpeed()
    {
        return monsterCurSpeed;
    }
    
   
    /**
     * zieht Leben des MOnsters ab
     * 
     * @param 'life': abzuziehendes Leben
     * 
     */
    public void removeLife( int Life )
    {
        monsterCurLife -= Life;
    }
    /**
     * Falls ein Monster in die World hinzugefügt wurde--> erstelle eine Lebensanzeige
     */
    @Override
    public void addedToWorld(World world)
    {
        setImage(monsterImage);
    }
    /**
     * zeiht dem Monster Geschwindigkeit ab
     * 
     * @param 'Speed': abzuziehende Geschwindigkeit
     * 
     */
    public void monsterRemovesSpeed(int Speed)
    {
        monsterCurSpeed -= Speed;
    }
}
