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

void CShop::LoadFromDict(const idDict& dict)
{
	// greebo: Assemble the difficulty prefix (e.g. "diff_0_")
	idStr diffPrefix = "diff_" + idStr(gameLocal.m_DifficultyManager.GetDifficultyLevel()) + "_";

	if (dict.GetBool("shop_skip","0") || dict.GetBool(diffPrefix + "shop_skip","0"))
	{
		// if skip flag is set, skip the shop
		_skipShop = true;

		// No need to parse any further, the shop will be skipped anyway
		return;
	}

	// Check for loot carry-over rules
	LoadLootRules(dict);

	// Check for an "all-difficulty" gold value
	if (dict.FindKey("shop_gold_start") != NULL)
	{
		SetGold(dict.GetInt("shop_gold_start"));
	}

	// Try to retrieve the starting gold for the given difficulty level
	if (dict.FindKey(diffPrefix + "shop_gold_start") != NULL)
	{
		SetGold(dict.GetInt(diffPrefix + "shop_gold_start"));
	}

	// items for sale
	AddItems(dict, "shopItem", _itemsForSale);

	// starting items (items that player already has
	AddItems(dict, "startingItem", _startingItems);
}

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

/*
========================
idAchievementManager::RestorePersistentData
========================
*/
void idAchievementManager::RestorePersistentData( const idDict& spawnArgs )
{
	for( int i = 0; i < ACHIEVEMENTS_NUM; ++i )
	{
		counts[i] = spawnArgs.GetInt( va( "ach_%d", i ), "0" );
	}
}

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

LootType CInventoryItem::GetLootTypeFromSpawnargs(const idDict& spawnargs)
{
	// Determine the loot type
	int lootTypeInt;
	LootType returnValue = LOOT_NONE;

	if (spawnargs.GetInt("inv_loot_type", "", lootTypeInt) != false)
	{
		if (lootTypeInt >= LOOT_NONE && lootTypeInt < LOOT_COUNT)
		{
			returnValue = static_cast<LootType>(lootTypeInt);
		}
		else
		{
			DM_LOG(LC_STIM_RESPONSE, LT_ERROR)LOGSTRING("Invalid loot type: %d\r", lootTypeInt);
		}
	}

	return returnValue;
}

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++;
			}
		}
//.........这里部分代码省略.........

int CShop::AddItems(const idDict& mapDict, const idStr& itemKey, ShopItemList& list)
{
	int diffLevel = gameLocal.m_DifficultyManager.GetDifficultyLevel();
	
	int itemsAdded = 0;

	// grayman (#2376)
	// Convert itemKey to lowercase. mapDict methods ignore case, but
	// StripLeadingOnce() doesn't. This change allows recognition of shop items defined as
	// "startingItem_*", "startingitem_*", "shopItem_*", and "shopitem_*.

	idStr itemKeyLower = itemKey;
	itemKeyLower.ToLower();

	bool isShopList = (itemKeyLower.Find("shop") >= 0); // for lockpick checking

	for (const idKeyValue* kv = mapDict.MatchPrefix(itemKeyLower); kv != NULL; kv = mapDict.MatchPrefix(itemKeyLower, kv))
	{
		// Inspect the matching prefix, check whether the difficulty level applies
		idStr postfix = kv->GetKey();
		postfix.ToLower(); // grayman (#2376) convert postfix to lowercase so StripLeadingOnce()
						   // matches lowercase against lowercase

		// Cut off the prefix including the following underscore _
		postfix.StripLeadingOnce(itemKeyLower + "_");
		
		int pos = postfix.Find("_item");
		
		if (pos == -1 || pos != postfix.Length() - 5)
		{
			continue; // no suitable "_item" found
		}

		// This is the number portion, like "1_2" or merely "2"
		idStr indexStr = postfix.Mid(0, pos);

		// Check if we have still an underscore in the index string, this implies
		// that there is a difficulty number included
		int underScorePos = indexStr.Find('_');

		// Extract the item index
		int itemIndex = (underScorePos != -1) ? atoi(indexStr.Mid(0, underScorePos)) : atoi(indexStr);

		if (underScorePos != -1)
		{
			// Check out the second number, this is the difficulty level
			idStr diffStr = indexStr.Mid(underScorePos + 1, indexStr.Length() - underScorePos);

			// Check if the difficulty level matches
			if (atoi(diffStr) != diffLevel)
			{
				// Ignore this spawnarg
				continue;
			}
		}

		idStr itemName = kv->GetValue();

		if (itemName.IsEmpty())
		{
			continue; // Empty names are not considered
		}

		// greebo: Assemble the item prefix (e.g. "shopItem_1_") to look up the rest of the spawnargs
		idStr itemPrefix = itemKey + "_" + idStr(itemIndex);
		idStr diffLevelStr = "_" + idStr(diffLevel);

		// look for quantity, but let a difficulty-specific setting override the general one
		int quantity = mapDict.GetInt(itemPrefix + "_qty");

		if (mapDict.FindKey(itemPrefix + diffLevelStr + "_qty") != NULL)
		{
			quantity = mapDict.GetInt(itemPrefix + diffLevelStr + "_qty");
		}

		// put the item in the shop
		if (quantity > 0)
		{
			// grayman (#2376) - Special handling for weapon quantities.

			int index = itemName.Find("weapon_");
			if (index >= 0)
			{
				// A shop entity should use atdm:weapon_*, but there's at least one
				// that uses weapon_*, so convert the latter to the former.

				idStr weaponName;
				if (index == 0)
				{
					weaponName = "atdm:" + itemName;
				}
				else
				{
					weaponName = itemName;
				}

				// Weapon quantities have limits. (Arrows in particular.)

				int max_ammo = GetMaxAmmo(weaponName);
				quantity = (quantity > max_ammo) ? max_ammo : quantity;
//.........这里部分代码省略.........

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