C++ DataTable::findColumnNumber方法代码示例

void BuildingObject::changeTeleportDestination(Vector & position, float & yaw) const
{
	if (!isAuthoritative())
	{
		WARNING(true, ("BuildingObject::changeTeleportDestination called on "
			"non-authoritative building %s", getNetworkId().getValueString().c_str()));
		return;
	}

	// call a script trigger that will give us the index of the cloning facility
	// tube to respawn in, if any
	int index = -1;
	ScriptParams params;
	params.addParam(index);
	IGNORE_RETURN(const_cast<GameScriptObject *>(getScriptObject())->trigAllScripts(
		Scripting::TRIG_GET_RESPAWN_LOC, params));
	index = params.getIntParam(0);
	if (index >= 0)
	{
		DataTable * respawnTable = DataTableManager::getTable(CLONE_RESPAWN_TABLE, 
			true);
		if (respawnTable != NULL)
		{
			int row = respawnTable->searchColumnString(0, getTemplateName());
			if (row >= 0)
			{
				char buffer[32];
				sprintf(buffer, "TUBE%d_X", index+1);
				int column = respawnTable->findColumnNumber(buffer);
				if (column >= 0)
				{
					position.x = respawnTable->getFloatValue(column, row);
					position.z = respawnTable->getFloatValue(column+1, row);
					yaw = convertDegreesToRadians(respawnTable->getFloatValue(column+2, row));
				}
			}
		}
	}
}

void LevelManager::install()
{
	if(m_installed)
		return;
	m_installed = true;

	DataTable *playerLevelDatatable = DataTableManager::getTable("datatables/player/player_level.iff", true);

	if (playerLevelDatatable)
	{
		ms_numLevels = playerLevelDatatable->getNumRows();

		const int levelColumn          = playerLevelDatatable->findColumnNumber("level");
		const int xp_requiredColumn    = playerLevelDatatable->findColumnNumber("xp_required");
		const int health_grantedColumn = playerLevelDatatable->findColumnNumber("health_granted");
		const int xp_typeColumn        = playerLevelDatatable->findColumnNumber("xp_type");
		const int xp_multiplierColumn  = playerLevelDatatable->findColumnNumber("xp_multiplier");


		// @NOTE: there are basically two independent tables in this data file
		//   there is level information and xp type information
		//   these are independent and have diffent lengths, so I'm putting the info
		//   into two different data structures
		int i;
		for(i = 0; i < ms_numLevels; ++i)
		{
			LevelRecord levelRecord;

			levelRecord.level       = (int16) playerLevelDatatable->getIntValue(levelColumn, i);
			levelRecord.xp_required = playerLevelDatatable->getIntValue(xp_requiredColumn, i);
			levelRecord.health      = playerLevelDatatable->getIntValue(health_grantedColumn, i);

			ms_levelRecords.insert(std::make_pair(levelRecord.level, levelRecord));

			std::string xpTypeName  = playerLevelDatatable->getStringValue(xp_typeColumn, i);
			if (!xpTypeName.empty())
			{
				const uint32 xpTypeNameCrc = Crc::calculate(xpTypeName.c_str());
				const int xpMultiplier = playerLevelDatatable->getIntValue(xp_multiplierColumn, i);
				ms_xpTypeRecords.insert(std::make_pair(xpTypeNameCrc, xpMultiplier));
			}
			if(levelRecord.level > ms_maxLevel)
				ms_maxLevel = levelRecord.level;
		}
		DataTableManager::close("datatables/player/player_level.iff");
	}

	DataTable *skillDatatable = DataTableManager::getTable("datatables/skill/skills.iff", true);

	if (skillDatatable)
	{
		const int numSkillRows = skillDatatable->getNumRows();
		
		const int skill_nameColumn = skillDatatable->findColumnNumber("NAME");
		const int type_nameColumn  = skillDatatable->findColumnNumber("XP_TYPE");
		const int xp_costColumn    = skillDatatable->findColumnNumber("XP_COST");

		int i;
		for(i = 0; i < numSkillRows; i++)
		{
			SkillRecord skillRecord;
			
			std::string skillName = skillDatatable->getStringValue(skill_nameColumn, i);
			uint32 skillNameCrc = Crc::calculate(skillName.c_str());

			std::string xpTypeName = skillDatatable->getStringValue(type_nameColumn, i);
			skillRecord.xp_type_name_Crc = Crc::calculate(xpTypeName.c_str());

			skillRecord.xp_cost = skillDatatable->getIntValue(xp_costColumn, i);

			ms_skillRecords.insert(std::make_pair(skillNameCrc, skillRecord));
		}
		DataTableManager::close("datatables/skill/skills.iff");
	}

	ExitChain::add(LevelManager::remove, "LevelManager::remove", 0, false);
}

void CitizenRankDataTable::install()
{
	DataTable * table = DataTableManager::getTable(cs_citizenRankDataTableName, true);
	if (table)
	{
		int const columnRankName = table->findColumnNumber("rankName");
		int const columnRankSlotId = table->findColumnNumber("rankSlotId");
		int const columnTitle = table->findColumnNumber("title");

		// the can be a variable number of "alternate title" columns, as long as the columns
		// are named alternateTitle1, alternateTitle2, alternateTitle3, alternateTitle4,
		// alternateTitle5, and so on
		std::vector<int> columnAlternateTitle;
		char buffer[128];
		int columnNumber;
		for (int i = 1; i <= 1000000000; ++i)
		{
			snprintf(buffer, sizeof(buffer)-1, "alternateTitle%d", i);
			buffer[sizeof(buffer)-1] = '\0';

			columnNumber = table->findColumnNumber(buffer);
			if (columnNumber < 0)
				break;

			columnAlternateTitle.push_back(columnNumber);
		}

		FATAL((columnRankName < 0), ("column \"rankName\" not found in %s", cs_citizenRankDataTableName));
		FATAL((columnRankSlotId < 0), ("column \"rankSlotId\" not found in %s", cs_citizenRankDataTableName));
		FATAL((columnTitle < 0), ("column \"title\" not found in %s", cs_citizenRankDataTableName));

		CitizenRankDataTable::CitizenRank const * currentRank = NULL;

		int const numRows = table->getNumRows();
		std::string rankName, alternateTitle;
		int slotId;
		bool title;
		std::vector<std::string> titles;
		std::map<std::string, int> names;
		std::map<int, CitizenRankDataTable::CitizenRank const *> allRanksById;
		for (int i = 0; i < numRows; ++i)
		{
			rankName = table->getStringValue(columnRankName, i);

			if (rankName.empty())
				continue;

			FATAL((names.count(rankName) >= 1), ("%s, row %d: rank name %s already used at row %d (either as a rank name or rank alternate title)", cs_citizenRankDataTableName, (i+3), rankName.c_str(), names[rankName]));
			names[rankName] = (i+3);

			slotId = table->getIntValue(columnRankSlotId, i);
			title = (table->getIntValue(columnTitle, i) != 0);

			// read all alternate titles
			titles.clear();
			if (title)
				titles.push_back(rankName);

			for (std::vector<int>::const_iterator iterColumnAlternateTitle = columnAlternateTitle.begin(); iterColumnAlternateTitle != columnAlternateTitle.end(); ++iterColumnAlternateTitle)
			{
				alternateTitle = table->getStringValue(*iterColumnAlternateTitle, i);

				if (!alternateTitle.empty())
				{
					FATAL((names.count(alternateTitle) >= 1), ("%s, row %d: alternate title %s already used at row %d (either as a rank name or rank alternate title)", cs_citizenRankDataTableName, (i+3), alternateTitle.c_str(), names[alternateTitle]));
					names[alternateTitle] = (i+3);

					titles.push_back(alternateTitle);
				}
			}

			FATAL((!titles.empty() && !title), ("%s: rank %s cannot have any alternate titles unless it is defined as \"titleable\")", cs_citizenRankDataTableName, rankName.c_str()));

			// check for valid slot id
			FATAL((slotId < 0), ("%s, row %d: rank slot id %d must be >= 0", cs_citizenRankDataTableName, (i+3), slotId));

			// create citizen rank info
			currentRank = new CitizenRank(rankName, slotId, titles);

			// check for duplicate slot id
			FATAL((allRanksById.count(slotId) >= 1), ("%s, row %d: rank slot id %d already used by rank %s", cs_citizenRankDataTableName, (i+3), slotId, allRanksById[slotId]->name.c_str()));
			allRanksById[slotId] = currentRank;

			s_allCitizenRankNames.push_back(currentRank->name);
			s_allCitizenRanks.push_back(currentRank);

			if (!currentRank->titles.empty())
				s_allTitleableCitizenRanks.push_back(currentRank);

			s_allCitizenRanksByName[currentRank->name] = currentRank;

			for (std::vector<std::string>::const_iterator iterTitle = currentRank->titles.begin(); iterTitle != currentRank->titles.end(); ++iterTitle)
				s_allCitizenRanksByTitle[*iterTitle] = currentRank;
		}

		DataTableManager::close(cs_citizenRankDataTableName);

		// do additional verification
		slotId = -1;
		for (std::map<int, CitizenRankDataTable::CitizenRank const *>::const_iterator iterSlotId = allRanksById.begin(); iterSlotId != allRanksById.end(); ++iterSlotId)
//.........这里部分代码省略.........