junteamheterog.java

TeamBots 是一个可移植的多代理机器人仿真器

        // if you are in FRONT
        if(behind > 0) {
            if( pointside > 0)
                behindpoint.sett(behindpoint.t + Math.PI / 2);
            else
                behindpoint.sett(behindpoint.t - Math.PI / 2);
        }
        
        nextmove.sett(eball.t);
        nextmove.setr(eball.r);
        nextmove.add(behindpoint);
        nextmove.setr(MAXSPEED);
    }

    /**
       If player is approximately behind the ball with
       respect to some target point, returns true.
     */
    private boolean behindBall(Vec2 eball, Vec2 etarget) {
        if (Math.abs(eball.t - etarget.t) < Math.PI / 10) 
            return true;
        else
            return false;
    }

    /**
       Has player kick the ball.
    */
    private void kickBall() {
        attemptkick = true;
    }

    /**
       Has player avoid a collision.
     */
    private void avoidCollision() {
        if (eteammate.r < abstract_robot.RADIUS * 1.4) {
            nextmove.setx(-eteammate.x);
            nextmove.sety(-eteammate.y);
            nextmove.setr(MAXSPEED);
        } else if (eopponent.r < abstract_robot.RADIUS * 1.4) {
            nextmove.setx(-eopponent.x);
            nextmove.sety(-eopponent.y);
            nextmove.setr(MAXSPEED);
        }
    }

    //////////////////////////////////////////////////
    // Proximity functions                          //
    //////////////////////////////////////////////////

    /**
       Returns true if player is closest to ball.
     */
    private boolean closestToBall(Vec2 gplayer) {
        return closestTo(gplayer, gball);
    }
    
    /**
       Returns true if player is closest to our goal.
    */
    private boolean closestToGoal(Vec2 gplayer) {
        return closestTo(gplayer, gourgoal);
    }
    
    /**
       Returns true if player is closest to opponents goal.
    */

    private boolean closestToOppGoal(Vec2 gplayer) {
        return closestTo(gplayer, goppgoal);
    }

    /** 
        Returns true if player is closest to center of field.
     */
    private boolean closestToCenter(Vec2 gplayer) {
        return closestTo(gplayer, new Vec2(ZERO, ZERO));
    }

    /**
       Returns true if player is closest to opponent goalkeeper.
     */
    private boolean closestToGoalkeeper(Vec2 gplayer) {

        return false;
    }

    /**
       Returns true if player is closest to opponent dribbler.
     */
    private boolean closestToDribbler(Vec2 gplayer) {

        return false;
    }

    /**
       Returns true if player is closest to target point among
       teammates.
    */
    private boolean closestTo(Vec2 gplayer, Vec2 gtarget) {

        Vec2 temp = new Vec2(gplayer.x, gplayer.y);
        temp.sub(gtarget);
        
        double MyDist = temp.r;
        for (int i = 0; i < eourteam.length; i++)
            {
                temp = new Vec2(eourteam[i].x, eourteam[i].y);
                temp.add(gplayer);
                temp.sub(gtarget);
                double TheirDist = temp.r;
                if (TheirDist < MyDist)
                    return false;
            }
        return true;
    }

    /**
       Returns vector towards the closest opponent.
     */
    private Vec2 closestOpponent() {
        
        Vec2 closest = new Vec2(INFINITY, 0);
        for (int i = 0; i < eoppteam.length; i++) {
            if (eoppteam[i].r < closest.r)
                closest = eoppteam[i];
        }
        return closest;
    }
    
    /**
       Returns the vector towards the closest teammate.
    */
    private Vec2 closestTeammate() {
        Vec2 closest = new Vec2(INFINITY, 0);
        for (int i = 0; i < eourteam.length; i++) {
            if (eourteam[i].r < closest.r)
                closest = eourteam[i];
        }
        return closest;
    }

    /**
       Returns player among players closest to target.
     */

    private Vec2 closestTo(Vec2[] objects, Vec2 point) {
        double dist = INFINITY;
        Vec2 result = new Vec2(0, 0);
        Vec2 temp = new Vec2(0, 0);
        
        for( int i=0; i < objects.length; i++)
            {
                
                // find the distance from the point to the current
                // object
                temp.sett( objects[i].t);
                temp.setr( objects[i].r);
                temp.sub( point);
                
                // if the distance is smaller than any other distance
                // then you have something closer to the point
                if(temp.r < dist)
                    {
                        result = objects[i];
                        dist = temp.r;
                    }
            }
        
        return result;
    }
    
    //////////////////////////////////////////////////
    // Zone functions                               //
    //////////////////////////////////////////////////
    
    /**
       If point is in goalzone, returns true.
    */
    private boolean goalzone(Vec2 gpoint) {
        if (side == WESTSIDE) {
            if ( (Math.abs(XMIN - gpoint.x) < EPSILON) && (Math.abs(gpoint.y) < GOALMAX) ) {
                return true;
            }
        } else {
            if ( (Math.abs(XMAX - gpoint.x) < EPSILON) && (Math.abs(gpoint.y) < GOALMAX) ) {
                return true;
            }
        }
        return false;
    }

    /** 
        If point is in defzone, returns true.
    */
    private boolean defzone(Vec2 gpoint) {
        if (side == WESTSIDE) {
            if ((gpoint.x < DZXMIN) && (Math.abs(gpoint.y) < DZYMAX)) {
                return true;
            }
        } else {
            if ((DZXMAX < gpoint.x) && (Math.abs(gpoint.y) < DZYMAX)) {
                return true;
            }
        }       
        return false;
    }

    /** 
        If point is in centerzone, returns true.
    */
    private boolean centerzone(Vec2 gpoint) {
        if (gpoint.r < (abstract_robot.RADIUS * 2)) {
            return true;
        }
        return false;
    }

    /**
       If point is in neargoalzone, returns true.
     */
    private boolean neargoalzone(Vec2 gpoint) {
        if (side == WESTSIDE) {
            if (gpoint.x < (XMIN / 2)) {
                return true;
            }
        } else {
            if ((XMAX / 2) < gpoint.x) {
                return true;
            }
        }       
        return false;
    }

    /**
       If point is in nearcenterzone, returns true.
     */
    private boolean nearcenterzone(Vec2 gpoint) {
        if (side == WESTSIDE) {
            if ( ((XMIN / 2) < gpoint.x) && (gpoint.x < ZERO) ) {
                return true;
            }
        } else {
            if ( (ZERO < gpoint.x) && ((XMAX / 2) < gpoint.x) ) {
                return true;
            }
        }       
        return false;
    }

    /**
       If point is in farcenterzone, returns true.
     */
    private boolean farcenterzone(Vec2 gpoint) {
        Vec2 temp = new Vec2(-gpoint.x, -gpoint.y);
        if (nearcenterzone(temp)) {
            return true; 
        }
        return false;
    }

    /**
       If point is in fargoalzone, returns true.
     */
    private boolean fargoalzone(Vec2 gpoint) {
        Vec2 temp = new Vec2(-gpoint.x, -gpoint.y);
        if (neargoalzone(temp)) {
            return true;
        }
        return false;
    }

    //////////////////////////////////////////////////
    // Memory functions                             //
    //////////////////////////////////////////////////

    /**
       Records player location into memory
     */
    private void recordLocation() {
        for (int i = 0; i < (MEMORY - 1); i++) {
            gplayerlocations[mynumber][i].sett(gplayerlocations[mynumber][i + 1].t);
            gplayerlocations[mynumber][i].setr(gplayerlocations[mynumber][i + 1].r);
        }
        gplayerlocations[mynumber][MEMORY - 1].sett(gplayer.t);
        gplayerlocations[mynumber][MEMORY - 1].setr(gplayer.r);
    }

    /**
       Records player position into memory
    */
    private void recordPosition(int gposition) {
        for (int i = 0; i < (MEMORY - 1); i++) {
            gplayerpositions[mynumber][i] = gplayerpositions[mynumber][i + 1];
        }
        gplayerpositions[mynumber][MEMORY - 1] = gposition;
    }

    /**
       Records ball location into memory
    */
    private void recordBall() {
        for (int i = 0; i < (MEMORY - 1); i++) {
            gballlocations[i] = gballlocations[i + 1];
        }
        gballlocations[MEMORY - 1] = gball;
    }

    /**
       Retrieve last position played
    */
    private int lastPosition() {
        return gplayerpositions[mynumber][MEMORY - 1];
    }

    /**
       Print last position played
     */
    private void displayLastPosition() {
        System.out.print("Player " + mynumber + ": ");
        switch (gplayerpositions[mynumber][MEMORY - 1]) {
        case UNDEFINED:
            System.out.println("undefined");
            break;
        case GOALKEEPER:
            System.out.println("goalkeeper");
            break;
        case CENTER:
            System.out.println("center");
            break;
        case TACKLER:
            System.out.println("tackler");
            break;
        case DRIBBLER:
            System.out.println("dribbler");
            break;
        case STOPPER:
            System.out.println("stopper");
            break;
        case DEFENDER:
            System.out.println("defender");
            break;
        }
    }

    /*
      Update player positions currently filled
    */
    private void updatePositions(int position) {

        boolean different = false;

        switch (position) {
        case GOALKEEPER:
            if (lastPosition() != GOALKEEPER) {
                goalkeeper++;
                different = true;
            }
            break;
        case CENTER:
            if (lastPosition() != CENTER) {
                center++;
                different = true;
            }
            break;
        case TACKLER:
            if (lastPosition() != TACKLER) {
                tackler++;
                different = true;
            }
            break;
        case DRIBBLER:
            if (lastPosition() != DRIBBLER) {
                dribbler++;
                different = true;
            }
            break;
        case STOPPER:
            if (lastPosition() != STOPPER) {
                stopper++;
                different = true;
            }
            break;
        case DEFENDER:
            if (lastPosition() != DEFENDER) {
                defender++;
                different = true;
            }
            break;
        }

        if (different) {
            switch (lastPosition()) {
            case GOALKEEPER:
                goalkeeper--;
                break;
            case CENTER:
                center--;
                break;
            case TACKLER:
                tackler--;
                break;
            case DRIBBLER:
                dribbler--;
                break;
            case STOPPER:
                stopper--;
                break;
            case DEFENDER:
                defender--;
                break;
            case UNDEFINED:
                break;
            }
        }
    }

    //////////////////////////////////////////////////
    // Actuator functions                           //
    //////////////////////////////////////////////////    

    /**
       Executes moves for player
    */
    private void updateActuators() {
        abstract_robot.setSteerHeading(ctime, nextmove.t);
        abstract_robot.setSpeed(ctime, nextmove.r);

        if (attemptkick) {
            if (abstract_robot.canKick(ctime))
                abstract_robot.kick(ctime);
        }
        recordLocation();
        recordBall();
        updatePositions(nextposition);
        recordPosition(nextposition);
    }
}