Subversion Repositories spk

#include "ShipData.h"

#include "spkdef.h"

CShipData::CShipData(void)

{

	this->CreateDefault();

}

CShipData::~CShipData(void)

{

	this->ClearLists();

}

Utils::WString CShipData::createData() const

{

	Utils::WString data = this->sModel;

	data.addToken(L";", Utils::WString::Number(this->iPictureID));

	data.addToken(L";", Utils::WString::FromFloat(this->fRotX, -1));

	data.addToken(L";", Utils::WString::FromFloat(this->fRotY, -1));

	data.addToken(L";", Utils::WString::FromFloat(this->fRotZ, -1));

	data.addToken(L";", CShipData::ConvertShipSubType(this->iSubType));

	data.addToken(L";", Utils::WString::Number(this->iDesc));

	data.addToken(L";", Utils::WString::Number(this->iSpeed));

	data.addToken(L";", Utils::WString::Number(this->iAccel));

	data.addToken(L";", Utils::WString::Number(this->iEngineSound));

	data.addToken(L";", Utils::WString::Number(this->iReactionDelay));

	data.addToken(L";", Utils::WString::Number(this->iEngineEffect));

	data.addToken(L";", Utils::WString::Number(this->iEngineGlow));

	data.addToken(L";", Utils::WString::Number(this->iPower));

	data.addToken(L";", Utils::WString::Number(this->iSoundMin));

	data.addToken(L";", Utils::WString::Number(this->iSoundMax));

	data.addToken(L";", this->sModelScene);

	data.addToken(L";", this->sCockpitScene);

	data.addToken(L";", Utils::WString::Number(this->iLaserMask));

	data.addToken(L";", Utils::WString::Number(this->iGunCount));

	data.addToken(L";", Utils::WString::Number(this->iLaserEnergy));

	data.addToken(L";", Utils::WString::FromFloat(this->fLaserRecharge, -1));

	data.addToken(L";", Utils::WString::Number(this->iShieldType));

	data.addToken(L";", Utils::WString::Number(this->iMaxShields));

	data.addToken(L";", Utils::WString::Number(this->iMissileMask));

	data.addToken(L";", Utils::WString::Number(this->iMissileCount));

	data.addToken(L";", Utils::WString::Number(this->iSpeedExtension));

	data.addToken(L";", Utils::WString::Number(this->iSteeringExtension));

	data.addToken(L";", Utils::WString::Number(this->iCargoMin));

	data.addToken(L";", Utils::WString::Number(this->iCargoMax));

	data.addToken(L";", Utils::WString::Number(this->iWareListID));

	// 6 turrets next

	for ( int i = 0; i < 6; i++ )

	{

		if ( this->cockpits[i].sCockpit.empty() )

			data.addToken(L";", Utils::WString::Number(this->cockpits[i].iCockpit));

		else

		{

			if ( this->cockpits[i].iCockpit > -1 )

				data.addToken(L";", this->cockpits[i].sCockpit + L"(" + (long)this->cockpits[i].iCockpit + L")");

			else

				data.addToken(L";", this->cockpits[i].sCockpit);

		}

		data.addToken(L";", Utils::WString::Number(this->cockpits[i].iPos));

	}

	data.addToken(L";", Utils::WString::Number(this->iDocking));

	data.addToken(L";", Utils::WString::Number(this->iCargoClass));

	data.addToken(L";", Utils::WString::Number(this->iRace));

	data.addToken(L";", Utils::WString::Number(this->iHull));

	data.addToken(L";", Utils::WString::Number(this->iExplosionDef));

	data.addToken(L";", Utils::WString::Number(this->iExplosionBody));

	data.addToken(L";", Utils::WString::Number(this->iParticle));

	data.addToken(L";", Utils::WString::Number(this->iVariation));

	data.addToken(L";", Utils::WString::Number(this->iRotationAccel));

	data.addToken(L";", Utils::WString::Number(this->iClass));

	data.addToken(L";", Utils::WString::Number(this->iTurretCount));

	// now do the turrets

	for ( int i = 0; i < this->iTurretCount; i++ )

	{

		STurretEntry *t = this->lTurrets[i];

		data.addToken(L";", Utils::WString::Number(t->iIndex));

		data.addToken(L";", Utils::WString::Number(t->iTurret));

		data.addToken(L";", t->sModel);

		data.addToken(L";", Utils::WString::Number(t->iSceneNode));

	}

	// the gun entries next

	data.addToken(L";", Utils::WString::Number(this->iGunsCount));

	for ( int i = 0; i < this->iGunsCount; i++ )

	{

		SGunGroup *g = this->lGuns[i];

		data.addToken(L";", Utils::WString::Number(g->iGunIndex));

		data.addToken(L";", Utils::WString::Number(g->iLaserCount));

		data.addToken(L";", Utils::WString::Number(g->iIndex));

		data.addToken(L";", Utils::WString::Number(g->iWeaponCount));

		for ( int j = 0; j < g->iWeaponCount; j++ )

		{

			SWeaponGroup *w = g->lWeapons[j];

			data.addToken(L";", Utils::WString::Number(w->iGunIndex));

			data.addToken(L";", Utils::WString::Number(w->iLaser));

			data.addToken(L";", w->sModel1);

			data.addToken(L";", Utils::WString::Number(w->iNode1));

			data.addToken(L";", w->sModel2);

			data.addToken(L";", Utils::WString::Number(w->iNode2));

		}

	}

	// now the rest of the data

	data.addToken(L";", Utils::WString::Number(this->iVolumn));

	data.addToken(L";", Utils::WString::Number(this->iRelVal));

	data.addToken(L";", Utils::WString::Number(this->iPriceMod1));

	data.addToken(L";", Utils::WString::Number(this->iPriceMod2));

	data.addToken(L";", Utils::WString::Number(this->iSize));

	data.addToken(L";", Utils::WString::Number(this->iRelValPlayer));

	data.addToken(L";", Utils::WString::Number(this->iMinNoto));

	data.addToken(L";", Utils::WString::Number(this->iVideoID));

	data.addToken(L";", Utils::WString::Number(this->iSkin));

	data.addToken(L";", this->sID);

	data += L";"; // add the end ;

	return data;

}

void CShipData::CreateDefault()

{

	this->sModel = L"0";

	this->iPictureID = 0;

	this->fRotX = 0.00f;

	this->fRotY = 0.00f;

	this->fRotZ = 0.00f;

	this->iSubType = 0;

	this->iDesc = 0;

	this->iSpeed = 0;

	this->iAccel = 0;

	this->iEngineSound = 106;

	this->iReactionDelay = 1;

	this->iEngineEffect = 5;

	this->iEngineGlow = 37;

	this->iPower = 0;

	this->iSoundMin = 112;

	this->iSoundMax = 202;

	this->sModelScene = L"";

	this->sCockpitScene = L"";

	this->iLaserMask = 0;

	this->iGunCount = 0;

	this->iLaserEnergy = 0;

	this->fLaserRecharge = 0.00f;

	this->iShieldType = 0;

	this->iMaxShields = 0;

	this->iMissileMask = 0;

	this->iMissileCount = 0;

	this->iSpeedExtension = 0;

	this->iSteeringExtension = 0;

	this->iCargoMin = 0;

	this->iCargoMax = 0;

	this->iWareListID = 0;

	this->iDocking = 0;

	this->iCargoClass = 0;

	this->iRace = 1;

	this->iHull = 0;

	this->iExplosionDef = 35;

	this->iExplosionBody = 36;

	this->iParticle = 1;

	this->iVariation = 0;

	this->iRotationAccel = 0;

	this->iClass = 0;

	this->iTurretCount = 0;

	this->iGunsCount = 0;

	this->iVolumn = 1;

	this->iRelVal = 0;

	this->iPriceMod1 = 25;

	this->iPriceMod2 = 1;

	this->iSize = 0;

	this->iRelValPlayer = 0;

	this->iMinNoto = 0;

	this->iVideoID = 0;

	this->iSkin = 0;

	this->sID = L"SC_NEW_SHIP";

	// make sure the lists are clear

	this->ClearLists();

}

void CShipData::ClearLists() 

{

	this->lTurrets.MemoryClear();

	for ( SGunGroup *g = this->lGuns.First(); g; g = this->lGuns.Next() )

		g->lWeapons.MemoryClear();

	this->lGuns.MemoryClear();

}

bool CShipData::readShipData(const Utils::WString &a_data)

{

	std::vector<Utils::WString> entries;

	a_data.tokenise(L";", entries);

	if (entries.size() >= 60)

	{

		this->sModel = entries[0];

		this->iPictureID = entries[1].toInt();

		this->fRotX = entries[2].toFloat();

		this->fRotY = entries[3].toFloat();

		this->fRotZ = entries[4].toFloat();

		if ( entries[5].isNumber() )

			this->iSubType = entries[5].toInt();

		else

			this->iSubType = CShipData::ConvertShipSubType(entries[5]);

		this->iDesc = entries[6].toInt();

		this->iSpeed = entries[7].toInt();

		this->iAccel = entries[8].toInt();

		this->iEngineSound = entries[9].toInt();

		this->iReactionDelay = entries[10].toInt();

		this->iEngineEffect = entries[11].toInt();

		this->iEngineGlow = entries[12].toInt();

		this->iPower = entries[13].toInt();

		this->iSoundMin = entries[14].toInt();

		this->iSoundMax = entries[15].toInt();

		this->sModelScene = entries[16];

		this->sCockpitScene = entries[17];

		this->iLaserMask = entries[18].toInt();

		this->iGunCount = entries[19].toInt();

		this->iLaserEnergy = entries[20].toInt();

		this->fLaserRecharge = entries[21].toFloat();

		this->iShieldType = entries[22].toInt();

		this->iMaxShields = entries[23].toInt();

		this->iMissileMask = entries[24].toInt();

		this->iMissileCount = entries[25].toInt();

		this->iSpeedExtension = entries[26].toInt();

		this->iSteeringExtension = entries[27].toInt();

		this->iCargoMin = entries[28].toInt();

		this->iCargoMax = entries[29].toInt();

		this->iWareListID = entries[30].toInt();

		for ( int i = 0; i < 6; i++ )

		{

			this->cockpits[i].iPos = entries[(i * 2) + 32].toInt();

			if ( entries[(i * 2) + 31].isNumber() )

				this->cockpits[i].iCockpit = entries[(i * 2) + 31].toInt();

			else

			{

				this->cockpits[i].sCockpit = entries[(i * 2) + 31];

				this->cockpits[i].iCockpit = -1; // custom cockpit

				if ( this->cockpits[i].sCockpit.contains(L"(") ) {

					this->cockpits[i].iCockpit = this->cockpits[i].sCockpit.tokens(L"(", 2).token(L")", 1).toInt();

					this->cockpits[i].sCockpit = this->cockpits[i].sCockpit.token(L"(", 1);

				}

			}

		}

		this->iDocking = entries[43].toInt();

		this->iCargoClass = entries[44].toInt();

		this->iRace = entries[45].toInt();

		this->iHull = entries[46].toInt();

		this->iExplosionDef = entries[47].toInt();

		this->iExplosionBody = entries[48].toInt();

		this->iParticle = entries[49].toInt();

		this->iVariation = entries[50].toInt();

		this->iRotationAccel = entries[51].toInt();

		if ( entries[52].isNumber() )

			this->iClass = entries[52].toInt();

		else

			this->iClass = CShipData::ConvertShipClass(entries[52]);

		this->iTurretCount = entries[53].toInt();

		// now read in the turret data

		int pos = 54;

		for ( int i = 0; i < this->iTurretCount; i++ )

		{

			STurretEntry *t = new STurretEntry;

			t->iIndex = entries[pos].toInt();

			t->iTurret = entries[pos + 1].toInt();

			t->sModel = entries[pos + 2];

			t->iSceneNode = entries[pos + 3].toInt();

			this->lTurrets.push_back(t);

			pos += 4;

		}

		if ( this->iTurretCount == 0 )

		{

			this->iTurretCount = 1;

			STurretEntry *t = this->lTurrets.push_back(new STurretEntry);

			t->iIndex = 0;

			t->iTurret = 1;

			t->iSceneNode = 0;

			t->sModel = L"0";

		}

		// next pos should be gun count

		this->iGunsCount = entries[pos].toInt();

		++pos;

		for ( int i = 0; i < this->iGunsCount; i++ )

		{

			SGunGroup *gun = new SGunGroup;

			gun->iGunIndex = entries[pos].toInt();

			gun->iLaserCount = entries[pos + 1].toInt();

			gun->iIndex = entries[pos + 2].toInt();

			gun->iWeaponCount = entries[pos + 3].toInt();

			pos += 4;

			for ( int j = 0; j < gun->iWeaponCount; j++ )

			{

				SWeaponGroup *weapon = new SWeaponGroup;

				weapon->iGunIndex = entries[pos].toInt();

				weapon->iLaser = entries[pos + 1].toInt();

				weapon->sModel1 = entries[pos + 2];

				weapon->iNode1 = entries[pos + 3].toInt();

				weapon->sModel2 = entries[pos + 4];

				weapon->iNode2 = entries[pos + 5].toInt();

				pos += 6;

				gun->lWeapons.push_back(weapon);

			}

			this->lGuns.push_back(gun);

		}

		if ( !this->iGunsCount )

		{

			this->iGunCount = 1;

			SGunGroup *gun = this->lGuns.push_back(new SGunGroup);

			gun->iGunIndex = 0;

			gun->iIndex = 0;

			gun->iLaserCount = 0;

			gun->iWeaponCount = 0;

		}

		this->iVolumn = entries[pos].toInt();

		this->iRelVal = entries[pos + 1].toInt();

		this->iPriceMod1 = entries[pos + 2].toInt();

		this->iPriceMod2 = entries[pos + 3].toInt();

		this->iSize = entries[pos + 4].toInt();

		this->iRelValPlayer = entries[pos + 5].toInt();

		this->iMinNoto = entries[pos + 6].toInt();

		this->iVideoID = entries[pos + 7].toInt();

		this->iSkin = entries[pos + 8].toInt();

		this->sID = entries[pos + 9];

		this->UpdateGunEntries();

		this->_capValues();

		return true;

	}

	return false;

}

void CShipData::_capValues()

{

	if ( this->iRelVal > 25000000 ) this->iRelVal = 25000000;

	if ( this->iRelValPlayer > 25000000 ) this->iRelValPlayer = 25000000;

}

int CShipData::GetShipClassFromNum(int shipclass)

{

	int classes[OBJ_SHIP_MAX];

	classes[0] = OBJ_SHIP_TL;

	classes[1] = OBJ_SHIP_TS;

	classes[2] = OBJ_SHIP_TP;

	classes[3] = OBJ_SHIP_TM;

	classes[4] = OBJ_SHIP_TL_PIRATE;

	classes[5] = OBJ_SHIP_TS_PIRATE;

	classes[6] = OBJ_SHIP_GONER;

	classes[7] = OBJ_SHIP_M0;

	classes[8] = OBJ_SHIP_M1;

	classes[9] = OBJ_SHIP_M2;

	classes[10] = OBJ_SHIP_M3;

	classes[11] = OBJ_SHIP_M4;

	classes[12] = OBJ_SHIP_M5;

	classes[13] = OBJ_SHIP_M6;

	classes[14] = OBJ_SHIP_M7;

	classes[15] = OBJ_SHIP_M8;

	return classes[shipclass];

}

int CShipData::ConvertShipClassToNum(int shipclass)

{

	int classes[OBJ_SHIP_MAX];

	classes[0] = OBJ_SHIP_TL;

	classes[1] = OBJ_SHIP_TS;

	classes[2] = OBJ_SHIP_TP;

	classes[3] = OBJ_SHIP_TM;

	classes[4] = OBJ_SHIP_TL_PIRATE;

	classes[5] = OBJ_SHIP_TS_PIRATE;

	classes[6] = OBJ_SHIP_GONER;

	classes[7] = OBJ_SHIP_M0;

	classes[8] = OBJ_SHIP_M1;

	classes[9] = OBJ_SHIP_M2;

	classes[10] = OBJ_SHIP_M3;

	classes[11] = OBJ_SHIP_M4;

	classes[12] = OBJ_SHIP_M5;

	classes[13] = OBJ_SHIP_M6;

	classes[14] = OBJ_SHIP_M7;

	classes[15] = OBJ_SHIP_M8;

	for ( int i = 0; i < OBJ_SHIP_MAX; i++ )

	{

		if ( classes[i] == shipclass )

			return i;

	}

	return 0;

}

int CShipData::ConvertShipClass(const Utils::WString &shipclass)

{

	for ( int i = 0; i < OBJ_SHIP_MAX; i++ )

	{

		int c = CShipData::GetShipClassFromNum(i);

		if ( CShipData::ConvertShipClass(c).Compare(shipclass) )

			return c;

	}

	return OBJ_SHIP_TL;

}

Utils::WString CShipData::ConvertShipClass(int shipclass)

{

	switch ( shipclass )

	{

		case OBJ_SHIP_TL:

			return L"OBJ_SHIP_TL";

		case OBJ_SHIP_TS:

			return L"OBJ_SHIP_TS";

		case OBJ_SHIP_TP:

			return L"OBJ_SHIP_TP";

		case OBJ_SHIP_TM:

			return L"OBJ_SHIP_TS";

		case OBJ_SHIP_TL_PIRATE:

			return L"OBJ_SHIP_TL_PIRATE";

		case OBJ_SHIP_TS_PIRATE:

			return L"OBJ_SHIP_TS_PIRATE";

		case OBJ_SHIP_GONER:

			return L"OBJ_SHIP_GONER";

		case OBJ_SHIP_M0:

			return L"OBJ_SHIP_M0";

		case OBJ_SHIP_M1:

			return L"OBJ_SHIP_M1";

		case OBJ_SHIP_M2:

			return L"OBJ_SHIP_M2";

		case OBJ_SHIP_M3:

			return L"OBJ_SHIP_M3";

		case OBJ_SHIP_M4:

			return L"OBJ_SHIP_M4";

		case OBJ_SHIP_M5:

			return L"OBJ_SHIP_M5";

		case OBJ_SHIP_M6:

			return L"OBJ_SHIP_M6";

		case OBJ_SHIP_M7:

			return L"OBJ_SHIP_M7";

		case OBJ_SHIP_M8:

			return L"OBJ_SHIP_M8";

	}

	return L"OBJ_SHIP_TL";

}

Utils::WString CShipData::ConvertShipSubType(int subtype)

{

	switch ( subtype )

	{

		case SG_SH_TL:

			return L"SG_SH_TL";

		case SG_SH_TS:

			return L"SG_SH_TS";

		case SG_SH_M0:

			return L"SG_SH_M0";

		case SG_SH_M1:

			return L"SG_SH_M1";

		case SG_SH_M2:

			return L"SG_SH_M2";

		case SG_SH_M3:

			return L"SG_SH_M3";

		case SG_SH_M4:

			return L"SG_SH_M4";

		case SG_SH_M5:

			return L"SG_SH_M5";

		case SG_SH_TL_P:

			return L"SG_SH_TL_P";

		case SG_SH_TS_P:

			return L"SG_SH_TS_P";

		case SG_SH_GO:

			return L"SG_SH_GO";

		case SG_SH_M6:

			return L"SG_SH_M6";

		case SG_SH_TP:

			return L"SG_SH_TP";

		case SG_SH_M7:

			return L"SG_SH_M7";

		case SG_SH_TM:

			return L"SG_SH_TM";

		case SG_SH_M8:

			return L"SG_SH_M8";

	}

	return L"SG_SH_TL";

}

int CShipData::ConvertShipSubType(const Utils::WString &subtype)

{

	int num = 0;

	for ( int i = 0; i < SG_SH_MAX; i++ )

	{

		if ( subtype.Compare(CShipData::ConvertShipSubType(i)) )

			return i;

	}

	return 0;

}

void CShipData::RemoveTurret(int t)

{

	if ( t >= 1 && t <= 6 )

	{

		if ( t >= this->lTurrets.size() )

			return;

		// remove the turret entry

		this->lTurrets.erase(t, true);

		int index = 0;

		for ( CListNode<STurretEntry> *node = this->lTurrets.Front(); node; node = node->next() )

		{

			node->Data()->iTurret = index;

			++index;

			node->Data()->iIndex = index;

		}

		--this->iTurretCount;

		// shuffle the other entries

		for ( int i = (t - 1); i < 5; i++ )

		{

			this->cockpits[i].iCockpit = this->cockpits[i + 1].iCockpit;

			this->cockpits[i].iPos  = this->cockpits[i + 1].iPos;

			this->cockpits[i].sCockpit = this->cockpits[i + 1].sCockpit;

		}

		// zero out the remaining

		this->cockpits[5].iCockpit = 0;

		this->cockpits[5].iPos = 0;

		this->cockpits[5].sCockpit = L"";

		// now remove the gun entries connected to the turret

		SGunGroup *g = this->lGuns.Get(t);

		if ( g )

		{

			g->lWeapons.MemoryClear();

			this->lGuns.remove(g, true);

			--this->iGunsCount;

		}

		// now we need to readjust the gun entrys

		this->UpdateGunEntries();

	}

}

void CShipData::UpdateGunEntries()

{

	int index = 1;

	int count = 1;

	int gunindex = 1;

	this->iGunCount = 0;

	for ( CListNode<SGunGroup> *node = this->lGuns.Front(); node; node = node->next() )

	{

		SGunGroup *g = node->Data();

		g->iLaserCount = 0;

		for ( CListNode<SWeaponGroup> *wNode = g->lWeapons.Front(); wNode; wNode = wNode->next() )

		{

			SWeaponGroup *w = wNode->Data();

			if ( (w->iNode1 > 0 || (w->iNode1 == 0 && w->sModel1 != L"0")) && !w->sModel1.empty() )

			{

				w->iLaser = 1;

				if ( (w->iNode2 > 0 || (w->iNode2 == 0 && w->sModel2 != L"0")) && !w->sModel2.empty() )

					w->iLaser = 2;

			}

			else

			{

				w->iLaser = 0;

				w->iNode2 = -1;

				w->sModel2 = L"";

			}

			w->iGunIndex = gunindex;

			gunindex += w->iLaser;

			g->iLaserCount += w->iLaser;

		}

		g->iWeaponCount = g->lWeapons.size();

		g->iGunIndex = index;

		index += g->iLaserCount;

		this->iGunCount += g->iLaserCount;

		g->iIndex = count;

		++count;

	}

	this->iTurretCount = this->lTurrets.size();

	this->iGunsCount = this->lGuns.size();

}

void CShipData::ClearTurrets()

{

	for ( int i = 0; i < 6; i++ )

	{

		this->cockpits[i].iCockpit = 0;

		this->cockpits[i].iPos = 0;

		this->cockpits[i].sCockpit = L"";

	}

	while ( this->lTurrets.size() > 1 )

		this->lTurrets.erase(1, true);

	while ( this->lGuns.size() > 1 )

		this->lGuns.erase(1, true);

	this->iTurretCount = 1;

	this->iGunsCount = 1;

}

void CShipData::AddNewTurret(int dir)

{

	if ( this->iTurretCount >= 7 )

		return;

	STurretEntry *t = new STurretEntry;

	SGunGroup *g = new SGunGroup;

	t->iSceneNode = 0;

	t->iIndex = this->iTurretCount + 1;

	t->iTurret = this->iTurretCount;

	this->cockpits[(this->iTurretCount - 1)].iCockpit = 0;

	this->cockpits[(this->iTurretCount - 1)].iPos = dir;

	g->iWeaponCount = 1;

	g->iLaserCount = 0;

	SWeaponGroup *w = new SWeaponGroup;

	w->iLaser = 0;

	w->iNode1 = 0;

	w->iNode2 = -1;

	w->sModel1 = L"0";

	g->lWeapons.push_back(w);

	this->lTurrets.push_back(t);

	this->lGuns.push_back(g);

	++this->iTurretCount;

	++this->iGunsCount;

	this->UpdateGunEntries();

}

Utils::WString CShipData::ConvertMissileGroup(int type)

{

	switch ( type )

	{

		case SG_MISSILE_LIGHT:

			return L"SG_MISSILE_LIGHT";

		case SG_MISSILE_MEDIUM:

			return L"SG_MISSILE_MEDIUM";

		case SG_MISSILE_HEAVY:

			return L"SG_MISSILE_HEAVY";

		case SG_MISSILE_TR_LIGHT:

			return L"SG_MISSILE_TR_LIGHT";

		case SG_MISSILE_TR_MEDIUM:

			return L"SG_MISSILE_TR_MEDIUM";

		case SG_MISSILE_TR_HEAVY:

			return L"SG_MISSILE_TR_HEAVY";

		case SG_MISSILE_KHAAK:

			return L"SG_MISSILE_KHAAK";

		case SG_MISSILE_BOMBER:

			return L"SG_MISSILE_BOMBOER";

		case SG_MISSILE_TORP_CAPTIAL:

			return L"SG_MISSILE_TORP_CAPTIAL";

		case SG_MISSILE_AF_CAPTIAL:

			return L"SG_MISSILE_AF_CAPTIAL";

		case SG_MISSILE_TR_BOMBER:

			return L"SG_MISSILE_TR_BOMBER";

		case SG_MISSILE_TR_TORP_CAPTIAL:

			return L"SG_MISSILE_TR_TORP_CAPTIAL";

		case SG_MISSILE_TR_AF_CAPTIAL:

			return L"SG_MISSILE_TR_AF_CAPTIAL";

		case SG_MISSILE_BOARDINGPOD:

			return L"SG_MISSILE_BOARDINGPOD";

		case SG_MISSILE_DMBF:

			return L"SG_MISSILE_DMBF";

	}

	return L"";

}

int CShipData::ConvertMissileGroupToID(int type)

{

	int arr[] = {SG_MISSILE_LIGHT, SG_MISSILE_MEDIUM, SG_MISSILE_HEAVY, SG_MISSILE_TR_LIGHT, SG_MISSILE_TR_MEDIUM, SG_MISSILE_TR_HEAVY, SG_MISSILE_KHAAK, SG_MISSILE_BOMBER, SG_MISSILE_TORP_CAPTIAL, 

		SG_MISSILE_AF_CAPTIAL, SG_MISSILE_TR_BOMBER, SG_MISSILE_TR_TORP_CAPTIAL, SG_MISSILE_AF_CAPTIAL, SG_MISSILE_BOARDINGPOD, SG_MISSILE_DMBF};

	for ( int i = 0; i < SG_MISSILE_MAX; i++ )

	{

		if ( arr[i] == type )

			return i;

	}

	return 0; 

}

int CShipData::ConvertMissileGroupToID(const Utils::WString &type)

{

	return CShipData::ConvertMissileGroupToID(CShipData::ConvertMissileGroup(type));

}

int CShipData::ConvertMissileGroup(const Utils::WString &type)

{

	if ( type.Compare(L"SG_MISSILE_LIGHT") )

		return SG_MISSILE_LIGHT;

	if ( type.Compare(L"SG_MISSILE_MEDIUM") )

		return SG_MISSILE_MEDIUM;

	if ( type.Compare(L"SG_MISSILE_HEAVY") )

		return SG_MISSILE_HEAVY;

	if ( type.Compare(L"SG_MISSILE_TR_LIGHT") )

		return SG_MISSILE_TR_LIGHT;

	if ( type.Compare(L"SG_MISSILE_TR_MEDIUM") )

		return SG_MISSILE_TR_MEDIUM;

	if ( type.Compare(L"SG_MISSILE_TR_HEAVY") )

		return SG_MISSILE_TR_HEAVY;

	if ( type.Compare(L"SG_MISSILE_KHAAK") )

		return SG_MISSILE_KHAAK;

	if ( type.Compare(L"SG_MISSILE_BOMBER") )

		return SG_MISSILE_BOMBER;

	if ( type.Compare(L"SG_MISSILE_TORP_CAPTIAL") )

		return SG_MISSILE_TORP_CAPTIAL;

	if ( type.Compare(L"SG_MISSILE_AF_CAPTIAL") )

		return SG_MISSILE_AF_CAPTIAL;

	if ( type.Compare(L"SG_MISSILE_TR_BOMBER") )

		return SG_MISSILE_TR_BOMBER;

	if ( type.Compare(L"SG_MISSILE_TR_TORP_CAPTIAL") )

		return SG_MISSILE_TR_TORP_CAPTIAL;

	if ( type.Compare(L"SG_MISSILE_TR_AF_CAPTIAL") )

		return SG_MISSILE_TR_AF_CAPTIAL;

	if ( type.Compare(L"SG_MISSILE_BOARDINGPOD") )

		return SG_MISSILE_BOARDINGPOD;

	if ( type.Compare(L"SG_MISSILE_DMBF") )

		return SG_MISSILE_DMBF;

	return 0;

}