{
	VectorCopy(_origin,vecDrawPoints[DrawPointsNextIndex].origin);
	vecDrawPoints[DrawPointsNextIndex].color_compiled = _color;
	vecDrawPoints[DrawPointsNextIndex].size = _size;
	vecDrawPoints[DrawPointsNextIndex].active = true;

	DrawPointsNextIndex++;
	if( DrawPointsNextIndex>=(int)vecDrawPoints.size() ) DrawPointsNextIndex=0;
}

// ======= DrawAllHudPoints
void DrawPoints::draw_all()
{
	typedef vector<ScheduledDrawPoint> vp;
	for( vp::iterator pos=vecDrawPoints.begin(); pos!=vecDrawPoints.end(); ++pos )
	{
		if( (*pos).active )
		{
			ScheduledDrawPoint& point = (*pos);
			point.active=false;
			gDrawFilledBoxAtLocation(point.origin,point.color_compiled,point.size);
		}
	}
}

// global DrawPoints
static DrawPoints gDrawPoints;

//===================================================================================
//===================================================================================
//===================================================================================
//===================================================================================
//===================================================================================
//===================================================================================
//===================================================================================

//==========================================================================================
void BoneAimbot::CalcTargetSpot(float* out)
{
	if( vPlayers[target].numTargetSpots && cvar.modelaim )
	{
		ModelBasedAim(out);
	} 
	else 
	{
		OriginAimbot::CalcTargetSpot(out);
	}
}

// ========================================================================
void BoneAimbot::ModelBasedAim(float* TargetVec)
{
	// try first spot:
	int i = firstaimspot;
	if( i<vPlayers[target].numTargetSpots && i>=0 )
	{
		//==========================
        //  copy+paste warning
		//==========================
		float* testvec = vPlayers[target].TargetSpots[i];
		if(pathFree(me.pmEyePos,testvec))
		{
			VectorCopy(testvec,TargetVec);
			return;
		}
	}

	for(int i=0;i<vPlayers[target].numTargetSpots;i++)
	{
		if(i==firstaimspot) continue; // already tested

		//==========================
        //  copy+paste warning
		//==========================
		float* testvec = vPlayers[target].TargetSpots[i];
		if(pathFree(me.pmEyePos,testvec))
		{
			VectorCopy(testvec,TargetVec);
			return;
		}
	}

	VectorCopy(vPlayers[target].TargetSpots[0], TargetVec );
}


//==========================================================================================
BoneAimbot::ModelInfo* BoneAimbot::getModelInfo(const char* arg_name)
{
	assert(arg_name);

	if(hashToInfo.size()>32) // prevent possible overflow
	{
		Con_Echo("&rerror: Model limit reached.");
		return NULL;
	}

	ModelInfo& info = hashToInfo[arg_name];
	info.name = arg_name;
	return &info;
}

//==========================================================================================
void BoneAimbot::draw()
{
	
	if(cvar.avdraw<=2) { OriginAimbot::draw(); return; };  // 1, 2

    
	gDrawPoints.draw_all();

}

//==============================================================================
void BoneAimbot::load(const char* filename)
{
	//ifstream ifs(filename);
	//if(!ifs) { Con_Echo( "&w%s&r read error.",filename); return; }

	//#define READ_DWORD(a)   { ifs.read((char*)&a,4); }
	//#define READ_BLOCK(a,n) { ifs.read((char*)a,n ); }

	//hashToInfo.clear();

	//int numModels;
	//READ_DWORD( numModels );


	//for(int i=0;i<numModels;i++)
	//{
	//	char tmp_name[64];
	//	int  tmp_length;
	//	READ_BLOCK( tmp_name,64 );
	//	READ_DWORD( tmp_length  );

	//	ModelInfo* pInfo = getModelInfo(tmp_name);
 //       
	//	int dummy;
	//	READ_DWORD( dummy ); // skip hash
	//	READ_DWORD( pInfo->team );
	//	READ_DWORD( pInfo->numAimspots );

	//	for( int k=0; k<pInfo->numAimspots; k++ )
	//	{
	//		ModelAimSpot& spot = pInfo->aimspots[k];
	//		READ_DWORD( spot.boneindex  );
	//		READ_DWORD( spot.boneindex2 );
	//		READ_DWORD( spot.factor2    );
	//	}
	//}

	//ifs.close();

}

//==============================================================================
void BoneAimbot::save(const char* filename)
{
	ofstream ofs(filename);
	if(!ofs) { Con_Echo( "&w%s&r write error.",filename); return; }
	else     { Con_Echo( "&w%s&g saved."      ,filename); }

	ofs<<"// this file is generated automatically. do not edit!"<<endl;
	ofs<<"mdl clear_models"<<endl;

	for( iterator pos = hashToInfo.begin(); pos!=hashToInfo.end(); ++pos )
	{
		ModelInfo& info = (*pos).second;
		ofs<<endl<<"mdl new "<<info.name<<endl;

		for(int i=0;i<info.numAimspots;i++)
		{
			ModelAimSpot& spot = info.aimspots[i];
			if(spot.boneindex)
				ofs<<"mdl add_spot "<<spot.boneindex<<" "<<spot.boneindex2<<" "<<spot.factor2<<endl;
			else
				ofs<<"mdl add_spot "<<spot.boneindex<<endl;
		}
	}
	ofs<<endl<<"mdl ov "<<offset_first.h<<" "<<offset_first.f<<" "<<offset_first.r<<endl;
}

// ==================================================================
static void calcPredictDelta(cl_entity_s* ent, float *delta)
{
	if (cvar.pred)
	{
			int  historyIndex = (ent->current_position+HISTORY_MAX-cvar.predback)%HISTORY_MAX;
			
			float* vFromOrigin = ent->ph[historyIndex].origin;
			float* vToOrigin   = ent->ph[ent->current_position].origin;
			
			delta[0] = vToOrigin[0] - vFromOrigin[0];
			delta[1] = vToOrigin[1] - vFromOrigin[1];
			delta[2] = vToOrigin[2] - vFromOrigin[2];

			delta[0] *= cvar.predahead;
			delta[1] *= cvar.predahead;
			delta[2] *= cvar.predahead;
	}
	else 
	{
        delta[0]=delta[1]=delta[2]=0;
	}
}

////==============================================================================
void BoneAimbot::PostStudioDrawPlayer( int flags, struct entity_state_s *pplayer )
{
	int ax = pplayer->number;
	//if (ax!=target) return; 
	if(!vPlayers[ax].getPVS()) return; 
	
	// non visible players return wrong bones!
	// also avoid storing bone positions for too many players
	if(GetAimingFov(ax) < (40.0-180.0)/-180.0) return; 
	
	cl_entity_s* ent = vPlayers[ax].getEnt();

	model_s* pModel = pIEngineStudio->SetupPlayerModel(ax-1);
	studiohdr_t* pStudioHeader = (studiohdr_t*)pIEngineStudio->Mod_Extradata( pModel );

	// get bone transform 
	typedef float TransformMatrix[ MAXSTUDIOBONES ][ 3 ][ 4 ];
	TransformMatrix*  pbonetransform = (TransformMatrix*)pIEngineStudio->StudioGetBoneTransform();

	// get model info
	if(cvar.avdraw==3) gSetHudMessage(pStudioHeader->name);
	ModelInfo* l_modelInfo = getModelInfo(pStudioHeader->name);
	if(!l_modelInfo) return;

	// grab target spots:
	vec3_t predictDelta; 
	calcPredictDelta(ent, predictDelta );

	for( int i=0;i<l_modelInfo->numAimspots;i++ )
	{
		ModelAimSpot& spot = l_modelInfo->aimspots[i];
		vec3_t&       pos  = vPlayers[ax].TargetSpots[i];

		pos [ 0 ] = (*pbonetransform)[ spot.boneindex  ][ 0 ][ 3 ];
		pos [ 1 ] = (*pbonetransform)[ spot.boneindex  ][ 1 ][ 3 ];
		pos [ 2 ] = (*pbonetransform)[ spot.boneindex  ][ 2 ][ 3 ];

		// interpolate between two bones
		if( spot.boneindex2 ) 
		{
			vec3_t to, diff;
			
			to  [ 0 ] = (*pbonetransform)[ spot.boneindex2 ][ 0 ][ 3 ];
			to  [ 1 ] = (*pbonetransform)[ spot.boneindex2 ][ 1 ][ 3 ];
			to  [ 2 ] = (*pbonetransform)[ spot.boneindex2 ][ 2 ][ 3 ];

			diff = to - pos;
			
			pos[0] += (spot.factor2 * diff[0]);
			pos[1] += (spot.factor2 * diff[1]);
			pos[2] += (spot.factor2 * diff[2]);
		}

		// predict
		pos[0] += predictDelta[0];
		pos[1] += predictDelta[1];
		pos[2] += predictDelta[2];

		// offset first spot
		if(!i)
		{
			vec3_t anglevec, forward, right, up, offset;
			anglevec[0]    = 0;
			anglevec[1]    = pplayer->angles[1];
			anglevec[2]    = 0;
			gEngfuncs.pfnAngleVectors(pplayer->angles,forward,right,up);
	        
			offset = forward*offset_first.f + right*offset_first.r + up*offset_first.h;
			vPlayers[ax].TargetSpots[0][0] += offset[0];
			vPlayers[ax].TargetSpots[0][1] += offset[1];
			vPlayers[ax].TargetSpots[0][2] += offset[2];
		}

		//if(ax==target)
		{
			// log for drawing
			if( cvar.avdraw==4 )
			{
				if( i==firstaimspot )  gDrawPoints.aggregate(pos,0xFF1111FF,2);
				else                   gDrawPoints.aggregate(pos,0xFFFFFFFF);
			} else
			if( cvar.avdraw==5 )
			{
				if( i==firstaimspot )  gDrawPoints.aggregate(pos,0xFF1111FF,2);
			}
		}
	}


	// handle Drawing
	if(cvar.avdraw>=3)
	{
		int i = my_curSelectedBone;
		if( i>=0 && i<pStudioHeader->numbones )
		{
			vec3_t pos;
			pos[ 0 ] = (*pbonetransform)[ i ][ 0 ][ 3 ];
			pos[ 1 ] = (*pbonetransform)[ i ][ 1 ][ 3 ];
			pos[ 2 ] = (*pbonetransform)[ i ][ 2 ][ 3 ];
			gDrawPoints.aggregate( pos, 0xFFFFAAFF, 2 );
			
			mstudiobone_t *pbones = (mstudiobone_t *)((byte *)pStudioHeader + pStudioHeader->boneindex);
			char tmp[64];sprintf(tmp,"#%d: %s",i,pbones[i].name);
			gSetHudMessage2(tmp);
		}
	}

	// update info:
	//vPlayers[ax].team           = l_modelInfo->team;
	vPlayers[ax].numTargetSpots = l_modelInfo->numAimspots;

}

//==================================================================================
void BoneAimbot::command()
{
	const char* thecommand = cmd.argC(1);

	if(0){}
	else if(!strcmp(thecommand,"first"))
	{
		firstaimspot = cmd.argI(2);
	}
	else if(!strcmp(thecommand,"list"))
	{
		//
		int i=0;
		for(HashToInfoMap::iterator pos=hashToInfo.begin();pos!=hashToInfo.end();++pos,++i)
		{
			Con_Echo("&g#%d: &w%s, spots: %d",i,(*pos).first.c_str(),(*pos).second.numAimspots );
		}
	}
	else if(!strcmp(thecommand,"select"))
	{
		//
		int scan = cmd.argI(2);
		int i=0;
		for(HashToInfoMap::iterator pos=hashToInfo.begin();pos!=hashToInfo.end();++pos,++i)
		{
			if(i==scan)
			{
				Con_Echo("current model: &r%s",(*pos).first.c_str());
				my_curModelInfo = getModelInfo( (*pos).first.c_str() );
				break;
			}
		}
	}
	else if(!strcmp(thecommand,"new"))
	{
		if(*cmd.argC(2))
		{
			my_curModelInfo = getModelInfo( cmd.argC(2) );
		}
	}
	else if(!strcmp(thecommand,"clear_models"))
	{
		my_curModelInfo=NULL;
		hashToInfo.clear();
	}
	else if(!strcmp(thecommand,"set_team"))
	{
		if(!my_curModelInfo) return;
		my_curModelInfo->team = cmd.argI(2);
	}
	else if(!strcmp(thecommand,"add_spot"))
	{
		if(!my_curModelInfo) return;
		int insert_index = my_curModelInfo->numAimspots;
		if( insert_index>=MAX_TARGET_SPOTS )
		{
			Con_Echo( "too many target spots" );
			return;
		}

		int   arg1 = cmd.argI(2);
		int   arg2 = cmd.argI(3);
		float arg3 = cmd.argF(4);
		if( arg1<0 || arg1>=MAXSTUDIOBONES || arg2<0 || arg2>=MAXSTUDIOBONES )
		{
			Con_Echo( "bone index out of bounds" );
			return;
		}

		my_curModelInfo->numAimspots++;
		ModelAimSpot& spot = my_curModelInfo->aimspots[insert_index];

		spot.boneindex  = arg1;
		spot.boneindex2 = arg2;
		spot.factor2    = arg3;
	}
	else if(!strcmp(thecommand,"clear_spots"))
	{
		if(!my_curModelInfo) return;
		my_curModelInfo->numAimspots=0;
	}
	else if(!strcmp(thecommand,"info"))
	{
		if(!my_curModelInfo) return;
		for(int i=0;i<my_curModelInfo->numAimspots;i++)
		{
			ModelAimSpot& spot = my_curModelInfo->aimspots[i];
			if(!spot.boneindex2)
			{
				Con_Echo("&w#%d&a: bone: %d",i,spot.boneindex);
			} 
			else
			{
				Con_Echo("&w#%d&a: %d -> %d , %5.3f",i,spot.boneindex,spot.boneindex2,spot.factor2);
			}
		}
		Con_Echo( "mdl=&w%s&a team=&w%d&a n=&w%d", my_curModelInfo->name.c_str(), my_curModelInfo->team, my_curModelInfo->numAimspots);
	}
	//else if(!strcmp(thecommand,"load"))
	//{
	//	string getOgcDirFile(const char* basename);
	//	load( getOgcDirFile(cmd.argC(2)).c_str() );
	//}
	else if(!strcmp(thecommand,"save"))
	{
		string getOgcDirFile(const char* basename);
		save( getOgcDirFile(cmd.argC(2)).c_str() );
	}
	else if(!strcmp(thecommand,"ov"))
	{
		offset_first.h = cmd.argF(2);
		offset_first.f = cmd.argF(3);
		offset_first.r = cmd.argF(4);
	}
	else
	{
		Con_Echo("unrecognized sub-command");
	}
}




//==================================================================================
AimingRandomizer::AimingRandomizer()
	: 
	rad_from(0),
	az_from(0),
	el_from(0),

	rad_to(0),
	el_to (0.05f),
	az_to (0.0f),

	rad(10),
	az (0),
	el (0),

	fraction(0)
	{}

//==================================================
inline float randomFloat(float from, float to)
{
    float onebased =  float(rand()) / float(RAND_MAX);
	return from + (to-from)*onebased;
}


//========================================
void AimingRandomizer::next()
{
	fraction += cvar.randspeed;
	if( fraction > 1)
	{
		// init a new target.
		fraction = 0;

		rad_from = rad_to;
		az_from  = az_to;
		el_from  = el_to;
		
		rad_to  = randomFloat(0,cvar.randmax);
		az_to   = randomFloat(0,2*M_PI);
		el_to   = randomFloat(0,2*M_PI);
	}

	// interpolate:
	rad = rad_from + (rad_to-rad_from)*fraction;
	az  = az_from  + (az_to -az_from )*fraction;
	el  = el_from  + (el_to -el_from )*fraction;

	// elevate:
	h = (float)sin(el);
	
	// rotate
	float rf_len = (float)cos(el);
	r = (float)sin(az)*rf_len;
	f = (float)cos(az)*rf_len;

	// scale
	h *= rad;
	r *= rad;
	f *= rad;
}