//////////////////////////////////////////////////////////////////////////////
//
// Asura_Project_Chunk_Entity.cpp
//
// Copyright (c) 2006 Rebellion. All rights reserved.
//
//////////////////////////////////////////////////////////////////////////////

// I N C L U D E S ///////////////////////////////////////////////////////////

#include "Core/Asura.h"

// Engine independent.
#include "ChunkSystem/Asura_Chunk_Entity.h"
#include "ChunkSystem/Asura_Chunk_Stream.h"
#include "Entity/Triggers/Asura_ServerEntity_CountedVolumeTrigger.h"
#include "Entity/Triggers/Asura_ServerEntity_DebugWaypointTrigger.h"
#include "Entity/Asura_StaticMessage_System.h"

// Project independent.
#include "Blueprint/AVP_Blueprint_HashIDs.h" // To access uAVP_BLUEPRINT_TYPE_ACTORS
#include "Camera/AVP_CameraShake_System.h"
#include "Core/AxonAVP_Messages.h"
#include "Entity/AVP_Entity_Classification.h"
#include "Entity/AVP_Messages.h"
#include "Entity/AVP_Server_Messages.h"
#include "Entity/CameraVolume/AVP_ClientEntity_CameraVolume.h"
#include "Entity/CameraVolume/AVP_ServerEntity_CameraVolume.h"
#include "Entity/CheckPointNode/AVP_ServerEntity_CheckPointNode.h"
#include "Entity/Controller/AVP_Controller_Messages.h"
#include "Entity/Controller/AVP_ServerEntity_Squad_Alien.h"
#include "Entity/Controller/AVP_ServerEntity_Squad_FaceHugger.h"
#include "Entity/Controller/AVP_ServerEntity_Squad_Marine.h"
#include "Entity/Controller/AVP_ServerEntity_Team_Alien.h"
#include "Entity/Controller/AVP_ServerEntity_Team_Marine.h"
#include "Entity/GameMode/AVP_ServerEntity_GameMode.h"
#include "Entity/GamePlayVolume/AVP_ServerEntity_GamePlayVolume.h"
#include "Entity/Locations/FleePoint/AVP_ServerNode_FleePoint.h"
#include "Entity/Locations/FormationPoint/AVP_ServerNode_FormationPoint.h"
#include "Entity/Locations/GuardZone/AVP_ServerNode_GuardZone.h"
#include "Entity/Locations/LookAt/AVP_ServerEntity_LookAt.h"
#include "Entity/Locations/Objective/AVP_ServerNode_Objective.h"
#include "Entity/Locations/Objective/Marine/AVP_ServerEntity_Objective_Marine.h"
#include "Entity/ObjectiveSystem/PlayerObjective/AVP_ServerEntity_PlayerObjective.h"
#include "Entity/Locations/OrientedNode/AVP_ServerNode_OrientedNode.h"
#include "Entity/Locations/OrientedNode/CoverpointNode/AVP_ServerNode_CoverpointNode.h"
#include "Entity/Locations/OrientedNode/GamesceneNode/AVP_ServerNode_GS2Node.h"
#include "Entity/Locations/OrientedNode/GamesceneNode/AttractorNode/AVP_ServerNode_GS2Attractor.h"
#include "Entity/ObjectiveSystem/RoomNode/AVP_ServerEntity_RoomNode.h"
#include "Entity/ObjectiveSystem/PlayerObjective/AVP_PlayerObjective_Messages.h"
#include "Entity/ObjectiveSystem/PlayerObjective/AVP_ServerEntity_LocationMarker.h"
#include "Entity/Locations/ShootAt/AVP_ServerEntity_ShootAt.h"
#include "Entity/Locations/Spline/GamesceneSpline/AVP_ServerNode_GS2Spline.h"
#include "Entity/Locations/VantagePoint/AVP_ServerNode_VantagePoint_Predator.h"
#include "Entity/MotionTrackerBlip/AVP_ServerEntity_MotionTrackerBlip.h"
#include "Entity/PhysicalObject/AVP_PhysicalObject_Messages.h"
#include "Entity/PhysicalObject/Actor/AVP_Actor_Messages.h"
#include "Entity/PhysicalObject/Actor/Vehicles/Dropship/AVP_ServerVehicle_Dropship.h"
#include "Entity/PhysicalObject/Actor/Vertebrates/Alien/AVP_ServerActor_Alien.h"
#include "Entity/PhysicalObject/Actor/Vertebrates/AlienQueen/AVP_ServerActor_AlienQueen.h"
#include "Entity/PhysicalObject/Actor/Vertebrates/AlienQueen/AVP_AlienQueen_Messages.h"
#include "Entity/PhysicalObject/Actor/Vertebrates/FaceHugger/AVP_ServerActor_FaceHugger.h"
#include "Entity/PhysicalObject/Actor/Vertebrates/FaceHugger/AVP_Messages_FaceHugger.h"
#include "Entity/PhysicalObject/Actor/Vertebrates/Human/AVP_Messages_Human.h"
#include "Entity/PhysicalObject/Actor/Vertebrates/Human/Android/AVP_ServerActor_Android.h"
#include "Entity/PhysicalObject/Actor/Vertebrates/Human/Civilian/AVP_ServerActor_Civilian.h"
#include "Entity/PhysicalObject/Actor/Vertebrates/Human/AVP_ServerActor_Human.h"
#include "Entity/PhysicalObject/Actor/Vertebrates/Human/Marine/AVP_ServerActor_Marine.h"
#include "Entity/PhysicalObject/Actor/Vertebrates/Predator/AVP_ServerActor_Predator.h"
#include "Entity/PhysicalObject/Actor/Vertebrates/Predalien/AVP_ServerActor_Predalien.h"
#include "Entity/PhysicalObject/Actor/Weapons/Sentrygun/AVP_Sentrygun_Messages.h"
#include "Entity/PhysicalObject/Actor/Weapons/Sentrygun/AVP_ServerWeapon_Sentrygun.h"
#include "Entity/PhysicalObject/CommandPost/AVP_ServerEntity_CommandPost.h"
#include "Entity/PhysicalObject/Interact/AVP_ServerEntity_InteractObject.h"
#include "Entity/PhysicalObject/Interact/ToolReceptacle/BatteryReceptacle/AVP_ServerEntity_InteractBatteryReceptacle.h"
#include "Entity/PhysicalObject/Interact/ToolReceptacle/HackingPoint/AVP_ServerEntity_InteractHackingPoint.h"
#include "Entity/PhysicalObject/Interact/ToolReceptacle/RetinalScanner/AVP_ServerEntity_InteractRetinalScanner.h"
#include "Entity/PhysicalObject/Interact/PredatorLock/AVP_ServerEntity_InteractPredatorLock.h"
#include "Entity/PhysicalObject/Interact/InvisiSwitch/AVP_ServerEntity_InteractInvisiSwitch.h"
#include "Entity/PhysicalObject/Lift/AVP_ServerEntity_Lift.h"
#include "Entity/PhysicalObject/PhysicsObject/AVP_ServerEntity_PhysicsObject.h"
#include "Entity/PhysicalObject/PhysicsObject/DamageableObject/AVP_ServerEntity_DamageableObject.h"
#include "Entity/PhysicalObject/Pickup/AVP_ServerEntity_Pickup.h"
#include "Entity/PhysicalObject/Projectile/AVP_ServerProjectile_Mine.h"
#include "Entity/PlayerInfo/AVP_PlayerInfo_Messages.h"
#include "Entity/PlayerInfo/AVP_ServerEntity_PlayerInfo.h"
#include "Entity/PlayerProxy/AVP_ServerEntity_PlayerProxy.h"
#include "Entity/Spawners/AVP_ServerEntity_SpawnController.h"
#include "Entity/Spawners/AVP_ServerEntity_SpawnPoint.h"
#include "Entity/Spawners/AVP_ServerEntity_SpawnPoint2.h"
#include "Entity/Spawners/AVP_SpawnerInterface.h"
#include "Entity/Spawners/AVP_ServerEntity_StartPoint.h"
#include "Entity/Spawners/Alien/AVP_ServerEntity_AlienSpawnPoint.h"
#include "Entity/Spawners/Human/AVP_ServerEntity_HumanSpawnPoint.h"
#include "Entity/Triggers/AVP_ServerEntity_AdvancedVolumeTrigger.h"
#include "Entity/Triggers/AVP_ServerEntity_InteractionTrigger.h"
#include "Entity/Triggers/AVP_ServerEntity_MultiDamageVolume.h"
#include "Entity/Triggers/AVP_ServerEntity_VolumeTrigger.h"
#include "Entity/Triggers/AVP_ServerEntity_WaypointBlockerVolume.h"
#include "Entity/Vent/AVP_ServerEntity_Vent.h"

// C L A S S   I M P L E M E N T A T I O N S /////////////////////////////////

//
// Asura_Chunk_Entity
//

bool Asura_Chunk_Entity::Project_Process( const char* pcChunkBfr ) const
{
	Asura_Chunk_ChunkBuffer_Stream	xStream(pcChunkBfr);

	// What sort of entity are we processing?
    switch (Classification)
    {
		case AsuraEntityClass_AdvancedVolumeTrigger:
		{
			AVP_ServerEntity_AdvancedVolumeTrigger::CreateFromChunkBuffer(Guid, pcChunkBfr);
			break;
		}

        case AsuraEntityClass_PhysicsObject:
		{
            AVP_ServerEntity_PhysicsObject*	pxServer = AVP_ServerEntity_PhysicsObject::Create(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AsuraEntityClass_Lift:
		{
			AVP_ServerEntity_Lift* pxServer = AVP_ServerEntity_Lift::Create(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AsuraEntityClass_MultiDamageVolume:
		{
			AVP_ServerEntity_MultiDamageVolume*	pxServer = AVP_ServerEntity_MultiDamageVolume::Create(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AsuraEntityClass_VolumeTrigger:
		{
			AVP_ServerEntity_VolumeTrigger::Create(Guid, xStream);
			break;
		}

		case AsuraEntityClass_CountedVolumeTrigger:
		{
			new Asura_ServerEntity_CountedVolumeTrigger(Guid, pcChunkBfr);
			break;
		}

		case AVP_ENTITYCLASS_INTERACTIONTRIGGER:
		{
			AVP_ServerEntity_InteractionTrigger* pxServer = AVP_ServerEntity_InteractionTrigger::Create(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_SPAWNPOINT:
		{
			AVP_ServerEntity_SpawnPoint* pxServer = AVP_ServerEntity_SpawnPoint::Create(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_ALIENSPAWNPOINT:
		{
			AVP_ServerEntity_AlienSpawnPoint* pxServer = AVP_ServerEntity_AlienSpawnPoint::Create(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_HUMANSPAWNPOINT:
		{
			AVP_ServerEntity_HumanSpawnPoint* pxServer = AVP_ServerEntity_HumanSpawnPoint::Create(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_GAMEPLAYVOLUME:
		{
			AVP_ServerEntity_GamePlayVolume* pxServer = AVP_ServerEntity_GamePlayVolume::Create(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}
		
		case AVP_ENTITYCLASS_GUARDZONE:
		{
			AVP_ServerNode_GuardZone* pxServer = AVP_ServerNode_GuardZone::Create(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_ORIENTEDNODE:
		{
			AVP_ServerNode_OrientedNode* pxServer = AVP_ServerNode_OrientedNode::Create(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}
		
	    case AVP_ENTITYCLASS_PREDATOR:
		{
            AVP_ServerActor_Predator* pxServer = AVP_ServerActor_Predator::CreateAndReturn(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_PREDALIEN:
		{
			AVP_ServerActor_Predalien* pxServer = AVP_ServerActor_Predalien::CreateAndReturn(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_ALIEN:
		{
            AVP_ServerActor_Alien* pxServer = AVP_ServerActor_Alien::CreateAndReturn(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_ALIENQUEEN:
		{
            AVP_ServerActor_AlienQueen* pxServer = AVP_ServerActor_AlienQueen::CreateAndReturn(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_ALIENFACEHUGGER:
		{
            AVP_ServerActor_FaceHugger*	pxServer = AVP_ServerActor_FaceHugger::CreateAndReturn(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_ANDROID:
		{
			AVP_ServerActor_Android* pxServer = AVP_ServerActor_Android::CreateAndReturn(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_CIVILIAN:
		{
			AVP_ServerActor_Civilian* pxServer = AVP_ServerActor_Civilian::CreateAndReturn(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_HUMAN:
		case AVP_ENTITYCLASS_MARINE:
		{
			AVP_ServerActor_Marine*	pxServer = AVP_ServerActor_Marine::CreateAndReturn(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_DROPSHIP:
		{
			AVP_ServerVehicle_Dropship*	pxServer = AVP_ServerVehicle_Dropship::CreateAndReturn(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_DAMAGEABLEOBJECT:
		{
			AVP_ServerEntity_DamageableObject* pxServer = AVP_ServerEntity_DamageableObject::Create(Guid);			
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_INTERACTOBJECT:
		{
			AVP_ServerEntity_InteractObject* pxServer = AVP_ServerEntity_InteractObject::Create(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

		case AVP_ENTITYCLASS_CHECKPOINTNODE:
		{
			AVP_ServerEntity_CheckPointNode* pxServer = AVP_ServerEntity_CheckPointNode::Create(Guid);
			pxServer->ReadFromChunkStream(xStream);
			break;
		}

        case AVP_ENTITYCLASS_ALIENTEAM:
        {
            AVP_ServerEntity_Team_Alien* pxAlienTeam = AVP_ServerEntity_Team_Alien::Create( Guid );
            pxAlienTeam->ReadFromChunkStream( xStream );
            break;
        }

		case AVP_ENTITYCLASS_MARINESQUAD:
		{
			AVP_ServerEntity_Squad_Marine* pxMarineSquad = AVP_ServerEntity_Squad_Marine::Create(Guid);
			pxMarineSquad->ReadFromChunkStream(xStream);
			break;
		}

        case AVP_ENTITYCLASS_MARINETEAM:
        {
            AVP_ServerEntity_Team_Marine* pxMarineTeam = AVP_ServerEntity_Team_Marine::Create( Guid );
            pxMarineTeam->ReadFromChunkStream( xStream );
            break;
        }

		case AVP_ENTITYCLASS_LOOKAT:
		{
			AVP_ServerEntity_LookAt* pxLookAt = AVP_ServerEntity_LookAt::Create( Guid );
			pxLookAt->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_COVERPOINT:
		{
			AVP_ServerNode_CoverpointNode* pxCoverPoint = AVP_ServerNode_CoverpointNode::Create( Guid );
			pxCoverPoint->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_FORMATIONPOINT:
		{
			AVP_ServerNode_FormationPoint* pxFormationPoint = AVP_ServerNode_FormationPoint::Create( Guid );
			pxFormationPoint->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_FLEEPOINT:
		{
			AVP_ServerNode_FleePoint* pxFleePoint = AVP_ServerNode_FleePoint::Create( Guid );
			pxFleePoint->ReadFromChunkStream( xStream );
			break;
		}

#ifdef ASURA_USE_CAMERA_VOLUME
		case AsuraEntityClass_CameraVolume:
		{
			AVP_ServerEntity_CameraVolume::CreateFromChunkBuffer(Guid, pcChunkBfr);
			break;
		}
#endif //ASURA_USE_CAMERA_VOLUME

		case AVP_ENTITYCLASS_PLAYERINFO:
		{
			AVP_ServerEntity_PlayerInfo::CreateFromChunkStream(Guid, xStream);
			break;
		}

		case AVP_ENTITYCLASS_VANTAGEPOINT_PREDATOR:
		{
			AVP_ServerNode_VantagePoint_Predator* pxPoint = new AVP_ServerNode_VantagePoint_Predator( Guid );
			pxPoint->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_AI_OBJECTIVE:
		{
			AVP_ServerNode_Objective* pxObjective = AVP_ServerNode_Objective::Create( Guid );
			pxObjective->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_AI_MARINE_OBJECTIVE:
		{
			AVP_ServerNode_Objective_Marine* pxObjective = AVP_ServerNode_Objective_Marine::Create( Guid );
			pxObjective->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_VENT:
		{
			AVP_ServerEntity_Vent* pxVent = AVP_ServerEntity_Vent::Create( Guid );
			pxVent->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_GS2NODE:
		{
			AVP_ServerNode_GS2Node::Create( Guid, xStream );
			break;
		}

		case AVP_ENTITYCLASS_GS2ATTRACTOR:
		{
			AVP_ServerNode_GS2Attractor::Create( Guid, xStream );
			break;
		}

		case AVP_ENTITYCLASS_GS2SPLINE:
		{
			AVP_ServerNode_GS2Spline::Create( Guid, xStream );
			break;
		}

		case AVP_ENTITYCLASS_SPAWNCONTROLLER:
		{
			AVP_ServerEntity_SpawnController* pxController = new AVP_ServerEntity_SpawnController( Guid );
			pxController->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_SPAWNPOINT2:
		{
			AVP_ServerEntity_SpawnPoint2* pxSpawnPoint = new AVP_ServerEntity_SpawnPoint2( Guid );
			pxSpawnPoint->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_ALIENSQUAD:
		{
			AVP_ServerEntity_Squad_Alien* pxSquad = new AVP_ServerEntity_Squad_Alien( Guid );
			pxSquad->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_SENTRYGUN:
		{
			AVP_ServerWeapon_Sentrygun* pxSentrygun = new AVP_ServerWeapon_Sentrygun( Guid );
			pxSentrygun->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_GAMEMODE:
		{
			AVP_ServerEntity_GameMode::CreateFromChunkStream( Guid, xStream );
			break;
		}

		case AVP_ENTITYCLASS_FACEHUGGERSQUAD:
		{
			AVP_ServerEntity_Squad_FaceHugger* pxSquad = new AVP_ServerEntity_Squad_FaceHugger( Guid );
			pxSquad->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_PICKUP:
		{
			AVP_ServerEntity_Pickup::CreateFromChunkStream( Guid, xStream );
			break;
		}

		case AVP_ENTITYCLASS_MINE:
		{
			AVP_ServerProjectile_Mine::CreateFromChunkStream( Guid, xStream );
			break;
		}

		case AVP_ENTITYCLASS_SHOOTAT:
		{
			AVP_ServerEntity_ShootAt* pxEntity = AVP_ServerEntity_ShootAt::Create( Guid );
			pxEntity->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_PLAYER_OBJECTIVE:
		{
			AVP_ServerEntity_PlayerObjective* pxObjective = AVP_ServerEntity_PlayerObjective::Create( Guid );
			pxObjective->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_INTERACT_PREDATOR_LOCK:
		{
			AVP_ServerEntity_InteractPredatorLock* pxEntity = AVP_ServerEntity_InteractPredatorLock::Create( Guid );
			pxEntity->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_INTERACT_BATTERY_RECEPTACLE:
		{
			AVP_ServerEntity_InteractBatteryReceptacle* pxEntity = AVP_ServerEntity_InteractBatteryReceptacle::Create( Guid );
			pxEntity->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_INTERACT_HACKING_POINT:
		{
			AVP_ServerEntity_InteractHackingPoint* pxEntity = AVP_ServerEntity_InteractHackingPoint::Create( Guid );
			pxEntity->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_INTERACT_SENTRYGUN_INVISISWITCH:
		{
			AVP_ServerEntity_InteractInvisiSwitch* pxEntity = AVP_ServerEntity_InteractInvisiSwitch::Create( Guid );
			pxEntity->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_INTERACT_RETINAL_SCANNER:
		{
			AVP_ServerEntity_InteractRetinalScanner* pxEntity = AVP_ServerEntity_InteractRetinalScanner::Create( Guid );
			pxEntity->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_COMMANDPOST:
		{
			AVP_ServerEntity_CommandPost* pxEntity = AVP_ServerEntity_CommandPost::Create( Guid );
			pxEntity->ReadFromChunkStream( xStream ); 
			break;
		}

		case AVP_ENTITYCLASS_ROOMNODE:
		{
			AVP_ServerEntity_RoomNode* pxEntity = AVP_ServerEntity_RoomNode::Create( Guid );
			pxEntity->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_MOTIONTRACKERBLIP:
		{
			AVP_ServerEntity_MotionTrackerBlip* pxEntity = AVP_ServerEntity_MotionTrackerBlip::Create( Guid );
			pxEntity->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_PLAYER_PROXY:
		{
			AVP_ServerEntity_PlayerProxy* pxEntity = AVP_ServerEntity_PlayerProxy::Create( Guid );
			pxEntity->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_LOCATIONMARKER:
		{
			AVP_ServerEntity_LocationMarker* pxMarker = AVP_ServerEntity_LocationMarker::Create( Guid );
			pxMarker->ReadFromChunkStream( xStream );
			break;
		}

		case AVP_ENTITYCLASS_WAYPOINTBLOCKERVOLUME:
		{
			AVP_ServerEntity_WaypointBlockerVolume* pxMarker = AVP_ServerEntity_WaypointBlockerVolume::Create( Guid );
			pxMarker->ReadFromChunkStream( xStream );
			break;
		}			

		case AsuraEntityClass_StartPoint:
		{
			AVP_ServerEntity_StartPoint::CreateFromChunkBuffer(Guid, pcChunkBfr);
			break;
		}

        default:
		{
			return false;
		}
    }

	return true;
}


bool Asura_Chunk_Entity::Project_ProcessClientEntities( const char* pcChunkBfr ) const
{
	switch (Classification)
    {
#ifdef ASURA_USE_CAMERA_VOLUME
		case AsuraEntityClass_CameraVolume:
		{
			new AVP_ClientEntity_CameraVolume(Guid, pcChunkBfr);
			return true;
		}
#endif //ASURA_USE_CAMERA_VOLUME
		
		default:
		{
			return(false);
		}
    }
}

//
// Asura_Chunk_StaticMessages
//

#ifdef ASURA_TOOLS

bool Asura_Chunk_StaticMessages::Project_FillInChunkBuffer( char*& pcChunkBuffer, Asura_StaticMessage* pxMessage )
{
	switch (pxMessage->m_usMsgID)
	{
		case AVP_MSGID_CONVERT_PLAYER_TO_AI:
		{
			// There is no data in this message
			return true;
		}

		case AVP_MSGID_CHUNK:
		{
			const AVP_Message_ChunkActor* const pxConvertMessage = static_cast< const AVP_Message_ChunkActor* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxConvertMessage->GetElement(), u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxConvertMessage->GetDamage(), float );
			return true;
		}

		case AVP_MSGID_CHANGE_ALIEN_SPAWN_SETTINGS:
		{
			const AVP_Message_ChangeAlienSpawnSettings* const pxAlienTeamMessage = static_cast< const AVP_Message_ChangeAlienSpawnSettings* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_uMaxSpawned, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fSpawnDelay, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fMaxValidThreatDist, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fThreatDistDropoffStart, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fSpawnDelayFromSame, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fSpawnDelayDropoffEnd, float );
			ASURA_CHUNK_BITFIELD_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_uFlags, u_int );
			return true;
		}

		case AVP_MSGID_ADD_ALIENS_TO_SPAWN_QUEUE:
		{
			const AVP_Message_AddAlienToSpawnQueue* const pxSpawnMessage = static_cast< const AVP_Message_AddAlienToSpawnQueue* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxSpawnMessage->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxSpawnMessage->GetNumToSpawn(), u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxSpawnMessage->GetBlueprintType(), u_int);
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxSpawnMessage->GetBlueprint(), u_int);
			return true;
		}

		case AVP_MSGID_ADD_AI_OBJECTIVE:
		{
			const AVP_Message_AddObjective* const pxObjectiveMessage = static_cast<const AVP_Message_AddObjective*>(pxMessage->m_pData);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxObjectiveMessage->m_uVersion, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxObjectiveMessage->m_uObjectiveGuid, u_int);
			return true;
		}

		case AVP_MSGID_SPAWN_HUMANOIDS:
		{
			const AVP_Message_SpawnHumanoids* const pxSpawnMessage = static_cast<const AVP_Message_SpawnHumanoids*>(pxMessage->m_pData);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSpawnMessage->m_uVersion, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSpawnMessage->m_iHumanoidType, int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSpawnMessage->m_iNumToSpawn, int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSpawnMessage->m_iSpawnMethod, int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSpawnMessage->m_uSquadControllerGuid, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSpawnMessage->m_uGamePlayVolumeGuid, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSpawnMessage->m_uSpawnPointGuid, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSpawnMessage->m_uBlueprintHashID, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSpawnMessage->m_uBlueprintTypeHashID, u_int);
			return true;
		}

		case AVP_MSGID_CHANGE_HUMANOID_SPAWN_SETTINGS:
		{
			const AVP_Message_ChangeHumanoidSpawnSettings* const pxSettingsMessage = static_cast<const AVP_Message_ChangeHumanoidSpawnSettings*>(pxMessage->m_pData);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSettingsMessage->m_uVersion, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSettingsMessage->m_fSpawnDelay, float);
			return true;
		}

		case AVP_MSGID_MERGE_HUMANOID_SQUADS:
		{
			const AVP_Message_MergeSquads* const pxSquadMessage = static_cast<const AVP_Message_MergeSquads*>(pxMessage->m_pData);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSquadMessage->m_uVersion, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSquadMessage->m_uSquadToMergeInto, Asura_Guid);
			return true;
		}

		case AVP_MSGID_SPLIT_HUMANOID_SQUAD:
		{
			const AVP_Message_SplitSquad* const pxSquadMessage = static_cast<const AVP_Message_SplitSquad*>(pxMessage->m_pData);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSquadMessage->m_uVersion, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSquadMessage->m_uSquadToAddTo, Asura_Guid);
			
			for (u_int u = 0; u < AVP_Message_SplitSquad::MAX_SQUAD_MEMBERS; ++u)
			{
				ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSquadMessage->m_auSplitMembers[u], Asura_Guid);
			}

			return true;
		}

		case AVP_MSGID_ADD_SQUAD_MEMBER:
		{
			const AVP_Message_AddSquadMember* const pxSquadMessage = static_cast<const AVP_Message_AddSquadMember*>(pxMessage->m_pData);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSquadMessage->m_uVersion, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSquadMessage->m_uGuidToAdd, u_int);
			return true;
		}

		case AVP_MSGID_REMOVE_SQUAD_MEMBER:
		{
			const AVP_Message_RemoveSquadMember* const pxSquadMessage = static_cast<const AVP_Message_RemoveSquadMember*>(pxMessage->m_pData);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSquadMessage->m_uVersion, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxSquadMessage->m_uGuidToRemove, u_int);
			return true;
		}

		case AVP_MSGID_REQUEST_HUMANOID_PATROL:
		{
			const AVP_Message_RequestPatrol* const pxRequestPatrolMessage = static_cast<const AVP_Message_RequestPatrol*>(pxMessage->m_pData);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxRequestPatrolMessage->m_uVersion, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxRequestPatrolMessage->m_bFullSquad, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxRequestPatrolMessage->m_uNumPatrolMembers, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxRequestPatrolMessage->m_uGuardZoneGuid, Asura_Guid);
			return true;
		}

		case AVP_MSGID_ALIEN_TEAM_SET_BEHAVIOUR:
		{
			const AVP_Message_SetAlienTeamBehaviour* const pxAlienTeamMessage = static_cast< const AVP_Message_SetAlienTeamBehaviour* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_iVersion, int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_iBehaviour, int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_uBlueprintHashID, Asura_Hash_ID );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_uBlueprintTypeHashID, Asura_Hash_ID );
			return true;
		}

		case AVP_MSGID_ALIEN_TEAM_ADD_SPAWNTOKEN:
		{
			const AVP_Message_AddAlienTeamTokens* const pxAlienTeamMessage = static_cast< const AVP_Message_AddAlienTeamTokens* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_iVersion, int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_uBlueprintHashID, Asura_Hash_ID );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_uBlueprintTypeHashID, Asura_Hash_ID );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_uTokenNum, u_int );
			return true;
		}

		case AVP_MSGID_ALIEN_TEAM_REMOVE_SPAWNTOKEN:
		{
			const AVP_Message_RemoveAlienTeamTokens* const pxAlienTeamMessage = static_cast< const AVP_Message_RemoveAlienTeamTokens* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_iVersion, int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_uBlueprintHashID, Asura_Hash_ID );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_uBlueprintTypeHashID, Asura_Hash_ID );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_uTokenNum, u_int );
			ASURA_CHUNK_BITFIELD_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_uFlags, u_int );
			return true;
		}

		case AVP_MSGID_ALIEN_TEAM_THREAT_BONUS:
		{
			const AVP_Message_ChangeThreatBonusValues* const pxAlienTeamMessage = static_cast< const AVP_Message_ChangeThreatBonusValues* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_iVersion, int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fUnknownBonus, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fCivilianBonus, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fMarineBonus, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fMarineShotgunBonus, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fMarineFlameBonus, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fMarineSmartgunBonus, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fMarinePlayerBonus, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fAndroidBonus, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fSentryGunBonus, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fPredatorBonus, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fPredatorPlayerBonus, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fSameTargetBonus, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_fPerAttackerBonus, float );
			ASURA_CHUNK_BITFIELD_FILLANDVERIFY( pcChunkBuffer, pxAlienTeamMessage->m_uFlags, u_int );
			return true;
		}

		case AVP_MSGID_SET_PREFERRED_TARGET_TYPE:
		{
			const AVP_Message_SetPreferredTargetType* pxData = static_cast< const AVP_Message_SetPreferredTargetType* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iPreferredTargetType, int );
			return true;
		}

		case AVP_MSGID_PERFORM_AI_OBJECTIVE_ACTION:
		{
			const AVP_Message_PerformObjectiveAction* pxData = static_cast<const AVP_Message_PerformObjectiveAction*>(pxMessage->m_pData);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxData->m_uVersion, u_int);
			ASURA_CHUNK_FILLANDVERIFY(pcChunkBuffer, pxData->m_uActionGuid, u_int);
			return true;
		}

		case AVP_MSGID_SPAWN:
		{
			const AVP_Msg_Spawn* pxData = static_cast< const AVP_Msg_Spawn* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uBPTypeHashID, Asura_Hash_ID );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uBPHashID, Asura_Hash_ID );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uSquadGuid, Asura_Guid );
			return true;
		}

		case AVP_MSGID_SPAWN_SET_MAX_SPAWN_COUNT:
		{
			const AVP_Msg_Spawn_SetMaxSpawnCount* pxData = static_cast< const AVP_Msg_Spawn_SetMaxSpawnCount* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iMaxSpawnCount, int );
			return true;
		}

		case AVP_MSGID_SPAWN_RESET_SPAWN_COUNTER:
		{
			return true;
		}

		case AVP_MSGID_SPAWN_SET_MAX_IN_PLAY:
		{
			const AVP_Msg_Spawn_SetMaxInPlay* pxData = static_cast< const AVP_Msg_Spawn_SetMaxInPlay* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iMaxInPlay, int );
			return true;
		}

		case AVP_MSGID_SET_ALIEN_SQUAD_BEHAVIOUR:
		{
			const AVP_Msg_SetAlienSquadBehaviour* pxData = static_cast< const AVP_Msg_SetAlienSquadBehaviour* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iBehaviour, int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uProtoBlueprintHashID, u_int);
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fJumpFraction, float )
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fStandFraction, float )
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fMinTimeBetweenGrapples, float)
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fDamageFromBehindMultiplier, float)
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iMoveInMode, int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fIdealDistanceMin, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fIdealDistanceMax, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fAttackDelay, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iMaxAttackersPerTarget, int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iMaxAttackersTotal, int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iMaxBurstPerTarget, int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iPostAttackAction, int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fRespawnDelay, float );
 			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fTimeBetweenAttacks, float );
 			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uMaxNumberOfChargers, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_bAttackIfInMarineLight, bool );
			// Pad to int
			*pcChunkBuffer++ = 0;
			*pcChunkBuffer++ = 0;
			*pcChunkBuffer++ = 0;
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fTimeInLightBeforeAttack, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fMinHideDistance, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fChaneToRehideIfCloseFraction, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fChaneToRehideIfInLightFraction, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fChaneToRehideAfterAttackFraction, float);
			return true;
		}

		case AVP_MSGID_SET_AI_TARGET_PRIORITIES:
		{
			const AVP_Msg_SetAITargetPriorities* pxData = static_cast< const AVP_Msg_SetAITargetPriorities* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uNumEntries, u_int );
			const AVP_Msg_SetAITargetPriorities::TPData* pxTPData = pxData->GetFirstTPDataPtr();
			for ( u_int u = 0; u < pxData->m_uNumEntries; ++u )
			{
				ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxTPData[ u ].m_iPriority, int );
				ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxTPData[ u ].m_iTargetType, int );
				ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxTPData[ u ].m_uSpecificGuid, Asura_Guid );
				ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxTPData[ u ].m_iSpecificGuidType, int );
			}
			return true;
		}

		case AVP_MSGID_CHANGE_MARINE_SQUAD_SETTINGS:
		{
			const AVP_Message_ChangeMarineSquadSettings* pxData = static_cast< const AVP_Message_ChangeMarineSquadSettings* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_bIsPlayersSquad, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_bIsAiLedPlayersSquad, u_int);
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_bIsRestrictedToCombatZone, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_bIgnoreAlertState, u_int);
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uCombatZoneGPVGuid, Asura_Guid );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iSquadCombatType, int );
			return true;
		}

		case AVP_MSGID_ATTACK_SCRIPTED_TARGET:
		{
			const AVP_Message_AttackScriptedTarget* pxData = static_cast< const AVP_Message_AttackScriptedTarget*>( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uShootAtGuid, u_int );
			return true;
		}

		case AVP_MSGID_PICKUP_SET_INTELLIGENT_AMOUNT:
		{
			const AVP_Message_Pickup_SetIntelligentAmount* pxData = static_cast< const AVP_Message_Pickup_SetIntelligentAmount* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iIntelligentAmount, int );
			return true;
		}

		case AVP_MSGID_ADD_PLAYER_OBJECTIVE:
		{
			const AVP_Message_AddPlayerObjective* pxData = static_cast< const AVP_Message_AddPlayerObjective* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uObjectiveGuid, u_int );
			return true;
		}

		case AVP_MSGID_SET_PLAYER_OBJECTIVE_COMPLETE:
		{
			const AVP_Message_PlayerObjectiveComplete* pxData = static_cast< const AVP_Message_PlayerObjectiveComplete* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uObjectiveGuid, u_int );
			return true;
		}

		case AVP_MSGID_PLAYER_OBJECTIVE_SET_MARKER_LOCATION:
		{
			const AVP_Message_PlayerObjectiveSetMarker* pxData = static_cast< const AVP_Message_PlayerObjectiveSetMarker* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uMarkerGuid, u_int );
			return true;
		}

		case AVP_MSGID_PLAYER_OBJECTIVE_SET_TARGET_ENTITY:
		{
			const AVP_Message_PlayerObjectiveSetEntity* pxData = static_cast< const AVP_Message_PlayerObjectiveSetEntity* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uEntityGuid, u_int );
			return true;
		}

		case AVP_MSGID_ADD_PLAYER_PICKUP:
		{
			const AVP_Message_AddPlayerPickup* pxData = static_cast< const AVP_Message_AddPlayerPickup* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uPickupGuid, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_bSetAsCurrent, bool );
			// Pad to int
			pcChunkBuffer += 3;
			return true;
		}

		case AVP_MSGID_SET_DROPSHIP_ATTACK_MODE:
		{
			const AVP_Message_DropshipAttackMode* pxData = static_cast< const AVP_Message_DropshipAttackMode* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_eMode, int );
			return true;
		}

		case AVP_MSGID_SET_PREDATOR_BEHAVIOUR:
		{
			const AVP_Message_SetPredatorBehaviour* pxData = static_cast< const AVP_Message_SetPredatorBehaviour* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iBehaviour, int );
			return true;
		}

		case AVP_MSGID_CHANGE_HUMANOID_SQUAD_MOVEMENT_MODE:
		{
			const AVP_Message_ChangeHumanoidMovementMode* pxData = static_cast< const AVP_Message_ChangeHumanoidMovementMode* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iMovementMode, int );
			return true;
		}

		case AVP_MSGID_LOOK_AT_ENTITY:
		{
			const AVP_Message_LookAtEntity* pxData = static_cast< const AVP_Message_LookAtEntity* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uLookAtGuid, Asura_Guid );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_bLookAtPlayer, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uLookAtMarker, Asura_Hash_ID );
			return true;
		}

		case AVP_MSGID_SET_GS2_MOVE_SPEED:
		{
			const AVP_Message_SetGS2MoveSpeed* pxData = static_cast< const AVP_Message_SetGS2MoveSpeed* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uMoveSpeed, u_int );
			return true;
		}

		case AVP_MSGID_SET_HEALTH:
		{
			const AVP_Message_SetHealth* pxData = static_cast< const AVP_Message_SetHealth* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fDirectHealthValue, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fPercentageHealthValue, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_bTreatAsDamage, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uSetHealthAsPercentageOfMaxHealth, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_bDamageComesFromOtherEntity, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uDamageFromGuid, Asura_Guid );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uDamageType, u_int );
			return true;
		}

		case AVP_MSGID_SET_FACEHUGGER_SQUAD_BEHAVIOUR:
		{
			const AVP_Msg_SetFaceHuggerSquadBehaviour* pxData = static_cast< const AVP_Msg_SetFaceHuggerSquadBehaviour* >( pxMessage->m_pData );				
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iBehaviour, int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fAvoidanceDistance, float);
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uMaxTargeters, int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fTimeBetweenAttacks, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fWanderDistance, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_bAttackIfInMarineLight, bool );
			// Pad to int
			pcChunkBuffer += 3;
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fTimeInLightBeforeAttack, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fMinHideDistance, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fChaneToRehideIfCloseFraction, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fChaneToRehideIfInLightFraction, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fChaneToRehideAfterAttackFraction, float );
			return true;
		}

		case AVP_MSGID_CHANGE_HUMANOID_KNOWLEDGE_SETTINGS:
		{
			const AVP_Message_ChangeHumanoidKnowledgeSettings* pxData = static_cast< const AVP_Message_ChangeHumanoidKnowledgeSettings* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uHumanoidType, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uBluepprintHashID, Asura_Hash_ID );
			return true;
		}

		case AVP_MSGID_SET_SENTRYGUN_SWEEP_SPEED:
		{
			const AVP_Message_SentryGun_Set_SweepSpeed* pxData = static_cast< const AVP_Message_SentryGun_Set_SweepSpeed* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fSpeed, float );
			return true;
		}

		case AVP_MSGID_SET_SENTRYGUN_VISION_RANGE:
		{
			const AVP_Message_SentryGun_Set_VisionRange* pxData = static_cast< const AVP_Message_SentryGun_Set_VisionRange* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fRange, float );
			return true;
		}

		case AVP_MSGID_SET_SENTRYGUN_HOR_FOV:
		{
			const AVP_Message_SentryGun_Set_HorizontalFOV* pxData = static_cast< const AVP_Message_SentryGun_Set_HorizontalFOV* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fHorFov, float );
			return true;
		}

		case AVP_MSGID_SET_SENTRYGUN_VER_FOV:
		{
			const AVP_Message_SentryGun_Set_VerticalFOV* pxData = static_cast< const AVP_Message_SentryGun_Set_VerticalFOV* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fVerFov, float );
			return true;
		}

		case AVP_MSGID_SET_SENTRYGUN_FIRING_ARC:
		{
			const AVP_Message_SentryGun_Set_FiringArc* pxData = static_cast< const AVP_Message_SentryGun_Set_FiringArc* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fArc, float );
			return true;
		}

		case AVP_MSGID_SET_SENTRYGUN_LETHAL_RANGE:
		{
			const AVP_Message_SentryGun_Set_LethalRange* pxData = static_cast< const AVP_Message_SentryGun_Set_LethalRange* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fRange, float );
			return true;
		}

		case AVP_MSGID_SENTRYGUN_DRYFIRE_TOGGLE:
		{
			const AVP_Message_SentryGun_Toggle_Dry_Fire* pxData = static_cast< const AVP_Message_SentryGun_Toggle_Dry_Fire* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_bToggleDryFire, bool );
			return true;
		}

		case AVP_MSGID_DETACH_WEAPON:
		case AVP_MSGID_CREATE_ATTACHMENT:
		case AVP_MSGID_DESTROY_ATTACHMENT:
		case AVP_MSGID_DETACH_ATTACHMENT:
		{
			const AVP_Message_Actor_Attachment* pxData = static_cast< const AVP_Message_Actor_Attachment* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uBlueprintHash, Asura_Hash_ID );
			return true;
		}

		case AVP_MSGID_ATTACH_WEAPON:
		{
			return true; // no data
		}

		case AVP_MSGID_ALIENQUEEN_ADD_TO_TARGET_LIST:
		{
			const AVP_Msg_Add_Entity_To_Queen_Target_List* pxData = static_cast<const AVP_Msg_Add_Entity_To_Queen_Target_List*>( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uQueenGuid, Asura_Guid );
			return true;
		}

		case AVP_MSGID_ALIENQUEEN_REMOVE_FROM_TARGET_LIST:
		{
			const AVP_Msg_Remove_Entity_From_Queen_Target_List* pxData = static_cast<const AVP_Msg_Remove_Entity_From_Queen_Target_List*>( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uQueenGuid, Asura_Guid );
			return true;
		}

		case AVP_MSGID_ALIENQUEEN_FORCE_ROAR:
		{
			const AVP_Msg_Alien_Queen_Start_Roar_Behaviour* pxData = static_cast<const AVP_Msg_Alien_Queen_Start_Roar_Behaviour*>( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uTargetGuid, Asura_Guid );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_bRoarAtPlayer, bool );
			return true;
		}

		case AVP_MSGID_ALIENQUEEN_SET_BEHAVIOUR:
		{
			const AVP_Message_SetAlienQueenBehaviour* pxData = static_cast< const AVP_Message_SetAlienQueenBehaviour* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iBehaviour, int );
			return true;
		}

		case AVP_MSGID_START_CAMERA_SHAKE:
		case AVP_MSGID_STOP_CAMERA_SHAKE:
		{
			AVP_Msg_CameraShake* pxMsgData = static_cast<AVP_Msg_CameraShake*>(pxMessage->m_pData);
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxMsgData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxMsgData->m_uShake, Asura_Hash_ID );			
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxMsgData->m_uSourceGuid, Asura_Guid );
			return true;
		}

		case AVP_MSGID_FACEHUGGER_HUG_ENTITY:
		{
			const AVP_FaceHugger_Hug_Entity* pxData = static_cast< const AVP_FaceHugger_Hug_Entity* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uTarget, Asura_Guid );
			return true;
		}

		case AVP_MSGID_DISMEMBER:
		{
			const AVP_Msg_Dismember* pxData = static_cast< const AVP_Msg_Dismember* >( pxMessage->m_pData );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uVersion, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_iElement, u_int );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_xDamagePosition.x, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_xDamagePosition.y, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_xDamagePosition.z, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_xRagdollDirection.x, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_xRagdollDirection.y, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_xRagdollDirection.z, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fRagdollImpulse, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_xGibDirection.x, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_xGibDirection.y, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_xGibDirection.z, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fGibImpulse, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_fDamage, float );
			ASURA_CHUNK_FILLANDVERIFY( pcChunkBuffer, pxData->m_uFromGuid, Asura_Hash_ID );
			return true;
		}

		default:
		{
			return false;
		}
	}
}

bool Asura_Chunk_StaticMessages::Project_FixData( Asura_StaticMessage* pxMessage )
{
	switch (pxMessage->m_usMsgID)
	{
		case AVP_MSGID_CHANGE_ALIEN_SPAWN_SETTINGS:
		{
			const AVP_Message_ChangeAlienSpawnSettings* const pxAlienTeamMessage = static_cast<const AVP_Message_ChangeAlienSpawnSettings*>(pxMessage->m_pData);

			if (pxAlienTeamMessage->m_uVersion != AVP_Message_ChangeAlienSpawnSettings::CURRENT_VERSION)
			{
				if( pxAlienTeamMessage->m_uVersion <= 1 )
				{
					struct
					{
						u_int	m_uVersion;
						u_int	m_uMaxAliensAlive; // This used to be an enum
						float	m_fRespawnRate;
						int		m_iSpawnMethod;
					} xOldData;

					//copy the bits we have
					Asura_Mem::Copy(&xOldData,pxMessage->m_pData,pxMessage->m_usDataSize);

					//reallocate the data in the message
					pxMessage->DeallocateMessageData();
					pxMessage->AllocateMessageData(sizeof(AVP_Message_ChangeAlienSpawnSettings),false);

					//set defaults in a new message
					AVP_Message_ChangeAlienSpawnSettings* pxNewData = static_cast<AVP_Message_ChangeAlienSpawnSettings*>(pxMessage->m_pData);

					pxNewData->Initialise();
					pxNewData->m_uMaxSpawned = (signed)xOldData.m_uMaxAliensAlive;
					pxNewData->m_fSpawnDelay = xOldData.m_fRespawnRate;
				}
				else
				{
					Asura_Assert(false, "AVP_MSGID_CHANGE_ALIEN_SPAWN_SETTINGS - Version has changed Fix up the data!!!");
				}
			}
			return true;
		}

		case AVP_MSGID_ADD_ALIENS_TO_SPAWN_QUEUE:
		{
			const AVP_Message_AddAlienToSpawnQueue* const pxSpawnMessage = static_cast<const AVP_Message_AddAlienToSpawnQueue*>( pxMessage->m_pData);

			if (pxSpawnMessage->m_uVersion != 1)
			{
				Asura_Assert(false, "AVP_MSGID_ADD_ALIENS_TO_SPAWN_QUEUE - Version has changed Fix up the data!!!");
			}
			return true;
		}

		case AVP_MSGID_ADD_AI_OBJECTIVE:
		{
			const AVP_Message_AddObjective* const pxObjectiveMessage = static_cast<const AVP_Message_AddObjective*>(pxMessage->m_pData);

			if (pxObjectiveMessage->m_uVersion == 1)
			{
				struct
				{
					u_int		m_uVersion;
					Asura_Guid	m_uObjectiveGuid; // This used to be an enum
					int			m_iObjectivetype;
				} xVersion1Data;

				//copy the bits we have
				Asura_Mem::Copy(&xVersion1Data, pxMessage->m_pData, pxMessage->m_usDataSize);

				pxMessage->DeallocateMessageData();
				pxMessage->AllocateMessageData( sizeof( AVP_Message_AddObjective ), false );

				//set defaults in a new message
				AVP_Message_AddObjective*	pxNewData = static_cast<AVP_Message_AddObjective*>(pxMessage->m_pData);

				pxNewData->Initialise();
				pxNewData->m_uVersion = 2;
				pxNewData->m_uObjectiveGuid = xVersion1Data.m_uObjectiveGuid;
			}
			else if (pxObjectiveMessage->m_uVersion != 2)
			{
				Asura_Assert(false, "AVP_MSGID_ADD_AI_OBJECTIVE - Version has changed Fix up the data!!!");
			}
			return true;
		}

		case AVP_MSGID_SPAWN_HUMANOIDS:
		{
			const AVP_Message_SpawnHumanoids* const pxSpawnMessage = static_cast<const AVP_Message_SpawnHumanoids*>(pxMessage->m_pData);

			if (pxSpawnMessage->m_uVersion != 1)
			{
				Asura_Assert(false, "AVP_MSGID_SPAWN_HUMANOIDS - Version has changed Fix up the data!!!");
			}
			return true;
		}

		case AVP_MSGID_CHANGE_HUMANOID_SPAWN_SETTINGS:
		{
			const AVP_Message_ChangeHumanoidSpawnSettings* const pxSettingsMessage = static_cast<const AVP_Message_ChangeHumanoidSpawnSettings*>(pxMessage->m_pData);

			if (pxSettingsMessage->m_uVersion != 1)
			{
				Asura_Assert(false, "AVP_MSGID_CHANGE_HUMANOID_SPAWN_SETTINGS - Version has changed Fix up the data!!!");
			}
			return true;
		}

		case AVP_MSGID_MERGE_HUMANOID_SQUADS:
		{
			const AVP_Message_MergeSquads* const pxSquadMessage = static_cast<const AVP_Message_MergeSquads*>(pxMessage->m_pData);

			if (pxSquadMessage->m_uVersion != 1)
			{
				Asura_Assert(false, "AVP_MSGID_MERGE_HUMANOID_SQUADS - Version has changed Fix up the data!!!");
			}
			return true;
		}

		case AVP_MSGID_SPLIT_HUMANOID_SQUAD:
		{
			const AVP_Message_SplitSquad* const pxSquadMessage = static_cast<const AVP_Message_SplitSquad*>(pxMessage->m_pData);

			if (pxSquadMessage->m_uVersion != 1)
			{
				Asura_Assert(false, "AVP_MSGID_SPLIT_HUMANOID_SQUAD - Version has changed Fix up the data!!!");
			}
			return true;
		}

		case AVP_MSGID_ADD_SQUAD_MEMBER:
		{
			const AVP_Message_AddSquadMember* const pxSquadMessage = static_cast<const AVP_Message_AddSquadMember*>(pxMessage->m_pData);

			if (pxSquadMessage->m_uVersion > 1)
			{
				Asura_Assert(false, "AVP_MSGID_ADD_SQUAD_MEMBER - Version has changed Fix up the data!!!");
			}
			return true;
		}

		case AVP_MSGID_REMOVE_SQUAD_MEMBER:
		{
			const AVP_Message_RemoveSquadMember* const pxSquadMessage = static_cast<const AVP_Message_RemoveSquadMember*>(pxMessage->m_pData);

			if (pxSquadMessage->m_uVersion > 1)
			{
				Asura_Assert(false, "AVP_MSGID_REMOVE_SQUAD_MEMBER - Version has changed Fix up the data!!!");
			}
			return true;
		}

		case AVP_MSGID_PERFORM_AI_OBJECTIVE_ACTION:
		{
			const AVP_Message_PerformObjectiveAction* const pxSquadMessage = static_cast<const AVP_Message_PerformObjectiveAction*>(pxMessage->m_pData);

			if (pxSquadMessage->m_uVersion > 1)
			{
				Asura_Assert(false, "AVP_MSGID_PERFORM_OBJECTIVE_ACTION - Version has changed Fix up the data!!!");
			}
			return true;
		}

		case AVP_MSGID_ALIEN_TEAM_SET_BEHAVIOUR:
		{
			const AVP_Message_SetAlienTeamBehaviour* const pxAlienTeamMessage = static_cast<const AVP_Message_SetAlienTeamBehaviour*>(pxMessage->m_pData);

			if( pxAlienTeamMessage->m_iVersion != AVP_Message_SetAlienTeamBehaviour::CURRENT_VERSION )
			{
				int iBehaviour = 0;

				switch(pxAlienTeamMessage->m_iVersion)
				{
					case 0:
					{
						struct
						{
							int		m_iVersion;
							int		m_iBehaviourEnum; // This used to be an enum
							u_int	m_uMaxSpawned;
							float	m_fSpawnDelay;
						} xVersion0Data;

						//copy the bits we have
						Asura_Mem::Copy(&xVersion0Data,pxMessage->m_pData,pxMessage->m_usDataSize);
						iBehaviour = static_cast<int>( xVersion0Data.m_iBehaviourEnum );
						break;
					}

					case 1:
					{
						struct
						{
							int		m_iVersion;
							u_int	m_uBehaviour;
							u_int	m_uMaxSpawned;
							float	m_fSpawnDelay;
						} xVersion1Data;

						//copy the bits we have
						Asura_Mem::Copy(&xVersion1Data,pxMessage->m_pData,pxMessage->m_usDataSize);
						iBehaviour = (unsigned) xVersion1Data.m_uBehaviour;
						break;
					}

					case 2:
					{
						struct
						{
							int		m_iVersion;
							int		m_iBehaviour;
							u_int	m_uMaxSpawned;
							float	m_fSpawnDelay;
						} xVersion2Data;

						//copy the bits we have
						Asura_Mem::Copy(&xVersion2Data,pxMessage->m_pData,pxMessage->m_usDataSize);
						iBehaviour = xVersion2Data.m_iBehaviour;
						break;
					}

					default:
						Asura_Assert(false, "AVP_MSGID_ALIEN_TEAM_SET_BEHAVIOUR - Version has changed, fix up the data!");
						break;
				}

				//reallocate the data in the message
				pxMessage->DeallocateMessageData();
				pxMessage->AllocateMessageData(sizeof(AVP_Message_SetAlienTeamBehaviour),false);

				//set defaults in a new message
				AVP_Message_SetAlienTeamBehaviour* pxNewData = static_cast<AVP_Message_SetAlienTeamBehaviour*>(pxMessage->m_pData);

				pxNewData->Initialise();
				pxNewData->m_iBehaviour = iBehaviour;
			}
			return true;
		}

		case AVP_MSGID_ALIEN_TEAM_ADD_SPAWNTOKEN:
		{
			const AVP_Message_AddAlienTeamTokens* const pxAlienTeamMessage = static_cast<const AVP_Message_AddAlienTeamTokens*>(pxMessage->m_pData);

			Asura_Hash_ID uBlueprintHashID = ASURA_HASH_ID_UNSET;
			Asura_Hash_ID uBlueprintTypeHashID = uAVP_BLUEPRINT_TYPE_ACTORS;
			u_int uTokenNum = 1;

			if( pxAlienTeamMessage->m_iVersion != AVP_Message_AddAlienTeamTokens::CURRENT_VERSION )
			{
				switch(pxAlienTeamMessage->m_iVersion)
				{
					case 0:
					{
						struct
						{
							int				m_iVersion;
							Asura_Hash_ID	m_uBlueprintHashID;
							float			m_fHealthPercent;
							u_int			m_uTokenNum;

							union
							{
								u_int		m_uFlags;

								struct
								{
									u_int	m_bLostLimbs	: 1,
															: 0;
								};
							};

						} xVersion0Data;

						//copy the bits we have
						Asura_Mem::Copy(&xVersion0Data,pxMessage->m_pData,pxMessage->m_usDataSize);
						uBlueprintHashID = xVersion0Data.m_uBlueprintHashID;
						uTokenNum = xVersion0Data.m_uTokenNum;

						break;
					}

					case 1:
					{
						struct
						{
							int				m_iVersion;
							Asura_Hash_ID	m_uBlueprintHashID;
							Asura_Hash_ID	m_uBlueprintTypeHashID;
							float			m_fHealthPercent;
							u_int			m_uTokenNum;

							union
							{
								u_int		m_uFlags;

								struct
								{
									u_int	m_bLostLimbs	: 1,
															: 0;
								};
							};

						} xVersion1Data;

						//copy the bits we have
						Asura_Mem::Copy(&xVersion1Data,pxMessage->m_pData,pxMessage->m_usDataSize);
						uBlueprintHashID = xVersion1Data.m_uBlueprintHashID;
						uTokenNum = xVersion1Data.m_uTokenNum;

						break;
					}

					default:
					{
						Asura_Assert(false, "AVP_MSGID_ALIEN_TEAM_ADD_SPAWNTOKEN - Version has changed, fix up the data!");
					}
				} // End of switch.

				//reallocate the data in the message
				pxMessage->DeallocateMessageData();
				pxMessage->AllocateMessageData(sizeof(AVP_Message_AddAlienTeamTokens),false);

				//set defaults in a new message
				AVP_Message_AddAlienTeamTokens*	pxNewData = static_cast<AVP_Message_AddAlienTeamTokens*>(pxMessage->m_pData);

				pxNewData->Initialise();
				pxNewData->m_uBlueprintHashID = uBlueprintHashID;
				pxNewData->m_uBlueprintTypeHashID = uBlueprintTypeHashID;
				pxNewData->m_uTokenNum = uTokenNum;
			}	
			return true;
		}

		case AVP_MSGID_ALIEN_TEAM_REMOVE_SPAWNTOKEN:
		{
			const AVP_Message_RemoveAlienTeamTokens* const pxAlienTeamMessage = static_cast<const AVP_Message_RemoveAlienTeamTokens*>(pxMessage->m_pData);

			switch(pxAlienTeamMessage->m_iVersion)
			{
				case 0:
				{
					struct
					{
						int				m_iVersion;
						Asura_Hash_ID	m_uBlueprintHashID;
						u_int			m_uTokenNum;

						union
						{
							u_int		m_uFlags;

							struct
							{
								u_int	m_bRemoveAll	: 1,
														: 0;
							};
						};

					} xOldData;


					//copy the bits we have
					Asura_Mem::Copy(&xOldData,pxMessage->m_pData,pxMessage->m_usDataSize);

					//reallocate the data in the message
					pxMessage->DeallocateMessageData();
					pxMessage->AllocateMessageData(sizeof(AVP_Message_RemoveAlienTeamTokens),false);

					//set defaults in a new message
					{
						AVP_Message_RemoveAlienTeamTokens*	pxNewData	= static_cast<AVP_Message_RemoveAlienTeamTokens*>(pxMessage->m_pData);

						pxNewData->Initialise();
						pxNewData->m_uBlueprintHashID = xOldData.m_uBlueprintHashID;
						pxNewData->m_bRemoveAll = xOldData.m_bRemoveAll;
						pxNewData->m_uTokenNum = xOldData.m_uTokenNum;
					}
					break;
				}

				case AVP_Message_RemoveAlienTeamTokens::CURRENT_VERSION:
				{
					break;
				}

				default:
				{
					Asura_Assert(false, "AVP_MSGID_ALIEN_TEAM_REMOVE_SPAWNTOKEN - Version has changed, fix up the data!");
				}
			}		// End of switch.
			return true;
		}

		case AVP_MSGID_ALIEN_TEAM_THREAT_BONUS:
		{
			const AVP_Message_ChangeThreatBonusValues* pxData = static_cast< const AVP_Message_ChangeThreatBonusValues* >( pxMessage->m_pData );
			if ( pxData->m_iVersion != AVP_Message_ChangeThreatBonusValues::CURRENT_VERSION )
			{
				if( pxData->m_iVersion == 0 )
				{
					struct
					{
						int		m_iVersion;

						float	m_fUnknownBonus;
						float	m_fCivilianBonus;

						float	m_fMarineBonus;
						float	m_fMarineShotgunBonus;
						float	m_fMarineFlameBonus;
						float	m_fMarineSmartgunBonus;
						float	m_fMarinePlayerBonus;

						float	m_fAndroidBonus;
						float	m_fSentryGunBonus;

						float	m_fPredatorBonus;
						float	m_fPredatorPlayerBonus;
							
						u_int	m_uFlags;
					} xOldData;

					//copy the bits we have
					Asura_Mem::Copy(&xOldData,pxData,pxMessage->m_usDataSize);

					//reallocate the data in the message
					pxMessage->DeallocateMessageData();
					pxMessage->AllocateMessageData(sizeof(AVP_Message_ChangeThreatBonusValues),false);

					//set defaults in a new message
					{
						AVP_Message_ChangeThreatBonusValues*	pxNewData	= static_cast<AVP_Message_ChangeThreatBonusValues*>(pxMessage->m_pData);

						pxNewData->Initialise();

						pxNewData->m_fUnknownBonus = xOldData.m_fUnknownBonus;
						pxNewData->m_fCivilianBonus = xOldData.m_fCivilianBonus;
						pxNewData->m_fMarineBonus = xOldData.m_fMarineBonus;
						pxNewData->m_fMarineShotgunBonus = xOldData.m_fMarineShotgunBonus;
						pxNewData->m_fMarineFlameBonus = xOldData.m_fMarineFlameBonus;
						pxNewData->m_fMarineSmartgunBonus = xOldData.m_fMarineSmartgunBonus;
						pxNewData->m_fMarinePlayerBonus = xOldData.m_fMarinePlayerBonus;
						pxNewData->m_fAndroidBonus = xOldData.m_fAndroidBonus;
						pxNewData->m_fSentryGunBonus = xOldData.m_fSentryGunBonus;
						pxNewData->m_fPredatorBonus = xOldData.m_fPredatorBonus;
						pxNewData->m_fPredatorPlayerBonus = xOldData.m_fPredatorPlayerBonus;

						pxNewData->m_uFlags = xOldData.m_uFlags;

						pxNewData->m_fSameTargetBonus = 1.0f;
						pxNewData->m_fPerAttackerBonus = 1.0f;
					}
				}
				else if( pxData->m_iVersion > AVP_Message_ChangeThreatBonusValues::CURRENT_VERSION )
				{
					Asura_Assert( false, "Asura_Chunk_StaticMessages::Project_FixData - old version of AVP_MSGID_ALIEN_TEAM_THREAT_BONUS" );
				}
			}

			return true;
		}

		case AVP_MSGID_SET_PREFERRED_TARGET_TYPE:
		{
			const AVP_Message_SetPreferredTargetType* pxData = static_cast< const AVP_Message_SetPreferredTargetType* >( pxMessage->m_pData );
			if ( pxData->m_uVersion != AVP_Message_SetPreferredTargetType::CURRENT_VERSION )
			{
				Asura_Assert( false, "Asura_Chunk_StaticMessages::Project_FixData - old version of AVP_MSGID_SET_PREFERRED_TARGET_TYPE" );
			}

			return true;
		}

		case AVP_MSGID_SPAWN:
		{
			const AVP_Msg_Spawn* pxData = static_cast< const AVP_Msg_Spawn* >( pxMessage->m_pData );
			Asura_Assert( pxData->m_uVersion == AVP_Msg_Spawn::uCURRENT_VERSION, "Asura_Chunk_StaticMessages::Project_FixData - old version of AVP_MSGID_SPAWN" );
			return true;
		}

		case AVP_MSGID_SET_ALIEN_SQUAD_BEHAVIOUR:
		{
			const AVP_Msg_SetAlienSquadBehaviour* pxData = static_cast< const AVP_Msg_SetAlienSquadBehaviour* >( pxMessage->m_pData );
			if ( pxData->m_uVersion == AVP_Msg_SetAlienSquadBehaviour::uCURRENT_VERSION )
			{
			}
			else if ( pxData->m_uVersion == 6 )
			{
				struct V0Data
				{					
					u_int m_uVersion;
					int m_iBehaviour;
					int m_iMoveInMode;
					float m_fIdealDistanceMin;
					float m_fIdealDistanceMax;
					float m_fAttackDelay;
					int m_iMaxAttackersPerTarget;
					int m_iMaxAttackersTotal;
					int m_iMaxBurstPerTarget;
					int m_iPostAttackAction;
					float m_fRespawnDelay;
					float m_fTimeBetweenAttacks;
					u_int m_uMaxNumberOfChargers; 
					bool m_bAttackIfInLight;
					float m_fTimeInLightBeforeAttack;
					float m_fMinHideDistance;
					float m_fChaneToRehideIfCloseFraction;
					float m_fChaneToRehideIfInLightFraction;
					float m_fChaneToRehideAfterAttackFraction;
				} xV0Data;

				Asura_Assert( sizeof( V0Data ) == pxMessage->m_usDataSize, "Error converting AVP_MSGID_SET_ALIEN_SQUAD_BEHAVIOUR data." );
				Asura_Mem::Copy( &xV0Data, pxData, pxMessage->m_usDataSize );

				pxMessage->DeallocateMessageData();
				pxMessage->AllocateMessageData( sizeof( AVP_Msg_SetAlienSquadBehaviour ), false );

				AVP_Msg_SetAlienSquadBehaviour* pxNewData = static_cast< AVP_Msg_SetAlienSquadBehaviour* >( pxMessage->m_pData );
				pxNewData->m_uVersion               = AVP_Msg_SetAlienSquadBehaviour::uCURRENT_VERSION;
				pxNewData->m_uProtoBlueprintHashID  = ASURA_HASH_ID_UNSET;
				pxNewData->m_fJumpFraction			= 0.5f;
				pxNewData->m_fStandFraction			= 0.5f;
				pxNewData->m_fMinTimeBetweenGrapples= 30.0f;
				pxNewData->m_fDamageFromBehindMultiplier = 0.1f;
				pxNewData->m_iBehaviour             = xV0Data.m_iBehaviour;
				pxNewData->m_iMoveInMode            = xV0Data.m_iMoveInMode;
				pxNewData->m_fIdealDistanceMin      = xV0Data.m_fIdealDistanceMin;
				pxNewData->m_fIdealDistanceMax      = xV0Data.m_fIdealDistanceMax;
				pxNewData->m_fAttackDelay           = xV0Data.m_fAttackDelay;
				pxNewData->m_iMaxAttackersPerTarget = xV0Data.m_iMaxAttackersPerTarget;
				pxNewData->m_iMaxAttackersTotal     = xV0Data.m_iMaxAttackersTotal;
				pxNewData->m_iMaxBurstPerTarget     = xV0Data.m_iMaxBurstPerTarget;
				pxNewData->m_iPostAttackAction      = xV0Data.m_iPostAttackAction;
				pxNewData->m_fRespawnDelay          = xV0Data.m_fRespawnDelay;
				pxNewData->m_fTimeBetweenAttacks	= xV0Data.m_fTimeBetweenAttacks;
				pxNewData->m_uMaxNumberOfChargers   = xV0Data.m_uMaxNumberOfChargers;
				pxNewData->m_bAttackIfInMarineLight		= xV0Data.m_bAttackIfInLight;
				pxNewData->m_fTimeInLightBeforeAttack = xV0Data.m_fTimeInLightBeforeAttack;
				pxNewData->m_fMinHideDistance		= xV0Data.m_fMinHideDistance;
				pxNewData->m_fChaneToRehideIfCloseFraction = xV0Data.m_fChaneToRehideIfCloseFraction;
				pxNewData->m_fChaneToRehideIfInLightFraction = xV0Data.m_fChaneToRehideIfInLightFraction;
				pxNewData->m_fChaneToRehideAfterAttackFraction = xV0Data.m_fChaneToRehideAfterAttackFraction;
			}
			else if ( pxData->m_uVersion == 5 )
			{
				struct V0Data
				{					
					u_int m_uVersion;
					int m_iBehaviour;
					int m_iMoveInMode;
					float m_fIdealDistanceMin;
					float m_fIdealDistanceMax;
					float m_fAttackDelay;
					int m_iMaxAttackersPerTarget;
					int m_iMaxAttackersTotal;
					int m_iMaxBurstPerTarget;
					int m_iPostAttackAction;
					float m_fRespawnDelay;
					float m_fTimeBetweenAttacks;
					u_int m_uMaxNumberOfChargers; 
					bool m_bAttackIfInLight;
					float m_fTimeInLightBeforeAttack;
					float m_fMinHideDistance;
					float m_fChaneToRehideIfCloseFraction;
					float m_fChaneToRehideIfInLightFraction;
				} xV0Data;

				Asura_Assert( sizeof( V0Data ) == pxMessage->m_usDataSize, "Error converting AVP_MSGID_SET_ALIEN_SQUAD_BEHAVIOUR data." );
				Asura_Mem::Copy( &xV0Data, pxData, pxMessage->m_usDataSize );

				pxMessage->DeallocateMessageData();
				pxMessage->AllocateMessageData( sizeof( AVP_Msg_SetAlienSquadBehaviour ), false );

				AVP_Msg_SetAlienSquadBehaviour* pxNewData = static_cast< AVP_Msg_SetAlienSquadBehaviour* >( pxMessage->m_pData );
				pxNewData->m_uVersion               = AVP_Msg_SetAlienSquadBehaviour::uCURRENT_VERSION;
				pxNewData->m_iBehaviour             = xV0Data.m_iBehaviour;
				pxNewData->m_uProtoBlueprintHashID  = ASURA_HASH_ID_UNSET;
				pxNewData->m_fJumpFraction			= 0.5f;
				pxNewData->m_fStandFraction			= 0.5f;
				pxNewData->m_fMinTimeBetweenGrapples= 30.0f;
				pxNewData->m_fDamageFromBehindMultiplier = 0.1f;
				pxNewData->m_iMoveInMode            = xV0Data.m_iMoveInMode;
				pxNewData->m_fIdealDistanceMin      = xV0Data.m_fIdealDistanceMin;
				pxNewData->m_fIdealDistanceMax      = xV0Data.m_fIdealDistanceMax;
				pxNewData->m_fAttackDelay           = xV0Data.m_fAttackDelay;
				pxNewData->m_iMaxAttackersPerTarget = xV0Data.m_iMaxAttackersPerTarget;
				pxNewData->m_iMaxAttackersTotal     = xV0Data.m_iMaxAttackersTotal;
				pxNewData->m_iMaxBurstPerTarget     = xV0Data.m_iMaxBurstPerTarget;
				pxNewData->m_iPostAttackAction      = xV0Data.m_iPostAttackAction;
				pxNewData->m_fRespawnDelay          = xV0Data.m_fRespawnDelay;
				pxNewData->m_fTimeBetweenAttacks	= xV0Data.m_fTimeBetweenAttacks;
				pxNewData->m_uMaxNumberOfChargers   = xV0Data.m_uMaxNumberOfChargers;
				pxNewData->m_bAttackIfInMarineLight		= xV0Data.m_bAttackIfInLight;
				pxNewData->m_fTimeInLightBeforeAttack = xV0Data.m_fTimeInLightBeforeAttack;
				pxNewData->m_fMinHideDistance		= xV0Data.m_fMinHideDistance;
				pxNewData->m_fChaneToRehideIfCloseFraction = xV0Data.m_fChaneToRehideIfCloseFraction;
				pxNewData->m_fChaneToRehideIfInLightFraction = xV0Data.m_fChaneToRehideIfInLightFraction;
				pxNewData->m_fChaneToRehideAfterAttackFraction = 0.0f;
			}
			else if ( pxData->m_uVersion == 4 )
			{
				struct V0Data
				{					
					u_int m_uVersion;
					int m_iBehaviour;
					int m_iMoveInMode;
					float m_fIdealDistanceMin;
					float m_fIdealDistanceMax;
					float m_fAttackDelay;
					int m_iMaxAttackersPerTarget;
					int m_iMaxAttackersTotal;
					int m_iMaxBurstPerTarget;
					int m_iPostAttackAction;
					float m_fRespawnDelay;
					float m_fTimeBetweenAttacks;
					u_int m_uMaxNumberOfChargers; 
					bool m_bAttackIfInLight;
					float m_fTimeInLightBeforeAttack;
					float m_fMinHideDistance;
				} xV0Data;

				Asura_Assert( sizeof( V0Data ) == pxMessage->m_usDataSize, "Error converting AVP_MSGID_SET_ALIEN_SQUAD_BEHAVIOUR data." );
				Asura_Mem::Copy( &xV0Data, pxData, pxMessage->m_usDataSize );

				pxMessage->DeallocateMessageData();
				pxMessage->AllocateMessageData( sizeof( AVP_Msg_SetAlienSquadBehaviour ), false );

				AVP_Msg_SetAlienSquadBehaviour* pxNewData = static_cast< AVP_Msg_SetAlienSquadBehaviour* >( pxMessage->m_pData );
				pxNewData->m_uVersion               = AVP_Msg_SetAlienSquadBehaviour::uCURRENT_VERSION;
				pxNewData->m_iBehaviour             = xV0Data.m_iBehaviour;
				pxNewData->m_uProtoBlueprintHashID  = ASURA_HASH_ID_UNSET;
				pxNewData->m_fJumpFraction			= 0.5f;
				pxNewData->m_fStandFraction			= 0.5f;
				pxNewData->m_fMinTimeBetweenGrapples= 30.0f;
				pxNewData->m_fDamageFromBehindMultiplier = 0.1f;
				pxNewData->m_iMoveInMode            = xV0Data.m_iMoveInMode;
				pxNewData->m_fIdealDistanceMin      = xV0Data.m_fIdealDistanceMin;
				pxNewData->m_fIdealDistanceMax      = xV0Data.m_fIdealDistanceMax;
				pxNewData->m_fAttackDelay           = xV0Data.m_fAttackDelay;
				pxNewData->m_iMaxAttackersPerTarget = xV0Data.m_iMaxAttackersPerTarget;
				pxNewData->m_iMaxAttackersTotal     = xV0Data.m_iMaxAttackersTotal;
				pxNewData->m_iMaxBurstPerTarget     = xV0Data.m_iMaxBurstPerTarget;
				pxNewData->m_iPostAttackAction      = xV0Data.m_iPostAttackAction;
				pxNewData->m_fRespawnDelay          = xV0Data.m_fRespawnDelay;
				pxNewData->m_fTimeBetweenAttacks	= xV0Data.m_fTimeBetweenAttacks;
				pxNewData->m_uMaxNumberOfChargers   = xV0Data.m_uMaxNumberOfChargers;
				pxNewData->m_bAttackIfInMarineLight		= xV0Data.m_bAttackIfInLight;
				pxNewData->m_fTimeInLightBeforeAttack = xV0Data.m_fTimeInLightBeforeAttack;
				pxNewData->m_fMinHideDistance		= xV0Data.m_fMinHideDistance;
				pxNewData->m_fChaneToRehideIfCloseFraction = 0.0f;
				pxNewData->m_fChaneToRehideIfInLightFraction = 1.0f;
				pxNewData->m_fChaneToRehideAfterAttackFraction = 0.0f;
			}
			else if ( pxData->m_uVersion == 3 )
			{
				struct V0Data
				{					
					u_int m_uVersion;
					int m_iBehaviour;
					int m_iMoveInMode;
					float m_fIdealDistanceMin;
					float m_fIdealDistanceMax;
					float m_fAttackDelay;
					int m_iMaxAttackersPerTarget;
					int m_iMaxAttackersTotal;
					int m_iMaxBurstPerTarget;
					int m_iPostAttackAction;
					float m_fRespawnDelay;
					float m_fTimeBetweenAttacks;
					u_int m_uMaxNumberOfChargers; 
				} xV0Data;

				Asura_Assert( sizeof( V0Data ) == pxMessage->m_usDataSize, "Error converting AVP_MSGID_SET_ALIEN_SQUAD_BEHAVIOUR data." );
				Asura_Mem::Copy( &xV0Data, pxData, pxMessage->m_usDataSize );

				pxMessage->DeallocateMessageData();
				pxMessage->AllocateMessageData( sizeof( AVP_Msg_SetAlienSquadBehaviour ), false );

				AVP_Msg_SetAlienSquadBehaviour* pxNewData = static_cast< AVP_Msg_SetAlienSquadBehaviour* >( pxMessage->m_pData );
				pxNewData->m_uVersion               = AVP_Msg_SetAlienSquadBehaviour::uCURRENT_VERSION;
				pxNewData->m_iBehaviour             = xV0Data.m_iBehaviour;
				pxNewData->m_uProtoBlueprintHashID  = ASURA_HASH_ID_UNSET;
				pxNewData->m_fJumpFraction			= 0.5f;
				pxNewData->m_fStandFraction			= 0.5f;
				pxNewData->m_fMinTimeBetweenGrapples= 30.0f;
				pxNewData->m_fDamageFromBehindMultiplier = 0.1f;
				pxNewData->m_iMoveInMode            = xV0Data.m_iMoveInMode;
				pxNewData->m_fIdealDistanceMin      = xV0Data.m_fIdealDistanceMin;
				pxNewData->m_fIdealDistanceMax      = xV0Data.m_fIdealDistanceMax;
				pxNewData->m_fAttackDelay           = xV0Data.m_fAttackDelay;
				pxNewData->m_iMaxAttackersPerTarget = xV0Data.m_iMaxAttackersPerTarget;
				pxNewData->m_iMaxAttackersTotal     = xV0Data.m_iMaxAttackersTotal;
				pxNewData->m_iMaxBurstPerTarget     = xV0Data.m_iMaxBurstPerTarget;
				pxNewData->m_iPostAttackAction      = xV0Data.m_iPostAttackAction;
				pxNewData->m_fRespawnDelay          = xV0Data.m_fRespawnDelay;
				pxNewData->m_fTimeBetweenAttacks	= xV0Data.m_fTimeBetweenAttacks;
				pxNewData->m_uMaxNumberOfChargers   = xV0Data.m_uMaxNumberOfChargers;
				pxNewData->m_bAttackIfInMarineLight		= false;
				pxNewData->m_fTimeInLightBeforeAttack = 5.0f;
				pxNewData->m_fMinHideDistance		= 5.0f;
				pxNewData->m_fChaneToRehideIfCloseFraction = 0.0f;
				pxNewData->m_fChaneToRehideIfInLightFraction = 1.0f;
				pxNewData->m_fChaneToRehideAfterAttackFraction = 0.0f;

			}
			else if ( pxData->m_uVersion == 2 )
			{
				struct V0Data
				{					
					u_int m_uVersion;
					int m_iBehaviour;
					int m_iMoveInMode;
					float m_fIdealDistanceMin;
					float m_fIdealDistanceMax;
					float m_fAttackDelay;
					int m_iMaxAttackersPerTarget;
					int m_iMaxAttackersTotal;
					int m_iMaxBurstPerTarget;
					int m_iPostAttackAction;
					float m_fRespawnDelay;
				} xV0Data;

				Asura_Assert( sizeof( V0Data ) == pxMessage->m_usDataSize, "Error converting AVP_MSGID_SET_ALIEN_SQUAD_BEHAVIOUR data." );
				Asura_Mem::Copy( &xV0Data, pxData, pxMessage->m_usDataSize );

				pxMessage->DeallocateMessageData();
				pxMessage->AllocateMessageData( sizeof( AVP_Msg_SetAlienSquadBehaviour ), false );

				AVP_Msg_SetAlienSquadBehaviour* pxNewData = static_cast< AVP_Msg_SetAlienSquadBehaviour* >( pxMessage->m_pData );
				pxNewData->m_uVersion               = AVP_Msg_SetAlienSquadBehaviour::uCURRENT_VERSION;
				pxNewData->m_iBehaviour             = xV0Data.m_iBehaviour;
				pxNewData->m_uProtoBlueprintHashID  = ASURA_HASH_ID_UNSET;
				pxNewData->m_fJumpFraction			= 0.5f;
				pxNewData->m_fStandFraction			= 0.5f;
				pxNewData->m_fMinTimeBetweenGrapples= 30.0f;
				pxNewData->m_fDamageFromBehindMultiplier = 0.1f;
				pxNewData->m_iMoveInMode            = xV0Data.m_iMoveInMode;
				pxNewData->m_fIdealDistanceMin      = xV0Data.m_fIdealDistanceMin;
				pxNewData->m_fIdealDistanceMax      = xV0Data.m_fIdealDistanceMax;
				pxNewData->m_fAttackDelay           = xV0Data.m_fAttackDelay;
				pxNewData->m_iMaxAttackersPerTarget = xV0Data.m_iMaxAttackersPerTarget;
				pxNewData->m_iMaxAttackersTotal     = xV0Data.m_iMaxAttackersTotal;
				pxNewData->m_iMaxBurstPerTarget     = xV0Data.m_iMaxBurstPerTarget;
				pxNewData->m_iPostAttackAction      = xV0Data.m_iPostAttackAction;
				pxNewData->m_fRespawnDelay          = xV0Data.m_fRespawnDelay;
				pxNewData->m_fTimeBetweenAttacks	= 0.0f;
				pxNewData->m_uMaxNumberOfChargers   = 5;
				pxNewData->m_bAttackIfInMarineLight		= false;
				pxNewData->m_fTimeInLightBeforeAttack = 5.0f;
				pxNewData->m_fMinHideDistance		= 5.0f;
				pxNewData->m_fChaneToRehideIfCloseFraction = 0.0f;
				pxNewData->m_fChaneToRehideIfInLightFraction = 1.0f;
				pxNewData->m_fChaneToRehideAfterAttackFraction = 0.0f;

			}
			else if ( pxData->m_uVersion == 1 )
			{
				struct V0Data
				{					
					u_int m_uVersion;
					int m_iBehaviour;
					int m_iMoveInMode;
					float m_fIdealDistanceMin;
					float m_fIdealDistanceMax;
					float m_fAttackDelay;
					int m_iMaxAttackersPerTarget;
					int m_iMaxAttackersTotal;
					int m_iPostAttackAction;
					float m_fRespawnDelay;
				} xV0Data;

				Asura_Assert( sizeof( V0Data ) == pxMessage->m_usDataSize, "Error converting AVP_MSGID_SET_ALIEN_SQUAD_BEHAVIOUR data." );
				Asura_Mem::Copy( &xV0Data, pxData, pxMessage->m_usDataSize );

				pxMessage->DeallocateMessageData();
				pxMessage->AllocateMessageData( sizeof( AVP_Msg_SetAlienSquadBehaviour ), false );

				AVP_Msg_SetAlienSquadBehaviour* pxNewData = static_cast< AVP_Msg_SetAlienSquadBehaviour* >( pxMessage->m_pData );
				pxNewData->m_uVersion               = AVP_Msg_SetAlienSquadBehaviour::uCURRENT_VERSION;
				pxNewData->m_iBehaviour             = xV0Data.m_iBehaviour;
				pxNewData->m_uProtoBlueprintHashID  = ASURA_HASH_ID_UNSET;
				pxNewData->m_fJumpFraction			= 0.5f;
				pxNewData->m_fStandFraction			= 0.5f;
				pxNewData->m_fMinTimeBetweenGrapples= 30.0f;
				pxNewData->m_fDamageFromBehindMultiplier = 0.1f;
				pxNewData->m_iMoveInMode            = xV0Data.m_iMoveInMode;
				pxNewData->m_fIdealDistanceMin      = xV0Data.m_fIdealDistanceMin;
				pxNewData->m_fIdealDistanceMax      = xV0Data.m_fIdealDistanceMax;
				pxNewData->m_fAttackDelay           = xV0Data.m_fAttackDelay;
				pxNewData->m_iMaxAttackersPerTarget = xV0Data.m_iMaxAttackersPerTarget;
				pxNewData->m_iMaxAttackersTotal     = xV0Data.m_iMaxAttackersTotal;
				pxNewData->m_iMaxBurstPerTarget     = 0;
				pxNewData->m_iPostAttackAction      = xV0Data.m_iPostAttackAction;
				pxNewData->m_fRespawnDelay          = xV0Data.m_fRespawnDelay;
				pxNewData->m_fTimeBetweenAttacks	= 0.0f;
				pxNewData->m_uMaxNumberOfChargers   = 5;
				pxNewData->m_bAttackIfInMarineLight		= false;
				pxNewData->m_fTimeInLightBeforeAttack = 5.0f;	
				pxNewData->m_fMinHideDistance		= 5.0f;
				pxNewData->m_fChaneToRehideIfCloseFraction = 0.0f;
				pxNewData->m_fChaneToRehideIfInLightFraction = 1.0f;
				pxNewData->m_fChaneToRehideAfterAttackFraction = 0.0f;

			}
			else if ( pxData->m_uVersion == 0 )
			{
				struct V0Data
				{
					u_int m_uVersion;
					int   m_iBehaviour;
					int	  m_iMoveInMode;
					float m_fIdealDistanceMin;
					float m_fIdealDistanceMax;
					int   m_iMaxAttackersTotal;
					int   m_iPostAttackAction;
					u_int m_uNumHidePoints;
					// Hide point guid array pointer shows up in the sizeof count, so we have to save out an extra int to keep things happy.
					int   m_iHidePointPtr;
				} xV0Data;

				Asura_Assert( sizeof( V0Data ) == pxMessage->m_usDataSize, "Error converting AVP_MSGID_SET_ALIEN_SQUAD_BEHAVIOUR data." );
				Asura_Mem::Copy( &xV0Data, pxData, pxMessage->m_usDataSize );

				pxMessage->DeallocateMessageData();
				pxMessage->AllocateMessageData( sizeof( AVP_Msg_SetAlienSquadBehaviour ), false );

				AVP_Msg_SetAlienSquadBehaviour* pxNewData = static_cast< AVP_Msg_SetAlienSquadBehaviour* >( pxMessage->m_pData );
                pxNewData->m_uVersion               = AVP_Msg_SetAlienSquadBehaviour::uCURRENT_VERSION;
                pxNewData->m_iBehaviour             = xV0Data.m_iBehaviour;
				pxNewData->m_uProtoBlueprintHashID  = ASURA_HASH_ID_UNSET;
				pxNewData->m_fJumpFraction			= 0.5f;
				pxNewData->m_fStandFraction			= 0.5f;
				pxNewData->m_fMinTimeBetweenGrapples= 30.0f;
				pxNewData->m_fDamageFromBehindMultiplier = 0.1f;
                pxNewData->m_iMoveInMode            = xV0Data.m_iMoveInMode;
                pxNewData->m_fIdealDistanceMin      = xV0Data.m_fIdealDistanceMin;
                pxNewData->m_fIdealDistanceMax      = xV0Data.m_fIdealDistanceMax;
                pxNewData->m_fAttackDelay           = 2.5f;
				pxNewData->m_iMaxAttackersPerTarget = 2;
                pxNewData->m_iMaxAttackersTotal     = xV0Data.m_iMaxAttackersTotal;
				pxNewData->m_iMaxBurstPerTarget     = 0;
                pxNewData->m_iPostAttackAction      = xV0Data.m_iPostAttackAction;
                pxNewData->m_fRespawnDelay          = 5.0f;
				pxNewData->m_fTimeBetweenAttacks	= 0.0f;
				pxNewData->m_uMaxNumberOfChargers   = 5;
				pxNewData->m_bAttackIfInMarineLight		= false;
				pxNewData->m_fTimeInLightBeforeAttack = 5.0f;
				pxNewData->m_fMinHideDistance		= 5.0f;
				pxNewData->m_fChaneToRehideIfCloseFraction = 0.0f;
				pxNewData->m_fChaneToRehideIfInLightFraction = 1.0f;
				pxNewData->m_fChaneToRehideAfterAttackFraction = 0.0f;
			}
			else
			{
				Asura_Assertf( false, ("AVP_MSGID_SET_ALIEN_SQUAD_BEHAVIOUR - Version &d has changed Fix up the data!!!",pxData->m_uVersion)  );
			}

			return true;
		}

		case AVP_MSGID_CHANGE_MARINE_SQUAD_SETTINGS:
		{
			const AVP_Message_ChangeMarineSquadSettings* const pxSquadMessage = static_cast< const AVP_Message_ChangeMarineSquadSettings* >( pxMessage->m_pData );

			switch ( pxSquadMessage->m_uVersion )
			{
				case 1:
				{
					struct
					{
						u_int		m_uVersion;
						u_int		m_bIsPlayersSquad;
						u_int		m_bIsAiLedPlayersSquad;
						u_int		m_bIsRestrictedToCombatZone;
						Asura_Guid	m_uCombatZoneGPVGuid;

					} xOldData;

					//copy the bits we have
					Asura_Mem::Copy( &xOldData, pxSquadMessage, pxMessage->m_usDataSize );

					pxMessage->DeallocateMessageData();
					pxMessage->AllocateMessageData( sizeof (AVP_Message_ChangeMarineSquadSettings), false);

					AVP_Message_ChangeMarineSquadSettings* pxNewMsgData = static_cast< AVP_Message_ChangeMarineSquadSettings* >( pxMessage->m_pData );

					pxNewMsgData->m_uVersion					= AVP_Message_ChangeMarineSquadSettings::CURRENT_MSG_VERSION;
					pxNewMsgData->m_bIsPlayersSquad				= xOldData.m_bIsPlayersSquad;
					pxNewMsgData->m_bIsAiLedPlayersSquad		= xOldData.m_bIsAiLedPlayersSquad;
					pxNewMsgData->m_bIgnoreAlertState			= 0;
					pxNewMsgData->m_bIsRestrictedToCombatZone	= xOldData.m_bIsRestrictedToCombatZone;
					pxNewMsgData->m_uCombatZoneGPVGuid			= xOldData.m_uCombatZoneGPVGuid;
					pxNewMsgData->m_iSquadCombatType			= 0;

				}break;

				case 2:
				{
					// my mess up, msg version got set incorrectly now I have two messages with the same version number but different datasizes.
					if ( pxMessage->m_usDataSize == 24 )
					{
						struct
						{
							u_int		m_uVersion;
							u_int		m_bIsPlayersSquad;
							u_int		m_bIsAiLedPlayersSquad;
							u_int		m_bIsRestrictedToCombatZone;
							u_int		m_bIgnoreAlertState;
							Asura_Guid	m_uCombatZoneGPVGuid;

						} xOldData;

						//copy the bits we have
						Asura_Mem::Copy( &xOldData, pxSquadMessage, pxMessage->m_usDataSize );

						pxMessage->DeallocateMessageData();
						pxMessage->AllocateMessageData( sizeof (AVP_Message_ChangeMarineSquadSettings), false);

						AVP_Message_ChangeMarineSquadSettings* pxNewMsgData = static_cast< AVP_Message_ChangeMarineSquadSettings* >( pxMessage->m_pData );

						pxNewMsgData->m_uVersion					= AVP_Message_ChangeMarineSquadSettings::CURRENT_MSG_VERSION;
						pxNewMsgData->m_bIsPlayersSquad				= xOldData.m_bIsPlayersSquad;
						pxNewMsgData->m_bIsAiLedPlayersSquad		= xOldData.m_bIsAiLedPlayersSquad;
						pxNewMsgData->m_bIgnoreAlertState			= xOldData.m_bIgnoreAlertState;
						pxNewMsgData->m_bIsRestrictedToCombatZone	= xOldData.m_bIsRestrictedToCombatZone;
						pxNewMsgData->m_uCombatZoneGPVGuid			= xOldData.m_uCombatZoneGPVGuid;
						pxNewMsgData->m_iSquadCombatType			= 0;
					}
					else if ( pxMessage->m_usDataSize == 28 )
					{
						struct
						{
							u_int		m_uVersion;
							u_int		m_bIsPlayersSquad;
							u_int		m_bIsAiLedPlayersSquad;
							u_int		m_bIsRestrictedToCombatZone;
							u_int		m_bIgnoreAlertState;
							Asura_Guid	m_uCombatZoneGPVGuid;
							int			m_iSquadCombatType;

						} xOldData;

						//copy the bits we have
						Asura_Mem::Copy( &xOldData, pxSquadMessage, pxMessage->m_usDataSize );

						pxMessage->DeallocateMessageData();
						pxMessage->AllocateMessageData( sizeof (AVP_Message_ChangeMarineSquadSettings), false);

						AVP_Message_ChangeMarineSquadSettings* pxNewMsgData = static_cast< AVP_Message_ChangeMarineSquadSettings* >( pxMessage->m_pData );

						pxNewMsgData->m_uVersion					= AVP_Message_ChangeMarineSquadSettings::CURRENT_MSG_VERSION;
						pxNewMsgData->m_bIsPlayersSquad				= xOldData.m_bIsPlayersSquad;
						pxNewMsgData->m_bIsAiLedPlayersSquad		= xOldData.m_bIsAiLedPlayersSquad;
						pxNewMsgData->m_bIgnoreAlertState			= xOldData.m_bIgnoreAlertState;
						pxNewMsgData->m_bIsRestrictedToCombatZone	= xOldData.m_bIsRestrictedToCombatZone;
						pxNewMsgData->m_uCombatZoneGPVGuid			= xOldData.m_uCombatZoneGPVGuid;
						pxNewMsgData->m_iSquadCombatType			= 0;
					}
					else
					{
						Asura_Assert( false, "Fixing AVP_MSGID_CHANGE_MARINE_SQUAD_SETTINGS message - Data size is incorrect for this message!!!");
					}

				}break;

				default:
				{
					Asura_Assert( pxSquadMessage->m_uVersion != 0 && pxSquadMessage->m_uVersion <= 3, "AVP_MSGID_CHANGE_MARINE_SQUAD_SETTINGS - Version has changed Fix up the data!!!" );
				}
			}
			
			return true;
		}

		case AVP_MSGID_SET_PREDATOR_BEHAVIOUR:
		{
			const AVP_Message_SetPredatorBehaviour* pxData = static_cast<  AVP_Message_SetPredatorBehaviour* >( pxMessage->m_pData );
			Asura_Assert( pxData->m_uVersion == 0 || pxData->m_uVersion == AVP_Message_SetPredatorBehaviour::uCURRENT_VERSION, "Asura_Chunk_StaticMessages::Project_FixData - old version of AVP_MSGID_SET_PREDATOR_BEHAVIOUR" );
			if (pxData->m_uVersion == 0)
			{
				// hack the broken early case back into reasonable data;
				const_cast<  AVP_Message_SetPredatorBehaviour* >( pxData)->m_uVersion = 1;
			}
			return true;
		}

		case AVP_MSGID_ATTACK_SCRIPTED_TARGET:
		{
			const AVP_Message_AttackScriptedTarget* const pxAttackMessage = static_cast< const AVP_Message_AttackScriptedTarget* >( pxMessage->m_pData );

			if ( pxAttackMessage->m_uVersion > 1 )
			{
				Asura_Assert( false, "AVP_MSGID_ATTACK_SCRIPTED_TARGET - Version has changed Fix up the data!!!" );
			}
			return true;
		}

		case AVP_MSGID_LOOK_AT_ENTITY:
		{
			const AVP_Message_LookAtEntity* const pxOldLookAtData = static_cast< const AVP_Message_LookAtEntity* >( pxMessage->m_pData );

			switch ( pxOldLookAtData->m_uVersion )
			{
				case 1:
				{
					struct
					{
						u_int m_uVersion;
						Asura_Guid m_uLookAtGuid;
						u_int m_bLookAtPlayer;
					} xOldData;

					//copy the bits we have
					Asura_Mem::Copy( &xOldData, pxOldLookAtData, pxMessage->m_usDataSize );

					pxMessage->DeallocateMessageData();
					pxMessage->AllocateMessageData( sizeof (AVP_Message_LookAtEntity), false);

					AVP_Message_LookAtEntity* pxNewMsgData = static_cast< AVP_Message_LookAtEntity* >( pxMessage->m_pData );

					pxNewMsgData->m_uVersion					= 2;
					pxNewMsgData->m_uLookAtGuid					= xOldData.m_uLookAtGuid;
					pxNewMsgData->m_bLookAtPlayer				= xOldData.m_bLookAtPlayer;

					pxNewMsgData->m_uLookAtMarker				= ASURA_HASH_ID_UNSET;
				}
				break;

				case 2:
				{
					//Current version
				}
				break;

				default:
				{
					Asura_Assert( false, "AVP_MSGID_LOOK_AT_ENTITY - Version has changed Fix up the data!!!" );
				}
				break;
			}
			return true;
		}

		case AVP_MSGID_SET_FACEHUGGER_SQUAD_BEHAVIOUR:
		{
			const AVP_Msg_SetAlienSquadBehaviour* pxData = static_cast< const AVP_Msg_SetAlienSquadBehaviour* >( pxMessage->m_pData );
			if ( pxData->m_uVersion == AVP_Msg_SetAlienSquadBehaviour::uCURRENT_VERSION )
			{
			}			
			else
			{
				Asura_Assertf( false, ("AVP_MSGID_SET_FACEHUGGER_SQUAD_BEHAVIOUR - Version &d has changed Fix up the data!!!",pxData->m_uVersion)  );
			}

			return true;
		}

		case AVP_MSGID_ALIENQUEEN_ADD_TO_TARGET_LIST:
		{
			const AVP_Msg_Add_Entity_To_Queen_Target_List* pxData = static_cast< const AVP_Msg_Add_Entity_To_Queen_Target_List* >( pxMessage->m_pData );
			switch ( pxData->m_uVersion )
			{
				case 0:
				{
					// current version
					break;
				}
				default:
				{
					Asura_Assert( false, "AVP_MSGID_ALIENQUEEN_ADD_TO_TARGET_LIST - Version has changed Fix up the data!!!" );
					break;
				}
			}
			
			return true;
		}

		case AVP_MSGID_ALIENQUEEN_REMOVE_FROM_TARGET_LIST:
		{
			const AVP_Msg_Remove_Entity_From_Queen_Target_List* pxData = static_cast< const AVP_Msg_Remove_Entity_From_Queen_Target_List* >( pxMessage->m_pData );
			switch ( pxData->m_uVersion )
			{
				case 0:
				{
					// current version
					break;
				}
				default:
				{
					Asura_Assert( false, "AVP_MSGID_ALIENQUEEN_REMOVE_FROM_TARGET_LIST - Version has changed Fix up the data!!!" );
					break;
				}
			}

			return true;
		}

		case AVP_MSGID_ALIENQUEEN_FORCE_ROAR:
		{
			AVP_Msg_Alien_Queen_Start_Roar_Behaviour* pxData = static_cast<AVP_Msg_Alien_Queen_Start_Roar_Behaviour*>( pxMessage->m_pData );
			switch ( pxData->m_uVersion )
			{
				case 1:
				{
					// current version. 
					break;
				}
				case 0:
				{
					pxData->SetRoarAtPlayer( false );
					pxData->m_uVersion = 1;
					break;
				}
				default:
				{
					Asura_Assert( false, "AVP_MSGID_ALIENQUEEN_FORCE_ROAR - Version has changed Fix up the data!!!" );
					break;
				}
			}

			return true;
		}

		case AVP_MSGID_ALIENQUEEN_SET_BEHAVIOUR:
		{
			const AVP_Message_SetAlienQueenBehaviour* pxData = static_cast<  AVP_Message_SetAlienQueenBehaviour* >( pxMessage->m_pData );
			Asura_Assert( pxData->m_uVersion == AVP_Message_SetAlienQueenBehaviour::uCURRENT_VERSION, "Asura_Chunk_StaticMessages::Project_FixData - old version of AVP_MSGID_ALIENQUEEN_SET_BEHAVIOUR" );
			if( pxData->m_uVersion == 0 )
			{
				// if we are not in the correct version then fix it, no data to change at the moment. 
				const_cast<AVP_Message_SetAlienQueenBehaviour*>( pxData)->m_uVersion = 1;
			}
			return true;
		}

		default:
		{
			return false;
		}
	}		// End of switch.
}

#endif // #ifdef ASURA_TOOLS

#if defined(ASURA_USE_STREAMING) && !defined(ASURA_TOOLS)
bool Asura_Chunk_StaticMessages::Project_FixGuidsForStreaming(Asura_StaticMessage& xMessage)
{
	// No special handling for now.
	return false;
}
#endif //#if defined(ASURA_USE_STREAMING) && !defined(ASURA_TOOLS)


/// End of file. ///
