aicommon.c

通过人工智能算法快速实现神经网络识别

#include "Toolbox.h"
#include "AICommon.h"
	
	TWindow							tbWindow;
	ai_World						MainWorld;
	
	TBitmap							terrainBMP;
	TBitmap							objectsBMP;
	TBitmap							objectsMaskBMP;
	TBitmap							offscreenBMP;

	unsigned long				nextGeneration;
	
	TRect								screenRect;
	TRect								destRect[kMaxRows][kMaxCols];
	int									averageFitness[360];

///////////////////////////////////////////////////////////////////////////////////////////////////////////

// ----------------------------------------------------------------- //
ai_World::ai_World()
// ----------------------------------------------------------------- //

{

	TRect				r;
	int					i;
	int					j;
	
	tb_InitializeToolbox();
	
	// offscreen buffer
	tb_SetRect(&screenRect,0,0,720,480);
	offscreenBMP=tb_CreateBitmap(&screenRect, 132, kScreenDepth);

	Encode();
	
	nextGeneration=0;
	
	for (i=0;i<360;i++)
		averageFitness[i]=0;
	
}

// ----------------------------------------------------------------- //
void ai_World::Encode(void)
// ----------------------------------------------------------------- //

{
	int					i;
	
	for (i=1;i<kMaxFlowers;i++)
		{
			temperature[i]=tb_Rnd(1,75);
			water[i]=tb_Rnd(1,75);
			sunlight[i]=tb_Rnd(1,75);
			nutrient[i]=tb_Rnd(1,75);
			beneficialInsect[i]=tb_Rnd(1,75);
			harmfulInsect[i]=tb_Rnd(1,75);
		}
		
	currentTemperature=tb_Rnd(1,75);
	currentWater=tb_Rnd(1,75);
	currentSunlight=tb_Rnd(1,75);
	currentNutrient=tb_Rnd(1,75);
	currentBeneficialInsect=tb_Rnd(1,75);
	currentHarmfulInsect=tb_Rnd(1,75);
	
	currentTemperature=tb_Rnd(1,75);
	currentWater=tb_Rnd(1,75);
	currentSunlight=tb_Rnd(1,75);
	currentNutrient=tb_Rnd(1,75);
	currentBeneficialInsect=tb_Rnd(1,75);
	currentHarmfulInsect=tb_Rnd(1,75);
	
}

// ----------------------------------------------------------------- //
ai_World::~ai_World()
// ----------------------------------------------------------------- //

{

}

// ----------------------------------------------------------------- //
void ai_World::UpdateWorld(void)
// ----------------------------------------------------------------- //
	
{
	int						i;
	int						fitness=0;
	
	if (TickCount()>nextGeneration)
		{

			for (i=1;i<kMaxFlowers;i++)
				fitness=fitness+Fitness(i);
			for (i=0;i<360;i++)
				if (averageFitness[i]==0)
					{
						averageFitness[i]=fitness/10;
						break;
					}
			Redraw();
			Evolve();
			nextGeneration=TickCount()+(0);
		}
		
		
}


// ----------------------------------------------------------------- //
void ai_World::KeyDown(int key)
// ----------------------------------------------------------------- //
	
{

}

// ----------------------------------------------------------------- //
int ai_World::Fitness(int flower)
// ----------------------------------------------------------------- //
	
{
	int				theFitness;
	
	
	theFitness=fabs(temperature[flower]-currentTemperature);
	theFitness=theFitness+fabs(water[flower]-currentWater);
	theFitness=theFitness+fabs(sunlight[flower]-currentSunlight);
	theFitness=theFitness+fabs(nutrient[flower]-currentNutrient);
	theFitness=theFitness+fabs(beneficialInsect[flower]-currentBeneficialInsect);
	theFitness=theFitness+fabs(harmfulInsect[flower]-currentHarmfulInsect);
		
	return (theFitness);

}

// ----------------------------------------------------------------- //
void ai_World::Evolve(void)
// ----------------------------------------------------------------- //
	
{
	int						fitTemperature[kMaxFlowers];
	int						fitWater[kMaxFlowers];
	int						fitSunlight[kMaxFlowers];
	int						fitNutrient[kMaxFlowers];
	int						fitBeneficialInsect[kMaxFlowers];
	int						fitHarmfulInsect[kMaxFlowers];
	int						fitness[kMaxFlowers];
	int						i;
	int						leastFit=0;
	int						leastFitIndex;
		
	for (i=1;i<kMaxFlowers;i++)
		if (Fitness(i)>leastFit)
			{
				leastFit=Fitness(i);
				leastFitIndex=i;
			}

	temperature[leastFitIndex]=temperature[tb_Rnd(1,10)];
	water[leastFitIndex]=water[tb_Rnd(1,10)];
	sunlight[leastFitIndex]=sunlight[tb_Rnd(1,10)];
	nutrient[leastFitIndex]=nutrient[tb_Rnd(1,10)];
	beneficialInsect[leastFitIndex]=beneficialInsect[tb_Rnd(1,10)];
	harmfulInsect[leastFitIndex]=harmfulInsect[tb_Rnd(1,10)];

	for (i=1;i<kMaxFlowers;i++)
		{
			fitTemperature[i]=temperature[tb_Rnd(1,10)];
			fitWater[i]=water[tb_Rnd(1,10)];
			fitSunlight[i]=sunlight[tb_Rnd(1,10)];
			fitNutrient[i]=nutrient[tb_Rnd(1,10)];
			fitBeneficialInsect[i]=beneficialInsect[tb_Rnd(1,10)];
			fitHarmfulInsect[i]=harmfulInsect[tb_Rnd(1,10)];
		}

	for (i=1;i<kMaxFlowers;i++)
		{
				temperature[i]=fitTemperature[i];
				water[i]=fitWater[i];
				sunlight[i]=fitSunlight[i];
				nutrient[i]=fitNutrient[i];
				beneficialInsect[i]=fitBeneficialInsect[i];
				harmfulInsect[i]=fitHarmfulInsect[i];
		}

	for (i=1;i<kMaxFlowers;i++)
		{
			if (tb_Rnd(1,100)==1)
				temperature[i]=tb_Rnd(1,75);
			if (tb_Rnd(1,100)==1)
				water[i]=tb_Rnd(1,75);
			if (tb_Rnd(1,100)==1)
				sunlight[i]=tb_Rnd(1,75);
			if (tb_Rnd(1,100)==1)
				nutrient[i]=tb_Rnd(1,75);
			if (tb_Rnd(1,100)==1)
				beneficialInsect[i]=tb_Rnd(1,75);
			if (tb_Rnd(1,100)==1)
				harmfulInsect[i]=tb_Rnd(1,75);
		}

}

// ----------------------------------------------------------------- //
void ai_World::Redraw(void)
// ----------------------------------------------------------------- //
	
{
	int							i;
	TRect						r;
	
	tb_CopyBitmap(offscreenBMP,tbWindow,&screenRect,&screenRect,false);

	tb_SetForeColor(tbWindow, 0, 32768, 0);
	
	tb_Line(tbWindow, 65, 480, 65, 480-(444-(Fitness(1))), 5);
	tb_DrawPictureToBitmap(tbWindow, 133, 65-21, 480-(444-(Fitness(1)))-47, &r);

	tb_Line(tbWindow, 130, 480, 130, 480-(444-(Fitness(2))), 5);
	tb_DrawPictureToBitmap(tbWindow, 133, 130-21, 480-(444-(Fitness(2)))-47, &r);

	tb_Line(tbWindow, 195, 480, 195, 480-(444-(Fitness(3))), 5);
	tb_DrawPictureToBitmap(tbWindow, 133, 195-21, 480-(444-(Fitness(3)))-47, &r);

	tb_Line(tbWindow, 260, 480, 260, 480-(444-(Fitness(4))), 5);
	tb_DrawPictureToBitmap(tbWindow, 133, 260-21, 480-(444-(Fitness(4)))-47, &r);

	tb_Line(tbWindow, 325, 480, 325, 480-(444-(Fitness(5))), 5);
	tb_DrawPictureToBitmap(tbWindow, 133, 325-21, 480-(444-(Fitness(5)))-47, &r);

	tb_Line(tbWindow, 390, 480, 390, 480-(444-(Fitness(6))), 5);
	tb_DrawPictureToBitmap(tbWindow, 133, 390-21, 480-(444-(Fitness(6)))-47, &r);

	tb_Line(tbWindow, 455, 480, 455, 480-(444-(Fitness(7))), 5);
	tb_DrawPictureToBitmap(tbWindow, 133, 455-21, 480-(444-(Fitness(7)))-47, &r);

	tb_Line(tbWindow, 520, 480, 520, 480-(444-(Fitness(8))), 5);
	tb_DrawPictureToBitmap(tbWindow, 133, 520-21, 480-(444-(Fitness(8)))-47, &r);

	tb_Line(tbWindow, 585, 480, 585, 480-(444-(Fitness(9))), 5);
	tb_DrawPictureToBitmap(tbWindow, 133, 585-21, 480-(444-(Fitness(9)))-47, &r);

	tb_Line(tbWindow, 650, 480, 650, 480-(444-(Fitness(10))), 5);
	tb_DrawPictureToBitmap(tbWindow, 133, 650-21, 480-(444-(Fitness(10)))-47, &r);

	for (i=0;i<360;i++)
		{
			if (averageFitness[i]>0)
				tb_Line(tbWindow, i*2, 480, i*2, 480-(300-averageFitness[i]), 2);
		}

}