gfc.cpp

机器人足球的一个自学的源代码

                        else if(by < 27.89 - BALLD/2)
                                keeper(robot,rID,desX,GBOTY- 2,270.0);
                        else if(by >= 52.92 && by <= 58.56 + BALLD/2){
                                if(hasEnemyNear(X,51.80) && by - ry > ROBOTWIDTH)
                                        keeper(robot,rID,desX,GTOPY + 2,270.0);
                                else
                                        sGo(robot,rID,X,FTOP);
                        }
                        else if(by <= 33.71 && by >= 27.89 - BALLD/2){
                                if(hasEnemyNear(X,30.30) && ry - by > ROBOTWIDTH)
                                        keeper(robot,rID,desX,GBOTY- 2,270.0);
                                else
                                        sGo(robot,rID,X,FBOT);
                        }
                        else if(by >33.71 && by < 52.92){
                                if(by > ry)
                                        sGo(robot,rID,X,FTOP);
                                else if(by < ry)
                                        sGo(robot,rID,X,FBOT);
                        }
                } //卡住归位
                if(rx < 7.23 + ROBOTWIDTH/2 - 0.8 && (49.68 - ry < 5.0 || ry - 33.93 < 5.0) ){
                        if(ry < my)
                                sTo(robot,rID,7.23 + ROBOTWIDTH,GBOTY + ROBOTWIDTH*3/2);
                        else if(ry > my)
                                sTo(robot,rID,7.23 +  ROBOTWIDTH,GTOPY - ROBOTWIDTH*3/2);
                }
                if(!hasEnemyIn(FLEFTX,27.89,19.80,58.56)){
                        if(bx < 19.80 && by > 27.98 && by < 58.56){
                                if(rx < bx)
                                        sGo(robot,rID,bx+ 0.5,by);
                        }
                }
        }
}

void toBRight(Robot *robot,int rID){
        //
        double rx,ry,bx,by;
        double dx,dy;
        double ax,ay;

        ax = 10;
        ay = 2*ROBOTWIDTH;
        rx = robot->pos.x;
        ry = robot->pos.y;
        bx = ENV->currentBall.pos.x;
        by = ENV->currentBall.pos.y;
        dx = rx - bx;
        dy = ry - by;
        predictBall(1/10);
        if(dx > - 3/2*ROBOTWIDTH && dx < 2){
                if(dy < 0){
                        if(PBP[1] > FBOT + 2*ROBOTWIDTH)
                                sGo(robot,rID,PBP[0],PBP[1] - ay);
                        else
                                sGo(robot,rID,PBP[0],PBP[1] + ay);
                }
                else{
                        sGo(robot,rID,PBP[0],PBP[1] + ay);
                }
                if(dy > 3/2*ROBOTWIDTH || dy < -3/2*ROBOTWIDTH){
                        sGo(robot,rID,PBP[0] + ax + 2,PBP[1] );
                }
        }
        else if(dx <= -3/2*ROBOTWIDTH){
                if(dy > 3/2*ROBOTWIDTH || dy < -3/2*ROBOTWIDTH)
                        sGo(robot,rID,PBP[0] + ax + 2,PBP[1] + ay/2);
                else if(dy > -3/2*ROBOTWIDTH && dy < 0){
                        if(PBP[1] > FBOT + 3/2*ROBOTWIDTH)
                                sGo(robot,rID,PBP[0] + ax + 2, PBP[1] - ay);
                        else
                                sGo(robot,rID,PBP[0],PBP[1] + ay);
                }
                else if(dy > 0 && dy < 3/2*ROBOTWIDTH)
                        sGo(robot,rID,PBP[0]  + ax + 2,PBP[1] + ay);
        }
        else if(dx >= 10)
                run(robot,rID,0,0);
}

void toBLeft(Robot *robot,int rID){
        //
        double rx,ry,bx,by;
        double dx,dy;
        double ax,ay;

        ax = 10;
        ay = 2*ROBOTWIDTH;
        rx = robot->pos.x;
        ry = robot->pos.y;
        bx = ENV->currentBall.pos.x;
        by = ENV->currentBall.pos.y;
        dx = rx - bx;
        dy = ry - by;
        predictBall(1/10);
        if(dx < 3/2*ROBOTWIDTH && dx > -2){
                if(dy < 0){
                        if(PBP[1] > FBOT + 2*ROBOTWIDTH)
                                sGo(robot,rID,PBP[0],PBP[1] - ay);
                        else
                                sGo(robot,rID,PBP[0],PBP[1] + ay);
                }
                else{
                        sGo(robot,rID,PBP[0],PBP[1] + ay);
                }
                if(dy >= 3/2*ROBOTWIDTH || dy <= -3/2*ROBOTWIDTH){
                        sGo(robot,rID,PBP[0] - ax - 2,PBP[1] );
                }
        }
        else if(dx >= 3/2*ROBOTWIDTH){
                if(dy > 3/2*ROBOTWIDTH || dy < -3/2*ROBOTWIDTH)
                        sGo(robot,rID,PBP[0] - ax - 2,PBP[1] + ay/2);
                else if(dy > -3/2*ROBOTWIDTH && dy < 0){
                        if(PBP[1] > FBOT + 3/2*ROBOTWIDTH)
                                sGo(robot,rID,PBP[0] - ax - 2, PBP[1] - ay);
                        else
                                sGo(robot,rID,PBP[0],PBP[1] + ay);
                }
                else if(dy > 0 && dy < 3/2*ROBOTWIDTH)
                        sGo(robot,rID,PBP[0]  - ax - 2,PBP[1] + ay);
        }
        else if(dx <= -10)
                run(robot,rID,0,0);
}

void toBUp(Robot *robot,int rID){
        //
        double rx,ry,bx,by;
        double dx,dy;

        rx = robot->pos.x;
        ry = robot->pos.y;
        bx = ENV->currentBall.pos.x;
        by = ENV->currentBall.pos.y;
        dx = rx - bx;
        dy = ry - by;
        if(fabs(dx) > 5){
                if(dy > 0)
                        sGo(robot,rID,bx,by + 3/2*ROBOTWIDTH);
                else if(dy < 0)
                        sGo(robot,rID,bx,by + 3/2*ROBOTWIDTH);
        }
        else if(dx > 0 && dx < 5){
                if(dy >= 1)
                        sGo(robot,rID,bx,by + 3/2*ROBOTWIDTH);
                else if(dy < 1)
                        sGo(robot,rID,bx + 6,by -0.5);
        }
        else if(dx < 0 && dx > -5){
                if(dy >= 1)
                        sGo(robot,rID,bx,by + 3/2*ROBOTWIDTH);
                else if(dy < 1)
                        sGo(robot,rID,bx - 6,by -0.5);
        }
}

void toBDown(Robot *robot,int rID){
        //
        double rx,ry,bx,by;
        double dx,dy;

        rx = robot->pos.x;
        ry = robot->pos.y;
        bx = ENV->currentBall.pos.x;
        by = ENV->currentBall.pos.y;
        dx = rx - bx;
        dy = ry - by;
        if(fabs(dx) > 5){
                if(dy > 0)
                        sGo(robot,rID,bx,by - 3/2*ROBOTWIDTH);
                else if(dy < 0)
                        sGo(robot,rID,bx,by - 3/2*ROBOTWIDTH);
        }
        else if(dx > 0 && dx < 5){
                if(dy <= -1)
                        sGo(robot,rID,bx,by - 3/2*ROBOTWIDTH);
                else if(dy > -1)
                        sGo(robot,rID,bx + 6,by +0.5);
        }
        else if(dx < 0 && dx > -5){
                if(dy <= -1)
                        sGo(robot,rID,bx,by - 3/2*ROBOTWIDTH);
                else if(dy > -1)
                        sGo(robot,rID,bx - 6,by +0.5);
        }
}

void leftSoccer(Robot *robot,int rID){
        //
        double rx,ry,bx,by;
        double dx,dy;
        double bvd,bv;
        double desX,desY;
        double L; //活动边界
        double revise;

        revise = 5.0;
        rx = robot->pos.x;
        ry = robot->pos.y;
        bx = ENV->currentBall.pos.x;
        by = ENV->currentBall.pos.y;
        dx = rx - bx;
        dy = ry - by;
        bvd = BALLVDIRECTION[0];
        bv = BALLEV[0];
        if(bv > 100 || l(rx,ry,bx,by) > 15)
                predictBall(1/8);
        else if(bv > 80 || l(rx,ry,bx,by) > 10)
                predictBall(1/15);
        else if(bv > 50 || l(rx,ry,bx,by) > 7)
                predictBall(1/25);
        else
                predictBall(1/40);
        if(l(rx,ry,bx,by) < 3)
                predictBall(0.0);
        if(WHO ==1){
                L = 33.71 + revise;
                if(by < L){ //球在范围
                        if(rx > bx+ 2.5){ //挨在球右边
                                if(fabs(dx) < BALLD/2 + sqrt(2)*ROBOTWIDTH/2 && fabs(dy) < BALLD/2 + ROBOTWIDTH/2){
                                        if(by < FBOT + ROBOTWIDTH){
                                                if(hasEnemyNear(bx,by))
                                                        turn(robot,rID,1);
                                                else
                                                        sGo(robot,rID,PBP[0],PBP[1] + 1);
                                        }
                                        else{
                                                if(bx < 27.81)
                                                        turnKick(robot,rID,2);
                                                else
                                                        sGo(robot,rID,GLEFT,(FTOP + FBOT)/2);
                                        }
                                }
                                else{
                                        if(by < FBOT + ROBOTWIDTH)
                                                sGo(robot,rID,bx,by + 1);
                                        else
                                                sGo(robot,rID,PBP[0],PBP[1]);
                                }                
                        }
                        else{ //在球左边
                                toBRight(robot,rID);
                        }
                        if(bx < FLEFTX + ROBOTWIDTH){ //球到敌方底线
                                if(dy < -0.5 && dy > -3.0 && fabs(dx) < BALLD/2 + sqrt(2)*ROBOTWIDTH/2){
                                        if(hasEnemyNear(bx,by))
                                                turn(robot,rID,1);
                                        else
                                                sGo(robot,rID,PBP[0],PBP[1] + 1);
                                }
                                else if(dx > 1){
                                        toBDown(robot,rID);
                                }
                                else
                                        sGo(robot,rID,PBP[0],PBP[1]);
                        }
                        if(bx > 70.12){ //回防
                                if(rx - bx > 2.5){
                                        sGo(robot,rID,PBP[0] - 1,PBP[1]);
                                }
                                else{
                                        if(by < 27.89 - ROBOTWIDTH){
                                                toBRight(robot,rID);
                                        }
                                        else
                                                keeper(robot,rID,FRIGHTX - ROBOTWIDTH,27.89 - ROBOTWIDTH/2,180.0);
                                }
                        }
                        if(bx > FRIGHTX - ROBOTWIDTH){ //球到我方底线
                                if(dy > 0.5 && dy < 2.5 && fabs(dx) < 1.2){
                                        if(hasEnemyNear(bx,by))
                                                turn(robot,rID,1);
                                        else
                                                sGo(robot,rID,bx,by);
                                }
                                else if(dy > 0.5 && fabs(dx) < 1.8)
                                        sGo(robot,rID,PBP[0],PBP[1]);
                                else //if(dx < -1)
                                        toBUp(robot,rID);
                        }
                }
                else if(by > L){ //球不在范围
                        if(bvd > 180.0 && bvd < 360.0){
                                double k;
                                desY = 19.94;
                                k = tanf(bvd/180.0*PI);
                                desX = fn(k,bx,by,desY);
                                desX += 3*ROBOTWIDTH;
                                if(desX > 70.12)
                                        desX = 70.12;
                                if(desX < 27.81)
                                        desX = 27.81;
                                sTo(robot,rID,desX,desY);
                        }
                        else{
                                desY = 19.94;
                                desX = bx + 3*ROBOTWIDTH;
                                if(desX > 70.12)
                                        desX = 70.12;
                                if(desX < 27.81)
                                        desX = 27.81;
                                sTo(robot,rID,desX,desY);
                        }
                }
        }
        else{ //for yellow
                L = 52.92 - revise;
                if(by > L){ //球在范围
                        if(rx < bx -2.5){ //挨在球左边
                                if(fabs(dx) < BALLD/2 + sqrt(2)*ROBOTWIDTH/2 && fabs(dy) < BALLD/2 + ROBOTWIDTH/2){
                                        if(by > FTOP - ROBOTWIDTH){
                                                if(hasEnemyNear(bx,by))
                                                        turn(robot,rID,1);
                                                else
                                                        sGo(robot,rID,PBP[0],PBP[1] + 1);
                                        }
                                        else{
                                                if(bx > 70.12)
                                                        turnKick(robot,rID,4);
                                                else
                                                        sGo(robot,rID,GRIGHT,(FTOP + FBOT)/2);
                                        }
                                }
                                else{
                                        if(by > FTOP - ROBOTWIDTH)
                                                sGo(robot,rID,bx,by + 1);
                                        else
                                                sGo(robot,rID,PBP[0],PBP[1]);
                                }                
                        }
                        else{ //在球右边
                                toBLeft(robot,rID);
                        }
                        if(bx > FRIGHTX - ROBOTWIDTH){ //球到敌方底线