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

/*
================
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() );
	}
}

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", "");
}

void LootRuleSet::LoadFromDict(const idDict& dict, const idStr& prefix)
{
	// greebo: Read each value from spawnarg and use the existing value as default argument, 
	// such that missing spawnargs don't change anything.
	conversionRate[LOOT_GOLD] = dict.GetFloat(prefix + "loot_convrate_gold", va("%f", conversionRate[LOOT_GOLD]));
	conversionRate[LOOT_JEWELS] = dict.GetFloat(prefix + "loot_convrate_jewels", va("%f", conversionRate[LOOT_JEWELS]));
	conversionRate[LOOT_GOODS] = dict.GetFloat(prefix + "loot_convrate_goods", va("%f", conversionRate[LOOT_GOODS]));

	goldLoss = dict.GetInt(prefix + "gold_loss", va("%d", goldLoss));
	goldLossPercent = dict.GetFloat(prefix + "gold_loss_percent", va("%f", goldLossPercent));
	goldMin = dict.GetInt(prefix + "gold_min", va("%d", goldMin));
	goldCap = dict.GetInt(prefix + "gold_cap", va("%d", goldCap));
}

void Setting::Apply(idDict& target)
{
	switch (appType) 
	{
		case EAssign:
			target.Set(spawnArg, argument);
			break;
		case EAdd:
			// Convert the old setting to float, add the argument, convert back to string and set as value
			target.Set(spawnArg, idStr(float(target.GetFloat(spawnArg) + atof(argument))));
			break;
		case EMultiply:
			// Convert the old setting to float, add the argument, convert back to string and set as value
			target.Set(spawnArg, idStr(float(target.GetFloat(spawnArg) * atof(argument))));
			break;
		case EIgnore:
			// Ignore => do nothing
			break;
		default:
			break;
	};
}

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;
}

//
// 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());
			}

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

/*
================
sdRequirementCheck_Property::Init
================
*/
void sdRequirementCheck_Property::Init( const idDict& parms ) {
	useOther					= parms.GetBool( "use_other" );
	const char* propertyName	= parms.GetString( "property" );
	const char* subPropertyName = parms.GetString( "property_type" );

	if ( !idStr::Icmp( propertyName, "health" ) ) {
		property = PT_HEALTH;
	} else if ( !idStr::Icmp( propertyName, "range" ) ) {
		property = PT_RANGE;
	} else if ( !idStr::Icmp( propertyName, "total_xp" ) ) {
		property = PT_TOTAL_XP;
	} else if ( !idStr::Icmp( propertyName, "xp" ) ) {
		property = PT_XP;
		const sdDeclProficiencyType* prof = gameLocal.declProficiencyTypeType[ subPropertyName ];
		if ( !prof ) {
			gameLocal.Error( "sdRequirementCheck_Property::Init Invalid Proficiency Type '%s'", subPropertyName );
		}
		subProperty = prof->Index();
	} else if ( !idStr::Icmp( propertyName, "need_revive" ) ) {
		property = PT_NEEDSREVIVE;
	} else if ( !idStr::Icmp( propertyName, "want_revive" ) ) {
		property = PT_WANT_REVIVE;
	} else if ( !idStr::Icmp( propertyName, "same_entity" ) ) {
		property = PT_SAME_ENTITY;
	} else if ( !idStr::Icmp( propertyName, "spectator" ) ) {
		property = PT_SPECTATOR;
	} else if ( !idStr::Icmp( propertyName, "prone" ) ) {
		property = PT_PRONE;
	} else if ( !idStr::Icmp( propertyName, "crouch" ) ) {
		property = PT_CROUCH;
	} else if ( !idStr::Icmp( propertyName, "need_repair" ) ) {
		property = PT_NEEDSREPAIR;
	} else if ( !idStr::Icmp( propertyName, "proficiency" ) ) {
		property = PT_PROFICIENCY;
		const sdDeclProficiencyType* prof = gameLocal.declProficiencyTypeType[ subPropertyName ];
		if ( !prof ) {
			gameLocal.Error( "sdRequirementCheck_Property::Init Invalid Proficiency Type '%s'", subPropertyName );
		}
		subProperty = prof->Index();
	} else if ( !idStr::Icmp( propertyName, "spawn_proficiency" ) ) {
		property = PT_SPAWN_PROFICIENCY;
		const sdDeclProficiencyType* prof = gameLocal.declProficiencyTypeType[ subPropertyName ];
		if ( !prof ) {
			gameLocal.Error( "sdRequirementCheck_Property::Init Invalid Proficiency Type '%s'", subPropertyName );
		}
		subProperty = prof->Index();
	} else if ( !idStr::Icmp( propertyName, "driver" ) ) {
		property = PT_DRIVER;
	} else if ( !idStr::Icmp( propertyName, "disguised" ) ) {
		property = PT_DISGUISED;
	} else if ( !idStr::Icmp( propertyName, "vehicle_full" ) ) {
		property = PT_VEHICLEFULL;
	} else if ( !idStr::Icmp( propertyName, "in_vehicle" ) ) {
		property = PT_INVEHICLE;
		subProperty = 0;
		if ( !idStr::Icmp( subPropertyName, "local_player" ) ) {
			subProperty = 1;
		}
	} else if ( !idStr::Icmp( propertyName, "same_fireteam" ) ) {
		property = PT_SAME_FIRETEAM;
	} else {
		gameLocal.Error( "sdRequirementCheck_Property::Init Invalid Property Type '%s'", propertyName );
	}

	value = parms.GetFloat( "value" );

	const char* conditionName = parms.GetString( "condition" );

	if ( !idStr::Icmp( conditionName, "==" ) ) {
		condition = CND_EQ;
	} else if ( !idStr::Icmp( conditionName, "!=" ) ) {
		condition = CND_NE;
	} else if ( !idStr::Icmp( conditionName, ">" ) ) {
		condition = CND_GT;
	} else if ( !idStr::Icmp( conditionName, "<" ) ) {
		condition = CND_LT;
	} else if ( !idStr::Icmp( conditionName, ">=" ) ) {
		condition = CND_GE;
	} else if ( !idStr::Icmp( conditionName, "<=" ) ) {
		condition = CND_LE;
	} else {
		gameLocal.Error( "sdRequirementCheck_Property::Init Invalid Condition Type '%s'", conditionName );
	}

	if ( property == PT_RANGE ) {
		value *= value;
	}
}

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 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;
}