C++ idDict::GetString方法代码示例

void CStimResponseCollection::CreateTimer(const idDict& args, const CStimPtr& stim, int index)
{
	CStimResponseTimer* timer = stim->GetTimer();

	timer->m_Reload = args.GetInt(va("sr_timer_reload_%u", index) , "-1");

	idStr str = args.GetString(va("sr_timer_type_%u", index), "");

	timer->m_Type = (str == "RELOAD") ? CStimResponseTimer::SRTT_RELOAD : CStimResponseTimer::SRTT_SINGLESHOT;
	
	args.GetString(va("sr_timer_time_%u", index), "0:0:0:0", str);

    TimerValue val = CStimResponseTimer::ParseTimeString(str);
	
	// if timer is actually set
	if (val.Time.Hour || val.Time.Minute || val.Time.Second || val.Time.Millisecond)
	{
		// TODO: Return a bool here so that the outer function knows not to add this to m_Stim in the collection?

		stim->AddTimerToGame();
		timer->SetTimer(val.Time.Hour, val.Time.Minute, val.Time.Second, val.Time.Millisecond);
		
		// timer starts on map startup by default, otherwise wait for start
		if (!args.GetBool(va("sr_timer_waitforstart_%u", index), "0"))
		{
			timer->Start(static_cast<unsigned long>(sys->GetClockTicks()));
		}
	}
}

void Setting::ParseFromDict(const idDict& dict, int level, int index)
{
	isValid = true; // in dubio pro reo

	// Get the classname, target spawnarg and argument
	className = dict.GetString(va(PATTERN_CLASS, level, index));
	spawnArg = dict.GetString(va(PATTERN_CHANGE, level, index));
	argument = dict.GetString(va(PATTERN_ARG, level, index));

	// Parse the application type
	appType = EAssign;

	if (!argument.IsEmpty())
	{
		// Check for ignore argument
		if (argument == APPTYPE_IGNORE)
		{
			appType = EIgnore;
			argument.Empty(); // clear the argument
		}
		else if (argument.Find(' ') != -1)
		{
			// greebo: We have a space in the argument, hence it cannot be 
			// a mathematical operation. This usually applies to vector arguments
			// like '-205 10 20', which can contain a leading minus sign.
		}
		// Check for special modifiers
		else if (argument[0] == '+')
		{
			appType = EAdd;
			// Remove the first character
			argument = idStr(argument, 1, argument.Length());
		}
		else if (argument[0] == '*')
		{
			appType = EMultiply;
			// Remove the first character
			argument = idStr(argument, 1, argument.Length());
		}
		else if (argument[0] == '-')
		{
			appType = EAdd;
			// Leave the "-" sign, it will be the sign of the parsed int
		}
	}

	if (spawnArg.IsEmpty())
	{
		// Spawnarg must not be empty
		isValid = false;
	}

	// classname can be empty (this is valid for entity-specific difficulties)
}

END_CLASS

/*
================
sdVehicleJointAimer::Setup
================
*/
bool sdVehicleJointAimer::Setup( sdTransport* _vehicle, const angleClamp_t& yaw, const angleClamp_t& pitch, const idDict& ikParms ) {
	joint = INVALID_JOINT;

	if ( !sdVehicleIKSystem::Setup( _vehicle, yaw, pitch, ikParms ) ) {
		return false;
	}

	yawSound = NULL;
	if ( clampYaw.sound != NULL ) {
		yawSound = vehicle->GetMotorSounds().Alloc();
		yawSound->Start( clampYaw.sound );
	}

	pitchSound = NULL;
	if ( clampPitch.sound != NULL ) {
		pitchSound = vehicle->GetMotorSounds().Alloc();
		pitchSound->Start( clampPitch.sound );
	}

	idAnimator* animator = vehicle->GetAnimator();
	joint = animator->GetJointHandle( ikParms.GetString( "joint" ) );

	if ( joint == INVALID_JOINT ) {
		return false;
	}

	animator->GetJointTransform( joint, gameLocal.time, baseAxis );
	angles = baseAxis.ToAngles();

	const char* weapon2Name = ikParms.GetString( "weapon2" );
	if ( *weapon2Name ) {
		weapon2 = _vehicle->GetWeapon( weapon2Name );
		if ( !weapon2 ) {
			gameLocal.Warning( "sdVehicleIKSystem::Setup Invalid Weapon '%s'", weapon2Name );
			return false;
		}
	} else {
		weapon2 = NULL;
	}

	return true;
}

DifficultySettings::InheritanceChain DifficultySettings::GetInheritanceChain(const idDict& dict)
{
	std::string className = dict.GetString("classname");

	// stgatilov: Look the class name up in the chains cache
	InheritanceChainsMap::iterator it = _inheritanceChains.find(className);
	if (it != _inheritanceChains.end())
		return it->second;

	InheritanceChain inheritanceChain;

	// Add the classname itself to the end of the list
	inheritanceChain.push_back(className);

	// greebo: Extract the inherit value from the raw declaration text, 
	// as the "inherit" key has been removed in the given "dict"
	for (std::string inherit = GetInheritValue(className); 
		!inherit.empty();
		inherit = GetInheritValue(inherit))
	{
		// Has parent, add to list
		inheritanceChain.push_back(inherit);
	}

	// stgatilov: reverse the chain so that parents go first
	std::reverse(inheritanceChain.begin(), inheritanceChain.end());

	// stgatilov: save the chain in cache
	_inheritanceChains[className] = inheritanceChain;

	return inheritanceChain;
}

void DifficultySettings::ApplySettings(idDict& target)
{
	std::string eclass = target.GetString("classname");

	if (eclass.empty()) {
		return; // no classname, no rules
	}

	// greebo: First, get the list of entity-specific difficulty settings from the dictionary
	// Everything processed here will be ignored in the second run (where the default settings are applied)
	idList<Setting> entSettings = Setting::ParseSettingsFromDict(target, _level);
	DM_LOG(LC_DIFFICULTY, LT_DEBUG)LOGSTRING("Found %d difficulty settings on the entity %s.\r", entSettings.Num(), target.GetString("name"));

	// Apply the settings one by one
	for (int i = 0; i < entSettings.Num(); i++)
	{
		DM_LOG(LC_DIFFICULTY, LT_DEBUG)LOGSTRING("Applying entity-specific setting: %s => %s.\r", entSettings[i].spawnArg.c_str(), entSettings[i].argument.c_str());
		entSettings[i].Apply(target);
	}

	// Second step: apply global settings

	// Get the inheritancechain for the given target dict
	const InheritanceChain &inheritanceChain = GetInheritanceChain(target);

	// Go through the inheritance chain front to back and apply the settings
	for (InheritanceChain::const_iterator c = inheritanceChain.begin(); c != inheritanceChain.end(); ++c)
	{
		std::string className = *c;

		// Process the list of default settings that apply to this entity class,
		// but ignore all keys that have been addressed by the entity-specific settings.
		for (SettingsMap::iterator i = _settings.find(className);
			 i != _settings.upper_bound(className) && i != _settings.end();
			 ++i)
		{
			Setting& setting = i->second;
			bool settingApplicable = true;

			// Check if the spawnarg has been processed in the entity-specific settings
			for (int k = 0; k < entSettings.Num(); k++)
			{
				if (entSettings[k].spawnArg == setting.spawnArg)
				{
					// This target spawnarg has already been processed in the first run, skip it
					DM_LOG(LC_DIFFICULTY, LT_DEBUG)LOGSTRING("Ignoring global setting: %s => %s.\r", setting.spawnArg.c_str(), setting.argument.c_str());
					settingApplicable = false;
					break;
				}
			}

			if (settingApplicable)
			{
				// We have green light, apply the setting
				DM_LOG(LC_DIFFICULTY, LT_DEBUG)LOGSTRING("Applying global setting: %s => %s.\r", setting.spawnArg.c_str(), setting.argument.c_str());
				setting.Apply(target);
			}
		}
	}
}

void CStimResponseCollection::InitFromSpawnargs(const idDict& args, idEntity* owner)
{
	if (owner == NULL)
	{
		DM_LOG(LC_STIM_RESPONSE, LT_ERROR)LOGSTRING("Owner set to NULL is not allowed!\r");
		return;
	}

	idStr name;

	for (int i = 1; /* in-loop break */; ++i)
	{
		idStr name = va("sr_class_%u", i);
		DM_LOG(LC_STIM_RESPONSE, LT_DEBUG)LOGSTRING("Looking for %s\r", name.c_str());

		idStr str;
		if (!args.GetString(name, "X", str))
		{
			break;
		}

		char sr_class = str[0];

		if (ParseSpawnArg(args, owner, sr_class, i) == false)
		{
			break;
		}
	}
}

void CInventoryItem::ParseSpawnargs(const idDict& spawnArgs)
{
	m_Persistent = spawnArgs.GetBool("inv_persistent", "0");
	m_LightgemModifier = spawnArgs.GetInt("inv_lgmodifier", "0");
	m_MovementModifier = spawnArgs.GetFloat("inv_movement_modifier", "1");
	m_FrobDistanceCap = spawnArgs.GetFloat("inv_frob_distance_cap", "-1");
	m_Icon = spawnArgs.GetString("inv_icon", "");
}

/*
================
sdRequirementCheck_Ability::Check
================
*/
void sdRequirementCheck_Ability::Init( const idDict& parms ) {
	const char* abilityValue = parms.GetString( "value" );
	if ( !*abilityValue ) {
		gameLocal.Error( "sdRequirementCheck_Ability::Init No 'value' key specified" );
	}

	abilityHandle = sdRequirementManager::GetInstance().RegisterAbility( abilityValue );
}

/*
============
sdGameRulesStopWatch::UpdateClientFromServerInfo
============
*/
void sdGameRulesStopWatch::UpdateClientFromServerInfo( const idDict& serverInfo, bool allowMedia ) {
	sdGameRules::UpdateClientFromServerInfo( serverInfo, allowMedia );

	idStr mapName = serverInfo.GetString( "si_map" );
	if( mapName.IsEmpty() ) {
		return;
	}
	mapName.StripFileExtension();

	using namespace sdProperties;

	// update status
	if ( sdUserInterfaceScope* scope = gameLocal.globalProperties.GetSubScope( "campaignInfo" ) ) {
		const idDict* metaData = gameLocal.mapMetaDataList->FindMetaData( mapName, &gameLocal.defaultMetaData );
		
		if( allowMedia ) {
			const sdDeclMapInfo* mapInfo = gameLocal.declMapInfoType.LocalFind( metaData->GetString( "mapinfo", "_default" ) );
			// setup the backdrop
			if ( sdProperty* property = scope->GetProperty( "backdrop", PT_STRING ) ) {
				*property->value.stringValue = mapInfo->GetData().GetString( "mtr_backdrop", "guis/assets/black" );
			}

			const char* status = "current";
			if( winningTeam != NULL ) {
				status = winningTeam->GetLookupName();
			}

			SetupLoadScreenUI( *scope, status, true, 1, *metaData, mapInfo );
		}

		// setup the name
		if ( sdProperty* property = scope->GetProperty( "name", PT_WSTRING ) ) {
			*property->value.wstringValue = va( L"%hs", metaData->GetString( "pretty_name" ) );
		}	

		if ( sdProperty* property = scope->GetProperty( "numMaps", PT_FLOAT ) ) {
			*property->value.floatValue = 1.0f;
		}

		if ( sdProperty* property = scope->GetProperty( "currentMap", PT_FLOAT ) ) {
			*property->value.floatValue = 1.0f;
		}

		idWStr text;
		if( timeToBeat > 0 ) {
			idWStr::hmsFormat_t format;
			format.showZeroMinutes = true;
			idWStrList args( 1 );

			args.Append( idWStr::MS2HMS( timeToBeat, format ) );
			text = common->LocalizeText( "guis/mainmenu/timetobeat", args );
		}
		// setup the status
		if ( sdProperty* property = scope->GetProperty( "ruleStatus", PT_WSTRING ) ) {
			*property->value.wstringValue = text;
		}	
	}
}

/*
================
sdVehiclePosition::LoadData
================
*/
void sdVehiclePosition::LoadData( const idDict& dict ) {
	requirements.Load( dict, "require" );

	const char* tipName = dict.GetString( "tt_blocked" );
	if ( *tipName ) {
		blockedTip = gameLocal.declToolTipType[ tipName ];
	}

	maxViewOffset	= dict.GetFloat( "max_view_offset", "0.f" );
	viewOffsetRate	= dict.GetFloat( "view_offset_rate", "0.f" );
	if ( maxViewOffset ) {
		viewOffsetRate /= maxViewOffset;
	}

	const char* attachJointName = dict.GetString( "joint_attach" );
	if ( !*attachJointName ) {
		attachJointName = "origin";
	}

	attachAnim				= dict.GetString( "player_anim", "VehicleDefault" );
	showPlayer				= dict.GetBool( "show_player" );
	minZfrac				= dict.GetFloat( "min_z_frac", "-2.f" );
	ejectOnKilled			= dict.GetBool( "use_fallback" );
	takesDamage				= dict.GetBool( "take_damage" );
	playerHeight			= dict.GetFloat( "player_height" );
	allowWeapon				= dict.GetBool( "allow_weapon" );
	allowAdjustBodyAngles	= dict.GetBool( "adjust_body_angles" );
	resetViewOnEnter		= dict.GetBool( "reset_view_on_enter", "1" );
	damageScale				= dict.GetFloat( "damage_scale", "1" );
	playerStance			= dict.GetBool( "player_stance_crouch" ) ? PS_CROUCH : PS_NORMAL;

	const char* iconJointName = dict.GetString( "joint_icon" );
	if ( *iconJointName != '\0' ) {
		iconJoint = transport->GetAnimator()->GetJointHandle( iconJointName );
	} else {
		iconJoint = INVALID_JOINT;
	}

	const idKeyValue* kv = NULL;
	while ( kv = dict.MatchPrefix( "ability", kv ) ) {
		abilities.Add( kv->GetValue() );
	}

	attachJoint				= transport->GetAnimator()->GetJointHandle( attachJointName );
	if ( attachJoint == INVALID_JOINT ) {
		gameLocal.Warning( "sdVehiclePosition::LoadData  Joint \"%s\" does not exist in vscript %s", attachJointName, transport->GetVehicleScript()->GetName() );
	}

	cockpitName = dict.GetString( "cockpit", "" );

	const char* statName = dict.GetString( "stat_name" );
	if ( *statName ) {
		sdStatsTracker& tracker = sdGlobalStatsTracker::GetInstance();

		statTimeSpent = tracker.GetStat( tracker.AllocStat( va( "%s_time_spent", statName ), sdNetStatKeyValue::SVT_INT ) );
	} else {
		gameLocal.Warning( "Missing Stat Name on '%s'", name.c_str() );
	}
}

//
// Set()
//
void hhReactionDesc::Set(const idDict &keys) {
	
	cause				= StrToCause(keys.GetString("cause"));
	effect				= StrToEffect(keys.GetString("effect"));

	flags				= 0;
	effectRadius		= keys.GetFloat("effect_radius","-1.0f");
	effectMinRadius		= keys.GetFloat("effect_min_radius","0.0f");

	if(keys.GetBool("snap_to_point")) {
		flags |= flag_SnapToPoint;
	}
	if(keys.GetBool("effect_all_players")) {
		flags |= flag_EffectAllPlayers;
	}
	if(keys.GetBool("effect_all_monsters")) {
		flags |= flag_EffectAllMonsters;
	}
	if(keys.GetBool("req_novehicle")) {
		flags |= flagReq_NoVehicle;
	}
	if(keys.GetBool("exclusive")) {
		flags |= flag_Exclusive;
	}
	if(keys.GetBool("effect_listener")) {
		flags |= flag_EffectListener;
	}
	
	if(keys.GetBool("anim_face_cause_dir")) {
		flags |= flag_AnimFaceCauseDir;
	}
	if(keys.GetBool("anim_trigger_cause")) {
		flags |= flag_AnimTriggerCause;
	}
		

	idStr keyString("");
	if(keys.GetString("req_key", "", keyString)) {
		if(keyString.Length() > 1) {
			flags |= flagReq_KeyValue;
			int firstSpace = keyString.Find(' ');
			if( firstSpace >= 0 ) {				
				key		= keyString.Left( firstSpace);		
				keyVal	= keyString.Right( keyString.Length() - firstSpace -1);
			}		
		}
		else
			gameLocal.Error("Invalide key for 'reaction_req_ley' value: %s", (const char*)keyString);
	}
//MDC begin
	keyString.Empty();
	if( keys.GetString( "finish_key", "", keyString)) {
		if( keyString.Length() > 1 ) {
			int firstSpace = keyString.Find(' ');
			if( firstSpace >= 0 ) {
				finish_key = keyString.Left( firstSpace );
				finish_val = keyString.Right( keyString.Length() - firstSpace - 1 );
			}
		}
	}
//MDC end

	idStr animString("");
	if(keys.GetString("req_anim", "", animString)) {
		flags |= flagReq_Anim;
		anim = animString;
	}

	if(keys.GetBool("req_rangeattack")) {
		flags |= flagReq_RangeAttack;
	}
	if(keys.GetBool("req_meleeattack")) {
		flags |= flagReq_MeleeAttack;
	}
	if(keys.GetBool("req_can_see")) {
		flags |= flagReq_CanSee;
	}

	if(keys.GetBool("req_telepathic") || cause == hhReactionDesc::Cause_Telepathic_Throw || cause == hhReactionDesc::Cause_Telepathic_Trigger) {
		flags |= flagReq_Telepathic;
	}

	
	// Effect volumes
	effectVolumes.Clear();
	const idKeyValue *kv = keys.MatchPrefix("effect_volume", NULL);
	while(kv) {
		idStr effectVolName = kv->GetValue();
		if(effectVolName.Length() > 0) {
			idEntity *e = gameLocal.FindEntity(effectVolName.c_str());
			if(!e) {
				gameLocal.Error("Failed to find effect_volume named %s", effectVolName.c_str());
			}
			if(!e->IsType(hhReactionVolume::Type)) {
				gameLocal.Error("effect_volume named %s was of incorrect spawn type. Must be hhReactionVolume", effectVolName.c_str());
			}

//.........这里部分代码省略.........

bool CStimResponseCollection::ParseSpawnArg( const idDict &args, idEntity *owner, const char sr_class, int index ) {
	bool rc = false;
	idStr str;
	CStimPtr stim;
	CResponsePtr resp;
	CStimResponsePtr sr;
	StimState state( SS_DISABLED );
	StimType typeOfStim;
	// Check if the entity contains either a stim or a response.
	if( sr_class != 'S' && sr_class != 'R' ) {
		DM_LOG( LC_STIM_RESPONSE, LT_ERROR )LOGSTRING( "Invalid sr_class value [%s]\r", str.c_str() );
		goto Quit;
	}
	// Get the id of the stim/response type so we know what sub-class to create
	args.GetString( va( "sr_type_%u", index ), "-1", str );
	// This is invalid as an entity definition
	if( str == "-1" ) {
		sr.reset();
		goto Quit;
	}
	// If the first character is alphanumeric, we check if it
	// is a known id and convert it.
	/* StimType */ typeOfStim = ST_DEFAULT;
	if( ( str[0] >= 'a' && str[0] <= 'z' )
			|| ( str[0] >= 'A' && str[0] <= 'Z' ) ) {
		// Try to recognise the string as known Stim type
		typeOfStim = CStimResponse::GetStimType( str );
		// If the string hasn't been found, we have id == ST_DEFAULT.
		if( typeOfStim == ST_DEFAULT ) {
			DM_LOG( LC_STIM_RESPONSE, LT_ERROR )LOGSTRING( "Invalid sr_type id [%s]\r", str.c_str() );
			sr.reset();
			goto Quit;
		}
	} else if( str[0] >= '0' && str[0] <= '9' ) { // Is it numeric?
		typeOfStim = ( StimType ) atol( str.c_str() );
	} else {	// neither a character nor a number, thus it is invalid.
		DM_LOG( LC_STIM_RESPONSE, LT_ERROR )LOGSTRING( "Invalid sr_type id [%s]\r", str.c_str() );
		sr.reset();
		goto Quit;
	}
	if( sr_class == 'S' ) {
		stim = CreateStim( owner, typeOfStim );
		if( stim == NULL ) { // grayman #2862
			goto Quit; // nasty goto!!
		}
		sr = stim;
	} else if( sr_class == 'R' ) {
		resp = CreateResponse( owner, typeOfStim );
		sr = resp;
	}
	// Set stim response type
	sr->m_StimTypeId = typeOfStim;
	// Set stim response name string
	sr->m_StimTypeName = str;
	// Read stim response state from the def file
	state = static_cast<StimState>( args.GetInt( va( "sr_state_%u", index ), "1" ) );
	sr->SetEnabled( state == SS_ENABLED );
	sr->m_Chance = args.GetFloat( va( "sr_chance_%u", index ), "1.0" );
	// A stim also may have a radius
	if( sr_class == 'S' ) {
		stim->m_Radius = args.GetFloat( va( "sr_radius_%u", index ), "0" );
		stim->m_RadiusFinal = args.GetFloat( va( "sr_radius_final_%u", index ), "-1" );
		stim->m_FallOffExponent = args.GetInt( va( "sr_falloffexponent_%u", index ), "0" );
		stim->m_bUseEntBounds = args.GetBool( va( "sr_use_bounds_%u", index ), "0" );
		stim->m_bCollisionBased = args.GetBool( va( "sr_collision_%u", index ), "0" );
		stim->m_Velocity = args.GetVector( va( "sr_velocity_%u", index ), "0 0 0" );
		stim->m_Bounds[0] = args.GetVector( va( "sr_bounds_mins_%u", index ), "0 0 0" );
		stim->m_Bounds[1] = args.GetVector( va( "sr_bounds_maxs_%u", index ), "0 0 0" );
		// set up time interleaving so the stim isn't fired every frame
		stim->m_TimeInterleave = args.GetInt( va( "sr_time_interval_%u", index ), "0" );
		// greebo: Add fuzzyness to the timer (ranging from 0.9 - 1.3);
		stim->m_TimeInterleave = static_cast<int>( stim->m_TimeInterleave * ( 0.9f + gameLocal.random.RandomFloat() * 0.4f ) );
		// userfriendly stim duration time
		stim->m_Duration = args.GetInt( va( "sr_duration_%u", index ), "0" );
		stim->m_Magnitude = args.GetFloat( va( "sr_magnitude_%u", index ), "1.0" );
		stim->m_MaxFireCount = args.GetInt( va( "sr_max_fire_count_%u", index ), "-1" );
		// Check if we have a timer on this stim.
		CreateTimer( args, stim, index );
	} else {	// this is only for responses
		sr->m_ChanceTimer = args.GetInt( va( "sr_chance_timeout_%u", index ), "-1" );
		resp->m_NumRandomEffects = args.GetInt( va( "sr_random_effects_%u", index ), "0" );
		// Get the name of the script function for processing the response
		args.GetString( "sr_script_" + str, "", str );
		resp->m_ScriptFunction = str;
		// Try to identify the ResponseEffect spawnargs
		int effectIdx = 1;
		while( effectIdx > 0 ) {
			// Try to find a string like "sr_effect_2_1"
			args.GetString( va( "sr_effect_%u_%u", index, effectIdx ), "", str );
			if( str.IsEmpty() ) {
				// Set the index to negative values to end the loop
				effectIdx = -1;
			} else {
				// Assemble the postfix of this effect for later key/value lookup
				// This is passed to the effect script eventually
				DM_LOG( LC_STIM_RESPONSE, LT_DEBUG )LOGSTRING( "Adding response effect\r" );
				resp->AddResponseEffect( str, va( "%u_%u", index, effectIdx ), args );
				effectIdx++;
			}
		}
//.........这里部分代码省略.........

void DifficultyManager::ApplyDifficultySettings(idDict& target)
{
	DM_LOG(LC_DIFFICULTY, LT_INFO)LOGSTRING("Applying difficulty settings to entity: %s.\r", target.GetString("name"));

	_globalSettings[_difficulty].ApplySettings(target);
}

bool DifficultyManager::InhibitEntitySpawn(const idDict& target) {
	bool isAllowed(true);

	// Construct the key ("diff_0_spawn")
	idStr key = va("diff_%d_nospawn", _difficulty);

	// The entity is allowed to spawn by default, must be set to 1 by the mapper
	isAllowed = !target.GetBool(key, "0");

	DM_LOG(LC_DIFFICULTY, LT_INFO)LOGSTRING("Entity %s is allowed to spawn on difficulty %i: %s.\r", target.GetString("name"), _difficulty, isAllowed ? "YES" : "NO");

	// Tels: #3223: See if this entity should spawn this time
	float random_remove = target.GetFloat( "random_remove", "1.1");
	float random_value = gameLocal.random.RandomFloat();
	if (random_remove < random_value)
	{
		isAllowed = false;
		DM_LOG(LC_ENTITY, LT_INFO)LOGSTRING("Removing entity %s due to random_remove %f < %f.\r", target.GetString("name"), random_remove, random_value);
	}

	// Return false if the entity is allowed to spawn
	return !isAllowed;
}

void Conversation::InitFromSpawnArgs( const idDict &dict, int index ) {
	idStr prefix = va( "conv_%d_", index );
	// A non-empty name is mandatory for a conversation
	if( !dict.GetString( prefix + "name", "", _name ) || _name.IsEmpty() ) {
		// No conv_N_name spawnarg found, bail out
		_isValid = false;
		return;
	}
	// Parse "global" conversation settings
	_talkDistance = dict.GetFloat( prefix + "talk_distance", "60" );
	// Parse participant actors
	// Check if this entity can be used by others.
	idStr actorPrefix = prefix + "actor_";
	for( const idKeyValue *kv = dict.MatchPrefix( actorPrefix ); kv != NULL; kv = dict.MatchPrefix( actorPrefix, kv ) ) {
		// Add each actor name to the list
		DM_LOG( LC_CONVERSATION, LT_DEBUG )LOGSTRING( "Adding actor %s to conversation %s.\r", kv->GetValue().c_str(), _name.c_str() );
		_actors.AddUnique( kv->GetValue() );
	}
	DM_LOG( LC_CONVERSATION, LT_DEBUG )LOGSTRING( "Conversation %s has %d actors.\r", _name.c_str(), _actors.Num() );
	if( _actors.Num() == 0 ) {
		_isValid = false; // no actors, no conversation
		gameLocal.Warning( "Ignoring conversation %s as it has no actors.", _name.c_str() );
		return;
	}
	// Start parsing the conversation scripts (i.e. the commands), start with index 1
	for( int i = 1; i < INT_MAX; i++ ) {
		idStr cmdPrefix = va( prefix + "cmd_%d_", i );
		DM_LOG( LC_CONVERSATION, LT_DEBUG )LOGSTRING( "Attempting to find command with index %d matching prefix %s.\r", i, cmdPrefix.c_str() );
		if( dict.MatchPrefix( cmdPrefix ) != NULL ) {
			// Found a matching "conv_N_cmd_M..." spawnarg, start parsing
			ConversationCommandPtr cmd( new ConversationCommand );
			// Let the command parse itself
			if( cmd->Parse( dict, cmdPrefix ) ) {
				// Parsing succeeded, add this to the command list
				_commands.Append( cmd );
			}
		} else {
			DM_LOG( LC_CONVERSATION, LT_DEBUG )LOGSTRING( "No match found, terminating loop on index %d.\r", i );
			break;
		}
	}
	DM_LOG( LC_CONVERSATION, LT_DEBUG )LOGSTRING( "%d Commands found for Conversation %s.\r", _commands.Num(), _name.c_str() );
	// Sanity check the commands
	if( _commands.Num() == 0 ) {
		// No commands, what kind of conversation is this?
		_isValid = false;
		gameLocal.Warning( "Ignoring conversation %s as it has no commands.", _name.c_str() );
		return;
	}
	// Sanity check the talk distance
	if( _talkDistance <= 0.0f ) {
		_isValid = false;
		gameLocal.Warning( "Ignoring conversation %s as it has a talk distance <= 0.", _name.c_str() );
		return;
	}
	// get max play count, default is -1, which means infinitely often
	_maxPlayCount = dict.GetInt( prefix + "max_play_count", "-1" );
	// per default, the actors should be within talk distance before they start talking
	_actorsMustBeWithinTalkDistance = dict.GetBool( prefix + "actors_must_be_within_talkdistance", "1" );
	_actorsAlwaysFaceEachOtherWhileTalking = dict.GetBool( prefix + "actors_always_face_each_other_while_talking", "1" );
	// greebo: For conversations with one actor some flags don't make sense
	if( _actors.Num() == 1 ) {
		_actorsMustBeWithinTalkDistance = false;
		_actorsAlwaysFaceEachOtherWhileTalking = false;
	}
	// Seems like we have everything we need
	_isValid = true;
}