types.h

RoboCup仿真组世界冠军源代码

/*
    Copyright (C) 2001  Tsinghuaeolus

    Authors : ChenJiang, YaoJinyi, CaiYunpeng, Lishi

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

	If you make any changes or have any comments we would appreciate a 
	message to [e-mail].
*/

#ifndef _type
#define _type
#include <stdlib.h>
#include "utils.h"

#ifndef _DEBUG_MOD
#define _DEBUG_MOD
#endif

#define TEXT_OUT 30000

enum SenseType{See_Msg,Sense_Msg,Hear_Msg,SP_Msg,SC_Msg,PP_Msg,PT_Msg,No_Msg};
enum VIEWQUALITY{VQ_High,VQ_Low};
enum VIEWWIDTH{VW_Narrow,VW_Normal,VW_Wide}; 
enum VWTime{VWT_Current,VWT_Future};

typedef int Time;
typedef int UNum;
typedef float AngleDeg;

#define PI 3.14159f
#define InvalidAngle 360.0f

enum MarkerType{
	Goal_L,
	Goal_R,

	Flag_C,
	Flag_CT,
	Flag_CB,
	Flag_LT,
	Flag_LB,
	Flag_RT,
	Flag_RB,

	Flag_PLT,
	Flag_PLC,
	Flag_PLB,
	Flag_PRT,
	Flag_PRC,
	Flag_PRB,

	Flag_GLT,
	Flag_GLB,
	Flag_GRT,
	Flag_GRB,

	Flag_TL50,
	Flag_TL40,
	Flag_TL30,
	Flag_TL20,
	Flag_TL10,
	Flag_T0,
	Flag_TR10,
	Flag_TR20,
	Flag_TR30,
	Flag_TR40,
	Flag_TR50,

	Flag_BL50,
	Flag_BL40,
	Flag_BL30,
	Flag_BL20,
	Flag_BL10,
	Flag_B0,
	Flag_BR10,
	Flag_BR20,
	Flag_BR30,
	Flag_BR40,
	Flag_BR50,
	Flag_LT30,
	Flag_LT20,
	Flag_LT10,
	Flag_L0,
	Flag_LB10,
	Flag_LB20,
	Flag_LB30,
	
	Flag_RT30,
	Flag_RT20,
	Flag_RT10,
	Flag_R0,
	Flag_RB10,
	Flag_RB20,
	Flag_RB30,
	No_Marker
};
enum PlayerSide{
	Side_My,
	Side_Opp,
	Side_Unknown,
};
enum ObjType{
	OBJ_Line,
	OBJ_Ball,
	OBJ_Marker,
	OBJ_Marker_Behind,  // Not seen but sensed obj
	OBJ_Player
};

enum SideLine{
	SL_Left,
	SL_Right,
	SL_Top,
	SL_Bottom,

	SL_No_Line
};


enum PlayMode{ 
	PM_No_Mode,	
	PM_Before_Kick_Off,
	PM_My_Kick_Off,
	PM_Their_Kick_Off,
	PM_My_Kick_In,
	PM_Their_Kick_In,
	PM_My_Corner_Kick,
	PM_Their_Corner_Kick,
	PM_My_Goal_Kick,
	PM_Their_Goal_Kick,
	PM_My_Free_Kick,
	PM_Their_Free_Kick,
	PM_My_Goalie_Free_Kick,     /* not a real play mode */
	PM_Their_Goalie_Free_Kick,  /* not a real play mode */
	PM_Drop_Ball,
	PM_My_Offside_Kick,
	PM_Their_Offside_Kick,
	PM_Play_On,
	PM_Half_Time,
	PM_Time_Up,
	PM_Extended_Time
};

enum KickOff_Mode{
	KickOff_Mine,
	KickOff_Theirs
};

enum CMDType {
	CMD_none,
	CMD_dash,
	CMD_turn,
	CMD_kick,
	CMD_say,
	CMD_turn_neck,
	CMD_catch,
	CMD_move,
	CMD_bye,
	CMD_change_view,
	CMD_sense_body,
	CMD_donothing,
	CMD_stay
};

enum ActionType{
	Action_none,
	Action_interception,

	Action_positioning_offense,
	Action_positioning_defense,
	Action_positioning_block,
	Action_positioning_mark,
	Action_positioning_coordinate,
	Action_positioning_setplay,
	Action_press,

	Action_passwait,
	Action_pass,
	Action_shoot,
	Action_dribble,
	Action_fastdribble,
	Action_catch,
	Action_turn_ball,
	Action_holdball,
	Action_avoidenemy,
	Action_clear,

	Action_visual,	
	
	Action_other
};

enum InputType{
	V_INT,
	V_FLOAT,
	V_BOOL,
	V_STRING,
	V_ONOFF,
	V_NONE
};

struct option_t {
   char	optname[50] ;
   void	*vptr ;
   InputType  vsize ;
};


#define PriorityA 1.0f
#define PriorityA_ 0.9f
#define PriorityB 0.8f
#define PriorityB_ 0.7f
#define PriorityC 0.6f
#define PriorityC_ 0.5f
#define PriorityD 0.4f
#define PriorityD_ 0.3f
#define PriorityE 0.2f
#define PriorityE_ 0.1f
#define NoPriority 0.0f
#define ALittlePriority 0.01f
#define QuarterPriority 0.025f
#define HalfPriority 0.05f
#define FifthPriority 0.02f
#define PriorityLevel 0.1f

#define Urgency_Crisis 0.9f 
#define Urgency_High 0.8f
#define Urgency_HalfHigh 0.7f
#define Urgency_Normal 0.6f
#define Urgency_HalfLow 0.45f
#define Urgency_Low 0.3f

#define InfCycles 1000.0f

enum TurnDir{
	Turn_none = 0,
	Turn_cw = 1,
	Turn_ccw = -1,
	Turn_avoid = 2,
};

enum KT_Res{
	KT_turnball,
	KT_lostball,
	KT_stopball,
	KT_kickaway,
	KT_success,
	KT_adjustball,
	KT_accelerate,
};

enum DR_Mode{
	DR_left = 1,
	DR_right = -1
};

enum KK_Mode{
	KK_fast,
	KK_slow
};

enum DribbleAction{
	DR_NoAction,
	DR_Turn,
	DR_KickTurn,
	DR_KickAdjust,
	DR_Dash,
	DR_KickForward
};

enum VS_mode{
	VS_normal,
	VS_noturn
};

enum SP_State{
	SPST_Initialize,
	SPST_Prego,
	SPST_ExecWait,
	SPST_Executing,
	SPST_AfterExec
};

enum GameState{
	GS_Before_Kick_Off,
	GS_Playing,
	GS_Their_PlaceKick,
	GS_My_PlaceKick,
	GS_Other
};

struct PlayerType{
public:
	int id;
	float player_speed_max;
	float stamina_inc_max;
	float player_decay;
	float inertia_moment;
	float dash_power_rate;
	float player_size;
	float kickable_margin;
	float kick_rand;
	float extra_stamina;
	float effort_max;
	float effort_min;
};

enum VisualObjType{
	VO_none,
	VO_ball,
	VO_player,
	VO_route,
	VO_ground
};

/*	Timed Data	*/
template <class Data> class TimedData{
public:
	TimedData(Time time = -2){ this->time = time;}
	TimedData(const Data& data, Time time){ this->data = data; this->time = time;}
	void Setdata(const Data& data, Time time){ this->data = data; this->time = time;}
	Data data;
	Time time;
	void operator = (const Data& d){ data = d;}
	TimedData operator + (TimedData d){ return TimedData(data + d, time);}
	TimedData operator - (TimedData d){ return TimedData(data - d, time);}
	TimedData operator / (TimedData d){ return TimedData(data / d, time);}
	TimedData operator * (TimedData d){ return TimedData(data * d, time);}
	/*Data operator + (Data d){ return data + d;}
	Data operator - (Data d){ return data - d;}
	Data operator / (Data d){ return data / d);}
	Data operator * (Data d){ return data * d;}
	void operator += (Data d){ data += d;}
	void operator -= (Data d){ data -= d;}
	void operator /= (Data d){ data /= d;}
	void operator *= (Data d){ data *= d;}
	bool operator == (Data d){ return bool(data == d);}
	bool operator != (Data d){ return bool(data != d);}
	bool operator >  (Data d){ return bool(data > d);}
	bool operator >= (Data d){ return bool(data >= d);}
	bool operator <  (Data d){ return bool(data < d);}
	bool operator <= (Data d){ return bool(data <= d);}*/
};

/*
template <class Data> Data operator + (Data d, TimedData<Data> timeddata){ return (timeddata.data + d);}
template <class Data> Data operator - (Data d, TimedData<Data> timeddata){ return (timeddata.data - d);}
template <class Data> Data operator / (Data d, TimedData<Data> timeddata){ return timeddata.data / d);}
template <class Data> Data operator * (Data d, TimedData<Data> timeddata){ return timeddata.data * d;}
template <class Data> void operator += (Data& d, TimedData<Data> timeddata){ d += timeddata.data;}
template <class Data> void operator -= (Data& d, TimedData<Data> timeddata){ d -= timeddata.data;}
template <class Data> void operator /= (Data& d, TimedData<Data> timeddata){ d /= timeddata.data;}
template <class Data> void operator *= (Data& d, TimedData<Data> timeddata){ d *= timeddata.data;}
template <class Data> bool operator == (Data d, TimedData<Data> timeddata){ return bool(timeddata.data == d);}
template <class Data> bool operator != (Data d, TimedData<Data> timeddata){ return bool(timeddata.data != d);}
template <class Data> bool operator >  (Data d, TimedData<Data> timeddata){ return bool(timeddata.data > d);}
template <class Data> bool operator >= (Data d, TimedData<Data> timeddata){ return bool(timeddata.data >= d);}
template <class Data> bool operator <  (Data d, TimedData<Data> timeddata){ return bool(timeddata.data < d);}
template <class Data> bool operator <= (Data d, TimedData<Data> timeddata){ return bool(timeddata.data <= d);}
*/
/*************	TimedDataArray	**********************/
template <class T, int size> class TimedDataArray{
private:
	TimedData<T> data[size];
	inline int Index(int idx){return idx % size >=0 ? idx % size : idx % size + size;}
public:	
	inline T& Data(int time){return data[Index(time)].data;}
	inline T ChkData(int time){return IsDataKnown(time) ? data[Index(time)].data : T(0);}
	inline bool IsDataKnown(int time){return data[Index(time)].time == time;}
	inline void Setdata(const T& data, int time){this->data[Index(time)].data = data; this->data[Index(time)].time = time;}
};

template <class T, int Tsize, int size> class Timed2D_Array{
private:
	TimedData<T[Tsize]> data[size];
	inline int Index(int idx){return idx % size >=0 ? idx % size : idx % size + size;}
public:	
	//inline T[]& Data(int time){return data[Index(time)].data;}	
	inline T& Data(int idx, int time){return data[Index(time)].data[idx];}
	inline bool IsDataKnown(int time){return data[Index(time)].time == time;}
	inline void Setdata(const T& data, int idx, int time){this->data[Index(time)].data[idx] = data; this->data[Index(time)].time = time;}
};

template <class T, int size> class TimedDataTri2DArray{
private:
	TimedData<T> data[size * (size -1) /2 + 1];
	inline int Index(int idx1, int idx2){
		if (!IsValidIdx(idx1, idx2))
			return size * (size -1) /2;//invalid unit
		
		if (idx1 > idx2)
			Swap(idx1, idx2);
		return (2 * size - 1  - idx1) * idx1 /2 + idx2 - idx1 - 1;
	}
public:
	inline bool IsValidIdx(int idx1, int idx2){
		if (idx1 < 0 || idx1 >= size){
		//wrong idx-1
			return false;
		}

		if (idx2 < 0 || idx2 >= size){
		//wrong idx-2
			return false;
		}

		if (idx1 == idx2){
		//wrong
			return false;
		}
		return true;
	}

	bool IsDataKnown(int idx1, int idx2, Time time){
		return data[Index(idx1, idx2)].time == time;
	}

	inline void SetData(const T& Data, int idx1, int idx2, Time time){
		data[Index(idx1, idx2)].data = Data;
		data[Index(idx1, idx2)].time = time;
	}

	inline void SetTime(int idx, int idx2, Time time){
		data[index(idx1, idx2)].time = time;
	}

	inline TimedData<T>& Element(int idx1, int idx2){ return data[Index(idx1, idx2)];}

	inline T& Data(int idx1, int idx2){return data[Index(idx1, idx2)].data;}
};

/*************	Ordered List	**********************/
template <class Data> class ListNode{
public:
	ListNode():next(NULL){}
	ListNode(Data d):next(NULL){data = d;}
	Data data;
	ListNode* next;
};

template <class Data> class OrderedList{
protected:
	ListNode<Data> * head, *pcurrent;
public: