Subversion Repositories spk

#include "ShipData.h"

#include "spkdef.h"

CShipData::CShipData(void)

{

	this->CreateDefault();

}

CShipData::~CShipData(void)

{

	this->ClearLists();

}

CyString CShipData::CreateData()

{

	CyString data = this->sModel;

	data.AddToken(";", CyString::Number(this->iPictureID));

	data.AddToken(";", CyString::CreateFromFloat(this->fRotX, -1));

	data.AddToken(";", CyString::CreateFromFloat(this->fRotY, -1));

	data.AddToken(";", CyString::CreateFromFloat(this->fRotZ, -1));

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

	data.AddToken(";", CyString::Number(this->iDesc));

	data.AddToken(";", CyString::Number(this->iSpeed));

	data.AddToken(";", CyString::Number(this->iAccel));

	data.AddToken(";", CyString::Number(this->iEngineSound));

	data.AddToken(";", CyString::Number(this->iReactionDelay));

	data.AddToken(";", CyString::Number(this->iEngineEffect));

	data.AddToken(";", CyString::Number(this->iEngineGlow));

	data.AddToken(";", CyString::Number(this->iPower));

	data.AddToken(";", CyString::Number(this->iSoundMin));

	data.AddToken(";", CyString::Number(this->iSoundMax));

	data.AddToken(";", this->sModelScene);

	data.AddToken(";", this->sCockpitScene);

	data.AddToken(";", CyString::Number(this->iLaserMask));

	data.AddToken(";", CyString::Number(this->iGunCount));

	data.AddToken(";", CyString::Number(this->iLaserEnergy));

	data.AddToken(";", CyString::CreateFromFloat(this->fLaserRecharge, -1));

	data.AddToken(";", CyString::Number(this->iShieldType));

	data.AddToken(";", CyString::Number(this->iMaxShields));

	data.AddToken(";", CyString::Number(this->iMissileMask));

	data.AddToken(";", CyString::Number(this->iMissileCount));

	data.AddToken(";", CyString::Number(this->iSpeedExtension));

	data.AddToken(";", CyString::Number(this->iSteeringExtension));

	data.AddToken(";", CyString::Number(this->iCargoMin));

	data.AddToken(";", CyString::Number(this->iCargoMax));

	data.AddToken(";", CyString::Number(this->iWareListID));

	// 6 turrets next

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

	{

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

			data.AddToken(";", CyString::Number(this->cockpits[i].iCockpit));

		else

		{

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

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

			else

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

		}

		data.AddToken(";", CyString::Number(this->cockpits[i].iPos));

	}

	data.AddToken(";", CyString::Number(this->iDocking));

	data.AddToken(";", CyString::Number(this->iCargoClass));

	data.AddToken(";", CyString::Number(this->iRace));

	data.AddToken(";", CyString::Number(this->iHull));

	data.AddToken(";", CyString::Number(this->iExplosionDef));

	data.AddToken(";", CyString::Number(this->iExplosionBody));

	data.AddToken(";", CyString::Number(this->iParticle));

	data.AddToken(";", CyString::Number(this->iVariation));

	data.AddToken(";", CyString::Number(this->iRotationAccel));

	data.AddToken(";", CyString::Number(this->iClass));

	data.AddToken(";", CyString::Number(this->iTurretCount));

	// now do the turrets

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

	{

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

		data.AddToken(";", CyString::Number(t->iIndex));

		data.AddToken(";", CyString::Number(t->iTurret));

		data.AddToken(";", t->sModel);

		data.AddToken(";", CyString::Number(t->iSceneNode));

	}

	// the gun entries next

	data.AddToken(";", CyString::Number(this->iGunsCount));

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

	{

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

		data.AddToken(";", CyString::Number(g->iGunIndex));

		data.AddToken(";", CyString::Number(g->iLaserCount));

		data.AddToken(";", CyString::Number(g->iIndex));

		data.AddToken(";", CyString::Number(g->iWeaponCount));

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

		{

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

			data.AddToken(";", CyString::Number(w->iGunIndex));

			data.AddToken(";", CyString::Number(w->iLaser));

			data.AddToken(";", w->sModel1);

			data.AddToken(";", CyString::Number(w->iNode1));

			data.AddToken(";", w->sModel2);

			data.AddToken(";", CyString::Number(w->iNode2));

		}

	}

	// now the rest of the data

	data.AddToken(";", CyString::Number(this->iVolumn));

	data.AddToken(";", CyString::Number(this->iRelVal));

	data.AddToken(";", CyString::Number(this->iPriceMod1));

	data.AddToken(";", CyString::Number(this->iPriceMod2));

	data.AddToken(";", CyString::Number(this->iSize));

	data.AddToken(";", CyString::Number(this->iRelValPlayer));

	data.AddToken(";", CyString::Number(this->iMinNoto));

	data.AddToken(";", CyString::Number(this->iVideoID));

	data.AddToken(";", CyString::Number(this->iSkin));

	data.AddToken(";", this->sID);

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

	return data;

}

void CShipData::CreateDefault()

{

	this->sModel = "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 = "";

	this->sCockpitScene = "";

	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 = "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(CyString a_data)

{

	int max;

	CyString *entries = a_data.SplitToken(";", &max);

	if ( max >= 60 && entries )

	{

		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

			}

		}

		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 = "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();

		CLEANSPLIT(entries, max);

		return true;

	}

	CLEANSPLIT(entries, max);

	return false;

}

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(CyString 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;

}

CyString CShipData::ConvertShipClass(int shipclass)

{

	switch ( shipclass )

	{

		case OBJ_SHIP_TL:

			return "OBJ_SHIP_TL";

		case OBJ_SHIP_TS:

			return "OBJ_SHIP_TS";

		case OBJ_SHIP_TP:

			return "OBJ_SHIP_TP";

		case OBJ_SHIP_TM:

			return "OBJ_SHIP_TS";

		case OBJ_SHIP_TL_PIRATE:

			return "OBJ_SHIP_TL_PIRATE";

		case OBJ_SHIP_TS_PIRATE:

			return "OBJ_SHIP_TS_PIRATE";

		case OBJ_SHIP_GONER:

			return "OBJ_SHIP_GONER";

		case OBJ_SHIP_M0:

			return "OBJ_SHIP_M0";

		case OBJ_SHIP_M1:

			return "OBJ_SHIP_M1";

		case OBJ_SHIP_M2:

			return "OBJ_SHIP_M2";

		case OBJ_SHIP_M3:

			return "OBJ_SHIP_M3";

		case OBJ_SHIP_M4:

			return "OBJ_SHIP_M4";

		case OBJ_SHIP_M5:

			return "OBJ_SHIP_M5";

		case OBJ_SHIP_M6:

			return "OBJ_SHIP_M6";

		case OBJ_SHIP_M7:

			return "OBJ_SHIP_M7";

		case OBJ_SHIP_M8:

			return "OBJ_SHIP_M8";

	}

	return "OBJ_SHIP_TL";

}

CyString CShipData::ConvertShipSubType(int subtype)

{

	switch ( subtype )

	{

		case SG_SH_TL:

			return "SG_SH_TL";

		case SG_SH_TS:

			return "SG_SH_TS";

		case SG_SH_M0:

			return "SG_SH_M0";

		case SG_SH_M1:

			return "SG_SH_M1";

		case SG_SH_M2:

			return "SG_SH_M2";

		case SG_SH_M3:

			return "SG_SH_M3";

		case SG_SH_M4:

			return "SG_SH_M4";

		case SG_SH_M5:

			return "SG_SH_M5";

		case SG_SH_TL_P:

			return "SG_SH_TL_P";

		case SG_SH_TS_P:

			return "SG_SH_TS_P";

		case SG_SH_GO:

			return "SG_SH_GO";

		case SG_SH_M6:

			return "SG_SH_M6";

		case SG_SH_TP:

			return "SG_SH_TP";

		case SG_SH_M7:

			return "SG_SH_M7";

		case SG_SH_TM:

			return "SG_SH_TM";

		case SG_SH_M8:

			return "SG_SH_M8";

	}

	return "SG_SH_TL";

}

int CShipData::ConvertShipSubType(CyString 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 = "";

		// 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 != "0")) && !w->sModel1.Empty() )

			{

				w->iLaser = 1;

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

					w->iLaser = 2;

			}

			else

			{

				w->iLaser = 0;

				w->iNode2 = -1;

				w->sModel2 = "";

			}

			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 = "";

	}

	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 = "0";

	g->lWeapons.push_back(w);

	this->lTurrets.push_back(t);

	this->lGuns.push_back(g);

	++this->iTurretCount;

	++this->iGunsCount;

	this->UpdateGunEntries();

}

CyString CShipData::ConvertMissileGroup(int type)

{

	switch ( type )

	{

		case SG_MISSILE_LIGHT:

			return "SG_MISSILE_LIGHT";

		case SG_MISSILE_MEDIUM:

			return "SG_MISSILE_MEDIUM";

		case SG_MISSILE_HEAVY:

			return "SG_MISSILE_HEAVY";

		case SG_MISSILE_TR_LIGHT:

			return "SG_MISSILE_TR_LIGHT";

		case SG_MISSILE_TR_MEDIUM:

			return "SG_MISSILE_TR_MEDIUM";

		case SG_MISSILE_TR_HEAVY:

			return "SG_MISSILE_TR_HEAVY";

		case SG_MISSILE_KHAAK:

			return "SG_MISSILE_KHAAK";

		case SG_MISSILE_BOMBER:

			return "SG_MISSILE_BOMBOER";

		case SG_MISSILE_TORP_CAPTIAL:

			return "SG_MISSILE_TORP_CAPTIAL";

		case SG_MISSILE_AF_CAPTIAL:

			return "SG_MISSILE_AF_CAPTIAL";

		case SG_MISSILE_TR_BOMBER:

			return "SG_MISSILE_TR_BOMBER";

		case SG_MISSILE_TR_TORP_CAPTIAL:

			return "SG_MISSILE_TR_TORP_CAPTIAL";

		case SG_MISSILE_TR_AF_CAPTIAL:

			return "SG_MISSILE_TR_AF_CAPTIAL";

		case SG_MISSILE_BOARDINGPOD:

			return "SG_MISSILE_BOARDINGPOD";

		case SG_MISSILE_DMBF:

			return "SG_MISSILE_DMBF";

	}

	return "";

}

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(CyString type)

{

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

}

int CShipData::ConvertMissileGroup(CyString type)

{

	if ( type.Compare("SG_MISSILE_LIGHT") )

		return SG_MISSILE_LIGHT;

	if ( type.Compare("SG_MISSILE_MEDIUM") )

		return SG_MISSILE_MEDIUM;

	if ( type.Compare("SG_MISSILE_HEAVY") )

		return SG_MISSILE_HEAVY;

	if ( type.Compare("SG_MISSILE_TR_LIGHT") )

		return SG_MISSILE_TR_LIGHT;

	if ( type.Compare("SG_MISSILE_TR_MEDIUM") )

		return SG_MISSILE_TR_MEDIUM;

	if ( type.Compare("SG_MISSILE_TR_HEAVY") )

		return SG_MISSILE_TR_HEAVY;

	if ( type.Compare("SG_MISSILE_KHAAK") )

		return SG_MISSILE_KHAAK;

	if ( type.Compare("SG_MISSILE_BOMBER") )

		return SG_MISSILE_BOMBER;

	if ( type.Compare("SG_MISSILE_TORP_CAPTIAL") )

		return SG_MISSILE_TORP_CAPTIAL;

	if ( type.Compare("SG_MISSILE_AF_CAPTIAL") )

		return SG_MISSILE_AF_CAPTIAL;

	if ( type.Compare("SG_MISSILE_TR_BOMBER") )

		return SG_MISSILE_TR_BOMBER;

	if ( type.Compare("SG_MISSILE_TR_TORP_CAPTIAL") )

		return SG_MISSILE_TR_TORP_CAPTIAL;

	if ( type.Compare("SG_MISSILE_TR_AF_CAPTIAL") )

		return SG_MISSILE_TR_AF_CAPTIAL;

	if ( type.Compare("SG_MISSILE_BOARDINGPOD") )

		return SG_MISSILE_BOARDINGPOD;

	if ( type.Compare("SG_MISSILE_DMBF") )

		return SG_MISSILE_DMBF;

	return 0;

}