新建 文本文档.txt

机器人的程序有需要的可以下古的支持本意发展

// 程序和平台之间交互的接口文件//  －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

#ifndef _INTERFACE_H_
#define _INTERFACE_H_

// 动态连接库中接口函数声明的宏定义
#ifdef  STRATEGY_EXPORTS
#define STRATEGY_API __declspec(dllexport)
#else
#define STRATEGY_API __declspec(dllimport)
#endif

#include <string.h>
#include <stdio.h>

//        -------------------------------全局参数----------------------------------------

const double PI = 3.1415923;                                                                // 

const long PLAYERS_PER_SIDE = 5;                                                        // 每队球员个数

// 比赛状态
const long FREE_BALL     = 1;                                                                // 当是自由球
const long PLACE_KICK    = 2;                                                                // 点球
const long PENALTY_KICK  = 3;                                                                // 罚球
const long FREE_KICK     = 4;                                                                // 任意球
const long GOAL_KICK     = 5;                                                                // 门球

// 发球方
const long ANYONES_BALL  = 0;                                                                // 没有发球方
const long BLUE_BALL     = 1;                                                                // 蓝队发球
const long YELLOW_BALL   = 2;                                                                // 黄队发球

// 场地信息
const double FTOP        = 77.2392;                                                        // 场地上边界
const double FBOT        = 6.3730;                                                        // 场地下边界
const double FRIGHTX     = 93.4259;                                                        // 场地右边界
const double FLEFTX      = 6.8118;                                                        // 场地左边界

const double GTOPY       = 49.6801;                                                        // 球门上边界
const double GBOTY       = 33.9320;                                                        // 球门下边界
const double GRIGHT      = 97.3632;                                                        // 球门右边界
const double GLEFT       = 2.8748;                                                        // 球门左边界


//位置向量定义
typedef struct
{
        double x, y, z;
} Vector3D;

//区域范围定义
typedef struct
{
        long left, right, top, bottom;
} Bounds;

//机器人的信息定义
typedef struct
{
        Vector3D pos;                                                                                        //机器人坐标
        double rotation;                                                                                //机器人方向角
        double velocityLeft, velocityRight;                                                //机器人左右轮速度
} Robot;

//对方机器人的信息的定义
typedef struct
{
        Vector3D pos;                                                                                        //机器人的坐标位置
        double rotation;                                                                                //机器人当前的转角
} OpponentRobot;

//小球的位置定义
typedef struct
{
        Vector3D pos;                                                                                        //小球的坐标位置
} Ball;

//主要的定义，包含所有运行时的的信息，由系统刷新
typedef struct
{
        Robot home[PLAYERS_PER_SIDE];                                                                        //我方机器人数组
        OpponentRobot opponent[PLAYERS_PER_SIDE];                                                        //敌方机器人数组
        Ball currentBall,                                                                                //当前小球的位置
                 lastBall,                                                                                //上一次小球的位置
                 predictedBall;                                                                                //预计的小球的位置
        Bounds fieldBounds,                                                                                //场地范围
                   goalBounds;                                                                                //球门的位置与范围
        long gameState;                                                                                        //当前游戏的状态
        long whosBall;                                                                                        //由谁控制球
        void *userData;                                                                                        //用户自定义信息
} Environment;                

//##ModelId=440D001A0271
typedef void (*MyStrategyProc)(Environment*);

extern "C" STRATEGY_API void Create ( Environment *env );        // Create    程序的初始化
extern "C" STRATEGY_API void Strategy ( Environment *env );        // Strategy  程序的主要执行逻辑
extern "C" STRATEGY_API void Destroy ( Environment *env );        // Destroy   程序的销毁

#endif // _INTERFACE_H_
//  －－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

[size=2[color=Red]]// 程序和平台之间交互的接口文件实现

#include <windows.h>
#include "InterFace.h"
#include "Strategy.h"

BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved )
{    
    return TRUE;
}

extern "C" STRATEGY_API void Create ( Environment *env )
{
}

extern "C" STRATEGY_API void Destroy ( Environment *env )
{
}

extern "C" STRATEGY_API void Strategy ( Environment *env )
{
        int testInt = 100;
        int nIndex  = 0;

        switch (env->gameState)
        {
                case 0:
                        {
                                // 缺省情况下的策略
                                // 三个机器人进行追逐对方的策略

                                MoonFollowOpponent ( &env->home [1], &env->opponent [2] );
                                MoonFollowOpponent ( &env->home [2], &env->opponent [3] );
                                MoonFollowOpponent ( &env->home [3], &env->opponent [4] );
                                
                                // 第四个抢球
                                MoonAttack ( &env->home [4], env );
                                // 守门员守门
                                Goalie1 ( &env->home [0], env );

                        }                                
                        break;

                case FREE_BALL:
                        {
                                // 跟随对方机器人
                                MoonFollowOpponent ( &env->home [1], &env->opponent [2] );
                                MoonFollowOpponent ( &env->home [2], &env->opponent [3] );
                                MoonFollowOpponent ( &env->home [3], &env->opponent [4] );

                                // 抢球
                                MoonAttack ( &env->home [4], env );

                                // 守门员守门
                                Goalie1 ( &env->home [0], env );
                        }
                        break;

                case PLACE_KICK:
                        {
                                // 发生坠球时的策略
                                // 由二号小车发球
                                MoonAttack ( &env->home [2], env );
                        }                        
                        break;        
                        
                case PENALTY_KICK:

                        // 发生罚球时的策略
                        switch (env->whosBall)
                        {
                                case ANYONES_BALL:
                                        MoonAttack ( &env->home [1], env );
                                        break;
                                case BLUE_BALL:
                                        MoonAttack ( &env->home [4], env );
                                        break;
                                case YELLOW_BALL:
                                        MoonAttack ( &env->home [0], env );
                                        break;
                        }
                        break;

                case FREE_KICK:
                        {
                                // 保存对方机器人的相关坐标
                                FILE * pDebugFile = NULL; 
                                pDebugFile = fopen("debugfile.txt", "a"); 
                                
                                for( nIndex = 0; nIndex < PLAYERS_PER_SIDE; nIndex++ ) 
                                {
                                        fprintf( pDebugFile, "robot: %d x: %f y: %f z: %f \n", 
                                                nIndex, env->opponent[nIndex].pos.x, 
                                                env->opponent[nIndex].pos.y, 
                                                env->opponent[nIndex].pos.z ); 
                                }                
                                
                                fclose(pDebugFile); 

                                // 发生任意球时的策略
                                MoonAttack ( &env->home [0], env );
                        }
                        break;

                case GOAL_KICK:
                        {
                                // 发生点球时的策略
                                MoonAttack ( &env->home [0], env );
                        }                        
                        break;
  }
}