worldmodel.cpp

2006年世界杯足球赛2D仿真组第16名的源代码。在此代码上随便改改

				putOutOfVisibleAngle(*fullPlayers[TID_TEAMMATE][i]);

			changePosDevBySee(*fullPlayers[TID_TEAMMATE][i]);
		}

		if (fullPlayers[TID_OPPONENT][i]->isAlive() &&
			fullPlayers[TID_OPPONENT][i]->getSeeTime() != getCurTime())
		{
			putOutOfVisibleDistance(*fullPlayers[TID_OPPONENT][i]);

			if (fabs(fullPlayers[TID_OPPONENT][i]->getHeadVec().getDirection()) <
				body->getViewAngle() - CHANGE_PLACE_SURE_ANGLE &&
				fullPlayers[TID_OPPONENT][i]->getAbsVec().getMagnitude() <
				UNUM_FAR_LENGTH - CHANGE_PLACE_SURE_DIST)
				putOutOfVisibleAngle(*fullPlayers[TID_OPPONENT][i]);

			changePosDevBySee(*fullPlayers[TID_OPPONENT][i]);
		}
	}

	for (i = 0; i <= HALF_PLAYERS_NUM; i++)
	{
		if (halfPlayers[TID_TEAMMATE][i]->isValid() &&
			halfPlayers[TID_TEAMMATE][i]->getSeeTime() != getCurTime())
		{
			putOutOfVisibleDistance(*halfPlayers[TID_TEAMMATE][i]);

			if (fabs(halfPlayers[TID_TEAMMATE][i]->getHeadVec().getDirection()) <
				body->getViewAngle() - CHANGE_PLACE_SURE_ANGLE &&
				halfPlayers[TID_TEAMMATE][i]->getAbsVec().getMagnitude() <
				TEAM_FAR_LENGTH - CHANGE_PLACE_SURE_DIST)
				putOutOfVisibleAngle(*halfPlayers[TID_TEAMMATE][i]);

			changePosDevBySee(*halfPlayers[TID_TEAMMATE][i]);
		}

		if (halfPlayers[TID_OPPONENT][i]->isValid() &&
			halfPlayers[TID_OPPONENT][i]->getSeeTime() != getCurTime())
		{
			putOutOfVisibleDistance(*halfPlayers[TID_OPPONENT][i]);

			if (fabs(halfPlayers[TID_OPPONENT][i]->getHeadVec().getDirection()) <
				body->getViewAngle() - CHANGE_PLACE_SURE_ANGLE &&
				halfPlayers[TID_OPPONENT][i]->getAbsVec().getMagnitude() <
				TEAM_FAR_LENGTH - CHANGE_PLACE_SURE_DIST)
				putOutOfVisibleAngle(*halfPlayers[TID_OPPONENT][i]);

			changePosDevBySee(*halfPlayers[TID_OPPONENT][i]);
		}
	}

	// Ball change place
	if (ball->isValid() && ball->getSeeTime() != getCurTime())
	{
		putOutOfVisibleDistance(*ball);
		changePosDevBySee(*ball);
	}

}

void WorldModel::updateMarkingPlayers() 
{
    markers.clear();
    
    for (int i = 0; i < FULL_PLAYERS_NUM; ++i) {
        if (getFullPlayer(TID_OPPONENT, i).isValid()) {
            if (getBody().getDistance(getFullPlayer(TID_OPPONENT, i)) <= 7) {
                // saving  information related to OTHER PLAYERS
                unsigned unum = getFullPlayer(TID_OPPONENT,i).getUniNum();
                correlationMap[unum].second = getCurCycle();
                if (correlationMap[unum].first.size() >= 10) {
                    for (unsigned j = 1 ; j < correlationMap[unum].first.size(); ++j)
                        correlationMap[unum].first[j-1] = correlationMap[unum].first[j];
                    correlationMap[unum].first[correlationMap[unum].first.size()-1]=
                        getFullPlayer(TID_OPPONENT,i).getPos();
                } else {
                    correlationMap[unum].first.push_back(getFullPlayer(TID_OPPONENT,i).getPos());
                }
            }
        }
    }

    // advanced STL (use IQ...)
    for (map<unsigned, pair<vector<Vector>,unsigned> >::iterator
             i = correlationMap.begin();
             i != correlationMap.end();) {
        if ( i->second.second != getCurCycle()) {
            map<unsigned, pair<vector<Vector>,unsigned> >::iterator j = i;
            ++i;
            correlationMap.erase(j);
        } else {
            ++i;
        }
    }

    if (ourPosition.size() >= 10) {
        for (unsigned j = 1 ; j < ourPosition.size(); ++j)
            ourPosition[j-1] = ourPosition[j];
        ourPosition[9]= getBody().getPos();
    } else {
        ourPosition.push_back(getBody().getPos());
    }

    for (map<unsigned, pair<vector<Vector>,unsigned> >::iterator
             i = correlationMap.begin();
             i != correlationMap.end(); ++i) {
        Vector ourSigma, oppSigma;
        float markingWeight = 0;
        if (i->second.first.size() > 1) {
            // ready for descision
            float decay = 1;
            for (int c = i->second.first.size() - 1; c >= 0; --c) {
                if (ourPosition[c].asPoint().getDistance (
                        i->second.first[c].asPoint()) <= (MARKING_AREA * (getBody().getKickableMargin() + getBody().getSize())))
                {
                    markingWeight += decay;
                }
                decay *= MARKING_DECAY_FACTOR;
            }
        } else {
            LOG << "Not enough data to decide about statistics..." << endl;
        }
        if (markingWeight > MARKING_THRESHOLD) {
            markers.insert(i->first);
            LOG << "Adding " << i->first << " to markers..." << endl;
        }
        
    }
}

void WorldModel::putOutOfVisibleAngle(Object &object)
{
	float rotateAngle;

	LOG << "obj.angle: " << object.getHeadVec().getDirection() << endl;

	if (object.getHeadVec().getDirection() > 0)
		rotateAngle = body->getViewAngle() - 
			object.getHeadVec().getDirection() +
			CHANGE_PLACE_SURE_ANGLE;
	else
		rotateAngle = -body->getViewAngle() -
			object.getHeadVec().getDirection() -
			CHANGE_PLACE_SURE_ANGLE;

	object.setAbsVec().rotate(rotateAngle);
	object.setBodyVec().rotate(rotateAngle);
	object.setHeadVec().rotate(rotateAngle);
	object.setPos() = body->getPos() + object.getAbsVec();

	if (dynamic_cast<Ball *>(&object))
		LOG << "Complete updates: ball putted out of visible angle." << endl;
	if (Player *player = dynamic_cast<Player *>(&object))
		LOG << "Complete updates: player " << player->getTeamId() << " "
			<< player->getUniNum() << " putted out of visible angle." << endl;
}

void WorldModel::putOutOfVisibleDistance(Object &object)
{
	if (object.getAbsVec().getMagnitude() < body->getVisibleDistance())
	{
		object.setAbsVec().setAsPolar(body->getVisibleDistance() +
									  PUT_OUT_VIS_SURE_DIST, object.getAbsVec().getDirection());
		object.setBodyVec().setAsPolar(body->getVisibleDistance() +
									   PUT_OUT_VIS_SURE_DIST, object.getBodyVec().getDirection());
		object.setHeadVec().setAsPolar(body->getVisibleDistance() +
									   PUT_OUT_VIS_SURE_DIST, object.getHeadVec().getDirection());

		object.setPos() = body->getPos() + object.getAbsVec();

		if (dynamic_cast<Ball *>(&object))
			LOG << "Complete updates: ball putted out of sense area." << endl;
		if (Player *player = dynamic_cast<Player *>(&object))
			LOG << "Complete updates: player " << player->getTeamId() << " "
				<< player->getUniNum() << " putted out of sense area." << endl;
	}
}

void WorldModel::changePosDevBySee(Object &object)
{
	const Player *player = dynamic_cast<const Player *>(&object);
	if (player && player->isGoalie() &&
		player->getTeamId() == TID_OPPONENT)
	{
		if (object.getAbsVec().getMagnitude() < object.getPosDeviation() +
			1.5 + PUT_OUT_VIS_SURE_DIST)
			object.setPosDeviation(object.getAbsVec().getMagnitude() -
								   1.5 - PUT_OUT_VIS_SURE_DIST);
	}

	else if (object.getAbsVec().getMagnitude() < object.getPosDeviation() +
			 body->getVisibleDistance() + PUT_OUT_VIS_SURE_DIST)
		object.setPosDeviation(object.getAbsVec().getMagnitude() -
							   body->getVisibleDistance() - PUT_OUT_VIS_SURE_DIST);
}

void WorldModel::logObjects()
{
	unsigned i;

	LOG << "Body"
		<< " Pos" << body->getPos()
		<< " Vel" << body->getVel()
		<< " Ang" << Point(body->getBodyDir(), body->getHeadDir())
		<< " Poi" << body->getPointingDir() << endl;

	LOG << "Ball"
		<< " Pos" << ball->getPos()
		<< " Vel" << ball->getVel()
		<< " Ang" << Point(ball->getBodyVec().getDirection(),
						   ball->getHeadVec().getDirection())
		<< " Len" << ball->getAbsVec().getMagnitude()
		<< " PoD" << ball->getPosDeviation()
		<< " VPoD" << ball->getValidPosDeviation() << endl;

	for (i = 0; i < FULL_PLAYERS_NUM; i++)
		if (fullPlayers[TID_TEAMMATE][i]->isValid() &&
			!fullPlayers[TID_TEAMMATE][i]->isBody())
			LOG << "OurF" << i+1
				<< " Pos" << fullPlayers[TID_TEAMMATE][i]->getPos()
				<< " Vel" << fullPlayers[TID_TEAMMATE][i]->getVel()
				<< " Ang" << Point(fullPlayers[TID_TEAMMATE][i]->getBodyDir(),
								   fullPlayers[TID_TEAMMATE][i]->getHeadDir())
				<< " Poi" << fullPlayers[TID_TEAMMATE][i]->getPointingDir()
				<< " Sta" << fullPlayers[TID_TEAMMATE][i]->getStamina()
				<< " PoD" << fullPlayers[TID_TEAMMATE][i]->getPosDeviation()
				<< " VPoD" << fullPlayers[TID_TEAMMATE][i]->getValidPosDeviation() << endl;

	for (i = 0; i < FULL_PLAYERS_NUM; i++)
		if (fullPlayers[TID_OPPONENT][i]->isValid())
			LOG << "OppF" << i+1
				<< " Pos" << fullPlayers[TID_OPPONENT][i]->getPos()
				<< " Vel" << fullPlayers[TID_OPPONENT][i]->getVel()
				<< " Ang" << Point(fullPlayers[TID_OPPONENT][i]->getBodyDir(),
								   fullPlayers[TID_OPPONENT][i]->getHeadDir())
				<< " Poi" << fullPlayers[TID_OPPONENT][i]->getPointingDir()
				<< " Sta" << fullPlayers[TID_OPPONENT][i]->getStamina()
				<< " PoD" << fullPlayers[TID_OPPONENT][i]->getPosDeviation()
				<< " VPoD" << fullPlayers[TID_OPPONENT][i]->getValidPosDeviation() << endl;

	for (i = 0; i < HALF_PLAYERS_NUM; i++)
		if (halfPlayers[TID_TEAMMATE][i]->isValid())
			LOG << "OurH" << i+1
				<< " Pos" << halfPlayers[TID_TEAMMATE][i]->getPos()
				<< " Vel" << halfPlayers[TID_TEAMMATE][i]->getVel()
				<< " Ang" << Point(halfPlayers[TID_TEAMMATE][i]->getBodyDir(),
								   halfPlayers[TID_TEAMMATE][i]->getHeadDir())
				<< " Poi" << halfPlayers[TID_TEAMMATE][i]->getPointingDir()
				<< " Sta" << halfPlayers[TID_TEAMMATE][i]->getStamina()
				<< " PoD" << halfPlayers[TID_TEAMMATE][i]->getPosDeviation()
				<< " VPoD" << halfPlayers[TID_TEAMMATE][i]->getValidPosDeviation() << endl;

	for (i = 0; i < HALF_PLAYERS_NUM; i++)
		if (halfPlayers[TID_OPPONENT][i]->isValid())
			LOG << "OppH" << i+1
				<< " Pos" << halfPlayers[TID_OPPONENT][i]->getPos()
				<< " Vel" << halfPlayers[TID_OPPONENT][i]->getVel()
				<< " Ang" << Point(halfPlayers[TID_OPPONENT][i]->getBodyDir(),
								   halfPlayers[TID_OPPONENT][i]->getHeadDir())
				<< " Poi" << halfPlayers[TID_OPPONENT][i]->getPointingDir()
				<< " Sta" << halfPlayers[TID_OPPONENT][i]->getStamina()
				<< " PoD" << halfPlayers[TID_OPPONENT][i]->getPosDeviation()
				<< " VPoD" << halfPlayers[TID_OPPONENT][i]->getValidPosDeviation() << endl;

	for (i = 0; i < QUARTER_PLAYERS_NUM; i++)
		if (quarterPlayers[i]->isValid())
			LOG << "Quar" << i+1
				<< " Pos" << quarterPlayers[i]->getPos()
				<< " Vel" << quarterPlayers[i]->getVel()
				<< " Ang" << Point(quarterPlayers[i]->getBodyDir(),
								   quarterPlayers[i]->getHeadDir())
				<< " Poi" << quarterPlayers[i]->getPointingDir()
				<< " Sta" << quarterPlayers[i]->getStamina()
				<< " PoD" << quarterPlayers[i]->getPosDeviation()
				<< " VPoD" << quarterPlayers[i]->getValidPosDeviation() << endl;

}

void WorldModel::updateCurInterCalculate()
{
	curInterCalculate.startSession(0);
//	curInterCalculate.setLogging(true);
	curInterCalculate.updateByWorldModel(this);
	curInterCalculate.run();
	curInterCalculate.logCheckedPlayers();
}

void WorldModel::updateCurKickCalculate()
{
	curKickCalculate.update(this);
}

// Some Utilities
bool WorldModel::isBallKickable() const
{
	float kickableArea;
	kickableArea = getBall().getSize() + getBody().getKickableMargin() + 
		getBody().getSize();

	if (getBall().getAbsVec().getMagnitude() <= kickableArea)
		return true;
	return false;
}

bool WorldModel::isBallKickable(const Ball &theBall) const
{
	float kickableArea;
	kickableArea = getBall().getSize() + getBody().getKickableMargin() + 
		getBody().getSize();

	if (theBall.getAbsVec().getMagnitude() <= kickableArea)
		return true;
	return false;
}

bool WorldModel::isBallCatchable() const
{
	float catchableArea;
	catchableArea = hypot(getBody().getCatchableAreaL() , 
						  (getBody().getCatchableAreaW() / 2));

	if (getBall().getAbsVec().getMagnitude() < catchableArea)
		return true;
	return false;
}

bool WorldModel::isBallCatchable(const Ball &theBall) const
{
	float catchableArea;
	catchableArea = hypot(getBody().getCatchableAreaL() , 
						  (getBody().getCatchableAreaW() / 2));

	if (theBall.getAbsVec().getMagnitude() < catchableArea)
		return true;
	return false;
}

bool WorldModel::isBallInTmmKickable() const
{
	register int i;
	float kickableArea;
	kickableArea = getBall().getSize() + getBody().getKickableMargin() + 
		getBody().getSize();
	
	for (i = 0; i < FULL_PLAYERS_NUM; i++)
		if (getFullPlayer(TID_TEAMMATE, i).isValid())
			if(!getFullPlayer(TID_TEAMMATE, i).isBody())
				if(getFullPlayer(TID_TEAMMATE, i).getDistance(getBall()) 
				   <=	kickableArea)
					return true;
					
	for (i = 0; i < HALF_PLAYERS_NUM; i++)
		if (getHalfPlayer(TID_TEAMMATE, i).isValid())
			if(!getHalfPlayer(TID_TEAMMATE, i).isBody())
				if(getHalfPlayer(TID_TEAMMATE, i).getDistance(getBall()) 
				   <=	kickableArea)
					return true;

	return false;
}

bool WorldModel::isBallInTmmKickable(const Ball &theBall) const
{
	register int i;
	float kickableArea;
	kickableArea = getBall().getSize() + getBody().getKickableMargin() + 
		getBody().getSize();
	
	for (i = 0; i < FULL_PLAYERS_NUM; i++)
		if (getFullPlayer(TID_TEAMMATE, i).isValid())
			if(!getFullPlayer(TID_TEAMMATE, i).isBody())
				if(getFullPlayer(TID_TEAMMATE, i).getDistance(theBall) 
				   <=	kickableArea)
					return true;
					
	for (i = 0; i < HALF_PLAYERS_NUM; i++)
		if (getHalfPlayer(TID_TEAMMATE, i).isValid())
			if(!getHalfPlayer(TID_TEAMMATE, i).isBody())
				if(getHalfPlayer(TID_TEAMMATE, i).getDistance(theBall) 
				   <=	kickableArea)
					return true;

	return false;
}

bool WorldModel::isBallInOppKickable() const
{
	register int i;
	float kickableArea;
	kickableArea = getBall().getSize() + getBody().getKickableMargin() + 
		getBody().getSize();
	
	for (i = 0; i < FULL_PLAYERS_NUM; i++)
		if (getFullPlayer(TID_OPPONENT, i).isValid())
			if(getFullPlayer(TID_OPPONENT, i).getDistance(getBall()) 
			   <=	kickableArea)
				return true;
					
	for (i = 0; i < HALF_PLAYERS_NUM; i++)
		if (getHalfPlayer(TID_OPPONENT,i).isValid())
			if(getHalfPlayer(TID_OPPONENT,i).getDistance(getBall()) 
			   <=	kickableArea)
				return true;

	return false;
}

bool WorldModel::isBallInOppKickable(const Ball &theBall) const
{
	register int i;
	float kickableArea;
	kickableArea = getBall().getSize() + getBody().getKickableMargin() + 
		getBody().getSize();
	
	for (i = 0; i < FULL_PLAYERS_NUM; i++)
		if (getFullPlayer(TID_OPPONENT, i).isValid())
			if(getFullPlayer(TID_OPPONENT, i).getDistance(theBall) 
			   <=	kickableArea)
				return true;
					
	for (i = 0; i < HALF_PLAYERS_NUM; i++)
		if (getHalfPlayer(TID_OPPONENT,i).isValid())
			if(getHalfPlayer(TID_OPPONENT,i).getDistance(theBall) 
			   <=	kickableArea)
				return true;

	return false;
}

bool WorldModel::isBallInField() const
{
	if (getBall().getPos().getX() < 52.5 + 0.5 && 
		getBall().getPos().getX() > -52.5 - 0.5 &&
		getBall().getPos().getY() < 34 + 0.5 && 
		getBall().getPos().getY() > -34 - 0.5)
		return true;
	return false;
}

bool WorldModel::isBallInField(const Ball &theBall)
{
	if (theBall.getPos().getX() < 52.5 + 0.5 && 
		theBall.getPos().getX() > -52.5 - 0.5 &&
		theBall.getPos().getY() < 34 + 0.5 && 
		theBall.getPos().getY() > -34 - 0.5)
		return true;
	return false;
}

float WorldModel::getBallOutDistance() const
{
	float xDistance = 0;
	float yDistance = 0;
	float distance;

	if (getBall().getPos().getX() < -52.5)
		xDistance = -getBall().getPos().getX() - 52.5;
	else if (getBall().getPos().getX() > 52.5)
		xDistance = +getBall().getPos().getX() - 52.5;

	if (getBall().getPos().getY() < -34)
		yDistance = -getBall().getPos().getY() - 34;
	else if (getBall().getPos().getY() > 34)
		yDistance = +getBall().getPos().getY() - 34;

	distance = hypot(xDistance, yDistance);
	return distance;
}

float WorldModel::getOutDistance(const Point &point)