예제 #1
0
void LogisticsSaveDialog::updateCampaignMissionInfo()
{

	FitIniFile file;
	FullPathFileName path;
	path.init( campaignPath, selectedName, ".fit" );
	if ( NO_ERR != file.open( path ) )
	{
		Assert( 0, 0, "coudln't find the campaign file\n" );
	}

	char fileName[256];

	if ( NO_ERR == file.seekBlock( "Group0Mission0" ) )
	{
		if ( NO_ERR != file.readIdString( "FileName", fileName, 1023 ) )
		{				
			setMission( "" );
		}		
		else
		{
			setMission( fileName );
		}
	}	
	else
		setMission( "" );

}
예제 #2
0
void LogisticsSaveDialog::readCampaignNameFromFile( char* fileName, char* resultName, long len )
{
	FullPathFileName path;
	path.init( campaignPath, fileName, ".fit" );

	FitIniFile file;

	if ( NO_ERR != file.open( (char*)(const char*)path ) )
	{
		char errorStr[256];
		sprintf( errorStr, "couldn't open file %s", path );
		Assert( 0, 0, errorStr );
	}

	
	long result = file.seekBlock( "Campaign" );
	Assert( result == NO_ERR, 0, "Coudln't find the mission settings block in the mission file" );

	resultName[0] = 0;
	long lName = 0;

	result = file.readIdLong( "NameID", lName );
	if ( result == NO_ERR )
	{
		cLoadString( lName, resultName, len );
	}
	else
	{
		result = file.readIdString( "CampaignName", resultName, len );
		Assert( result == NO_ERR, 0, "couldn't find the missionName" );
	}
}
void LogisticsVehicle::init(FitIniFile& file)
{
	componentCount = 0;
	file.seekBlock("ObjectType");
	char tmp[256];
	file.readIdString("AppearanceName", tmp, 255);
	fileName = tmp;
	file.seekBlock("General");
	file.readIdLong("DescIndex", chassisNameID);
	file.readIdFloat("CurTonnage", maxWeight);
	char tmpWeightClass[256];
	cLoadString(IDS_VEHICLE_CLASS, tmpWeightClass, 256);
	mechClass = tmpWeightClass;
	if(NO_ERROR != file.readIdLong("HouseID", houseID))
	{
		houseID = -1;
	}
	if(NO_ERROR != file.readIdLong("EncyclopediaID", encyclopediaID))
	{
		encyclopediaID = IDS_VEHICLE_DESCRIPTION_0;
	}
	file.seekBlock("VehicleDynamics");
	file.readIdFloat("MaxVelocity", speed);
	PSTR parts[5] = { "Front", "Left", "Right", "Rear", "Turret" };
	baseArmor = 0;
	uint8_t pts;
	int32_t i;
	for(i = 0; i < 5; i++)
	{
		file.seekBlock(parts[i]);
		file.readIdUChar("MaxArmorPoints", pts);
		baseArmor += pts;
		file.readIdUChar("CurInternalStructure", pts);
		baseArmor += pts;
	}
	file.seekBlock("InventoryInfo");
	file.readIdUChar("NumWeapons", pts);
	char blockName[256];
	for(i = 4; i < 4 + pts; i++)
	{
		sprintf(blockName, "Item:%ld", i);
		if(NO_ERROR == file.seekBlock(blockName))
		{
			uint8_t fitID;
			file.readIdUChar("MasterID", fitID);
			LogisticsComponent* pComponent = LogisticsData::instance->getComponent(fitID);
			if(pComponent)
			{
				components[componentCount].component = pComponent;
				components[componentCount].xCoord = 0;
				components[componentCount].yCoord = 0;
				componentCount++;
			}
		}
	}
}
예제 #4
0
static long sReadIdString(FitIniFile &missionFile, const char *varName, CString &CStr) {
	long result = 0;
	char buffer[2001/*buffer size*/]; buffer[0] = '\0';
	result = missionFile.readIdString((char *)varName, buffer, 2001/*buffer size*/ - 1);
	if (NO_ERR != result) {
		//assert(false);
	} else {
		CStr = buffer;
	}
	return result;
}
예제 #5
0
void LogisticsSaveDialog::setMission( const char* fileName)
{
	if ( strlen( fileName ) )
	{

		long textureHandle = MissionBriefingScreen::getMissionTGA( fileName );

		statics[MAP_STATIC].setTexture( textureHandle );
		statics[MAP_STATIC].setUVs( 0, 127, 127, 0);
		statics[MAP_STATIC].setColor( 0xffffffff );

		FullPathFileName path;
		FitIniFile file;

		path.init( missionPath, fileName, ".fit" );

		if ( NO_ERR == file.open( path ) )
		{
			char missionName[256];
			missionName[0] = 0;
			bool bRes = 0;

			file.seekBlock( "MissionSettings" );
			file.readIdBoolean( "MissionNameUseResourceString", bRes );
			if ( bRes )
			{
				unsigned long lRes;
				file.readIdULong( "MissionNameResourceStringID", lRes );
				cLoadString(lRes, missionName, 255);
			}
			else
			{
				file.readIdString("MissionName", missionName, 255);
			}

			textObjects[2].setText(missionName);

		}
		else
		{
			textObjects[2].setText( "" );
		}

	}
	else
	{
		statics[MAP_STATIC].setColor( 0 );
		textObjects[2].setText( "" );

	}

}
void ComponentListItem::assignAnimation(FitIniFile& file, int32_t whichChild, char animNames[COMP_ANIMATION_COUNT][32],
										aObject* object)
{
	s_templateItem->pChildAnims[whichChild] = 0;
	char tmpAnimName[32];
	file.readIdString("Animation", tmpAnimName, 31);
	for(size_t i = 0; i < COMP_ANIMATION_COUNT; i++)
	{
		if(_stricmp(animNames[i], tmpAnimName) == 0)
		{
			s_templateItem->pChildAnims[whichChild] = &s_templateItem->animations[i];
			break;
		}
	}
	s_templateItem->addChild(object);
}
void LogisticsMechIcon::assignAnimation( FitIniFile& file, long& number )
{
	number = -1;
	char buffer[64];
	if ( NO_ERR == file.readIdString( "Animation", buffer, 63 ) )
	{
		for ( int i = 0; i < strlen( buffer ); i++ )
		{
			if ( isdigit( buffer[i] ) )
			{
				buffer[i+1] = 0;
				number = atoi( &buffer[i] );
			}
		}
	}
}
예제 #8
0
static int32_t sReadIdString(FitIniFile& missionFile, PCSTR varName, CString& CStr)
{
	int32_t result = 0;
	char buffer[2001/*buffer size*/];
	buffer[0] = '\0';
	result = missionFile.readIdString((PSTR)varName, buffer, 2001/*buffer size*/ - 1);
	if(NO_ERROR != result)
	{
		//assert(false);
	}
	else
	{
		CStr = buffer;
	}
	return result;
}
void LogisticsPilotListBoxItem::setAnimation(FitIniFile& file, int32_t whichOne)
{
	char animationText[64];
	if(NO_ERROR == file.readIdString("Animation", animationText, 63))
	{
		for(size_t i = 0; i < strlen(animationText); i++)
		{
			if(isdigit(animationText[i]))
			{
				animationText[i + 1] = nullptr;
				s_templateItem->pChildAnimations[whichOne] = atoi(&animationText[i]);
				return;
			}
		}
	}
	s_templateItem->pChildAnimations[whichOne] = -1;
}
예제 #10
0
void MechListBoxItem::assignAnimation( FitIniFile& file, long& curAnim )
{
	char tmpStr[64];

	s_templateItem->animationIDs[curAnim] = -1;
	if ( NO_ERR == file.readIdString( "Animation", tmpStr, 63 ) )
	{
		for ( int j = 0; j < strlen( tmpStr ); j++ )
		{
			if ( isdigit( tmpStr[j] ) )
			{
				tmpStr[j+1] = 0;
				s_templateItem->animationIDs[curAnim] = atoi( &tmpStr[j] );
			}
		}
	}
	curAnim++;
}
예제 #11
0
void aAnimTextListItem::init( FitIniFile& file, const char* blockName )
{
	file.seekBlock( blockName );

	long x, y, width, height;

	file.readIdLong( "XLocation", x );
	file.readIdLong( "YLocation", y );
	file.readIdLong( "Width", width );
	file.readIdLong( "Height", height );

	aObject::init( x, y, width, height );

	long color;
	file.readIdLong( "Color", color );
	setColor( color );

	// I could read the font here

	char animationSt[256];
	if ( NO_ERR == file.readIdString( "Animation", animationSt, 255 ) )
		animInfo.init( &file, animationSt );
}
예제 #12
0
void MPLoadMap::getMapNameFromFile( const char* pFileName, char* missionName, long bufferLength )
{
	FullPathFileName path;
	path.init( missionPath, pFileName, ".fit" );

	FitIniFile file;

	if ( NO_ERR != file.open( (char*)(const char*)path ) )
	{
		char errorStr[256];
		sprintf( errorStr, "couldn't open file %s", path );
		Assert( 0, 0, errorStr );
	}

	
	long result = file.seekBlock( "MissionSettings" );
	Assert( result == NO_ERR, 0, "Coudln't find the mission settings block in the mission file" );

	missionName[0] = 0;
	bool bRes = 0;

	result = file.readIdBoolean( "MissionNameUseResourceString", bRes );
	//Assert( result == NO_ERR, 0, "couldn't find the MissionNameUseResourceString" );
	if ( bRes )
	{
		unsigned long lRes;
		result = file.readIdULong( "MissionNameResourceStringID", lRes );
		Assert( result == NO_ERR, 0, "couldn't find the MissionNameResourceStringID" );
		cLoadString( lRes, missionName, bufferLength );
	}
	else
	{
		result = file.readIdString( "MissionName", missionName, bufferLength );
		Assert( result == NO_ERR, 0, "couldn't find the missionName" );
	}
}
예제 #13
0
void LogisticsMapInfoDialog::setMap( const char* pFileName )
{
	long textureHandle = MissionBriefingScreen::getMissionTGA( pFileName );
	statics[10].setTexture( textureHandle );
	statics[10].setUVs( 0, 127, 127, 0  );
	statics[10].setColor( 0xffffffff );

	// need to set all the map info too....

		FitIniFile file;
		FullPathFileName path;
		path.init( missionPath, pFileName, ".fit" );

		if ( NO_ERR == file.open( path ) )
		{
		
			char missionName[256];
			char text[1024];
			missionName[0] = 0;
			char text2[1024];
			bool bRes = 0;

			char totalText[1024];

			file.seekBlock( "MissionSettings" );
			file.readIdBoolean( "MissionNameUseResourceString", bRes );
			if ( bRes )
			{
				unsigned long lRes;
				file.readIdULong( "MissionNameResourceStringID", lRes );
				cLoadString(lRes, missionName, 255);
			}
			else
			{
				file.readIdString("MissionName", missionName, 255);
			}
	
			cLoadString( IDS_MP_LM_MAP_LIST_MAP_NAME, text, 255 );
			sprintf(text2, text, missionName);

			sprintf( totalText, text2 );
			strcat( totalText, "\n" );

				unsigned long type = 0;
			file.readIdULong( "MissionType", type );
			cLoadString( IDS_MP_LM_MAP_LIST_TYPE, text, 255 );
			char mType[128];
			cLoadString( IDS_MP_LM_TYPE0 + type, mType, 127 );
			
			sprintf( text2, text, mType );

			strcat( totalText, text2 );
			strcat( totalText, "\n" );

			unsigned long numPlayers = 2;

			file.readIdULong( "MaximumNumberOfPlayers", numPlayers );
			cLoadString( IDS_MP_LM_MAP_LIST_MAX_PLAYERS, text, 255 );
			sprintf( text2, text, numPlayers );

			strcat( totalText, text2 );
			strcat( totalText, "\n" );

			textObjects[1].setText( totalText );

			char blurb[1024];
			long result = file.readIdString("Blurb2", blurb, 1023 );

			bool tmpBool = false;
			result = file.readIdBoolean("Blurb2UseResourceString", tmpBool);
			if (NO_ERR == result && tmpBool )
			{
				unsigned long tmpInt = 0;
				result = file.readIdULong("Blurb2ResourceStringID", tmpInt);
				if (NO_ERR == result)
				{
					cLoadString( tmpInt, blurb, 1024 );
				}
			}

			textObjects[2].setText( blurb );

		}

}
void MissionBriefingScreen::begin()
{
	missionListBox.removeAllItems( true );

	runTime = 0;
	bClicked = 0;

	statics[VIDEO_SCREEN].setColor( 0 );

	memset( objectiveButtons, 0, sizeof ( aObject* ) * MAX_OBJECTIVES );
	// need to set up all pertinent mission info
	EString missionName = LogisticsData::instance->getCurrentMission();


	long tmpMapTextureHandle = getMissionTGA(missionName);
	statics[MAP_INDEX].setTexture( tmpMapTextureHandle );
	statics[MAP_INDEX].setUVs( 0, 127, 127, 0 );
	statics[MAP_INDEX].setColor( 0xffffffff );


	// need to get all the objectives and stuff
	FullPathFileName fitPath;
	fitPath.init(missionPath, missionName, ".fit");
	FitIniFile fitFile;
	fitFile.open( fitPath );

	// put initial divider in list box
	addItem(IDS_MN_DIVIDER, 0xff005392, -1);

	fitFile.seekBlock( "MissionSettings" );

	long result = fitFile.seekBlock( "MissionSettings" );
	Assert( result == NO_ERR, 0, "Coudln't find the mission settings block in the mission file" );

	bool bRes;
	result = fitFile.readIdBoolean( "MissionNameUseResourceString", bRes );
	Assert( result == NO_ERR, 0, "couldn't find the MissionNameUseResourceString" );
	if ( bRes )
	{
		unsigned long ulRes;
		result = fitFile.readIdULong( "MissionNameResourceStringID", ulRes );
		Assert( result == NO_ERR, 0, "couldn't find the MissionNameResourceStringID" );
		addItem(ulRes, 0xff005392, -1);
	}
	else
	{
		char missionName[256];
		fitFile.readIdString("MissionName", missionName, 255);
		addLBItem(missionName, 0xff005392, -1);

	}

	addItem(IDS_MN_DIVIDER, 0xff005392, -1);
	addItem( IDS_MN_MISSION_OBJECTIVES, 0xff005392, -1 );
	addItem(IDS_MN_DIVIDER, 0xff005392, -1);

	// put in primary objectives
	fitFile.seekBlock( "Team0Objectives" );
	unsigned long objectiveCount;
	fitFile.readIdULong( "NumObjectives", objectiveCount );
	bool bHasSecondary = 0;
	int count = 0; 

	fitFile.seekBlock( "Terrain" );
	float terrainExtentX;
	float terrainExtentY;
	fitFile.readIdFloat( "TerrainMinX", terrainExtentX );
	if ( !terrainExtentX )
		terrainExtentX = 120 * 128;
	fitFile.readIdFloat( "TerrainMinY", terrainExtentY );
	if ( !terrainExtentY )
		terrainExtentY = 120 * 128;

	CObjectives Objectives(0/*alignment*/);
	/*Note that ObjectManager is probably NULL as these objectives are read, so it's not
	cool to call any of the Status() functions of this instance of objectives (access violation
	may ensue).*/
	Objectives.Read(&fitFile);

	gosASSERT( Objectives.Count() < MAX_OBJECTIVES );

	int buttonCount = 0;

	for ( int j = 1; j < 3; j++ )
	{
		CObjectives::EIterator it = Objectives.Begin();
		buttonCount = 0;
		for ( int i = 0; i < Objectives.Count(); i++, it++ )
		{
			CObjective *pObjective = (*it);
			if ( (!pObjective->IsHiddenTrigger()) && (pObjective->IsActive()) )
			{
				
				if ( pObjective->Priority() == j )
				{
					addObjectiveButton( pObjective->MarkerX(), pObjective->MarkerY(), buttonCount,pObjective->Priority(), fabs(terrainExtentX),
									fabs(terrainExtentY), pObjective->DisplayMarker());

					if ( j == 0 )
					{
						bHasSecondary = true;
						if ( i == 0 )
							addItem( IDS_MN_DIVIDER, 0xff005392, -1 );
					}

					addLBItem( (pObjective->LocalizedDescription()).Data(), 0xffffffff, count );

					objectiveModels[count] = (pObjective->ModelName()).Data();
					modelTypes[count] = pObjective->ModelType();

					modelColors[count][0] = pObjective->ModelBaseColor();
					modelColors[count][1] = pObjective->ModelHighlightColor();
					modelColors[count][2] = pObjective->ModelHighlightColor2();
					modelScales[count] = pObjective->ModelScale();

					count++;
					buttonCount++;
				}
			}
		}
	}
	
	addItem( IDS_MN_DIVIDER, 0xff005392, -1 );

	fitFile.seekBlock( "MissionSettings" );

	char blurb[4096];
	result = fitFile.readIdString("Blurb", blurb, 4095 );

	bool tmpBool = false;
	result = fitFile.readIdBoolean("BlurbUseResourceString", tmpBool);
	if (NO_ERR == result && tmpBool )
	{
		unsigned long tmpInt = 0;
		result = fitFile.readIdULong("BlurbResourceStringID", tmpInt);
		if (NO_ERR == result)
		{
			cLoadString( tmpInt, blurb, 2047 );
		}
	}


	addLBItem( blurb, 0xff005392, -1 );

	int RP = LogisticsData::instance->getCBills();
	char text[32];
	sprintf( text, "%ld ", RP );
	textObjects[RP_INDEX].setText( text );

	// need to find a drop zone, because our designers were never convinced to place
	// 'em explicitly, we need to do it for them
	int i = 1;
	while( true )
	{
		char blockName[32];
		sprintf( blockName, "Part%ld", i );
		i++;
		if ( NO_ERR != fitFile.seekBlock( blockName ) )
			break;
		
		bool bPlayer = 0;
		fitFile.readIdBoolean( "PlayerPart", bPlayer );

		if ( bPlayer )
		{
			float fX;
			float fY;

			fitFile.readIdFloat( "PositionX", fX );
			fitFile.readIdFloat( "PositionY", fY );

			setupDropZone( fX, fY, fabs(terrainExtentX), fabs(terrainExtentY) );
		
			break;
		}
	}

	statics[BUTTON_TEXT].showGUIWindow( 0 );
	status = RUNNING;

}
예제 #15
0
long GateType::init (FilePtr objFile, unsigned long fileSize, const char* builName)
{
	long result = 0;
	//magic 24022011 begin
	//char tmp1[16]; //magic 29112011 disabled
	//sprintf( tmp1, "%ld", objFile ); //magic 29112011 disabled
	//char tmp2[256];
	//FitIniFile MtestFile;
	//MtestFile.open("data\\vehicle_load.fit", CREATE);
	//MtestFile.writeBlock( tmp1 );
	//MtestFile.writeBlock( vehicleName );
	//MtestFile.close();
	FitIniFile bldgFile;
	FitIniFile objTypeFile;
	
	result = objTypeFile.open(objFile, fileSize);
	if (result != NO_ERR)
	{
		FullPathFileName mFullFileName;
		mFullFileName.init(objectPath, builName, ".fit");
		//FitIniFile objTypeFile;
		//MtestFile.writeBlock( mFullFileName );
		//MtestFile.close();

		long result1 = bldgFile.open(mFullFileName);
		if (result1 != NO_ERR)
		{
			Fatal(objTypeNum, " BuildingType.init1: can't open building file ");
		}
	}
	else
		bldgFile.open(objFile, fileSize);

	objTypeFile.close();

	//magic 24022011 end	
	/*FitIniFile bldgFile;
	result = bldgFile.open(objFile,fileSize);
	if (result != NO_ERR)
		return(result);*/
	
	//------------------------------------------------------------------
	// Read in the data needed for the Gates
	result = bldgFile.seekBlock("GateData");
	if (result != NO_ERR)
		return(result);

	result = bldgFile.readIdULong("DmgLevel",dmgLevel);
	if (result != NO_ERR)
		return(result);

	bldgFile.readIdULong("BlownEffectId",blownEffectId);
	if (result != NO_ERR)
		blownEffectId = -1;
		
	bldgFile.readIdULong("NormalEffectId",normalEffectId);
	if (result != NO_ERR)
		normalEffectId = -1;
		
	bldgFile.readIdULong("DamageEffectId",damageEffectId);
	if (result != NO_ERR)
		damageEffectId = -1;

	result = bldgFile.readIdLong("BasePixelOffsetX",basePixelOffsetX);
	if (result != NO_ERR)
		basePixelOffsetX = 0;
	
	result = bldgFile.readIdLong("BasePixelOffsetY",basePixelOffsetY);
	if (result != NO_ERR)	
		basePixelOffsetY = 0;

	result = bldgFile.readIdFloat("ExplosionRadius",explRad);
	if (result != NO_ERR)
		explRad = 0.0;
		
	result = bldgFile.readIdFloat("ExplosionDamage",explDmg);
	if (result != NO_ERR)
		explDmg = 0.0;

	result = bldgFile.readIdFloat("OpenRadius",openRadius);
	if (result != NO_ERR)
		return(result);

	result = bldgFile.readIdFloat("LittleExtent",littleExtent);
	if (result != NO_ERR)
		littleExtent = 20.0;

	result = bldgFile.readIdLong ("BuildingName", gateTypeName);
	if (result != NO_ERR)
		gateTypeName = IDS_BLDOBJ_NAME;

	result = bldgFile.readIdLong( "BuildingDescription", buildingDescriptionID );
	if ( result != NO_ERR )
			buildingDescriptionID = -1;


	result = bldgFile.readIdBoolean("BlocksLineOfFire",blocksLineOfFire);
	if (result != NO_ERR)
		blocksLineOfFire = FALSE;

	//magic 09092011 begin
	char s[255];
	result = bldgFile.readIdString("Name",s,254); //magic 09092011
	strcpy_s(buildingName, s);//magic 09092011

	//magic 09092011 end

	//------------------------------------------------------------------
	// Initialize the base object Type from the current file.
	result = ObjectType::init(&bldgFile);
	return(result);
}
예제 #16
0
int MPPrefs::init( FitIniFile& file )
{
	LogisticsScreen::init( file, "Static", "Text", "Rect", "Button" );

	for ( int i = 0; i < buttonCount; i++ )
	{
		if ( buttons[i].getID() != MP_PREFS_BASE &&
			buttons[i].getID() != MP_PREFS_STRIPE )
			buttons[i].setMessageOnRelease( );

		int id = buttons[i].getID();
		if ( id != MB_MSG_NEXT && id != MB_MSG_PREV && id != MB_MSG_MAINMENU )
		{
			buttons[i].setPressFX( LOG_VIDEOBUTTONS );
			buttons[i].setHighlightFX( LOG_DIGITALHIGHLIGHT );
			buttons[i].setDisabledFX( LOG_WRONGBUTTON );
		}
	}

	file.seekBlock( "ComboBoxes" );
	long count = 0;
	file.readIdLong( "ComboBoxCount", count );
	char blockName[256];

	const char* headers[3] = {"PlayerNameComboBox", "UnitNameComboBox", "UnitInsigniaComboBox" };
	for ( i = 0;  i< count; i++ )
	{
		sprintf( blockName, "ComboBox%ld",  i );
		file.seekBlock( blockName );
		file.readIdString( "FileName", blockName, 255);

		long tmpX;
		long tmpY;
		file.readIdLong( "XLocation", tmpX );
		file.readIdLong( "YLocation", tmpY );

		FitIniFile tmpFile;
		FullPathFileName path;
		path.init( artPath, blockName, ".fit" );
		
		if ( NO_ERR != tmpFile.open( path ) )
		{
			char error[256];
			sprintf( error, "couldn't open file %s", path );
			Assert( 0, 0, error );
			return -1;
		}

		comboBox[i].moveTo( tmpX, tmpY );

		comboBox[i].init( &tmpFile, headers[i] );
		comboBox[i].ListBox().setOrange(true );

		comboBox[0].EditBox().limitEntry( 24 );
		comboBox[1].EditBox().limitEntry( 24 );

		if ( i == 2 )
		{
			insigniaBmp.init( &tmpFile, "Static0" );
			//insigniaBmp.move( comboBox[i].globalX(), comboBox[i].globalY() );
			comboBox[i].addChild( &insigniaBmp );
		}

		comboBox[i].EditBox().allowIME( 0 );
	}


	comboBox[2].EditBox().setReadOnly(true);
	

	camera.init( rects[2].left(), rects[2].top(), rects[2].right(), rects[2].bottom() );

	status = NEXT;


	return 0;
}
예제 #17
0
void StaticInfo::init( FitIniFile& file, char* blockName, long hiResOffsetX, long hiResOffsetY, DWORD neverFlush )
{
	memset( location, 0, sizeof( location ) );
	char fileName[256];
	textureHandle = 0;
	textureWidth = 0; 
	
	if ( NO_ERR != file.seekBlock( blockName ) )
	{
		char errBuffer[256];
		sprintf( errBuffer, "couldn't find static block %s", blockName );
		Assert( 0, 0, errBuffer );
		return;
	}

	long x, y, width, height;
	file.readIdLong( "XLocation", x );
	file.readIdLong( "YLocation", y );

	x += hiResOffsetX;
	y += hiResOffsetY;

	file.readIdLong( "Width", width );
	file.readIdLong( "Height", height );

	file.readIdString( "FileName", fileName, 32 );

	if ( !textureHandle )
	{
		FullPathFileName fullPath;
		_strlwr( fileName );
		fullPath.init( artPath, fileName, ".tga" );
		int ID = mcTextureManager->loadTexture( fullPath, gos_Texture_Alpha, 0, 0, 0x2 );
		textureHandle = ID;
		unsigned long gosID = mcTextureManager->get_gosTextureHandle( ID );
		TEXTUREPTR textureData;
		gos_LockTexture( gosID, 0, 0, 	&textureData );
		textureWidth = textureData.Width;
		gos_UnLockTexture( gosID );
	}

	bool bRotated = 0;

	file.readIdLong( "UNormal", u );
	file.readIdLong( "VNormal", v );
	file.readIdLong( "UWidth", uWidth );
	file.readIdLong( "VHeight", vHeight );
	file.readIdBoolean( "texturesRotated", bRotated );

	for ( int k = 0; k < 4; k++ )
	{
		location[k].argb = 0xffffffff;
		location[k].frgb = 0;
		location[k].x = x;
		location[k].y = y;
		location[k].z = 0.f;
		location[k].rhw = .5;
		location[k].u = (float)u/(float)textureWidth + (.1f / (float)textureWidth);
		location[k].v = (float)v/(float)textureWidth + (.1f / (float)textureWidth);
	}

	location[3].x = location[2].x = x + width;
	location[2].y = location[1].y = y + height;

	location[2].u = location[3].u = ((float)(u + uWidth))/((float)textureWidth) + (.1f / (float)textureWidth);
	location[1].v = location[2].v = ((float)(v + vHeight))/((float)textureWidth) + (.1f / (float)textureWidth);

	if ( bRotated )
	{

		location[0].u = (u + uWidth)/(float)textureWidth + (.1f / (float)textureWidth);;
		location[1].u = u/(float)textureWidth + (.1f / (float)textureWidth);;
		location[2].u = u/(float)textureWidth + (.1f / (float)textureWidth);
		location[3].u = (u + uWidth)/(float)textureWidth + (.1f / (float)textureWidth);

		location[0].v = v/(float)textureWidth + (.1f / (float)textureWidth);;
		location[1].v = v/(float)textureWidth + (.1f / (float)textureWidth);;
		location[2].v = (v + vHeight)/(float)textureWidth + (.1f / (float)textureWidth);;
		location[3].v = (v + vHeight)/(float)textureWidth + (.1f / (float)textureWidth);;
	}

}
예제 #18
0
void aButton::init( FitIniFile& buttonFile, const char* str, HGOSFONT3D font )
{
	textureHandle = 0;

	long result = buttonFile.seekBlock( str );
	if ( result != NO_ERR )
	{
		char errorStr[256];
		sprintf(  errorStr, "couldn't find button %s", str );
		Assert( 0, 0, errorStr );
		return;
	}


	buttonFile.readIdLong( "ID", data.ID );
	buttonFile.readIdString("FileName", data.fileName, 32 );

	buttonFile.readIdLong( "HelpCaption", helpHeader );
	buttonFile.readIdLong( "HelpDesc", helpID );
	buttonFile.readIdLong( "TextID", data.textID );
	buttonFile.readIdLong( "TextNormal", data.textColors[0] );
	buttonFile.readIdLong( "TextPressed", data.textColors[1] );
	buttonFile.readIdLong( "TextDisabled", data.textColors[2] );
	buttonFile.readIdBoolean( "Toggle", toggleButton );
	buttonFile.readIdBoolean( "outline", data.outline );
	long fontID;
	buttonFile.readIdLong( "Font", fontID );
	if ( fontID )
		data.textFont = aFont::loadFont( fontID, data.textSize );
	else
		data.textFont = 0;


	long x, y, width, height;

	buttonFile.readIdLong( "XLocation", x );
	buttonFile.readIdLong( "YLocation", y );
		
	buttonFile.readIdLong( "Width", width );
	buttonFile.readIdLong( "Height", height );

	buttonFile.readIdLong( "HelpCaption", helpHeader );
	buttonFile.readIdLong( "HelpDesc", helpID );

	buttonFile.readIdBoolean( "texturesRotated", data.textureRotated );

	if ( NO_ERR != buttonFile.readIdLong( "Alignment", data.textAlign ) )
		data.textAlign = 2;
	
	location[0].x = location[1].x = x;
	location[0].y = location[3].y = y;
	location[2].x = location[3].x = x + width;
	location[1].y = location[2].y = y + height;

	for ( int j = 0; j < 4; j++ )
	{
		location[j].argb = 0xffffffff;
		location[j].frgb = 0;
		location[j].rhw = .5;
		location[j].u = 0.f;
		location[j].v = 0.f;
		location[j].z = 0.f;
	}
		
	
	if ( 0 == textureHandle && data.fileName && strlen( data.fileName ) )
	{
		char file[256];
		strcpy( file, artPath );
		strcat( file, data.fileName );
		_strlwr( file );
		if ( !strstr( data.fileName, ".tga" ) )
			strcat( file, ".tga" );
		
		int ID = mcTextureManager->loadTexture( file, gos_Texture_Alpha, 0, 0, 0x2 );
		int gosID = mcTextureManager->get_gosTextureHandle( ID );
		TEXTUREPTR textureData;
		gos_LockTexture( gosID, 0, 0, 	&textureData );
		gos_UnLockTexture( gosID );

		textureHandle = ID;
		data.fileWidth = textureData.Width;
		data.fileHeight = data.fileWidth;
	}

	if ( NO_ERR != buttonFile.readIdLong( "UNormal", data.stateCoords[0][0] ) )
		data.stateCoords[0][0] = -1.f;

	if ( NO_ERR != buttonFile.readIdLong( "VNormal", data.stateCoords[0][1] ) )
		data.stateCoords[0][1] = -1.f;


	if ( NO_ERR != buttonFile.readIdLong( "UPressed", data.stateCoords[1][0] ) )
		data.stateCoords[1][0] = -1.f;

	if ( NO_ERR != buttonFile.readIdLong( "VPressed", data.stateCoords[1][1] ) )
		data.stateCoords[1][1] = -1.f;

	if ( NO_ERR != buttonFile.readIdLong( "UDisabled", data.stateCoords[2][0] ) )
		data.stateCoords[2][0] = -1.f;

	if ( NO_ERR != buttonFile.readIdLong( "VDisabled", data.stateCoords[2][1] ) )
		data.stateCoords[2][1] = -1.f;

	if ( NO_ERR != buttonFile.readIdLong( "UAmbiguous", data.stateCoords[3][0] ) )
		data.stateCoords[3][0] = -1.f;

	if ( NO_ERR != buttonFile.readIdLong( "VAmbiguous", data.stateCoords[3][1] ) )
		data.stateCoords[3][1] = -1.f;

	if ( NO_ERR != buttonFile.readIdLong( "UHighlight", data.stateCoords[4][0] ) )
	{
		data.stateCoords[4][0] = data.stateCoords[0][0];
	}

	if ( NO_ERR != buttonFile.readIdLong( "VHighlight", data.stateCoords[4][1] ) )
	{
		data.stateCoords[4][1] = data.stateCoords[0][1];
	}

	buttonFile.readIdLong( "UWidth", data.textureWidth );
	buttonFile.readIdLong( "VHeight", data.textureHeight );

	if ( data.textID )
		buttonFile.readIdBoolean( "TextOutline", data.outlineText );


	if ( NO_ERR == buttonFile.readIdLong( "XTextLocation", data.textRect.left ) )
	{
		buttonFile.readIdLong( "YTextLocation", data.textRect.top );
		buttonFile.readIdLong( "TextWidth", width );
		buttonFile.readIdLong( "TextHeight", height );
		data.textRect.right = data.textRect.left + width;
		data.textRect.bottom = data.textRect.top + height;
		buttonFile.readIdBoolean( "TextOutline", data.outlineText );
	}
	else
	{
		data.textRect.left = x;
		data.textRect.right = x + width;
		data.textRect.top = y;
		data.textRect.bottom = y + height;
	}

	char bmpName[256];
	strcpy( bmpName, str );
	strcat( bmpName, "Bmp" );
	char finalName[256];
	int counter = 0;
	while(true)
	{
		sprintf( finalName, "%s%ld", bmpName, counter );
		if ( NO_ERR != buttonFile.seekBlock( finalName) )
			break;

		aObject* pObject = new aObject;
		pObject->init( &buttonFile, finalName );
		// Dorje is doing this in global coords
		pObject->move( -globalX(), -globalY() );
		addChild( pObject );

		counter++;
	}


	buttonFile.seekBlock( str );
	disable( 0 );
	press( 0 );


}
예제 #19
0
//---------------------------------------------------------------------------
void __stdcall InitializeGameEngine()
{
	gosResourceHandle = gos_OpenResourceDLL("mc2res.dll");
	char temp[256];
	cLoadString(IDS_FLOAT_HELP_FONT, temp, 255);
	PSTR pStr = strstr(temp, ",");
	if(pStr)
	{
		gosFontScale = atoi(pStr + 2);
		*pStr = 0;
	}
	char path [256];
	strcpy(path, "assets\\graphics\\");
	strcat(path, temp);
	gosFontHandle = gos_LoadFont(path);
	//-------------------------------------------------------------
	// Find the CDPath in the registry and save it off so I can
	// look in CD Install Path for files.
	//Changed for the shared source release, just set to current directory
	//uint32_t maxPathLength = 1023;
	//gos_LoadDataFromRegistry("CDPath", CDInstallPath, &maxPathLength);
	//if (!maxPathLength)
	// strcpy(CDInstallPath,"..\\");
	strcpy(CDInstallPath, ".\\");
	cLoadString(IDS_MC2_FILEMISSING, FileMissingString, 511);
	cLoadString(IDS_MC2_CDMISSING, CDMissingString, 1023);
	cLoadString(IDS_MC2_MISSING_TITLE, MissingTitleString, 255);
	//--------------------------------------------------------------
	// Start the SystemHeap and globalHeapList
	globalHeapList = new HeapList;
	gosASSERT(globalHeapList != nullptr);
	globalHeapList->init();
	globalHeapList->update(); //Run Instrumentation into GOS Debugger Screen
	systemHeap = new UserHeap;
	gosASSERT(systemHeap != nullptr);
	systemHeap->init(systemHeapSize, "SYSTEM");
	float doubleClickThreshold = 0.2f;
	int32_t dragThreshold = .016667;
	//--------------------------------------------------------------
	// Read in System.CFG
	FitIniFile systemFile;
#ifdef _DEBUG
	int32_t systemOpenResult =
#endif
		systemFile.open("system.cfg");
#ifdef _DEBUG
	if(systemOpenResult != NO_ERROR)
	{
		char Buffer[256];
		gos_GetCurrentPath(Buffer, 256);
		STOP(("Cannot find \"system.cfg\" file in %s", Buffer));
	}
#endif
	{
#ifdef _DEBUG
		int32_t systemBlockResult =
#endif
			systemFile.seekBlock("systemHeap");
		gosASSERT(systemBlockResult == NO_ERROR);
		{
			int32_t result = systemFile.readIdULong("systemHeapSize", systemHeapSize);
			result;
			gosASSERT(result == NO_ERROR);
		}
#ifdef _DEBUG
		int32_t systemPathResult =
#endif
			systemFile.seekBlock("systemPaths");
		gosASSERT(systemPathResult == NO_ERROR);
		{
			int32_t result = systemFile.readIdString("terrainPath", terrainPath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("artPath", artPath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("fontPath", fontPath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("savePath", savePath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("spritePath", spritePath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("shapesPath", shapesPath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("soundPath", soundPath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("objectPath", objectPath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("cameraPath", cameraPath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("tilePath", tilePath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("missionPath", missionPath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("warriorPath", warriorPath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("profilePath", profilePath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("interfacepath", interfacePath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("moviepath", moviePath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("CDsoundPath", CDsoundPath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("CDmoviepath", CDmoviePath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("tglPath", tglPath, 79);
			gosASSERT(result == NO_ERROR);
			result = systemFile.readIdString("texturePath", texturePath, 79);
			gosASSERT(result == NO_ERROR);
		}
#ifdef _DEBUG
		int32_t fastFileResult =
#endif
			systemFile.seekBlock("FastFiles");
		gosASSERT(fastFileResult == NO_ERROR);
		{
			int32_t result = systemFile.readIdLong("NumFastFiles", maxFastFiles);
			if(result != NO_ERROR)
				maxFastFiles = 0;
			if(maxFastFiles)
			{
				fastFiles = (FastFile**)malloc(maxFastFiles * sizeof(FastFile*));
				memset(fastFiles, 0, maxFastFiles * sizeof(FastFile*));
				int32_t fileNum = 0;
				char fastFileId[10];
				char fileName[100];
				sprintf(fastFileId, "File%d", fileNum);
				while(systemFile.readIdString(fastFileId, fileName, 99) == NO_ERROR)
				{
					bool result = FastFileInit(fileName);
					if(!result)
						STOP(("Unable to startup fastfiles. Probably an old one in the directory!!"));
					fileNum++;
					sprintf(fastFileId, "File%d", fileNum);
				}
			}
		}
	}
	systemFile.close();
	//--------------------------------------------------------------
	// Read in Prefs.cfg
	bool fullScreen = false;
	FitIniFilePtr prefs = new FitIniFile;
#ifdef _DEBUG
	int32_t prefsOpenResult =
#endif
		prefs->open("prefs.cfg");
	gosASSERT(prefsOpenResult == NO_ERROR);
	{
#ifdef _DEBUG
		int32_t prefsBlockResult =
#endif
			prefs->seekBlock("MechCommander2");
		gosASSERT(prefsBlockResult == NO_ERROR);
		{
			int32_t filterSetting;
			int32_t result = prefs->readIdLong("FilterState", filterSetting);
			if(result == NO_ERROR)
			{
				switch(filterSetting)
				{
					default:
					case 0:
						FilterState = gos_FilterNone;
						break;
					case 1:
						FilterState = gos_FilterBiLinear;
						break;
					case 2:
						FilterState = gos_FilterTriLinear;
						break;
				}
			}
			result = prefs->readIdLong("TerrainTextureRes", TERRAIN_TXM_SIZE);
			if(result != NO_ERROR)
				TERRAIN_TXM_SIZE = 64;
			result = prefs->readIdLong("ObjectTextureRes", ObjectTextureSize);
			if(result != NO_ERROR)
				ObjectTextureSize = 128;
			result = prefs->readIdLong("Brightness", gammaLevel);
			if(result != NO_ERROR)
				gammaLevel = 0;
			// store volume settings in global variable since soundsystem
			// does not exist yet. These will be set in SoundSystem::init()
			result = prefs->readIdLong("DigitalMasterVolume", DigitalMasterVolume);
			if(result != NO_ERROR)
				DigitalMasterVolume = 255;
			result = prefs->readIdLong("MusicVolume", MusicVolume);
			if(result != NO_ERROR)
				MusicVolume = 64;
			result = prefs->readIdLong("RadioVolume", RadioVolume);
			if(result != NO_ERROR)
				RadioVolume = 64;
			result = prefs->readIdLong("SFXVolume", sfxVolume);
			if(result != NO_ERROR)
				sfxVolume = 64;
			result = prefs->readIdFloat("DoubleClickThreshold", doubleClickThreshold);
			if(result != NO_ERROR)
				doubleClickThreshold = 0.2f;
			result = prefs->readIdLong("DragThreshold", dragThreshold);
			if(result != NO_ERROR)
				dragThreshold = .016667;
			result = prefs->readIdULong("BaseVertexColor", BaseVertexColor);
			if(result != NO_ERROR)
				BaseVertexColor = 0x00000000;
			result = prefs->readIdBoolean("FullScreen", fullScreen);
			if(result != NO_ERROR)
				fullScreen = true;
			result = prefs->readIdLong("Rasterizer", renderer);
			if(result != NO_ERROR)
				renderer = 0;
			if((renderer < 0) || (renderer > 3))
				renderer = 0;
		}
	}
	prefs->close();
	delete prefs;
	prefs = nullptr;
	//-------------------------------
	// Used to output debug stuff!
	// Mondo COOL!
	// simply do this in the code and stuff goes to the file called mc2.output
	// DEBUG_STREAM << thing_you_want_to_output
	//
	// IMPORTANT NOTE:
	Stuff::InitializeClasses();
	MidLevelRenderer::InitializeClasses(8192 * 4, 1024, 0, 0, true);
	gosFX::InitializeClasses();
	gos_PushCurrentHeap(MidLevelRenderer::Heap);
	MidLevelRenderer::TGAFilePool* pool = new MidLevelRenderer::TGAFilePool("data\\Effects\\");
	MidLevelRenderer::MLRTexturePool::Instance = new MidLevelRenderer::MLRTexturePool(pool);
	MidLevelRenderer::MLRSortByOrder* cameraSorter = new MidLevelRenderer::MLRSortByOrder(MidLevelRenderer::MLRTexturePool::Instance);
	theClipper = new MidLevelRenderer::MLRClipper(0, cameraSorter);
	gos_PopCurrentHeap();
	//------------------------------------------------------
	// Start the GOS FX.
	gos_PushCurrentHeap(gosFX::Heap);
	gosFX::EffectLibrary::Instance = new gosFX::EffectLibrary();
	Check_Object(gosFX::EffectLibrary::Instance);
	FullPathFileName effectsName;
	effectsName.init(effectsPath, "mc2.fx", "");
	File effectFile;
	int32_t result = effectFile.open(effectsName);
	if(result != NO_ERROR)
		STOP(("Could not find MC2.fx"));
	int32_t effectsSize = effectFile.fileSize();
	puint8_t effectsData = (puint8_t)systemHeap->Malloc(effectsSize);
	effectFile.read(effectsData, effectsSize);
	effectFile.close();
	effectStream = new Stuff::MemoryStream(effectsData, effectsSize);
	gosFX::EffectLibrary::Instance->Load(effectStream);
	gosFX::LightManager::Instance = new gosFX::LightManager();
	gos_PopCurrentHeap();
	systemHeap->Free(effectsData);
	//------------------------------------------------
	// Fire up the MC Texture Manager.
	mcTextureManager = new MC_TextureManager;
	mcTextureManager->start();
	//Startup the vertex array pool
	mcTextureManager->startVertices(500000);
	//--------------------------------------------------
	// Setup Mouse Parameters from Prefs.CFG
	userInput = new UserInput;
	userInput->init();
	userInput->setMouseDoubleClickThreshold(doubleClickThreshold);
	userInput->setMouseDragThreshold(dragThreshold);
	userInput->initMouseCursors("cursors");
	userInput->setMouseCursor(mState_NORMAL);
	userInput->mouseOn();
	// now the sound system
	soundSystem = new GameSoundSystem;
	soundSystem->init();
	((SoundSystem*)soundSystem)->init("sound");
	sndSystem = soundSystem; // for things in the lib that use sound
	soundSystem->playDigitalMusic(LOGISTICS_LOOP);
	pLogData = new LogisticsData;
	pLogData->init();
	pMechlopedia = new Mechlopedia;
	pMechlopedia->init();
	pMechlopedia->begin();
}
예제 #20
0
void MPLoadMap::seedFromCampaign()
{
		char searchStr[255];
		cLoadString( IDS_AUTOSAVE_NAME, searchStr, 255 );
		EString finalStr;
		finalStr =  "*.fit";
		FullPathFileName findPath;
		findPath.init( savePath, finalStr, ".fit" );

		EString newestFile;
		long	groupCount = -1;
		long	missionCount = -1;
		FitIniFile tmpFile;

		WIN32_FIND_DATA	findResult;
		HANDLE searchHandle = FindFirstFile(findPath,&findResult); 
		 if ( searchHandle != INVALID_HANDLE_VALUE )
		 {
			do
			{
				if ((findResult.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
				{
					FullPathFileName path;
					path.init( savePath, findResult.cFileName, ".fit" );
 					tmpFile.open( path  );

					 if ( NO_ERR == tmpFile.seekBlock( "General" ) )
					 {
						 long group, missions;

						tmpFile.readIdLong( "Group ", group );
						if ( group > groupCount )
						{
							groupCount = group;
							tmpFile.readIdLong( "CompletedMissions", missions );
							missionCount = missions;
							newestFile = findResult.cFileName;
						}
						else if ( group == groupCount )
						{
							tmpFile.readIdLong( "CompletedMissions", missions );
							if ( missions > missionCount )
								missionCount = missions;
							newestFile = findResult.cFileName;
						}
					 }

					tmpFile.close();


				}
			} while (FindNextFile(searchHandle,&findResult) != 0);
		 }

		 FindClose(searchHandle);

		 if ( newestFile.Length() )
		 {
			 findPath.init( savePath, newestFile, ".fit" );
			 FitIniFile file;
			 long group;
			 long missions;
			 char campaignFileName[256];
			 campaignFileName[0] = 0;
			 if ( NO_ERR == file.open( findPath ) )
			 {
				 if ( NO_ERR == file.seekBlock( "General" ) )
				 {
					file.readIdLong( "Group ", group );
					file.readIdLong( "CompletedMissions", missions );
					file.readIdString( "CampaignFile", campaignFileName, 255 );
				 }
			 }

			 if ( strlen( campaignFileName ) && ( group || missions ) )
			 {
				FitIniFile campaignFile;
				if ( NO_ERR == campaignFile.open( campaignFileName ) )
				{
					for ( int i = 0; i < group+1; i++ )
					{
						char blockName[64];
						sprintf( blockName,  "Group%ld", i );
						if ( NO_ERR == campaignFile.seekBlock( blockName ) )
						{
							long count = missions;
							if ( i < group )
							{
								campaignFile.readIdLong( "MissionCount", count );
							}

							for ( int j = 0; j < count; j++ )
							{
								sprintf( blockName, "Group%ldMission%ld", i, j );
								if ( NO_ERR == campaignFile.seekBlock( blockName ) )
								{
									char tmpFileName[255];
									campaignFile.readIdString( "FileName", tmpFileName, 255 );

									aLocalizedListItem* pEntry = new aLocalizedListItem();
									*pEntry = templateItem;
									pEntry->resize( mapList.width() - mapList.getScrollBarWidth() - 20, pEntry->height());
									pEntry->setHiddenText( tmpFileName );
									char displayName[256];
									getMapNameFromFile( tmpFileName, displayName, 255 );
									pEntry->setText( displayName );
									pEntry->sizeToText();
									mapList.AddItem( pEntry );
								}
							}
						}
					}
				}
			 }
		 }
}
예제 #21
0
void LogisticsSaveDialog::updateMissionInfo()
{
	if ( !selectedName.Length() )
	{
		statics[MAP_STATIC].setColor( 0 );
		return;
	}

	if ( bCampaign )
	{
		updateCampaignMissionInfo();
		return;
	}


	FullPathFileName fileName;
	fileName.init( savePath, selectedName, ".fit" );

	FitIniFile file;
	if ( NO_ERR == file.open( fileName ) )
	{
		char tmp[256];
		char tmp2[256];
		char real[1024];
		file.seekBlock( "General" );

		tmp[0] = 0;
		file.readIdString( "CampaignName", tmp, 255);
		_splitpath( tmp, NULL, NULL, tmp2, NULL );
		strcpy( real, tmp2 );
		strcat( real, "\n" );

		if ( NO_ERR == file.readIdString( "MissionName", tmp, 255 ) )
		{
			strcat( real, tmp );
			strcat( real, "\n" );
		}

		if ( NO_ERR == file.readIdString( "MissionFileName", tmp, 255 ) )
		{
			long textureHandle = MissionBriefingScreen::getMissionTGA( tmp );

			statics[MAP_STATIC].setTexture( textureHandle );
			statics[MAP_STATIC].setUVs( 0, 127, 127, 0 );
			statics[MAP_STATIC].setColor( 0xffffffff );
		}
		else
			statics[MAP_STATIC].setColor( 0 );


		long cBills;
		file.readIdLong( "CBills", cBills );
		cLoadString( IDS_DIALOG_CBILLS, tmp2, 255 );
		sprintf( tmp, tmp2, cBills );
		strcat( real, tmp );
		strcat( real, "\n" );

		time_t time = file.getFileMTime();
		struct tm* ptm = localtime(&time);

		char* timeStr = gos_GetFormattedTime( ptm->tm_hour, ptm->tm_min, ptm->tm_sec );
		char* dateStr = gos_GetFormattedDate( 0, ptm->tm_year + 1900, ptm->tm_mon + 1, ptm->tm_mday );


		cLoadString( IDS_DIALOG_TIME, tmp2, 255 );
		sprintf( tmp, tmp2, dateStr, timeStr  );
		strcat( real, tmp );


		textObjects[2].setText( real );
	}
	else
	{
		textObjects[2].setText( "" );
		statics[MAP_STATIC].setColor( 0 );
	}


}
예제 #22
0
void MPLoadMap::updateMapInfo()
{
	int sel = mapList.GetSelectedItem();
	if ( sel != -1 )
	{

		FitIniFile file;
		FullPathFileName path;
		const char* fileName = ((aTextListItem*)mapList.GetItem( sel ))->getText();
		selMapName = ((aLocalizedListItem*)mapList.GetItem(sel))->getHiddenText();
		path.init( missionPath, selMapName, ".fit" );

		if ( NO_ERR == file.open( path ) )
		{
			
			char missionName[256];
			missionName[0] = 0;
			bool bRes = 0;

			char text[1024];
			char text2[1024];

			file.seekBlock( "MissionSettings" );
			file.readIdBoolean( "MissionNameUseResourceString", bRes );
			if ( bRes )
			{
				unsigned long lRes;
				file.readIdULong( "MissionNameResourceStringID", lRes );
				cLoadString( lRes, missionName, 255 );
			}
			else
			{
				file.readIdString( "MissionName", missionName, 255 );
			}

			long textureHandle = MissionBriefingScreen::getMissionTGA( selMapName );
			statics[18].setTexture( textureHandle );
			statics[18].setUVs( 0, 127, 127, 0 );
			statics[18].setColor( 0xffffffff );
 
			cLoadString( IDS_MP_LM_MAP_LIST_MAP_NAME, text, 255 );
			sprintf( text2, text, missionName );
			textObjects[3].setText( text2 );

			if ( !bIsSingle )
			{
				unsigned long type = 0;
				file.readIdULong( "MissionType", type );
				cLoadString( IDS_MP_LM_MAP_LIST_TYPE, text, 255 );
				char mType[128];
				cLoadString( IDS_MP_LM_TYPE0 + type, mType, 127 );
				
				sprintf( text2, text, mType );
				textObjects[4].setText( text2 );
			
	
				unsigned long numPlayers = 0;
				file.readIdULong( "MaximumNumberOfPlayers", numPlayers );

				cLoadString( IDS_MP_LM_MAP_LIST_MAX_PLAYERS, text, 255 );
				sprintf( text2, text, numPlayers );
				textObjects[2].setText( text2 );
			}
			else
			{
				textObjects[4].setText( "" );
				textObjects[2].setText( "" );
			}

			char blurb[1024];
			blurb[0] = 0;
			long result = file.readIdString("Blurb2", blurb, 1023 );

			bool tmpBool = false;
			result = file.readIdBoolean("Blurb2UseResourceString", tmpBool);
			if (NO_ERR == result && tmpBool )
			{
				unsigned long tmpInt = 0;
				result = file.readIdULong("Blurb2ResourceStringID", tmpInt);
				if (NO_ERR == result)
				{
					cLoadString( tmpInt, blurb, 1024 );
				}
			}

			textObjects[5].setText( blurb );

  

		}

	}
	else
	{
		textObjects[4].setText( "" );
		textObjects[3].setText( "" );
		textObjects[2].setText( "" );
		textObjects[5].setText( "" );
		statics[18].setColor( 0 );


	}
}
예제 #23
0
//-----------------------------
int32_t convertASE2TGL(PSTR file)
{
	//---------------------------------------------------
	// Get all of the .ASE files in the tgl directory.
	char findString[1024];
	char armFileName[1024];
	if (file[0] == '\0')
	{
		sprintf(findString, "%s*.ini", tglPath);
	}
	else
	{
		strcpy(findString, tglPath);
		strcat(findString, file);
	}
	int32_t count = 0;
	WIN32_FIND_DATA findResult;
	HANDLE searchHandle = FindFirstFile(findString, &findResult);
	do
	{
		if ((findResult.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
		{
			//-----------------------------------
			// Search for TGLData
			FullPathFileName iniName;
			iniName.init(tglPath, findResult.cFileName, "");
			FitIniFile iniFile;
			int32_t result = iniFile.open(iniName);
			if (result != NO_ERROR)
				return result;
			// ARM
			IProviderAssetPtr iniAsset =
				armProvider->OpenAsset((PSTR)iniName, AssetType_Physical, ProviderType_Primary);
			iniAsset->AddProperty("Type", "Object Definition");
			iniAsset->AddProperty("Version", "1.0");
			TG_TypeMultiShape* shape = nullptr;
			result					 = iniFile.seekBlock("TGLData");
			if (result == NO_ERROR)
			{
				char fileName[1024];
				result = iniFile.readIdString("FileName", fileName, 1023);
				if (result != NO_ERROR)
				{
					//---------------------------------------------
					// We have LODs -- handle differently
					// We will get animation from LAST LOD loaded
					int32_t i = 0;
					char fileCheck[1024];
					sprintf(fileCheck, "FileName%d", i);
					result = iniFile.readIdString(fileCheck, fileName, 1023);
					while (result == NO_ERROR)
					{
						if (shape)
						{
							delete shape;
							shape = nullptr;
						}
						char aseName[1024];
						sprintf(aseName, "%s%s%s", tglPath, fileName, ".ase");
						//---------------------------------------------------------------------------------------------
						// Load Base Shape or LOD 0 Shape.
						shape = new TG_TypeMultiShape;
						gosASSERT(shape != nullptr);
						printf("Processing Main Shape %s\n", aseName);
						char lodID[4];
						sprintf(lodID, "%02d", count);
						IProviderRelationshipPtr armLink =
							iniAsset->AddRelationship("LOD Shape", aseName);
						armLink->AddProperty("LOD", lodID);
						shape->LoadTGMultiShapeFromASE(aseName, true, armProvider);
						i++;
						sprintf(fileCheck, "FileName%d", i);
						result = iniFile.readIdString(fileCheck, fileName, 1023);
					}
				}
				char aseName[1024];
				sprintf(aseName, "%s%s%s", tglPath, fileName, ".ase");
				//---------------------------------------------------------------------------------------------
				// Load Base Shape or LOD 0 Shape.
				shape = new TG_TypeMultiShape;
				gosASSERT(shape != nullptr);
				printf("Processing Main Shape %s\n", aseName);
				IProviderRelationshipPtr armLink = iniAsset->AddRelationship("Main Shape", aseName);
				shape->LoadTGMultiShapeFromASE(aseName, true, armProvider);
				//-------------------------------------------
				// Gotta make the special shadow shape now!!
				// MUST use its own shape or animation below
				// will go straight to HELL!!
				result = iniFile.readIdString("ShadowName", fileName, 1023);
				if (result == NO_ERROR)
				{
					char aseName[1024];
					sprintf(aseName, "%s%s%s", tglPath, fileName, ".ase");
					//---------------------------------------------------------------------------------------------
					// Load Base Shape or LOD 0 Shape.
					TG_TypeMultiShapePtr shadowShape = new TG_TypeMultiShape;
					gosASSERT(shadowShape != nullptr);
					printf("Processing Shadow Shape %s\n", aseName);
					IProviderRelationshipPtr armLink =
						iniAsset->AddRelationship("Shadow Shape", aseName);
					shadowShape->LoadTGMultiShapeFromASE(aseName, true, armProvider);
					delete shadowShape;
					shadowShape = nullptr;
				}
				int32_t i = 0;
				char animCheck[1024];
				sprintf(animCheck, "Animation:%d", i);
				result = iniFile.seekBlock(animCheck);
				while (result == NO_ERROR) // This thing has animations. Process them!
				{
					char fileName[1024];
					result = iniFile.readIdString("AnimationName", fileName, 1023);
					if (result == NO_ERROR)
					{
						FullPathFileName aseName;
						aseName.init(tglPath, fileName, ".ase");
						TG_AnimateShape* anim = new TG_AnimateShape;
						gosASSERT(mechAnim != nullptr);
						//-----------------------------------------------
						// Skip this one if its already a binary file.
						// Happens ALOT!
						printf("Processing Animation %s\n", aseName);
						IProviderRelationshipPtr armLink =
							iniAsset->AddRelationship("Animation", (PSTR)aseName);
						anim->LoadTGMultiShapeAnimationFromASE(aseName, shape, true);
						delete anim;
						anim = nullptr;
					}
					i++;
					sprintf(animCheck, "Animation:%d", i);
					result = iniFile.seekBlock(animCheck);
				}
				if (!i) // No Animations, BUT they may mean we are a MECH!!!
				{
					if (iniFile.seekBlock("Gestures0") == NO_ERROR)
					{
						// We ARE a mech. Load all of the animations for this
						// mech and write 'em out.
						for (size_t i = 0; i < MaxGestures; i++)
						{
							char name[MAX_PATH];
							_splitpath(findResult.cFileName, nullptr, nullptr, name, nullptr);
							char mechFileName[1024];
							sprintf(
								mechFileName, "%s%s%s.ase", tglPath, name, MechAnimationNames[i]);
							TG_AnimateShape* anim = new TG_AnimateShape;
							gosASSERT(anim != nullptr);
							//-----------------------------------------------
							// Skip this one if its already a binary file.
							// Happens ALOT!
							printf("Processing Animation %s\n", mechFileName);
							IProviderRelationshipPtr armLink =
								iniAsset->AddRelationship("Animation", mechFileName);
							anim->LoadTGMultiShapeAnimationFromASE(mechFileName, shape, true);
							delete anim;
							anim = nullptr;
						}
					}
				}
				if (!i) // No Animations, BUT they may mean we are a MECH!!!
				{
					if (iniFile.seekBlock("Gestures0") == NO_ERROR)
					{
						// We ARE a mech. Load all of the destroyed shapes for
						// this mech and write 'em out.
						for (size_t i = MaxGestures; i < MaxGestures + 2; i++)
						{
							char name[MAX_PATH];
							_splitpath(findResult.cFileName, nullptr, nullptr, name, nullptr);
							char mechFileName[1024];
							sprintf(
								mechFileName, "%s%s%s.ase", tglPath, name, MechAnimationNames[i]);
							//-----------------------------------------------
							shape = new TG_TypeMultiShape;
							gosASSERT(shape != nullptr);
							printf("Processing Animation %s\n", mechFileName);
							IProviderRelationshipPtr armLink =
								iniAsset->AddRelationship("Destroyed Shape", mechFileName);
							shape->LoadTGMultiShapeFromASE(mechFileName, true, armProvider);
							delete shape;
							shape = nullptr;
						}
					}
				}
				if (iniFile.seekBlock("TGLDamage") == NO_ERROR)
				{
					char fileName[1024];
					result = iniFile.readIdString("FileName", fileName, 1023);
					if (result == NO_ERROR)
					{
						if (shape)
						{
							delete shape;
							shape = nullptr;
						}
						char aseName[1024];
						sprintf(aseName, "%s%s%s", tglPath, fileName, ".ase");
						//---------------------------------------------------------------------------------------------
						// Load Base Shape or LOD 0 Shape.
						shape = new TG_TypeMultiShape;
						gosASSERT(shape != nullptr);
						printf("Processing Damage Shape %s\n", aseName);
						IProviderRelationshipPtr armLink =
							iniAsset->AddRelationship("Damage Shape", aseName);
						shape->LoadTGMultiShapeFromASE(aseName, true, armProvider);
					}
					//-------------------------------------------
					// Gotta make the special shadow shape now!!
					// MUST use its own shape or animation below
					// will go straight to HELL!!
					result = iniFile.readIdString("ShadowName", fileName, 1023);
					if (result == NO_ERROR)
					{
						char aseName[1024];
						sprintf(aseName, "%s%s%s", tglPath, fileName, ".ase");
						//---------------------------------------------------------------------------------------------
						// Load Base Shape or LOD 0 Shape.
						TG_TypeMultiShapePtr shadowShape = new TG_TypeMultiShape;
						gosASSERT(shadowShape != nullptr);
						printf("Processing Damage Shadow Shape %s\n", aseName);
						IProviderRelationshipPtr armLink =
							iniAsset->AddRelationship("Damage Shadow Shape", aseName);
						shadowShape->LoadTGMultiShapeFromASE(aseName, true, armProvider);
						delete shadowShape;
						shadowShape = nullptr;
					}
				}
			}
			delete shape;
			shape = nullptr;
			iniAsset->Close();
		}
	} while (FindNextFile(searchHandle, &findResult) != 0);
	FindClose(searchHandle);
	return 0;
}
예제 #24
0
//---------------------------------------------------------------------------
long SoundSystem::init (char *soundFileName)
{
	if (useSound)
	{
		FullPathFileName soundName;
		soundName.init(soundPath,soundFileName,".snd");
		
		FitIniFile soundFile;
		long result = soundFile.open(soundName);
		gosASSERT(result == NO_ERR);

		result = soundFile.seekBlock("SoundSetup");
		gosASSERT(result == NO_ERR);

		result = soundFile.readIdULong("soundHeapSize",soundHeapSize);
		gosASSERT(result == NO_ERR);
		
		result = soundFile.readIdFloat("MaxSoundDistance",maxSoundDistance);
		gosASSERT(result == NO_ERR);

		soundHeap = new UserHeap;
		gosASSERT(soundHeap != NULL);

		result = soundHeap->init(soundHeapSize,"SOUND");
		gosASSERT(result == NO_ERR);

		//-----------------------------------------------------------------------
		// Startup the Sound packet File with the sound Blocks in it.
		// This works by sound ID.  The sound ID is the packet number.
		// When ordered to play a sample, the sound system check to see if that
		// sound ID is in the cache.  If not, it is loaded.  If there is no more
		// room, any idle sounds are flushed in order of priority.
		soundDataFile = new PacketFile;
		gosASSERT(soundDataFile != NULL);
		
		FullPathFileName soundDataPath;
		soundDataPath.init(CDsoundPath,soundFileName,".pak");
		
		result = soundDataFile->open(soundDataPath);
		gosASSERT(result == NO_ERR);
		
		bettyDataFile = new PacketFile;
		gosASSERT(bettyDataFile != NULL);
		
		FullPathFileName bettyDataPath;
		bettyDataPath.init(CDsoundPath,"Betty",".pak");
		
		result = bettyDataFile->open(bettyDataPath);
		gosASSERT(result == NO_ERR);

		numBettySamples = bettyDataFile->getNumPackets();
		
		supportDataFile = new PacketFile;
		gosASSERT(supportDataFile != NULL);
		
		FullPathFileName supportDataPath;
		supportDataPath.init(CDsoundPath,"support",".pak");
		
		result = supportDataFile->open(supportDataPath);
		gosASSERT(result == NO_ERR);

		numSupportSamples = supportDataFile->getNumPackets();
 		//-----------------------------------------------------------------------
		// Load all of the sound Bite data.  Do not load actual packet unless
		// preload field is TRUE.
		result = soundFile.seekBlock("SoundBites");
		gosASSERT(result == NO_ERR);

		result = soundFile.readIdULong("numBites",numSoundBites);
		gosASSERT(result == NO_ERR);

		//-----------------------------------------------------------------------
		// Preallocate SoundBites
		sounds = (SoundBite *)soundHeap->Malloc(sizeof(SoundBite) * numSoundBites);
		gosASSERT(sounds != NULL);
		memset(sounds,0,sizeof(SoundBite) * numSoundBites);
		
		for (long i=0;i<(long)numSoundBites;i++)
		{
			char biteBlock[20];
			sprintf(biteBlock,"SoundBite%d",i);
			
			result = soundFile.seekBlock(biteBlock);
			gosASSERT(result == NO_ERR);
			
			result = soundFile.readIdULong("priority",sounds[i].priority);
			gosASSERT(result == NO_ERR);
			
			result = soundFile.readIdULong("cache",sounds[i].cacheStatus);
			gosASSERT(result == NO_ERR);
			
			result = soundFile.readIdULong("soundId",sounds[i].soundId);
			gosASSERT(result == NO_ERR);
			
			preloadSoundBite(i);		//ALWAYS Preload!!!!!!!!!!!!!

			result = soundFile.readIdFloat("volume",sounds[i].volume);
			gosASSERT(result == NO_ERR);
		}		

		//---------------------------------------------------------------
		// Load the digital Music Data Strings
		result = soundFile.seekBlock("DigitalMusic");
		gosASSERT(result == NO_ERR);
			
		result = soundFile.readIdLong("NumDMS",numDMS);
		gosASSERT(result == NO_ERR);

		result = soundFile.readIdFloat("StreamFadeDownTime",streamFadeDownTime);
		gosASSERT(result == NO_ERR);

		result = soundFile.readIdULong("StreamBitDepth",digitalStreamBitDepth);
		gosASSERT(result == NO_ERR);
			
		result = soundFile.readIdULong("StreamChannels",digitalStreamChannels);
		gosASSERT(result == NO_ERR);

		digitalMusicIds = (char **)soundHeap->Malloc(sizeof(char *) * numDMS);
		gosASSERT(digitalMusicIds != NULL);
			
		digitalMusicLoopFlags = (bool *)soundHeap->Malloc(sizeof(bool)*numDMS);
		gosASSERT(digitalMusicLoopFlags != NULL);

		digitalMusicVolume = (float *)soundHeap->Malloc(sizeof(float) * numDMS);
			
		for (i=0;i<numDMS;i++)
		{
			char digitalMSId[20];
			sprintf(digitalMSId,"DMS%d",i);
			
			char digitalMSBId[20];
			sprintf(digitalMSBId,"DMSLoop%d",i);

			char digitalMSVId[25];
			sprintf(digitalMSVId,"DMSVolume%d",i);
			
			digitalMusicIds[i] = (char *)soundHeap->Malloc(30);
			result = soundFile.readIdString(digitalMSId,digitalMusicIds[i],29);
			gosASSERT(result == NO_ERR);
			
			result = soundFile.readIdBoolean(digitalMSBId,digitalMusicLoopFlags[i]);
			gosASSERT(result == NO_ERR);

			result = soundFile.readIdFloat(digitalMSVId,digitalMusicVolume[i]);
			if (result != NO_ERR)
				digitalMusicVolume[i] = 1.0f;
		}	
		
		soundFile.close();
		
		for (i=0;i<MAX_DIGITAL_SAMPLES+4;i++)
		{
			gosAudio_AllocateChannelSliders(i,gosAudio_Volume | gosAudio_Panning);
		}
	}
	
	digitalMasterVolume = float(DigitalMasterVolume) / 256.0f;
	SFXVolume = float(sfxVolume) / 256.0f;
	musicVolume = float(MusicVolume) / 256.0f;
	radioVolume = float(RadioVolume) / 256.0f;
	bettyVolume = float(BettyVolume) / 256.0f;

	stream1Id = stream2Id = 0;

	return(NO_ERR);
}
예제 #25
0
int MechLabScreen::init( FitIniFile& file )
{
	if ( saveDlg )// already initialized
		return -1;

	ComponentListItem::init( file );

	LogisticsScreen::init( file, "Static", "Text", "Rect", "Button" );

	componentListBox.init( rects[2].left(), rects[2].top(),
							rects[2].width(), rects[2].height() );

	componentListBox.setHighlightFX( -1 ); // want to do this by hand.
	
	saveDlg = new LogisticsVariantDialog;
	acceptDlg = new LogisticsAcceptVariantDialog;

	FitIniFile saveFile;
	FullPathFileName path;
	path.init( artPath, "MCL_SV", ".fit" );

	if ( NO_ERR != saveFile.open( path ) )
	{
		Assert( 0, 0, "couldn't open MCL_SV.fit" );
		return -1;
	}

	saveDlg->init( saveFile );
	saveFile.close();

	path.init( artPath, "mcl_sv_acceptchanges", ".fit" );

	if ( NO_ERR != saveFile.open( path ) )
	{
		Assert( 0, 0, "couldn't open MCL_SV.fit" );
		return -1;
	}

	acceptDlg->init( saveFile );


	payloadIcon.init( &file, "PayloadUnit" );	  

	char blockName[64];
	for ( int i = 0; i < MECH_LAB_ATTRIBUTE_METER_COUNT; i++ )
	{
		sprintf( blockName, "AttributeMeter%ld", i );
		attributeMeters[i].init( &file, blockName );
	}

	for ( i= 0; i < buttonCount; i++ )
	{
		switch( buttons[i].getID() )
		{
			case	COMPONENT_FORM_WEAPON_ENERGY:
			case	COMPONENT_FORM_WEAPON_BALLISTIC:
			case	COMPONENT_FORM_WEAPON_MISSILE:
			case	COMPONENT_FORM_JUMPJET:
				break;

			default:
				{
				buttons[i].setMessageOnRelease();
				buttons[i].setPressFX(LOG_CLICKONBUTTON );
				}

				
		}	
	}

	file.seekBlock( "ComboBox0" );
	long xLoc, yLoc;
	file.readIdLong( "XLocation", xLoc );
	file.readIdLong( "YLocation", yLoc );
	char fileName[256];
	file.readIdString( "FileName", fileName, 255 );

	path.init( artPath, fileName, ".fit" );

	FitIniFile comboFile;

	if ( NO_ERR != comboFile.open( path ) )
	{
		char errorStr[255];
		sprintf( errorStr, "couldn't open file %s", (char*)path );
		Assert( 0, 0, errorStr );
	}


	variantList.init( &comboFile, "VariantComboBox" );
	variantList.setReadOnly( true );
	variantList.ListBox().setOrange(true);
	variantList.setParent( this );
	variantList.setHelpID( IDS_HELP_MC_VARIANT_DROP_DOWN_LIST_BOX );

	camera.init( rects[4].left(), rects[4].top(), rects[4].right(), rects[4].bottom() );

	getButton( COMPONENT_FORM_WEAPON_ENERGY )->setPressFX( LOG_VIDEOBUTTONS );
	getButton( COMPONENT_FORM_WEAPON_BALLISTIC )->setPressFX( LOG_VIDEOBUTTONS );
	getButton( COMPONENT_FORM_WEAPON_MISSILE )->setPressFX( LOG_VIDEOBUTTONS );
	getButton( COMPONENT_FORM_JUMPJET )->setPressFX( LOG_VIDEOBUTTONS );

	getButton( COMPONENT_FORM_WEAPON_ENERGY )->setHighlightFX( LOG_DIGITALHIGHLIGHT );
	getButton( COMPONENT_FORM_WEAPON_BALLISTIC )->setHighlightFX( LOG_DIGITALHIGHLIGHT );
	getButton( COMPONENT_FORM_WEAPON_MISSILE )->setHighlightFX( LOG_DIGITALHIGHLIGHT );
	getButton( COMPONENT_FORM_JUMPJET )->setHighlightFX( LOG_DIGITALHIGHLIGHT );


	
	// initialize the selection rectangles
	for ( i = 0; i < 5; i++ )
	{
		for ( int j = 0; j < 2; j++ )
		{
			sprintf( fileName, "mcl_mc_%ldby%ld_selection.tga", j+1, i+1 );
			path.init( artPath, fileName, ".tga" );

			if ( fileExists( path ) )
			{
				selRects[j][i].setTexture( path );
				selRects[j][i].resize( (j+1) * LogisticsComponent::XICON_FACTOR, (i+1) * LogisticsComponent::YICON_FACTOR );
				// now need to set the UV's
				selRects[j][i].setUVs( 0, 0, selRects[j][i].width(), selRects[j][i].height()  );
			}

		}
	}

	path.init( artPath, "mcl_mc_jumpjets_selection", ".tga" );
	selJumpJetRect.setTexture( path );
	selJumpJetRect.resize( 2 * LogisticsComponent::XICON_FACTOR, 2 * LogisticsComponent::YICON_FACTOR );
	// now need to set the UV's
	selJumpJetRect.setUVs( 0, 0, selJumpJetRect.width(), selJumpJetRect.height()  );

	return true;
}