main.cpp

人工智能

#include "main.h"
#include "time.h"
#include "MyNeuralNetwork.h"


#define		_TIMESTEP						0.0025
#define		_TOL							1e-10
#define		_FWDTIME						10
#define		_THRUSTFACTOR					1.0
#define     _CHASESETUP						true
#define		_SPAWN_AREA_R					300

#define		_MAX_NUM_UNITS					20

#define		_UNIT_LENGTH					4

#define		_WIDEVIEW_RADIUS_FACTOR				200
#define		_NARROWVIEW_RADIUS_FACTOR			50
#define		_LIMITEDVIEW_RADIUS_FACTOR			30
#define		_CRITICAL_RADIUS_FACTOR				6

#define		_SEPARATION_FACTOR				5
#define		_BACK_VIEW_ANGLE_FACTOR			1
#define		_FRONT_VIEW_ANGLE_FACTOR		1

#define		_MAXHITPOINTS					500

// Global Variables:
int				FrameCounter = 0;
RigidBody2D		Units[_MAX_NUM_UNITS];
Vector			Target;

NeuralNetwork	TheBrain;

double			TrainingSet[14][7] = {	
0,		1,		0,		0.2,	0.9,	0.1,	0.1,
0,		1,		1,		0.2,	0.9,	0.1,	0.1,
0,		1,		0,		0.8,	0.1,	0.1,	0.1,
0.1,	0.5,	0,		0.2,	0.9,	0.1,	0.1,
0,		0.25,	1,		0.5,	0.1,	0.9,	0.1,
0,		0.2,	1,		0.2,	0.1,	0.1,	0.9,
0.3,	0.2,	0,		0.2,	0.9,	0.1,	0.1,
0,		0.2,	0,		0.3,	0.1,	0.9,	0.1,
0,		1,		0,		0.2,	0.1,	0.9,	0.1,
0,		1,		1,		0.6,	0.1,	0.1,	0.1,
0,		1,		0,		0.8,	0.1,	0.9,	0.1,
0.1,	0.2,	0,		0.2,	0.1,	0.1,	0.9,
0,		0.25,	1,		0.5,	0.1,	0.1,	0.9,
0,		0.6,	0,		0.2,	0.1,	0.1,	0.9
};


/*
double			TrainingSet[14][8] = {	
0,		1,		0,		0.2,	0.9,	0.1,	0.1,	0,
0,		1,		1,		0.2,	0.9,	0.1,	0.1,	0,
0,		1,		0,		0.8,	0.1,	0.1,	0.1,	1,
0.1,	0.5,	0,		0.2,	0.9,	0.1,	0.1,	0,
0,		0.25,	1,		0.5,	0.1,	0.9,	0.1,	0,
0,		0.2,	1,		0.2,	0.1,	0.1,	0.9,	0,
0.3,	0.2,	0,		0.2,	0.9,	0.1,	0.1,	0,
0,		0.2,	0,		0.3,	0.1,	0.9,	0.1,	0,
0,		1,		0,		0.2,	0.1,	0.9,	0.1,	1,
0,		1,		1,		0.6,	0.1,	0.1,	0.1,	1,
0,		1,		0,		0.8,	0.1,	0.9,	0.1,	0,
0.1,	0.2,	0,		0.2,	0.1,	0.1,	0.9,	0,
0,		0.25,	1,		0.5,	0.1,	0.1,	0.9,	0,
0,		0.6,	0,		0.2,	0.1,	0.1,	0.9,	0
};
*/


double			DamageRate = 0.4;


void	TrainTheBrain(void)
{
	int		i;
	double	error = 1;
	int		c = 0;	
	
	TheBrain.DumpData("PreTraining.txt");

	while((error > 0.05) && (c<50000))
	{
		error = 0;
		c++;
		for(i=0; i<14; i++)
		{
			TheBrain.SetInput(0, TrainingSet[i][0]);	
			TheBrain.SetInput(1, TrainingSet[i][1]);	
			TheBrain.SetInput(2, TrainingSet[i][2]);
			TheBrain.SetInput(3, TrainingSet[i][3]);

							
			TheBrain.SetDesiredOutput(0, TrainingSet[i][4]);	
			TheBrain.SetDesiredOutput(1, TrainingSet[i][5]);	
			TheBrain.SetDesiredOutput(2, TrainingSet[i][6]);
			//TheBrain.SetDesiredOutput(3, TrainingSet[i][7]);
	
			TheBrain.FeedForward();
			error += TheBrain.CalculateError();
			TheBrain.BackPropagate();

		}
		error = error / 14.0f;		
	}

	//c = c * 1;

	TheBrain.DumpData("PostTraining.txt");


}

void	ReTrainTheBrain(int i, double d0, double d1, double d2, double d3)
{
	double	error = 1;
	int		c = 0;	
	
	while((error > 0.1) && (c<5000))
	{
		
		c++;
		TheBrain.SetInput(0, Units[i].Inputs[0]);	
		TheBrain.SetInput(1, Units[i].Inputs[1]);		
		TheBrain.SetInput(2, Units[i].Inputs[2]);
		TheBrain.SetInput(3, Units[i].Inputs[3]);											
		TheBrain.SetDesiredOutput(0, d0);	
		TheBrain.SetDesiredOutput(1, d1);	
		TheBrain.SetDesiredOutput(2, d2);
		//TheBrain.SetDesiredOutput(3, d3);
	
		TheBrain.FeedForward();
		error = TheBrain.CalculateError();
		TheBrain.BackPropagate();		
	}

	//c = c * 1;
}

bool	Initialize(void)
{
	int i;

	GetRandomNumber(0, _WINWIDTH, true);
			
	for(i=0; i<_MAX_NUM_UNITS; i++)
	{	
		Units[i].fMass = 10;
		Units[i].fInertia = 10;
		Units[i].fInertiaInverse = 1/10;
		Units[i].vPosition.x = GetRandomNumber(_WINWIDTH/2-_SPAWN_AREA_R, _WINWIDTH/2+_SPAWN_AREA_R, false);
		Units[i].vPosition.y = GetRandomNumber(_WINHEIGHT/2-_SPAWN_AREA_R, _WINHEIGHT/2+_SPAWN_AREA_R, false);
		Units[i].fWidth = _UNIT_LENGTH/2;
		Units[i].fLength = _UNIT_LENGTH;
		Units[i].fHeight = _UNIT_LENGTH;
		Units[i].fOrientation = GetRandomNumber(0, 360, false);	
		Units[i].CD.y = -0.12*Units[i].fLength;		Units[i].CD.x = 0.0f;			// coordinates of the body center of drag
		Units[i].CT.y = -0.50*Units[i].fLength;		Units[i].CT.x = 0.0f;			// coordinates of the propeller thrust vector
		Units[i].CPT.y = 0.5*Units[i].fLength;		Units[i].CPT.x = -0.5*Units[i].fWidth;	// coordinates of the port bow thruster
		Units[i].CST.y = 0.5*Units[i].fLength;		Units[i].CST.x = 0.5*Units[i].fWidth;	// coordinates of the starboard bow thruster

		Units[i].ProjectedArea = (Units[i].fLength + Units[i].fWidth) * Units[i].fHeight;

		Units[i].ThrustForce = _THRUSTFORCE;
		Units[i].HitPoints = _MAXHITPOINTS;
		Units[i].Chase = false;
		Units[i].Flock = false;
		Units[i].Evade = false;
		Units[i].Wander = true;

	}

	Units[0].vPosition.x = 0;
	Units[0].vPosition.y = 0;
	Units[0].fOrientation = 45;
	Units[0].HitPoints = _MAXHITPOINTS;
	Units[0].ThrustForce = _THRUSTFORCE*2;

	TheBrain.Initialize(4, 3, 3/*4*/);
	TheBrain.SetLearningRate(0.2);
	TheBrain.SetMomentum(true, 0.9);
	TrainTheBrain();


	return true;
}

void	Finalize(void)
{
	TheBrain.DumpData("Final.txt");
}

void	DoUnitAI(int i)
{
		
		int		j;
		int		N;
		Vector	Pave;
		Vector	Vave;
		Vector	Fs;
		Vector	Pfs;
		Vector	d, u, v, w;
		double	m;
		int		Nf, Na;
		bool	InView;		
		int		RadiusFactor;

		// begin Flock AI
		Fs.x = Fs.y = Fs.z = 0;
		Pave.x = Pave.y = Pave.z = 0;
		Vave.x = Vave.y = Vave.z = 0;
		N = 0;
		Pfs.x = 0;
		Pfs.y = Units[i].fLength / 2.0f;
		Nf = 0;
		Na = 0;
		
		for(j=1; j<_MAX_NUM_UNITS; j++)
		{
			if(i!=j)
			{
				InView = false;
				d = Units[j].vPosition - Units[i].vPosition;
				w = VRotate2D(-Units[i].fOrientation, d);
				
				if(((w.y > 0) && (fabs(w.x) < fabs(w.y)*_FRONT_VIEW_ANGLE_FACTOR))) 
					if(d.Magnitude() <= (Units[i].fLength * _NARROWVIEW_RADIUS_FACTOR))
						Nf++;

				if(d.Magnitude() <= (Units[i].fLength * _LIMITEDVIEW_RADIUS_FACTOR))
						Na++;

				if(Units[i].Flock)
				{
					InView = (w.y > 0);
					RadiusFactor = _LIMITEDVIEW_RADIUS_FACTOR;
				}
				
				if(InView)			
				{
					if(d.Magnitude() <= (Units[i].fLength * RadiusFactor))
					{
						Pave += Units[j].vPosition;
						Vave += Units[j].vVelocity;
						N++;
					}
				}

				if(!Units[i].Flock) // even if we're not flocking keep the units apart
				{
					InView = ((w.y > 0) || ((w.y < 0) && (fabs(w.x) > fabs(w.y)*_BACK_VIEW_ANGLE_FACTOR)));
					RadiusFactor = _WIDEVIEW_RADIUS_FACTOR;
				}						

				// Separation Rule:
				if(InView)
				{					
					if(d.Magnitude() <= (Units[i].fLength * _SEPARATION_FACTOR))
					{
						if(w.x < 0) m = 1;
						if(w.x > 0) m = -1;						
						
						Fs.x += m*_STEERINGFORCE * (Units[i].fLength * _SEPARATION_FACTOR) / d.Magnitude();
					}
				}
				
			}
		}

		Units[i].NumFriends = Na;
		

		// Cohesion Rule: 
		if(Units[i].Flock && (N > 0))
		{
			Pave = Pave / N;
			v = Units[i].vVelocity;
			v.Normalize();
			u = Pave - Units[i].vPosition;
			u.Normalize();
			w = VRotate2D(-Units[i].fOrientation, u);
			if(w.x < 0) m = -1;
			if(w.x > 0) m = 1;
			if(fabs(v*u) < 1.0f)
				Fs.x += m * _STEERINGFORCE * acos(v * u) / pi;
		}

		// Alignment Rule:
		if(Units[i].Flock && (N > 0))
		{
			Vave = Vave / N;
			u = Vave;
			u.Normalize();
			v = Units[i].vVelocity;
			v.Normalize();			
			w = VRotate2D(-Units[i].fOrientation, u);
			if(w.x < 0) m = -1;
			if(w.x > 0) m = 1;
			if(fabs(v*u) < 1)
				Fs.x += m * _STEERINGFORCE * acos(v * u) / pi;
		}

		// Chase
		if(Units[i].Chase)
		{
			u = Units[0].vPosition;
			d = u - Units[i].vPosition;
			w = VRotate2D(-Units[i].fOrientation, d);
			if(w.x < 0) m = -1;
			if(w.x > 0) m = 1;
			Fs.x += m*_STEERINGFORCE;