Index: code/branches/AI_HS15/src/orxonox/controllers/CommonController.cc
===================================================================
--- code/branches/AI_HS15/src/orxonox/controllers/CommonController.cc	(revision 10795)
+++ code/branches/AI_HS15/src/orxonox/controllers/CommonController.cc	(revision 10796)
@@ -358,4 +358,197 @@
         }
     }
+    float CommonController::randomInRange(float a, float b)
+    {
+        float random = rnd(1.0f);
+        float diff = b - a;
+        float r = random * diff;
+        return a + r;
+    }
+    void CommonController::attack()
+    {
+        if ( !this->getControllableEntity() )
+            return;
+        if ( this->target_ )
+        {
+            this->positionOfTarget_ = getPredictedPosition( 
+                this->getControllableEntity()->getWorldPosition(), 
+                hardcoded_projectile_speed, 
+                this->target_->getWorldPosition(), 
+                this->target_->getVelocity() 
+                );
+            Vector3 diffVector = this->positionOfTarget_ - this->getControllableEntity()->getWorldPosition();
+            float diffLength = diffVector.length();
+            if (diffLength < 100)
+            {
+                Vector3* targetPosition;
+                targetPosition = new Vector3 ( 
+                    //randomInRange(200, 300), 
+                    0,
+                    //randomInRange(-300, -200), 
+                    0,
+                    randomInRange(-300, -400) 
+                    );
+                Quaternion rotationToTarget = (this->getControllableEntity()->getOrientation() * WorldEntity::FRONT).getRotationTo(diffVector);
+                Vector3 target = rotationToTarget * (*targetPosition);
+                moveToPoint( 
+                    target, 
+                    randomInRange(45, 180) 
+                    );
+                executingMoveToPoint_ = true; 
+                return;
+            }
+            this->bShooting_ = true;
+            this->positionOfTarget_ = getPredictedPosition( 
+                this->getControllableEntity()->getWorldPosition(), 
+                hardcoded_projectile_speed, 
+                this->target_->getWorldPosition(), 
+                this->target_->getVelocity() 
+                );
+            this->targetPosition_ = positionOfTarget_;
+
+        }    
+        else
+        {
+            this->chooseManeuverType();
+        }
+    }
+    void CommonController::scissors()
+    {
+        if ( !this->getControllableEntity() )
+            return;
+        if ( this->target_ )
+        {
+            this->positionOfTarget_ = getPredictedPosition( 
+                this->getControllableEntity()->getWorldPosition(), 
+                hardcoded_projectile_speed, 
+                this->target_->getWorldPosition(), 
+                this->target_->getVelocity() 
+                );
+            Vector3 diffVector = this->positionOfTarget_ - this->getControllableEntity()->getWorldPosition();
+            float diffLength = diffVector.length();
+            Vector3 opponentForwardVector = this->target_->getOrientation() * WorldEntity::FRONT;
+            float opponentDotProduct = diffVector.dotProduct(opponentForwardVector);            
+            
+            int f = (int) rnd(100.0f);
+            f = (f % 2 == 0 ? 1 : -1);
+
+            if(!this->executingMoveToPoint_)
+            {
+                Vector3* targetPosition;
+                if ( diffLength < 100 )
+                {
+                    targetPosition = new Vector3 ( 
+                        //f * randomInRange(200, 300), 
+                        0,
+                        //f * randomInRange(-300, -200), 
+                        0,
+                        //randomInRange(-300, -400) 
+                        0
+                        );
+                }
+                else
+                {
+                    if ( opponentDotProduct < 0 )
+                    {
+                        targetPosition = new Vector3 ( 
+                        //f * randomInRange(200, 300), 
+                        0,
+                        //f * randomInRange(-300, -200), 
+                        0,
+                        //randomInRange(-300, -400) 
+                        -300
+                        );
+                    }
+                    else
+                    {
+                        targetPosition = new Vector3 ( 
+                        //f * randomInRange(200, 300), 
+                        0,
+                        //f * randomInRange(-300, -200), 
+                        0,
+                        //randomInRange(-300, -400) 
+                        300
+                        );
+                    }
+                }
+                Quaternion rotationToTarget = (this->getControllableEntity()->getOrientation() * WorldEntity::FRONT).getRotationTo(diffVector);
+                Vector3 target = rotationToTarget * (*targetPosition);
+                moveToPoint( 
+                    target, 
+                    randomInRange(45, 180) 
+                    );
+                executingMoveToPoint_ = true;  
+            }
+        }
+        
+        else
+        {
+            this->chooseManeuverType();
+        }
+    }
+    void CommonController::gunsD()
+    {
+        if ( !this->getControllableEntity() )
+            return;
+        if ( this->target_ )
+        {
+            this->positionOfTarget_ = getPredictedPosition( 
+                this->getControllableEntity()->getWorldPosition(), 
+                hardcoded_projectile_speed, 
+                this->target_->getWorldPosition(), 
+                this->target_->getVelocity() 
+                );
+            Vector3 diffVector = this->positionOfTarget_ - this->getControllableEntity()->getWorldPosition();
+            float diffLength = diffVector.length();
+            if(!this->executingMoveToPoint_)
+            {
+                Vector3* targetPosition;
+                if ( diffLength < 200 )
+                {
+                    targetPosition = new Vector3 ( 
+                        //f * randomInRange(200, 300), 
+                        0,
+                        //f * randomInRange(-300, -200), 
+                        0,
+                        //randomInRange(-300, -400) 
+                        0
+                        );
+                }
+                else if ( diffLength < 500 )
+                {
+                    targetPosition = new Vector3 ( 
+                        //randomInRange(100, 200), 
+                        0,
+                        //randomInRange(-200, -100), 
+                        0,
+                        //randomInRange(-400, -600) 
+                        500
+                        );
+                }
+                else
+                {
+                    targetPosition = new Vector3 ( 
+                        //randomInRange(200, 300), 
+                        0,
+                        //randomInRange(-300, -200), 
+                        0,
+                        //randomInRange(-400, -600) 
+                        500
+                        );
+                }
+                Quaternion rotationToTarget = (this->getControllableEntity()->getOrientation() * WorldEntity::FRONT).getRotationTo(diffVector);
+                Vector3 target = rotationToTarget * (*targetPosition);
+                moveToPoint( 
+                    target, 
+                    randomInRange(45, 180) 
+                    );
+                executingMoveToPoint_ = true;  
+            }
+        }
+        else
+        {
+            this->chooseManeuverType();
+        }
+    }
     //to be called in action
     //PRE: relativeTargetPosition is desired position relative to the spaceship,
Index: code/branches/AI_HS15/src/orxonox/controllers/CommonController.h
===================================================================
--- code/branches/AI_HS15/src/orxonox/controllers/CommonController.h	(revision 10795)
+++ code/branches/AI_HS15/src/orxonox/controllers/CommonController.h	(revision 10796)
@@ -79,5 +79,7 @@
     class _OrxonoxExport CommonController : public Controller
     {
+
         public:
+        static const float hardcoded_projectile_speed = 750;
 
             static const float ACTION_INTERVAL = 1.0f;
@@ -147,5 +149,5 @@
             int getFiremode(std::string name);
 
-
+            float randomInRange(float a, float b);
             bool bHasTargetPosition_;
             Vector3 targetPosition_;
@@ -167,5 +169,7 @@
 
             void chooseManeuverType();
-
+            void gunsD();
+            void attack();
+            void scissors();
             FormationMode::Value formationMode_;
             Rank::Value rank_;
Index: code/branches/AI_HS15/src/orxonox/controllers/DivisionController.cc
===================================================================
--- code/branches/AI_HS15/src/orxonox/controllers/DivisionController.cc	(revision 10795)
+++ code/branches/AI_HS15/src/orxonox/controllers/DivisionController.cc	(revision 10796)
@@ -77,4 +77,34 @@
             executingMoveToPoint_ = !this->moveAndRoll(dt);
         }
+        else
+        {
+            if (this->target_)
+            {
+                this->positionOfTarget_ = getPredictedPosition( 
+                    this->getControllableEntity()->getWorldPosition(), 
+                    hardcoded_projectile_speed, 
+                    this->target_->getWorldPosition(), 
+                    this->target_->getVelocity() 
+                    );
+                Vector3 diffVector = this->positionOfTarget_ - this->getControllableEntity()->getWorldPosition();
+                float diffLength = diffVector.length();
+               /* Quaternion rotationToTarget = (this->getControllableEntity()->getOrientation() * WorldEntity::FRONT).getRotationTo(diffVector);
+                Vector3* targetPosition = new Vector3 ( 0, 0, -200 );
+                Vector3 target = rotationToTarget * (*targetPosition);*/
+                if (diffLength > 200)
+                    this->setTargetPosition( this->positionOfTarget_ - 0.6f*diffVector);
+                
+                else
+                    this->setTargetPosition( this->getControllableEntity()->getWorldPosition() );
+                executingMoveToPoint_ = true;  
+            }
+            
+            
+            if (this->maneuverType_ == ManeuverType::OFFENSIVE)
+            {
+                this->attack();
+                this->moveAndRoll(dt);
+            }
+        }
         if (this->bShooting_)
             doFire();
@@ -104,5 +134,5 @@
             }
         }*/
-        this->chooseManeuverType();
+        //this->chooseManeuverType();
         switch (this->maneuverType_)
         {
@@ -113,15 +143,26 @@
                 break;
             }
-            case ManeuverType::DEFENSIVE:
+            case ManeuverType::DEFENCIVE:
             {
                 this->gunsD();
+                break;
             }
             case ManeuverType::OFFENSIVE:
             {
                 this->attack();
+                break;
+            }
+            case ManeuverType::NEUTRAL:
+            {
+                this->scissors();
+            }
+            default:
+            {
+                this->gunsD();
+                break;
             }
         }
        
-        if (!executingMoveToPoint_)
+        /*if (!executingMoveToPoint_)
         {
             Vector3* targetPosition = new Vector3 (0, 0, -2000);
@@ -129,5 +170,5 @@
             executingMoveToPoint_ = true;
         }
-        
+        */
         if (this->myFollower_ && this->target_)
             this->myFollower_->setTarget(this->target_);
