pass.h

RoboCup 2D 仿真组老牌强队Mersad 2005的完整源代码

/*
 *  Copyright 2002-2005, Mersad Team, Allameh Helli High School (NODET).
 *
 *  This program is free software, you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation.
 *
 *  This program 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 Library General Public License for more details.
 *
 *  This file is created by: Ahmad Boorghany
 *
 *  Released on Monday 1 August 2005, 10 Mordad 1384 by Mersad RoboCup Team.
 *  For more information please read README file.
*/

#ifndef __PASS_H
#define __PASS_H


#include <Dribble.h>
#include <AdvancedAction.h>


#define CROSS_DIR_STEP 5.00
#define CROSS_DIR_NUM 12
#define CROSS_CENTER_POINT Point(45, 0)
#define CROSS_CALCULATES_NUM CROSS_DIR_NUM
#define CROSS_PERMITTED_X 30

#define MIN_PASS_DIST 2
#define MAX_FACTORS_NUM 4
#define PASS_OFFSIDE_DELTA_DIST (-2)
#define SUGGEST_REAL_DELTA_WEIGHT (-6)

#define BPM_CROSS 1
#define BPM_OFFENSE 2
#define BPM_SECUREBALL 4
#define BPM_BREAKOFFSIDE 8
#define BPM_SUGGESTED 16
#define BPM_ALL (BPM_CROSS+BPM_OFFENSE+BPM_SECUREBALL+BPM_BREAKOFFSIDE+BPM_SUGGESTED)

#define BPN_ALL 0
#define BPN_HALF_PLAYERS 12

enum PassModel
{
	PAM_NONE,
	PAM_CROSS,
	PAM_OFFENSE,
	PAM_SECURE_BALL,
	PAM_BREAK_OFFSIDE,
	PAM_SUGGESTED,
	PAM_KICK_OFF
};

struct PassWeightFactor
{
	float minValue;
	float maxValue;
	float minWeight;
	float maxWeight;
};

struct PassFactors
{
	PassWeightFactor posDev;
	PassWeightFactor offense;
	PassWeightFactor seeInfo;
	PassWeightFactor ballDist;
	PassWeightFactor dashDist;
	PassWeightFactor breakOffside;
	PassWeightFactor passedOppNum;
	PassWeightFactor statusOppNum;
	PassWeightFactor securityDeltaCycle;
	PassWeightFactor statusOppDist;
	PassWeightFactor statusOppDir;
	PassWeightFactor statusShoot;
	PassWeightFactor dribblePath;
	PassWeightFactor defenseLine;
	PassWeightFactor extraCatch;
};

struct ExactPassFlag
{
	float weight;
	unsigned simulateID;

	PassModel model;
	const Player *player;
	const KickInterceptCalculate *interCalc;
};

class CrossCalculate: public KickCalculate
{
  public:
	virtual ~CrossCalculate();

	void init();
	void update(const WorldModel *worldModel);
};

class Pass: public AdvancedAction
{
protected:
	// global pass vars
    float crossRate;
    float crossAlpha;
    float offenseRate;
    float offenseAlpha;
    float secureBallRate;
    float secureBallAlpha;
    float breakOffsideRate;
    float breakOffsideAlpha;
    unsigned logLevel;

    float offenseValues[KICK_CALCULATES_NUM];
    float secureBallValues[KICK_CALCULATES_NUM];
    float breakOffsideValues[KICK_CALCULATES_NUM];
    float crossValues[KICK_CALCULATES_NUM + CROSS_CALCULATES_NUM];

    unsigned offenseMaxer;
    unsigned secureBallMaxer;
    unsigned breakOffsideMaxer;
    unsigned crossMaxer;

    PassFactors crossFactors;
    PassFactors offenseFactors;
    PassFactors secureBallFactors;
    PassFactors breakOffsideFactors;

    DribblePath dribblePath;
    CrossCalculate *crossCalculate;
    const KickCalculate *curKickCalculate;

	// the best pass informations
    float passValue;
    PassModel passModel;
    KickCommand *passCommand;
    const Player *passPlayer;
    const KickInterceptCalculate *passInterCalc;

    void fillValues();
    void resetValues();
    void fillMaxValues();
    void applyGlobalVars();
    void loadPassFactors();
    void applyNoiseValues();
    void calculateGlobalVars();
    void fillPassValuesByFactors(const KickCalculate &kickCalc,
                                 const PassFactors **factors,
                                 float *valuesList[], unsigned num = 1);
    void fillOnePassValuesByFactors(const KickInterceptCalculate &interCalc,
                                    const PassFactors **factors,
                                    float *valuesList[], unsigned num = 1);
    void fillOtherCrossValuesByFactors(const CrossCalculate &crossCalc,
                                       const PassFactors &factors, float values[]);
    float getTheBestPass(const KickInterceptCalculate *&interCalc);
    float getPlanWeight(unsigned kickerNum, unsigned passNum,
			const Point &kickPoint);

public:
    Pass(const WorldModel *worldModel, bool dontCreateCrossCalc = false);
    virtual ~Pass();

    static float getShootDirValue(const Point &point,
                                  const WorldModel *worldModel);

    virtual void execute(Form &form, const Library &library);
    virtual float getValue(const Library &library);

	// getting functions
    float getPassValue() const;
    PassModel getPassModel() const;
    const Player *getPassPlayer() const;
    const KickInterceptCalculate *getPassInterCalc() const;

	// setting functions
    void setCurKickCalculate(const KickCalculate *curKickCalculateArg);
};

class PassLibrary: public Pass
{
private:

public:
	PassLibrary(const WorldModel *worldModel);

	void calculate();
	ExactPassFlag PassLibrary::getTheBestPass(
			unsigned models = BPM_ALL, unsigned number = BPN_ALL,
			float passAngleFrom = -180, float passAngleTo = +180,
			float playerAngleFrom = -180, float playerAngleTo = +180) const;
	Command* PassLibrary::execute(const ExactPassFlag passLib,
			Form &form, const Library &library) const;
};

#endif // __PASS_H