Der SDK-Fragen-Thread

[Kathy]

Okay, so herum spielt mein Einwand keine Rolle (und WIDGET auch nicht), das ist erst für den Techtree wichtig.

Bei der von dir gezeigten Stelle von CvTeam.cpp wird der Bonus beim Erforschen der Tech sichtbar gemacht, ich denke also schon, dass sie für das Feature auch kopiert werden muss.

[Monaldinio]

Ach verdammt, welches der beiden muss ich kopieren und anpassen...und vor allem wohin?
Ich verliere den Überblick!

Das habe ich auch noch in der CvTeam.cpp gefunden...was macht das?

if (bAnnounce)
			{
				if (GC.getGameINLINE().isFinalInitialized() && !(gDLL->GetWorldBuilderMode()))
				{
					announceTechToPlayers(eIndex);

					for (iI = 0; iI < GC.getMapINLINE().numPlotsINLINE(); iI++)
					{
						pLoopPlot = GC.getMapINLINE().plotByIndexINLINE(iI);

						if (pLoopPlot->getTeam() == getID())
						{
							eBonus = pLoopPlot->getBonusType();

							if (eBonus != NO_BONUS)
							{
								if (GC.getBonusInfo(eBonus).getTechReveal() == eIndex && !isForceRevealedBonus(eBonus))
								{
									pCity = GC.getMapINLINE().findCity(pLoopPlot->getX_INLINE(), pLoopPlot->getY_INLINE(), NO_PLAYER, getID(), false);

									if (pCity != NULL)
									{
										szBuffer = gDLL->getText("TXT_KEY_MISC_YOU_DISCOVERED_BONUS", GC.getBonusInfo(eBonus).getTextKeyWide(), pCity->getNameKey());
										gDLL->getInterfaceIFace()->addMessage(pLoopPlot->getOwnerINLINE(), false, GC.getEVENT_MESSAGE_TIME(), szBuffer, "AS2D_DISCOVERBONUS", MESSAGE_TYPE_INFO, GC.getBonusInfo(eBonus).getButton(), (ColorTypes)GC.getInfoTypeForString("COLOR_WHITE"), pLoopPlot->getX_INLINE(), pLoopPlot->getY_INLINE(), true, true);
									}
								}
							}
						}
					}

for (iI = 0; iI < GC.getMapINLINE().numPlotsINLINE(); iI++)
	{
		pLoopPlot = GC.getMapINLINE().plotByIndexINLINE(iI);

		eBonus = pLoopPlot->getBonusType();

		if (eBonus != NO_BONUS)
		{
			if (GC.getBonusInfo(eBonus).getTechReveal() == eTech)
			{
				pLoopPlot->updateYield();
				pLoopPlot->setLayoutDirty(true);
			}
		}
	}

[Monaldinio]

1>CvPlot.cpp(6016) : error C2511: 'FeatureTypes CvPlot::getFeatureType(TeamTypes) const' : overloaded member function not found in 'CvPlot'
1> c:\Users\Martin\Desktop\Civ\CIV 4\Civ 4 Kram\28.08.2015 NEUE DLL COC\CvGameCoreDLL\CvPlot.h(41) : see declaration of 'CvPlot'
1>NMAKE : warning U4010: 'Release\CvPlot.obj' : build failed; /K specified, continuing ...

FeatureTypes CvPlot::getFeatureType(TeamTypes eTeam) const
{
	if (eTeam != NO_TEAM)
	{
		if (m_eFeatureType != NO_FEATURE)
		{
			if (!GET_TEAM(eTeam).isHasTech((TechTypes)(GC.getFeatureInfo((FeatureTypes)m_eFeatureType).getTechReveal())))
			{
				return NO_FEATURE;
			}
		}
	}
	return (FeatureTypes)m_eFeatureType;
}

Ich habe wohl in der CvPlott.h etwas vergessen zu deklarieren...aber ich weiß nicht so richtig was...

[Commander Bello]

Ich habe wohl in der CvPlott.h etwas vergessen zu deklarieren...aber ich weiß nicht so richtig was...

Dann ist es auf jeden Fall der richtige Gedanke, uns die CvPlot.h nicht zu zeigen.

[Monaldinio]

CvPlot.h

Achtung Spoiler:

#pragma once

// CvPlot.h

#ifndef CIV4_PLOT_H
#define CIV4_PLOT_H

//#include "CvStructs.h"
#include "LinkedList.h"
#include <bitset>

#pragma warning( disable: 4251 )		// needs to have dll-interface to be used by clients of class

class CvArea;
class CvMap;
class CvPlotBuilder;
class CvRoute;
class CvRiver;
class CvCity;
class CvPlotGroup;
class CvFeature;
class CvUnit;
class CvSymbol;
class CvFlagEntity;



//rucivfan[
//old code[
//typedef bool (*ConstPlotUnitFunc)( const CvUnit* pUnit, int iData1, int iData2);
//typedef bool (*PlotUnitFunc)(CvUnit* pUnit, int iData1, int iData2);
//]old code

//new code[
typedef bool (*ConstPlotUnitFunc)( const CvUnit* pUnit, int iData1, int iData2, const CvUnit* pComparisonUnit);
typedef bool (*PlotUnitFunc)(CvUnit* pUnit, int iData1, int iData2, const CvUnit* pComparisonUnit);
//]new code
//]rucivfan

class CvPlot    
{                                                          #### (Zeile 41)

public:
	CvPlot();
	virtual ~CvPlot();

	void init(int iX, int iY);
	void uninit();
	void reset(int iX = 0, int iY = 0, bool bConstructorCall=false);
	void setupGraphical();
	void updateGraphicEra();

	DllExport void erase();																																								// Exposed to Python

	DllExport float getPointX() const;														
	DllExport float getPointY() const;														
	DllExport NiPoint3 getPoint() const;																																	// Exposed to Python

	float getSymbolSize() const;
	DllExport float getSymbolOffsetX(int iID) const;
	DllExport float getSymbolOffsetY(int iID) const;

	TeamTypes getTeam() const;																																	// Exposed to Python

	void doTurn();

	void doImprovement();

	void updateCulture(bool bBumpUnits, bool bUpdatePlotGroups);

	void updateFog();
	void updateVisibility();

	void updateSymbolDisplay();
	void updateSymbolVisibility();
	void updateSymbols();

	void updateMinimapColor();

	void updateCenterUnit();

	void verifyUnitValidPlot();

	void nukeExplosion(int iRange, CvUnit* pNukeUnit = NULL);																							// Exposed to Python

	bool isConnectedTo( const CvCity* pCity) const;																												// Exposed to Python
	bool isConnectedToCapital(PlayerTypes ePlayer = NO_PLAYER) const;																			// Exposed to Python
	int getPlotGroupConnectedBonus(PlayerTypes ePlayer, BonusTypes eBonus) const;													// Exposed to Python
	bool isPlotGroupConnectedBonus(PlayerTypes ePlayer, BonusTypes eBonus) const;								// Exposed to Python
	bool isAdjacentPlotGroupConnectedBonus(PlayerTypes ePlayer, BonusTypes eBonus) const;				// Exposed to Python
	void updatePlotGroupBonus(bool bAdd);

	bool isAdjacentToArea(int iAreaID) const;
	bool isAdjacentToArea(const CvArea* pArea) const;																						// Exposed to Python
	bool shareAdjacentArea( const CvPlot* pPlot) const;																					// Exposed to Python
	bool isAdjacentToLand() const;																															// Exposed to Python 
	bool isCoastalLand(int iMinWaterSize = -1) const;																																	// Exposed to Python

	bool isVisibleWorked() const;
	bool isWithinTeamCityRadius(TeamTypes eTeam, PlayerTypes eIgnorePlayer = NO_PLAYER) const;	// Exposed to Python

	DllExport bool isLake() const;																															// Exposed to Python
	bool isFreshWater() const;																												// Exposed to Python
	bool isPotentialIrrigation() const;																													// Exposed to Python
	bool canHavePotentialIrrigation() const;																										// Exposed to Python
	DllExport bool isIrrigationAvailable(bool bIgnoreSelf = false) const;												// Exposed to Python

	DllExport bool isRiverMask() const;
	DllExport bool isRiverCrossingFlowClockwise(DirectionTypes eDirection) const;
	bool isRiverSide() const;																																		// Exposed to Python
	bool isRiver() const;																																				// Exposed to Python
	bool isRiverConnection(DirectionTypes eDirection) const;																		// Exposed to Python

	CvPlot* getNearestLandPlotInternal(int iDistance) const;
	int getNearestLandArea() const;																															// Exposed to Python
	CvPlot* getNearestLandPlot() const;																													// Exposed to Python

	int seeFromLevel(TeamTypes eTeam) const;																										// Exposed to Python  
	int seeThroughLevel() const;																																// Exposed to Python
	void changeAdjacentSight(TeamTypes eTeam, int iRange, bool bIncrement, CvUnit* pUnit, bool bUpdatePlotGroups);
	bool canSeePlot(CvPlot *plot, TeamTypes eTeam, int iRange, DirectionTypes eFacingDirection) const;
	bool canSeeDisplacementPlot(TeamTypes eTeam, int dx, int dy, int originalDX, int originalDY, bool firstPlot, bool outerRing) const;
	bool shouldProcessDisplacementPlot(int dx, int dy, int range, DirectionTypes eFacingDirection) const;
	void updateSight(bool bIncrement, bool bUpdatePlotGroups);
	void updateSeeFromSight(bool bIncrement, bool bUpdatePlotGroups);

	bool canHaveBonus(BonusTypes eBonus, bool bIgnoreLatitude = false) const;																						// Exposed to Python
	bool canHaveImprovement(ImprovementTypes eImprovement, TeamTypes eTeam = NO_TEAM, bool bPotential = false) const;		// Exposed to Python

	bool canBuild(BuildTypes eBuild, PlayerTypes ePlayer = NO_PLAYER, bool bTestVisible = false, bool bNoOwner = false) const;														// Exposed to Python
	int getBuildTime(BuildTypes eBuild) const;																																										// Exposed to Python
// BUG - Partial Builds - start
	int getBuildTurnsLeft(BuildTypes eBuild, PlayerTypes ePlayer) const;
	int getBuildTurnsLeft(BuildTypes eBuild, int iNowExtra, int iThenExtra, bool bIncludeUnits = true) const;																			// Exposed to Python
// BUG - Partial Builds - end
	int getFeatureProduction(BuildTypes eBuild, TeamTypes eTeam, CvCity** ppCity) const;																// Exposed to Python

	DllExport CvUnit* getBestDefender(PlayerTypes eOwner, PlayerTypes eAttackingPlayer = NO_PLAYER, const CvUnit* pAttacker = NULL, bool bTestAtWar = false, bool bTestPotentialEnemy = false, bool bTestCanMove = false) const;		// Exposed to Python
	int AI_sumStrength(PlayerTypes eOwner, PlayerTypes eAttackingPlayer = NO_PLAYER, DomainTypes eDomainType = NO_DOMAIN, bool bDefensiveBonuses = true, bool bTestAtWar = false, bool bTestPotentialEnemy = false) const;	
	CvUnit* getSelectedUnit() const;																																// Exposed to Python				
	int getUnitPower(PlayerTypes eOwner = NO_PLAYER) const;																					// Exposed to Python				

	int defenseModifier(TeamTypes eDefender, bool bIgnoreBuilding, bool bHelp = false) const;									// Exposed to Python				
	int movementCost(const CvUnit* pUnit, const CvPlot* pFromPlot) const;														// Exposed to Python				

	int getExtraMovePathCost() const;																																// Exposed to Python
	void changeExtraMovePathCost(int iChange);																																// Exposed to Python

	bool isAdjacentOwned() const;																																		// Exposed to Python
	bool isAdjacentPlayer(PlayerTypes ePlayer, bool bLandOnly = false) const;												// Exposed to Python
	bool isAdjacentTeam(TeamTypes eTeam, bool bLandOnly = false) const;															// Exposed to Python
	bool isWithinCultureRange(PlayerTypes ePlayer) const;																						// Exposed to Python
	int getNumCultureRangeCities(PlayerTypes ePlayer) const;																				// Exposed to Python
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      11/30/08                                jdog5000      */
/*                                                                                              */
/* General AI                                                                                   */
/************************************************************************************************/
	bool isHasPathToEnemyCity( TeamTypes eAttackerTeam, bool bIgnoreBarb = true );
	bool isHasPathToPlayerCity( TeamTypes eMoveTeam, PlayerTypes eOtherPlayer = NO_PLAYER );
	int calculatePathDistanceToPlot( TeamTypes eTeam, CvPlot* pTargetPlot );
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      08/21/09                                jdog5000      */
/*                                                                                              */
/* Efficiency                                                                                   */
/************************************************************************************************/
	// Plot danger cache
	bool isActivePlayerNoDangerCache() const;
	bool isTeamBorderCache( TeamTypes eTeam ) const;
	void setIsActivePlayerNoDangerCache( bool bNewValue );
	void setIsTeamBorderCache( TeamTypes eTeam, bool bNewValue );
	void invalidateIsTeamBorderCache();
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/

	PlayerTypes calculateCulturalOwner(bool bInfested = false) const;

	//rucivfan[
	//old code[
	//void plotAction(PlotUnitFunc func, int iData1 = -1, int iData2 = -1, PlayerTypes eOwner = NO_PLAYER, TeamTypes eTeam = NO_TEAM);
	//int plotCount(ConstPlotUnitFunc funcA, int iData1A = -1, int iData2A = -1, PlayerTypes eOwner = NO_PLAYER, TeamTypes eTeam = NO_TEAM, ConstPlotUnitFunc funcB = NULL, int iData1B = -1, int iData2B = -1) const;
	//CvUnit* plotCheck(ConstPlotUnitFunc funcA, int iData1A = -1, int iData2A = -1, PlayerTypes eOwner = NO_PLAYER, TeamTypes eTeam = NO_TEAM, ConstPlotUnitFunc funcB = NULL, int iData1B = -1, int iData2B = -1) const;
	//]old code

	//new code[
	void plotAction(PlotUnitFunc func, int iData1 = -1, int iData2 = -1, const CvUnit* pComparisonUnit = NULL, PlayerTypes eOwner = NO_PLAYER, TeamTypes eTeam = NO_TEAM);
	int plotCount(ConstPlotUnitFunc funcA, int iData1A = -1, int iData2A = -1, const CvUnit* pComparisonUnitA = NULL, PlayerTypes eOwner = NO_PLAYER, TeamTypes eTeam = NO_TEAM, ConstPlotUnitFunc funcB = NULL, int iData1B = -1, int iData2B = -1, const CvUnit* pComparisonUnitB = NULL) const;
	CvUnit* plotCheck(ConstPlotUnitFunc funcA, int iData1A = -1, int iData2A = -1, const CvUnit* pComparisonUnitA = NULL, PlayerTypes eOwner = NO_PLAYER, TeamTypes eTeam = NO_TEAM, ConstPlotUnitFunc funcB = NULL, int iData1B = -1, int iData2B = -1, const CvUnit* pComparisonUnitB = NULL) const;
	//]new code
	//]rucivfan

	bool isOwned() const;																																							// Exposed to Python
	bool isBarbarian() const;																																					// Exposed to Python
	bool isRevealedBarbarian() const;																																	// Exposed to Python

	DllExport bool isVisible(TeamTypes eTeam, bool bDebug) const;																			// Exposed to Python
	DllExport bool isActiveVisible(bool bDebug) const;																								// Exposed to Python
	bool isVisibleToCivTeam() const;																																	// Exposed to Python
	bool isVisibleToWatchingHuman() const;																														// Exposed to Python
	bool isAdjacentVisible(TeamTypes eTeam, bool bDebug) const;																				// Exposed to Python
	bool isAdjacentNonvisible(TeamTypes eTeam) const;																				// Exposed to Python

	DllExport bool isGoody(TeamTypes eTeam = NO_TEAM) const;																					// Exposed to Python
	bool isRevealedGoody(TeamTypes eTeam = NO_TEAM) const;																						// Exposed to Python
	void removeGoody();																																								// Exposed to Python

	DllExport bool isCity(bool bCheckImprovement = false, TeamTypes eForTeam = NO_TEAM) const;																																		// Exposed to Python
	// rucivfan[
	DllExport bool isCityWithOrbitalComparison(bool bOrbital, bool bCheckImprovement = false, TeamTypes eForTeam = NO_TEAM) const;
	// ]rucivfan
	bool isFriendlyCity(const CvUnit& kUnit, bool bCheckImprovement) const;																												// Exposed to Python
	bool isEnemyCity(const CvUnit& kUnit) const;																													// Exposed to Python

	bool isOccupation() const;																																				// Exposed to Python
	bool isBeingWorked() const;																															// Exposed to Python

	bool isUnit() const;																																							// Exposed to Python
	bool isInvestigate(TeamTypes eTeam) const;																												// Exposed to Python
	bool isVisibleEnemyDefender(const CvUnit* pUnit) const;																						// Exposed to Python
	CvUnit *getVisibleEnemyDefender(PlayerTypes ePlayer) const;
	int getNumDefenders(PlayerTypes ePlayer) const;																										// Exposed to Python
	int getNumVisibleEnemyDefenders(const CvUnit* pUnit) const;																				// Exposed to Python
	int getNumVisiblePotentialEnemyDefenders(const CvUnit* pUnit) const;															// Exposed to Python
	DllExport bool isVisibleEnemyUnit(PlayerTypes ePlayer) const;																			// Exposed to Python
	DllExport int getNumVisibleUnits(PlayerTypes ePlayer) const;
	bool isVisibleEnemyUnit(const CvUnit* pUnit) const;
	bool isVisibleOtherUnit(PlayerTypes ePlayer) const;																								// Exposed to Python
	DllExport bool isFighting() const;																																// Exposed to Python

	bool canHaveFeature(FeatureTypes eFeature, bool bIsSpreadCheck = false) const;																				// Exposed to Python

	DllExport bool isRoute() const;																																		// Exposed to Python
	bool isValidRoute(const CvUnit* pUnit) const;																											// Exposed to Python
	bool isTradeNetworkImpassable(TeamTypes eTeam) const;																														// Exposed to Python
	bool isNetworkTerrain(TeamTypes eTeam) const;																											// Exposed to Python
	bool isBonusNetwork(TeamTypes eTeam) const;																												// Exposed to Python
	bool isTradeNetwork(TeamTypes eTeam) const;																												// Exposed to Python
	bool isTradeNetworkConnected(const CvPlot * pPlot, TeamTypes eTeam) const;												// Exposed to Python
	bool isRiverNetwork(TeamTypes eTeam) const;

	bool isValidDomainForLocation(const CvUnit& unit) const;																					// Exposed to Python
	bool isValidDomainForAction(const CvUnit& unit) const;																						// Exposed to Python
	bool isImpassable() const;																															// Exposed to Python

	DllExport int getX() const;																																				// Exposed to Python
#ifdef _USRDLL
	inline int getX_INLINE() const
	{
		return m_iX;
	}
#endif
	DllExport int getY() const;																																				// Exposed to Python
#ifdef _USRDLL
	inline int getY_INLINE() const
	{
		return m_iY;
	}
#endif
	bool at(int iX, int iY) const;																																		// Exposed to Python
	int getLatitude() const;																																					// Exposed to Python  
	int getFOWIndex() const;

	CvArea* area() const;																																							// Exposed to Python
/********************************************************************************/
/* 	BETTER_BTS_AI_MOD						01/02/09		jdog5000		*/
/* 																			*/
/* 	General AI																*/
/********************************************************************************/
/* original BTS code
	CvArea* waterArea() const;
*/
	CvArea* waterArea(bool bNoImpassable = false) const;
/********************************************************************************/
/* 	BETTER_BTS_AI_MOD						END								*/
/********************************************************************************/	

	CvArea* secondWaterArea() const;
	int getArea() const;																																		// Exposed to Python
	void setArea(int iNewValue);			

	DllExport int getFeatureVariety() const;																													// Exposed to Python

	int getOwnershipDuration() const;																																	// Exposed to Python
	bool isOwnershipScore() const;																																		// Exposed to Python
	void setOwnershipDuration(int iNewValue);																													// Exposed to Python
	void changeOwnershipDuration(int iChange);																												// Exposed to Python

	int getImprovementDuration() const;																																// Exposed to Python
	void setImprovementDuration(int iNewValue);																												// Exposed to Python
	void changeImprovementDuration(int iChange);																											// Exposed to Python

	int getUpgradeProgress() const;																													// Exposed to Python
	int getUpgradeTimeLeft(ImprovementTypes eImprovement, PlayerTypes ePlayer) const;				// Exposed to Python
	void setUpgradeProgress(int iNewValue);																														// Exposed to Python
	void changeUpgradeProgress(int iChange);																													// Exposed to Python

	int getForceUnownedTimer() const;																																	// Exposed to Python
	bool isForceUnowned() const;																																			// Exposed to Python
	void setForceUnownedTimer(int iNewValue);																													// Exposed to Python
	void changeForceUnownedTimer(int iChange);																												// Exposed to Python

	int getCityRadiusCount() const;																																		// Exposed to Python
	int isCityRadius() const;																																					// Exposed to Python
	void changeCityRadiusCount(int iChange);

	bool isStartingPlot() const;																																			// Exposed to Python
	void setStartingPlot(bool bNewValue);																															// Exposed to Python
	
	DllExport bool isNOfRiver() const;																																// Exposed to Python					
	DllExport void setNOfRiver(bool bNewValue, CardinalDirectionTypes eRiverDir);											// Exposed to Python					
																																																		
	DllExport bool isWOfRiver() const;																																// Exposed to Python					
	DllExport void setWOfRiver(bool bNewValue, CardinalDirectionTypes eRiverDir);											// Exposed to Python					
																																																		
	DllExport CardinalDirectionTypes getRiverNSDirection() const;																			// Exposed to Python					
	DllExport CardinalDirectionTypes getRiverWEDirection() const;																			// Exposed to Python					

	CvPlot* getInlandCorner() const;																																	// Exposed to Python
	bool hasCoastAtSECorner() const;

	bool isIrrigated() const;																																					// Exposed to Python
	void setIrrigated(bool bNewValue);
	void updateIrrigated();

	bool isPotentialCityWork() const;																																						// Exposed to Python
	bool isPotentialCityWorkForArea(CvArea* pArea) const;																												// Exposed to Python
	void updatePotentialCityWork();

	bool isShowCitySymbols() const;
	void updateShowCitySymbols();

	bool isFlagDirty() const;																																										// Exposed to Python
	void setFlagDirty(bool bNewValue);																																					// Exposed to Python

	DllExport PlayerTypes getOwner() const;																																			// Exposed to Python
#ifdef _USRDLL
	inline PlayerTypes getOwnerINLINE() const
	{
		return (PlayerTypes)m_eOwner;
	}
#endif
	void setOwner(PlayerTypes eNewValue, bool bCheckUnits, bool bUpdatePlotGroup);

	PlotTypes getPlotType() const;																																			// Exposed to Python
	DllExport bool isWater() const;																																								// Exposed to Python
	bool isFlatlands() const;																																											// Exposed to Python
	DllExport bool isHills() const;																																								// Exposed to Python
	DllExport bool isPeak() const;																																								// Exposed to Python
	void setPlotType(PlotTypes eNewValue, bool bRecalculate = true, bool bRebuildGraphics = true);			// Exposed to Python

	DllExport TerrainTypes getTerrainType() const;																																	// Exposed to Python
	void setTerrainType(TerrainTypes eNewValue, bool bRecalculate = true, bool bRebuildGraphics = true);	// Exposed to Python

	DllExport FeatureTypes getFeatureType() const;																																	// Exposed to Python
	DllExport void setFeatureType(FeatureTypes eNewValue, int iVariety = -1);																				// Exposed to Python
	DllExport void setFeatureDummyVisibility(const char *dummyTag, bool show);																				// Exposed to Python
	DllExport void addFeatureDummyModel(const char *dummyTag, const char *modelTag);
	DllExport void setFeatureDummyTexture(const char *dummyTag, const char *textureTag);
	DllExport CvString pickFeatureDummyTag(int mouseX, int mouseY);
	DllExport void resetFeatureModel();

	DllExport BonusTypes getBonusType(TeamTypes eTeam = NO_TEAM) const;																							// Exposed to Python
	BonusTypes getNonObsoleteBonusType(TeamTypes eTeam = NO_TEAM) const;																	// Exposed to Python
	void setBonusType(BonusTypes eNewValue);																															// Exposed to Python

	DllExport ImprovementTypes getImprovementType() const;																													// Exposed to Python
	DllExport void setImprovementType(ImprovementTypes eNewValue);																									// Exposed to Python

	DllExport RouteTypes getRouteType() const;																																			// Exposed to Python
	DllExport void setRouteType(RouteTypes eNewValue, bool bUpdatePlotGroup);																															// Exposed to Python
	void updateCityRoute(bool bUpdatePlotGroup);

	DllExport CvCity* getPlotCity() const;																																					// Exposed to Python
	void setPlotCity(CvCity* pNewValue);

	CvCity* getWorkingCity() const;																																				// Exposed to Python
	void updateWorkingCity();

	CvCity* getWorkingCityOverride() const;																															// Exposed to Python
	void setWorkingCityOverride( const CvCity* pNewValue);

	int getRiverID() const;																																							// Exposed to Python
	void setRiverID(int iNewValue);																																			// Exposed to Python

	int getMinOriginalStartDist() const;																																// Exposed to Python
	void setMinOriginalStartDist(int iNewValue);

	int getReconCount() const;																																					// Exposed to Python
	void changeReconCount(int iChange);

	int getRiverCrossingCount() const;																																	// Exposed to Python
	void changeRiverCrossingCount(int iChange);

	short* getYield();
	DllExport int getYield(YieldTypes eIndex) const;																										// Exposed to Python
	int calculateNatureYield(YieldTypes eIndex, TeamTypes eTeam, bool bIgnoreFeature = false) const;		// Exposed to Python
	int calculateBestNatureYield(YieldTypes eIndex, TeamTypes eTeam) const;															// Exposed to Python
	int calculateTotalBestNatureYield(TeamTypes eTeam) const;																						// Exposed to Python
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      10/06/09                                jdog5000      */
/*                                                                                              */
/* City AI                                                                                      */
/************************************************************************************************/
	int calculateImprovementYieldChange(ImprovementTypes eImprovement, YieldTypes eYield, PlayerTypes ePlayer, bool bOptimal = false, bool bBestRoute = false, bool bDisplay = false) const;	// Exposed to Python
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/
	int calculateYield(YieldTypes eIndex, bool bDisplay = false) const;												// Exposed to Python
	bool hasYield() const;																																		// Exposed to Python
	void updateYield();
	int calculateMaxYield(YieldTypes eYield) const;
	int getYieldWithBuild(BuildTypes eBuild, YieldTypes eYield, bool bWithUpgrade) const;

	int getCulture(PlayerTypes eIndex) const;																									// Exposed to Python
	int countTotalCulture() const;																														// Exposed to Python
	int countFriendlyCulture(TeamTypes eTeam) const;
	TeamTypes findHighestCultureTeam() const;																														// Exposed to Python
	PlayerTypes findHighestCulturePlayer() const;
	int calculateCulturePercent(PlayerTypes eIndex) const;																		// Exposed to Python
	int calculateTeamCulturePercent(TeamTypes eIndex) const;																						// Exposed to Python
	void setCulture(PlayerTypes eIndex, int iNewValue, bool bUpdate, bool bUpdatePlotGroups);																		// Exposed to Python
	void changeCulture(PlayerTypes eIndex, int iChange, bool bUpdate);																	// Exposed to Python

	int countNumAirUnits(TeamTypes eTeam) const;																					// Exposed to Python
	int airUnitSpaceAvailable(TeamTypes eTeam) const;
/********************************************************************************/
/* 	BETTER_BTS_AI_MOD						10/17/08		jdog5000		*/
/* 																			*/
/* 	Air AI																	*/
/********************************************************************************/
	int countAirInterceptorsActive(TeamTypes eTeam) const;
/********************************************************************************/
/* 	BETTER_BTS_AI_MOD						END								*/
/********************************************************************************/

	int getFoundValue(PlayerTypes eIndex);																															// Exposed to Python
	bool isBestAdjacentFound(PlayerTypes eIndex);																												// Exposed to Python
	void setFoundValue(PlayerTypes eIndex, int iNewValue);

	int getPlayerCityRadiusCount(PlayerTypes eIndex) const;																							// Exposed to Python
	bool isPlayerCityRadius(PlayerTypes eIndex) const;																									// Exposed to Python
	void changePlayerCityRadiusCount(PlayerTypes eIndex, int iChange);

	CvPlotGroup* getPlotGroup(PlayerTypes ePlayer) const;
	CvPlotGroup* getOwnerPlotGroup() const;
	void setPlotGroup(PlayerTypes ePlayer, CvPlotGroup* pNewValue);
	void updatePlotGroup();
	void updatePlotGroup(PlayerTypes ePlayer, bool bRecalculate = true);

	int getVisibilityCount(TeamTypes eTeam) const;																											// Exposed to Python
	void changeVisibilityCount(TeamTypes eTeam, int iChange, InvisibleTypes eSeeInvisible, bool bUpdatePlotGroups);							// Exposed to Python

	int getStolenVisibilityCount(TeamTypes eTeam) const;																								// Exposed to Python
	void changeStolenVisibilityCount(TeamTypes eTeam, int iChange);

	int getBlockadedCount(TeamTypes eTeam) const;																								// Exposed to Python
	void changeBlockadedCount(TeamTypes eTeam, int iChange);

	DllExport PlayerTypes getRevealedOwner(TeamTypes eTeam, bool bDebug) const;													// Exposed to Python
	DllExport TeamTypes getRevealedTeam(TeamTypes eTeam, bool bDebug) const;														// Exposed to Python
	void setRevealedOwner(TeamTypes eTeam, PlayerTypes eNewValue);
	void updateRevealedOwner(TeamTypes eTeam);

	DllExport bool isRiverCrossing(DirectionTypes eIndex) const;																				// Exposed to Python
	void updateRiverCrossing(DirectionTypes eIndex);
	void updateRiverCrossing();

	DllExport bool isRevealed(TeamTypes eTeam, bool bDebug) const;																								// Exposed to Python
	DllExport void setRevealed(TeamTypes eTeam, bool bNewValue, bool bTerrainOnly, TeamTypes eFromTeam, bool bUpdatePlotGroup);	// Exposed to Python
	bool isAdjacentRevealed(TeamTypes eTeam) const;																				// Exposed to Python
	bool isAdjacentNonrevealed(TeamTypes eTeam) const;																				// Exposed to Python

	DllExport ImprovementTypes getRevealedImprovementType(TeamTypes eTeam, bool bDebug) const;					// Exposed to Python
	void setRevealedImprovementType(TeamTypes eTeam, ImprovementTypes eNewValue);			

	DllExport RouteTypes getRevealedRouteType(TeamTypes eTeam, bool bDebug) const;											// Exposed to Python
	void setRevealedRouteType(TeamTypes eTeam, RouteTypes eNewValue);							

	int getBuildProgress(BuildTypes eBuild) const;																											// Exposed to Python  
	bool changeBuildProgress(BuildTypes eBuild, int iChange, TeamTypes eTeam = NO_TEAM);								// Exposed to Python 

// BUG - Partial Builds - start
	bool hasAnyBuildProgress() const;
// BUG - Partial Builds - end

	void updateFeatureSymbolVisibility(); 
	void updateFeatureSymbol(bool bForce = false);

	DllExport bool isLayoutDirty() const;							// The plot layout contains bonuses and improvements --- it is, like the city layout, passively computed by LSystems
	DllExport void setLayoutDirty(bool bDirty);
	DllExport bool isLayoutStateDifferent() const;
	DllExport void setLayoutStateToCurrent();
	bool updatePlotBuilder();

	DllExport void getVisibleImprovementState(ImprovementTypes& eType, bool& bWorked);				// determines how the improvement state is shown in the engine
	DllExport void getVisibleBonusState(BonusTypes& eType, bool& bImproved, bool& bWorked);		// determines how the bonus state is shown in the engine
	DllExport bool shouldUsePlotBuilder();
	DllExport CvPlotBuilder* getPlotBuilder() { return m_pPlotBuilder; }

	DllExport CvRoute* getRouteSymbol() const;
	void updateRouteSymbol(bool bForce = false, bool bAdjacent = false);

	DllExport CvRiver* getRiverSymbol() const;
	void updateRiverSymbol(bool bForce = false, bool bAdjacent = false);
	void updateRiverSymbolArt(bool bAdjacent = true);

	CvFeature* getFeatureSymbol() const;

	DllExport CvFlagEntity* getFlagSymbol() const;
	DllExport CvFlagEntity* getFlagSymbolOffset() const;
	DllExport void updateFlagSymbol();

	DllExport CvUnit* getCenterUnit() const;
	DllExport CvUnit* getDebugCenterUnit() const;
	void setCenterUnit(CvUnit* pNewValue);

	int getCultureRangeCities(PlayerTypes eOwnerIndex, int iRangeIndex) const;														// Exposed to Python
	bool isCultureRangeCity(PlayerTypes eOwnerIndex, int iRangeIndex) const;															// Exposed to Python
	void changeCultureRangeCities(PlayerTypes eOwnerIndex, int iRangeIndex, int iChange, bool bUpdatePlotGroups);

	int getInvisibleVisibilityCount(TeamTypes eTeam, InvisibleTypes eInvisible) const;										// Exposed to Python
	bool isInvisibleVisible(TeamTypes eTeam, InvisibleTypes eInvisible) const;														// Exposed to Python
	void changeInvisibleVisibilityCount(TeamTypes eTeam, InvisibleTypes eInvisible, int iChange);					// Exposed to Python

	DllExport int getNumUnits() const;																																		// Exposed to Python
	DllExport CvUnit* getUnitByIndex(int iIndex) const;																													// Exposed to Python
	void addUnit(CvUnit* pUnit, bool bUpdate = true);
	void removeUnit(CvUnit* pUnit, bool bUpdate = true);
	DllExport CLLNode<IDInfo>* nextUnitNode(CLLNode<IDInfo>* pNode) const;
	DllExport CLLNode<IDInfo>* prevUnitNode(CLLNode<IDInfo>* pNode) const;
	DllExport CLLNode<IDInfo>* headUnitNode() const;
	DllExport CLLNode<IDInfo>* tailUnitNode() const;

	DllExport int getNumSymbols() const;
	CvSymbol* getSymbol(int iID) const;
	CvSymbol* addSymbol();

	void deleteSymbol(int iID);
	void deleteAllSymbols();

	// Script data needs to be a narrow string for pickling in Python
	CvString getScriptData() const;																											// Exposed to Python
	void setScriptData(const char* szNewValue);																					// Exposed to Python

	bool canTrigger(EventTriggerTypes eTrigger, PlayerTypes ePlayer) const;
	bool canApplyEvent(EventTypes eEvent) const;
	void applyEvent(EventTypes eEvent);

	bool canTrain(UnitTypes eUnit, bool bContinue, bool bTestVisible) const;

	bool isEspionageCounterSpy(TeamTypes eTeam) const;

	DllExport int getAreaIdForGreatWall() const;
	DllExport int getSoundScriptId() const;
	DllExport int get3DAudioScriptFootstepIndex(int iFootstepTag) const;
	DllExport float getAqueductSourceWeight() const;  // used to place aqueducts on the map
	DllExport bool shouldDisplayBridge(CvPlot* pToPlot, PlayerTypes ePlayer) const;
	DllExport bool checkLateEra() const;

	void read(FDataStreamBase* pStream);
	void write(FDataStreamBase* pStream);

protected:

	short m_iX;
	short m_iY;
	int m_iArea;
	mutable CvArea *m_pPlotArea;
	short m_iFeatureVariety;
	short m_iOwnershipDuration;
	short m_iImprovementDuration;
	short m_iUpgradeProgress;
	short m_iForceUnownedTimer;
	short m_iCityRadiusCount;
	int m_iRiverID;
	short m_iMinOriginalStartDist;
	short m_iReconCount;
	short m_iRiverCrossingCount;

	bool m_bStartingPlot:1;
	bool m_bHills:1;
	bool m_bNOfRiver:1;
	bool m_bWOfRiver:1;
	bool m_bIrrigated:1;
	bool m_bPotentialCityWork:1;
	bool m_bShowCitySymbols:1;
	bool m_bFlagDirty:1;
	bool m_bPlotLayoutDirty:1;
	bool m_bLayoutStateWorked:1;

	char /*PlayerTypes*/ m_eOwner;
	short /*PlotTypes*/ m_ePlotType;
	short /*TerrainTypes*/ m_eTerrainType;
	short /*FeatureTypes*/ m_eFeatureType;
	short /*BonusTypes*/ m_eBonusType;
	short /*ImprovementTypes*/ m_eImprovementType;
	short /*RouteTypes*/ m_eRouteType;
	char /*CardinalDirectionTypes*/ m_eRiverNSDirection;
	char /*CardinalDirectionTypes*/ m_eRiverWEDirection;

	IDInfo m_plotCity;
	IDInfo m_workingCity;
	IDInfo m_workingCityOverride;

/************************************************************************************************/
/* BETTER_BTS_AI_MOD                      08/21/09                                jdog5000      */
/*                                                                                              */
/* Efficiency                                                                                   */
/************************************************************************************************/
	// Plot danger cache
	bool m_bIsActivePlayerNoDangerCache;
	bool* m_abIsTeamBorderCache;
/************************************************************************************************/
/* BETTER_BTS_AI_MOD                       END                                                  */
/************************************************************************************************/

	short* m_aiYield;
	int* m_aiCulture;
	short* m_aiFoundValue;
	char* m_aiPlayerCityRadiusCount;
	int* m_aiPlotGroup;			// IDs - keep as int
	short* m_aiVisibilityCount;
	short* m_aiStolenVisibilityCount;
	short* m_aiBlockadedCount;
	char* m_aiRevealedOwner;

	bool* m_abRiverCrossing;	// bit vector
	bool* m_abRevealed;

	short* /*ImprovementTypes*/ m_aeRevealedImprovementType;
	short* /*RouteTypes*/ m_aeRevealedRouteType;

	char* m_szScriptData;

	short* m_paiBuildProgress;

	CvFeature* m_pFeatureSymbol;
	CvRoute* m_pRouteSymbol;
	CvRiver* m_pRiverSymbol;
	CvFlagEntity* m_pFlagSymbol;
	CvFlagEntity* m_pFlagSymbolOffset;
	CvUnit* m_pCenterUnit;

	CvPlotBuilder* m_pPlotBuilder;		// builds bonuses and improvements

	char** m_apaiCultureRangeCities;
	short** m_apaiInvisibleVisibilityCount;

	CLinkList<IDInfo> m_units;

	std::vector<CvSymbol*> m_symbols;

	void doFeature();
	void doCulture();

	void processArea(CvArea* pArea, int iChange);
	void doImprovementUpgrade();

	ColorTypes plotMinimapColor();

	// added so under cheat mode we can access protected stuff
	friend class CvGameTextMgr;

	// ************************
	// Added for Planetfall
	// ************************

protected:
	CvPlot** m_paAdjacentPlot;
public:
	CvPlot* getAdjacentPlot(DirectionTypes eDirection) const;
	/*
	inline CvPlot* getAdjacentPlot(DirectionTypes eDirection) const
	{
		FAssert(eDirection > NO_DIRECTION);
		FAssert(eDirection < NUM_DIRECTION_TYPES);
		FAssert(m_paAdjacentPlot[eDirection] != plotDirection(getPointX(), getPointY(), eDirection));
		return m_paAdjacentPlot[eDirection];
	}
	*/

	inline CvPlot* getAdjacentPlotOrSelf(DirectionTypes eDirection)
	{
		if (eDirection == NO_DIRECTION)
		{
			return this;
		}
		FAssert(eDirection > NO_DIRECTION);
		FAssert(eDirection < NUM_DIRECTION_TYPES);
		return m_paAdjacentPlot[eDirection];
	}

	void setAdjacentPlot(DirectionTypes eDirection, CvPlot* pPlot);

protected:
	//updates terrain according to rainfall modifications of improvements
	short /*TerrainTypes*/ m_eOriginalTerrainType_ForCondenser; // Updated only in Condenser code, don't expect it to be valid for other things

	void updateRainfall(bool bAdd);

	// Returns true if this plot is a land plot adjacent to an ocean plot
public:	

	bool isActivePlayerNoRangedDangerCache() const;
	void setIsActivePlayerNoRangedDangerCache( bool bNewValue );
	bool hasDefender(bool bCheckCanAttack, PlayerTypes eOwner, PlayerTypes eAttackingPlayer = NO_PLAYER, const CvUnit* pAttacker = NULL, bool bTestAtWar = false, bool bTestPotentialEnemy = false, bool bTestCanMove = false) const;
	bool isBlockadedMemory() const;
	int getBlockadedMemory() const;
	void setBlockadedMemory(int iNewValue);
	bool isConnectedToCapitalPlanetfall(PlayerTypes ePlayer = NO_PLAYER) const;
	bool isOceanCoastalPlot();
	bool isImprovementInRange(ImprovementTypes eImprovement, int iRange, bool bCheckBuildProgress) const;
	bool isNatureHabitable() const;
	int getNatureSpreadAtFloweringCounter() const;
	bool isCanBloomUpon() const;
	void updateNatureSpreadAtFloweringCounter();
	int getSpawnValue(const CvCity* pCity, const CvPlot* eBestBloomPlot, bool bBloom, bool bSpawn) const;
	void doSpawningSpotSpawns();
	int calculateFeatureYieldChange(FeatureTypes eFeature, YieldTypes eYield, PlayerTypes ePlayer, bool bOptimal = false, bool bDisplay = false) const;
	CvArea* landArea() const;
	TerrainTypes getOriginalTerrainType() const;
	CvUnit* getBestRangedDefender(PlayerTypes eOwner, PlayerTypes eAttackingPlayer = NO_PLAYER, const CvUnit* pAttacker = NULL, bool bTestAtWar = false, bool bTestPotentialEnemy = false, bool bTestCanMove = false, bool bRangedStrike = false) const;
	
protected:

	bool m_bIsActivePlayerNoRangedDangerCache;
	int m_iBlockadedMemory;
	int m_iNatureSpreadAtFloweringCounter;

	// ************************
	// End Added For Planetfall
	// ************************
};

#endif

[Commander Bello]

ich habe da jetzt beim Durchscrollen nur eine Funktion

DllExport FeatureTypes getFeatureType() const;

gefunden

[Monaldinio]

ich habe da jetzt beim Durchscrollen nur eine Funktion

DllExport FeatureTypes getFeatureType() const;

gefunden

Für den Bonus habe ich das gefunden...

DllExport BonusTypes getBonusType(TeamTypes eTeam = NO_TEAM) const;

Dann würde ich deine Funktion folgendermaßen ergänzen???

DllExport FeatureTypes getFeatureType(TeamTypes eTeam = NO_TEAM) const;

[Monaldinio]

Nachdem ich die oben genannte Änderung in der CvPlot.h durchgeführt habe, konnte ich ohne Fehler kompilieren.
Danach habe ich den neuen Tag in das TerrainSchema eingetragen, ob der Tag an der richtigen stelle sitzt, weiß ich nicht.

Achtung Spoiler:

<!-- edited with XMLSPY v2004 rel. 2 U (http://www.xmlspy.com) by Alex Mantzaris (Firaxis Games) -->
<!-- Sid Meier's Civilization 4 -->
<!-- Copyright Firaxis Games 2005 -->
<!-- -->
<!-- Terrain Schema -->
<Schema xmlns="urn:schemas-microsoft-com:xml-data" xmlns:dt="urn:schemas-microsoft-com:datatypes">
	<!-- Added for Planetfall -->
	<ElementType name="bNature" content="textOnly" dt:type="boolean"/>
	<ElementType name="ReplaceFeatureType" content="textOnly"/>
	<ElementType name="TradeTech" content="textOnly"/>
	<ElementType name="iReplaceFeatureBeforeFloweringCounter" content="textOnly" dt:type="int"/>
	<ElementType name="iAdjacentRainfallChange100" content="textOnly" dt:type="int"/>
	
	<ElementType name="iFloweringCounter100" content="textOnly" dt:type="int"/>

	<ElementType name="iNatureHabitableAtFloweringCounter" content="textOnly" dt:type="int"/>
	<ElementType name="iTerrainSpecialType" content="textOnly" dt:type="int"/>
	<ElementType name="DrierTerrainType" content="textOnly"/>
	<ElementType name="MoisterTerrainType" content="textOnly"/>

	<!-- PlotType-specific Yield Changes -->
	<ElementType name="PlotType" content="textOnly"/>
	<ElementType name="PlotTypeYieldChange" content="eltOnly">
		<element type="PlotType" minOccurs="1" maxOccurs="1"/> <!-- The type of plot (PLOT_HILLS, PLOT_PEAK, PLOT_LAND,  PLOT_OCEAN -->
		<element type="Yields" minOccurs="1" maxOccurs="1"/> <!-- The typical three iYields values -->
	</ElementType>
	<ElementType name="PlotTypeYieldChanges" content="eltOnly">
		<element type="PlotTypeYieldChange" maxOccurs="*"/> <!-- A group of PlotType and Yields for that plot type. One of these for each plot you want to have the yields changed for. -->
	</ElementType>

	<!-- TerrainType-specific Yield Changes -->
	<ElementType name="TerrainTypeYieldChange" content="eltOnly">
		<element type="TerrainType" minOccurs="1" maxOccurs="1"/> <!-- The type of  terrain (such as TERRAIN_PLAINS) -->
		<element type="Yields" minOccurs="1" maxOccurs="1"/> <!-- The typical three iYields values -->
	</ElementType>
	<ElementType name="TerrainTypeYieldChanges" content="eltOnly">
		<element type="TerrainTypeYieldChange" maxOccurs="*"/> <!-- A group of TerrainType and Yields for that terrain type. One of these for each terrain you want to have the yields changed for. -->
	</ElementType>

	<!-- Coastal plot Yield Changes -->

	<ElementType name="CoastalYieldChange" content="eltOnly">		
		<element type="iYield" minOccurs="0" maxOccurs="*"/> <!-- The typical three iYields values -->
	</ElementType>

	<!-- City Planet Value -->
	<ElementType name="iCityPlanet" content="textOnly" dt:type="int"/>
	<ElementType name="iCityPlanetPercent" content="textOnly" dt:type="int"/>

	<!-- Building Improvement Yield Changes -->
	<ElementType name="BuildingType" content="textOnly"/>

	<ElementType name="BuildingYieldChange" content="eltOnly">
		<element type="BuildingType"/>
		<element type="Yields"/>
	</ElementType>

	<ElementType name="BuildingYieldChanges" content="eltOnly">
		<element type="BuildingYieldChange" minOccurs="0" maxOccurs="*"/>
	</ElementType>

	<!-- Feature Growth Changes -->
	<ElementType name="iGrowthChange" content="textOnly" dt:type="int"/>

	<ElementType name="TechGrowthChange" content="eltOnly">
		<element type="PrereqTech" minOccurs="1" maxOccurs="1"/> <!-- The tech that causes the change -->
		<element type="iGrowthChange" minOccurs="1" maxOccurs="1"/> <!-- The change in probability (out of 10,000, so a value of "10" is an additional 10/10,000, or 0.1% change) -->
	</ElementType>

	<ElementType name="TechGrowthChanges" content="eltOnly">
		<element type="TechGrowthChange" minOccurs="0" maxOccurs="*"/> <!-- Changes the probabiliy of a feature spreading to another plot -->
	</ElementType>

	<ElementType name="bBadTerrain" content="textOnly" dt:type="boolean"/>
	<ElementType name="bRocky" content="textOnly" dt:type="boolean"/>

	<!-- End Added for Planetfall -->
	
	<ElementType name="Civilopedia" content="textOnly"/>
	<ElementType name="Help" content="textOnly"/>
	<ElementType name="SymbolMeshPath" content="textOnly"/>
	<ElementType name="SymbolMeshPaths" content="eltOnly">
		<element type="SymbolMeshPath" maxOccurs="*"/>
	</ElementType>
	<ElementType name="iYield" content="textOnly" dt:type="int"/>
	<ElementType name="Yields" content="eltOnly">
		<element type="iYield" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="RiverYieldChange" content="eltOnly">
		<element type="iYield" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="HillsYieldChange" content="eltOnly">
		<element type="iYield" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="bWater" content="textOnly" dt:type="boolean"/>
	<ElementType name="bImpassable" content="textOnly" dt:type="boolean"/>
	<ElementType name="bFound" content="textOnly" dt:type="boolean"/>
	<ElementType name="bFoundCoast" content="textOnly" dt:type="boolean"/>
	<ElementType name="bFoundFreshWater" content="textOnly" dt:type="boolean"/>
	<ElementType name="iMovement" content="textOnly" dt:type="int"/>
	<ElementType name="iSeeFrom" content="textOnly" dt:type="int"/>
	<ElementType name="iSeeThrough" content="textOnly" dt:type="int"/>
	<ElementType name="iBuildModifier" content="textOnly" dt:type="int"/>
	<ElementType name="iDefense" content="textOnly" dt:type="int"/>
	<ElementType name="Button" content="textOnly"/>
	<ElementType name="FootstepAudioType" content="textOnly"/>
	<ElementType name="FootstepAudioScript" content="textOnly"/>
	<ElementType name="FootstepSound" content="eltOnly">
		<element type="FootstepAudioType" minOccurs="1"/>
		<element type="FootstepAudioScript"/>
	</ElementType>
	<ElementType name="FootstepSounds" content="eltOnly">
		<element type="FootstepSound" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="WorldSoundscapeAudioScript" content="textOnly"/>
	<ElementType name="bGraphicalOnly" content="textOnly" dt:type="boolean"/>
	<ElementType name="TerrainInfo" content="eltOnly">
		<element type="Type"/>
		<element type="Description"/>

		<!-- Added for Planetfall -->

		<element type="iNatureHabitableAtFloweringCounter" minOccurs="0"/>
		<element type="iTerrainSpecialType" minOccurs="0"/>
		<element type="DrierTerrainType" minOccurs="0"/>
		<element type="MoisterTerrainType" minOccurs="0"/>
		<element type="bBadTerrain" minOccurs="0"/>
		<element type="bRocky" minOccurs="0"/>

		<!-- End for Planetfall -->

		<element type="Civilopedia"/>
		<element type="Help" minOccurs="0"/>
		<element type="ArtDefineTag"/>
		<element type="Yields"/>
		<element type="RiverYieldChange"/>
		<element type="HillsYieldChange"/>
		<element type="bWater"/>
		<element type="bImpassable"/>
		<element type="bFound"/>
		<element type="bFoundCoast"/>
		<element type="bFoundFreshWater"/>
		<element type="iMovement"/>
		<element type="iSeeFrom"/>
		<element type="iSeeThrough"/>
		<element type="iBuildModifier"/>
		<element type="iDefense"/>
		<element type="Button"/>
		<element type="FootstepSounds"/>
		<element type="WorldSoundscapeAudioScript" minOccurs="0"/>
		<element type="bGraphicalOnly"/>
	</ElementType>
	<ElementType name="TerrainInfos" content="eltOnly">
		<element type="TerrainInfo" maxOccurs="*"/>
	</ElementType>
	<ElementType name="Description" content="textOnly"/>
	<ElementType name="iHillsChange" content="textOnly" dt:type="int"/>
	<ElementType name="iPeakChange" content="textOnly" dt:type="int"/>
	<ElementType name="iLakeChange" content="textOnly" dt:type="int"/>
	<ElementType name="iCityChange" content="textOnly" dt:type="int"/>
	<ElementType name="iPopulationChangeOffset" content="textOnly" dt:type="int"/>
	<ElementType name="iPopulationChangeDivisor" content="textOnly" dt:type="int"/>
	<ElementType name="iMinCity" content="textOnly" dt:type="int"/>
	<ElementType name="iTradeModifier" content="textOnly" dt:type="int"/>
	<ElementType name="iGoldenAgeYield" content="textOnly" dt:type="int"/>
	<ElementType name="iGoldenAgeYieldThreshold" content="textOnly" dt:type="int"/>
	<ElementType name="iAIWeightPercent" content="textOnly" dt:type="int"/>
	<ElementType name="ColorType" content="textOnly"/>
	<ElementType name="SymbolPath" content="textOnly"/>
	<ElementType name="SymbolPaths" content="eltOnly">
		<element type="SymbolPath" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="YieldInfo" content="eltOnly">
		<element type="Type"/>
		<element type="Description"/>
		<element type="iHillsChange"/>
		<element type="iPeakChange"/>
		<element type="iLakeChange"/>
		<element type="iCityChange"/>
		<element type="iPopulationChangeOffset"/>
		<element type="iPopulationChangeDivisor"/>
		<element type="iMinCity"/>
		<element type="iTradeModifier"/>
		<element type="iGoldenAgeYield"/>
		<element type="iGoldenAgeYieldThreshold"/>
		<element type="iAIWeightPercent"/>
		<element type="ColorType"/>
		<element type="SymbolPaths"/>
	</ElementType>
	<ElementType name="YieldInfos" content="eltOnly">
		<element type="YieldInfo" maxOccurs="*"/>
	</ElementType>
	<ElementType name="FeatureType" content="textOnly"/>
	<ElementType name="FeatureName" content="textOnly"/>
	<ElementType name="iYieldChange" content="textOnly" dt:type="int"/>
	<ElementType name="YieldChanges" content="eltOnly">
		<element type="iYieldChange" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="iHealthPercent" content="textOnly" dt:type="int"/>
	<ElementType name="iAppearance" content="textOnly" dt:type="int"/>
	<ElementType name="iDisappearance" content="textOnly" dt:type="int"/>
	<ElementType name="TechReveal" content="textOnly"/>						<!-- Hier Hinzugefügt, neuer Tag für FeatureInfos -->
	<ElementType name="iGrowth" content="textOnly" dt:type="int"/>
	<ElementType name="iTurnDamage" content="textOnly" dt:type="int"/>
	<ElementType name="bNoCoast" content="textOnly" dt:type="boolean"/>
	<ElementType name="bNoRiver" content="textOnly" dt:type="boolean"/>
	<ElementType name="bNoAdjacent" content="textOnly" dt:type="boolean"/>
	<ElementType name="bRequiresFlatlands" content="textOnly" dt:type="boolean"/>
	<ElementType name="bRequiresRiver" content="textOnly" dt:type="boolean"/>
	<ElementType name="bAddsFreshWater" content="textOnly" dt:type="boolean"/>
	<ElementType name="bNoCity" content="textOnly" dt:type="boolean"/>
	<ElementType name="bNoImprovement" content="textOnly" dt:type="boolean"/>
	<ElementType name="bVisibleAlways" content="textOnly" dt:type="boolean"/>
	<ElementType name="bNukeImmune" content="textOnly" dt:type="boolean"/>
	<ElementType name="bTerrain" content="textOnly" dt:type="boolean"/>
	<ElementType name="TerrainBoolean" content="eltOnly">
		<element type="TerrainType"/>
		<element type="bTerrain"/>
	</ElementType>
	<ElementType name="TerrainBooleans" content="eltOnly">
		<element type="TerrainBoolean" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="EffectType" content="textOnly"/>
	<ElementType name="iEffectProbability" content="textOnly" dt:type="int"/>
	<ElementType name="OnUnitChangeTo" content="textOnly"/>
	<ElementType name="FeatureInfo" content="eltOnly">
		<element type="Type"/>
		<element type="Description"/>

		<!-- Added for Planetfall -->

		<element type="iNatureHabitableAtFloweringCounter" minOccurs="0"/>
		<element type="iFloweringCounter100" minOccurs="0"/>
		<element type="iCityPlanetPercent" minOccurs="0"/>
		<element type="bNature" minOccurs="0"/>
		<element type="ReplaceFeatureType" minOccurs="0"/>
		<element type="iReplaceFeatureBeforeFloweringCounter" minOccurs="0"/>
		<element type="TradeTech" minOccurs="0"/>
		<element type="TechYieldChanges" minOccurs="0"/>
		<element type="TechGrowthChanges" minOccurs="0"/>

		<!-- End Added for Planetfall -->

		<element type="Civilopedia"/>
		<element type="Help" minOccurs="0"/>
		<element type="ArtDefineTag"/>
		<element type="YieldChanges"/>
		<element type="RiverYieldChange"/>
		<element type="HillsYieldChange"/>
		<element type="iMovement"/>
		<element type="iSeeThrough"/>
		<element type="iHealthPercent"/>
		<element type="iDefense"/>
		<element type="iAppearance"/>
		<element type="iDisappearance"/>
		<element type="TechReveal"/>			<!-- Hier Hinzugefügt, neuer Tag für FeatureInfos -->
		<element type="iGrowth"/>
		<element type="iTurnDamage"/>
		<element type="bNoCoast"/>
		<element type="bNoRiver"/>
		<element type="bNoAdjacent"/>
		<element type="bRequiresFlatlands"/>
		<element type="bRequiresRiver"/>
		<element type="bAddsFreshWater"/>
		<element type="bImpassable"/>
		<element type="bNoCity"/>
		<element type="bNoImprovement"/>
		<element type="bVisibleAlways"/>
		<element type="bNukeImmune"/>
		<element type="OnUnitChangeTo"/>
		<element type="TerrainBooleans"/>
		<element type="FootstepSounds"/>
		<element type="WorldSoundscapeAudioScript" minOccurs="0"/>
		<element type="EffectType"/>
		<element type="iEffectProbability"/>
		<element type="iAdvancedStartRemoveCost"/>
	</ElementType>
	<ElementType name="FeatureInfos" content="eltOnly">
		<element type="FeatureInfo" maxOccurs="*"/>
	</ElementType>
	<ElementType name="BonusClassInfo" content="eltOnly">
		<element type="Type"/>
		<element type="iUnique"/>
	</ElementType>
	<ElementType name="BonusClassInfos" content="eltOnly">
		<element type="BonusClassInfo" maxOccurs="*"/>
	</ElementType>
	<ElementType name="BonusName" content="textOnly"/>
	<ElementType name="TerrainType" content="textOnly"/>
	<ElementType name="BonusClassType" content="textOnly"/>
	<ElementType name="TechReveal" content="textOnly"/>	
	<ElementType name="TechCityTrade" content="textOnly"/>
	<ElementType name="TechObsolete" content="textOnly"/>
	<ElementType name="iAITradeModifier" content="textOnly" dt:type="int"/>
	<ElementType name="iAIObjective" content="textOnly" dt:type="int"/>
	<ElementType name="iHealth" content="textOnly" dt:type="int"/>
	<ElementType name="iHappiness" content="textOnly" dt:type="int"/>
	<ElementType name="iPlacementOrder" content="textOnly" dt:type="int"/>
	<ElementType name="iConstAppearance" content="textOnly" dt:type="int"/>
	<ElementType name="iMinAreaSize" content="textOnly" dt:type="int"/>
	<ElementType name="iMinLatitude" content="textOnly" dt:type="int"/>
	<ElementType name="iMaxLatitude" content="textOnly" dt:type="int"/>
	<ElementType name="iRandApp1" content="textOnly" dt:type="int"/>
	<ElementType name="iRandApp2" content="textOnly" dt:type="int"/>
	<ElementType name="iRandApp3" content="textOnly" dt:type="int"/>
	<ElementType name="iRandApp4" content="textOnly" dt:type="int"/>
	<ElementType name="Rands" content="eltOnly">
		<element type="iRandApp1"/>
		<element type="iRandApp2"/>
		<element type="iRandApp3"/>
		<element type="iRandApp4"/>
	</ElementType>
	<ElementType name="iPlayer" content="textOnly" dt:type="int"/>
	<ElementType name="iTilesPer" content="textOnly" dt:type="int"/>
	<ElementType name="iMinLandPercent" content="textOnly" dt:type="int"/>
	<ElementType name="iUnique" content="textOnly" dt:type="int"/>
	<ElementType name="iGroupRange" content="textOnly" dt:type="int"/>
	<ElementType name="iGroupRand" content="textOnly" dt:type="int"/>
	<ElementType name="bArea" content="textOnly" dt:type="boolean"/>
	<ElementType name="bHills" content="textOnly" dt:type="boolean"/>
	<ElementType name="bFlatlands" content="textOnly" dt:type="boolean"/>
	<ElementType name="bNoRiverSide" content="textOnly" dt:type="boolean"/>
	<ElementType name="bNormalize" content="textOnly" dt:type="boolean"/>
	<ElementType name="bFeature" content="textOnly" dt:type="boolean"/>
	<ElementType name="FeatureBoolean" content="eltOnly">
		<element type="FeatureType"/>
		<element type="bFeature"/>
	</ElementType>
	<ElementType name="FeatureBooleans" content="eltOnly">
		<element type="FeatureBoolean" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="bFeatureTerrain" content="textOnly" dt:type="boolean"/>
	<ElementType name="FeatureTerrainBoolean" content="eltOnly">
		<element type="TerrainType"/>
		<element type="bFeatureTerrain"/>
	</ElementType>
	<ElementType name="FeatureTerrainBooleans" content="eltOnly">
		<element type="FeatureTerrainBoolean" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="bUseLSystem" content="textOnly" dt:type="boolean"/>
	<ElementType name="BonusInfo" content="eltOnly">
		<element type="Type"/>
		<element type="Description"/>

		<!-- Added for Planetfall -->

		<!-- City Planet Value -->
		<element type="iCityPlanet" minOccurs="0"/> <!-- Changes the planet value of a city that is connected to this resource. -->
		<element type="bGraphicalOnly" minOccurs="0"/>

		<!-- End Added for Planetfall -->

		<element type="Civilopedia"/>
		<element type="Help" minOccurs="0"/>
		<element type="BonusClassType"/>
		<element type="ArtDefineTag"/>
		<element type="TechReveal"/>
		<element type="TechCityTrade"/>
		<element type="TechObsolete"/>
		<element type="YieldChanges"/>
		<element type="iAITradeModifier"/>
		<element type="iAIObjective"/>
		<element type="iHealth"/>
		<element type="iHappiness"/>
		<element type="iPlacementOrder"/>
		<element type="iConstAppearance"/>
		<element type="iMinAreaSize"/>
		<element type="iMinLatitude"/>
		<element type="iMaxLatitude"/>
		<element type="Rands"/>
		<element type="iPlayer"/>
		<element type="iTilesPer"/>
		<element type="iMinLandPercent"/>
		<element type="iUnique"/>
		<element type="iGroupRange"/>
		<element type="iGroupRand"/>
		<element type="bArea"/>
		<element type="bHills"/>
		<element type="bFlatlands"/>
		<element type="bNoRiverSide"/>
		<element type="bNormalize"/>
		<element type="TerrainBooleans"/>
		<element type="FeatureBooleans"/>
		<element type="FeatureTerrainBooleans"/>
		<element type="bUseLSystem" minOccurs="0"/>
	</ElementType>
	<ElementType name="BonusInfos" content="eltOnly">
		<element type="BonusInfo" maxOccurs="*"/>
	</ElementType>
	<ElementType name="Civ4TerrainInfos" content="eltOnly">
		<element type="TerrainInfos" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="Civ4YieldInfos" content="eltOnly">
		<element type="YieldInfos" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="Civ4FeatureInfos" content="eltOnly">
		<element type="FeatureInfos" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="Civ4BonusInfos" content="eltOnly">
		<element type="BonusInfos" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="Civ4BonusClassInfos" content="eltOnly">
		<element type="BonusClassInfos" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="Civ4Terrain" content="eltOnly">
		<element type="TerrainInfos" minOccurs="0" maxOccurs="*"/>
		<element type="YieldInfos" minOccurs="0" maxOccurs="*"/>
		<element type="FeatureInfos" minOccurs="0" maxOccurs="*"/>
		<element type="BonusInfos" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="ArtDefineTag" content="textOnly"/>
	<ElementType name="Type" content="textOnly"/>
	<ElementType name="iWaterHeight" content="textOnly" dt:type="int"/>
	<ElementType name="bRandomMap" content="textOnly" dt:type="boolean"/>
	<ElementType name="HeightMap" content="textOnly"/>
	<ElementType name="TerrainMap" content="textOnly"/>
	<ElementType name="NormalMap" content="textOnly"/>
	<ElementType name="BlendMap" content="textOnly"/>
	<ElementType name="SkyArt" content="textOnly"/>
	<ElementType name="iFogR" content="textOnly" dt:type="int"/>
	<ElementType name="iFogG" content="textOnly" dt:type="int"/>
	<ElementType name="iFogB" content="textOnly" dt:type="int"/>
	<ElementType name="fTextureScaleX" content="textOnly"/>
	<ElementType name="fTextureScaleY" content="textOnly"/>
	<ElementType name="iPlotsPerCellX" content="textOnly" dt:type="int"/>
	<ElementType name="iPlotsPerCellY" content="textOnly" dt:type="int"/>
	<ElementType name="iGameCellSizeX" content="textOnly" dt:type="int"/>
	<ElementType name="iGameCellSizeY" content="textOnly" dt:type="int"/>
	<ElementType name="fZScale" content="textOnly"/>
	<ElementType name="bTerrainShader" content="textOnly" dt:type="boolean"/>
	<ElementType name="bUseLightmap" content="textOnly" dt:type="boolean"/>
	<ElementType name="fPeakScale" content="textOnly"/>
	<ElementType name="fHillScale" content="textOnly"/>
	<ElementType name="TerrainTextureInfo" content="eltOnly">
		<element type="Type"/>
		<element type="Description"/>
		<element type="ArtDefineTag"/>
	</ElementType>
	<ElementType name="TerrainTextureInfos" content="eltOnly">
		<element type="TerrainTextureInfo" minOccurs="1" maxOccurs="*"/>
	</ElementType>
	<ElementType name="PrereqNatureYields" content="eltOnly">
		<element type="iYield" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="RouteType" content="textOnly"/>
	<ElementType name="RouteYields" content="eltOnly">
		<element type="iYield" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="RouteYieldChange" content="eltOnly">
		<element type="RouteType"/>
		<element type="RouteYields"/>
	</ElementType>
	<ElementType name="RouteYieldChanges" content="eltOnly">
		<element type="RouteYieldChange" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="PrereqTech" content="textOnly"/>
	<ElementType name="TechYields" content="eltOnly">
		<element type="iYield" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="TechYieldChange" content="eltOnly">
		<element type="PrereqTech"/>
		<element type="TechYields"/>
	</ElementType>
	<ElementType name="TechYieldChanges" content="eltOnly">
		<element type="TechYieldChange" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="RiverSideYieldChange" content="eltOnly">
		<element type="iYield" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="IrrigatedYieldChange" content="eltOnly">
		<element type="iYield" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="BonusType" content="textOnly"/>
	<ElementType name="bBonusMakesValid" content="textOnly" dt:type="boolean"/>
	<ElementType name="bBonusTrade" content="textOnly" dt:type="boolean"/>
	<ElementType name="iDiscoverRand" content="textOnly" dt:type="int"/>
	<ElementType name="BonusTypeStruct" content="eltOnly">
		<element type="BonusType"/>
		<element type="bBonusMakesValid"/>
		<element type="bBonusTrade"/>
		<element type="iDiscoverRand"/>
		<element type="YieldChanges" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="BonusTypeStructs" content="eltOnly">
		<element type="BonusTypeStruct" maxOccurs="*"/>
	</ElementType>
	<ElementType name="ImprovementPillage" content="textOnly"/>
	<ElementType name="ImprovementUpgrade" content="textOnly"/>
	<ElementType name="bActsAsCity" content="textOnly" dt:type="boolean"/>
	<ElementType name="bHillsMakesValid" content="textOnly" dt:type="boolean"/>
	<ElementType name="bFreshWaterMakesValid" content="textOnly" dt:type="boolean"/>
	<ElementType name="bRiverSideMakesValid" content="textOnly" dt:type="boolean"/>
	<ElementType name="bNoFreshWater" content="textOnly" dt:type="boolean"/>
	<ElementType name="bRequiresRiverSide" content="textOnly" dt:type="boolean"/>
	<ElementType name="bRequiresIrrigation" content="textOnly" dt:type="boolean"/>
	<ElementType name="bCarriesIrrigation" content="textOnly" dt:type="boolean"/>
	<ElementType name="bRequiresFeature" content="textOnly" dt:type="boolean"/>
	<ElementType name="bGoody" content="textOnly" dt:type="boolean"/>
	<ElementType name="bPermanent" content="textOnly" dt:type="boolean"/>
	<ElementType name="iGoodyRange" content="textOnly" dt:type="int"/>
	<ElementType name="iFeatureGrowth" content="textOnly" dt:type="int"/>
	<ElementType name="iAirBombDefense" content="textOnly" dt:type="int"/>
	<ElementType name="iDefenseModifier" content="textOnly" dt:type="int"/>
	<ElementType name="iPillageGold" content="textOnly" dt:type="int"/>
	<ElementType name="bOutsideBorders" content="textOnly" dt:type="boolean"/>
	<ElementType name="iAdvancedStartCost" content="textOnly" dt:type="int"/>
	<ElementType name="iAdvancedStartRemoveCost" content="textOnly" dt:type="int"/>
	<ElementType name="iAdvancedStartCostIncrease" content="textOnly" dt:type="int"/>
	<ElementType name="iTilesPerGoody" content="textOnly" dt:type="int"/>
	<ElementType name="iUpgradeTime" content="textOnly" dt:type="int"/>
	<ElementType name="bMakesValid" content="textOnly" dt:type="boolean"/>
	<ElementType name="TerrainMakesValid" content="eltOnly">
		<element type="TerrainType"/>
		<element type="bMakesValid"/>
	</ElementType>
	<ElementType name="TerrainMakesValids" content="eltOnly">
		<element type="TerrainMakesValid" minOccurs="0" maxOccurs="*"/>
	</ElementType>
	<ElementType name="FeatureMakesValid" content="eltOnly">
		<element type="FeatureType"/>
		<element type="bMakesValid"/>
	</ElementType>
	<ElementType name="FeatureMakesValids" content="eltOnly">
		<element type="FeatureMakesValid" minOccurs="0" maxOccurs="*"/>
	</ElementType>
<!-- Orbital Cities-->
	<ElementType name="bOrbital" content="textOnly" dt:type="boolean"/>
	<ElementType name="ImprovementInfo" content="eltOnly">
		<element type="Type"/>
		<element type="Description"/>

		<!-- Added for Planetfall -->

		<!-- Improvements add fresh water -->
		<element type="iNatureHabitableAtFloweringCounter"/>
		<element type="bAddsFreshWater" minOccurs="0"/> <!-- This improvement provides the plot with fresh water if true -->
		<element type="iAdjacentRainfallChange100" minOccurs="0"/> <!-- This improvement changes rainfall in adjacent squares (100 = +1 rainfall) -->
		<element type="iFloweringCounter100" minOccurs="0"/>
		
		<!-- Allow yield changes depending on underlying plot type -->
		<element type="PlotTypeYieldChanges" minOccurs="0"/> <!-- Modifies the yields of a plot with this improvement depending on the plot type (water,land,hill,peak) -->
		<element type="TerrainTypeYieldChanges" minOccurs="0"/> <!-- Modifies the yields of a plot with this improvement depending on the terrain type (plains, grass, etc.) -->
		<element type="CoastalYieldChange" minOccurs="0"/> <!-- Modifies the yields of a plot with this improvement if it's a coastal plot -->

		<!-- City Planet Value -->
		<element type="iCityPlanetPercent" minOccurs="0"/> <!-- The change in a city's Planet value if this improvement is within their range. A value of 100 changes one point. These accumulate with other features or improvements with this tag, so two features with 50 iPercentValue do 100 percent, or one additional planet value -->

		<!-- Building Improvement Yield Changes -->
		<element type="BuildingYieldChanges" minOccurs="0"/> <!-- Modifiers to the yields when the city working this improvement's plot has a specific building -->

		<!-- End Added for Planetfall -->

		<element type="Civilopedia"/>
		<element type="Help" minOccurs="0"/>
		<element type="ArtDefineTag"/>
		<element type="PrereqNatureYields" minOccurs="0"/>
		<element type="YieldChanges" minOccurs="0"/>
		<element type="RiverSideYieldChange" minOccurs="0"/>
		<element type="HillsYieldChange" minOccurs="0"/>
		<element type="IrrigatedYieldChange" minOccurs="0"/>
		<element type="bActsAsCity"/>
		<element type="bHillsMakesValid"/>
		<element type="bFreshWaterMakesValid"/>
		<element type="bRiverSideMakesValid"/>
		<element type="bNoFreshWater"/>
		<element type="bRequiresFlatlands"/>
		<element type="bRequiresRiverSide"/>
		<element type="bRequiresIrrigation"/>
		<element type="bCarriesIrrigation"/>
		<element type="bRequiresFeature"/>
		<element type="bWater"/>
		<element type="bGoody"/>
		<element type="bPermanent"/>
		<element type="bUseLSystem" minOccurs="0"/>
		<element type="iAdvancedStartCost"/>
		<element type="iAdvancedStartCostIncrease"/>
		<element type="iTilesPerGoody"/>
		<element type="iGoodyRange"/>
		<element type="iFeatureGrowth"/>
		<element type="iUpgradeTime"/>
		<element type="iAirBombDefense"/>
		<element type="iDefenseModifier"/>
		<element type="iHappiness"/>
		<element type="iPillageGold"/>
		<element type="bOutsideBorders"/>
		<element type="TerrainMakesValids"/>
		<element type="FeatureMakesValids"/>
		<element type="BonusTypeStructs" minOccurs="0" maxOccurs="*"/>
		<element type="ImprovementPillage"/>
		<element type="ImprovementUpgrade"/>
		<element type="TechYieldChanges"/>
		<element type="RouteYieldChanges"/>
		<element type="WorldSoundscapeAudioScript" minOccurs="0"/>
		<element type="bGraphicalOnly"/>
<!--Orbital Cities from Planetfall-->
		<element type="bOrbital" minOccurs="0"/>
	</ElementType>
	<ElementType name="ImprovementInfos" content="eltOnly">
		<element type="ImprovementInfo" maxOccurs="*"/>
	</ElementType>
	<ElementType name="LandscapeInfo" content="eltOnly">
		<element type="Type"/>
		<element type="iWaterHeight"/>
		<element type="bRandomMap"/>
		<element type="HeightMap"/>
		<element type="TerrainMap"/>
		<element type="NormalMap"/>
		<element type="BlendMap"/>
		<element type="SkyArt"/>
		<element type="iFogR"/>
		<element type="iFogG"/>
		<element type="iFogB"/>
		<element type="fTextureScaleX"/>
		<element type="fTextureScaleY"/>
		<element type="iPlotsPerCellX"/>
		<element type="iPlotsPerCellY"/>
		<element type="iGameCellSizeX"/>
		<element type="iGameCellSizeY"/>
		<element type="fZScale"/>
		<element type="bTerrainShader"/>
		<element type="bUseLightmap"/>
		<element type="fPeakScale"/>
		<element type="fHillScale"/>
	</ElementType>
	<ElementType name="LandscapeInfos" content="eltOnly">
		<element type="LandscapeInfo" minOccurs="1" maxOccurs="*"/>
	</ElementType>
	<ElementType name="Civ4TerrainSettings" content="eltOnly">
		<element type="LandscapeInfos" minOccurs="1" maxOccurs="1"/>
	</ElementType>
	<ElementType name="Civ4ImprovementInfos" content="eltOnly">
		<element type="ImprovementInfos" minOccurs="0" maxOccurs="*"/>
	</ElementType>
</Schema>

Beim Start bekomme ich folgenden Fehler, siehe Bild!
Am der TechInfo habe ich nichts gemacht.

[Flunky]

Soweit ok. Jetzt braucht jede FeatureInfo in CIV4FeatureInfos.xml einen Knoten TechReveal an dieser Stelle.

[Monaldinio]

Wenn die Ursache des Fehlers wirklich ein Fehlen des <TechTeveal> Tags in der FestureInfo.xml wäre,
Würde doch die Fehlermeldung "...entspricht nicht dem TerrainSchemata.xml" kommen.

Außerdem habe ich einmal den neuen Tag in der FeatureInfo.xml eingebaut...

Naja, ich werd ihn nochmal bei jedem FeatureInfo einbauen und mich dann melden.

[Flunky]

Dann schau dich mal in der CvInfos.cpp um, da wird SetVariableListTagPair benutzt.

[Monaldinio]

Da gibts es dutzende die so beginnen: SetVariableListTagPair

Glaube noch jedoch das der Fehler wohl doch irgendwo in den xml liegt.

Als laie würde ich meinen es liegt an der TarrainSchema...
Aber ich wüsste auch nicht was ich anders machen sollte...

[Flunky]

Aye, dutzende, die den xml-Einträgen irgendwas anderes zuordnen. Zumindest würd ich das spontan so interpretieren. Neuer xml-Eintrag -> neuer call zu SetVariableListTagPair.

[Monaldinio]

Aye, dutzende, die den xml-Einträgen irgendwas anderes zuordnen. Zumindest würd ich das spontan so interpretieren. Neuer xml-Eintrag -> neuer call zu SetVariableListTagPair.

Ich habe aber nichts dergleichen hinzugefügt, alles was ich in der CvInfo.cpp und .h hinzugefügt habe war:

Achtung Spoiler:

Hier mal was ich in der cvInfo.ccp eingebaut habe

//======================================================================================================
//					CvFeatureInfo
//======================================================================================================

//------------------------------------------------------------------------------------------------------
//
//  FUNCTION:   CvFeatureInfo()
//
//  PURPOSE :   Default constructor
//
//------------------------------------------------------------------------------------------------------
CvFeatureInfo::CvFeatureInfo() :
m_iMovementCost(0),
m_iSeeThroughChange(0),
m_iHealthPercent(0),
m_iAppearanceProbability(0),
m_iDisappearanceProbability(0),
m_iTechReveal(0),

CvFeatureInfo::~CvFeatureInfo()
{
	SAFE_DELETE_ARRAY(m_piYieldChange);
	SAFE_DELETE_ARRAY(m_piRiverYieldChange);
	SAFE_DELETE_ARRAY(m_piHillsYieldChange);
	SAFE_DELETE_ARRAY(m_pi3DAudioScriptFootstepIndex);
	SAFE_DELETE_ARRAY(m_pbTerrain);

	// ************************
	// Added for Planetfall
	// ************************
	// Feature Tech Yield Changes
	int iI;
	if (m_ppiTechYieldChanges != NULL)
	{
		for (iI=0;iI<GC.getNumTechInfos();iI++)
		{
			SAFE_DELETE_ARRAY(m_ppiTechYieldChanges[iI]);
		}
		SAFE_DELETE_ARRAY(m_ppiTechYieldChanges);
	}
	// ************************
	// End Added for Planetfall
	// ************************
}

int CvFeatureInfo::getMovementCost() const
{
	return m_iMovementCost;
}

int CvFeatureInfo::getSeeThroughChange() const
{
	return m_iSeeThroughChange;
}

int CvFeatureInfo::getHealthPercent() const
{
	return m_iHealthPercent;
}

int CvFeatureInfo::getAppearanceProbability() const
{
	return m_iAppearanceProbability;
}

int CvFeatureInfo::getDisappearanceProbability() const
{
	return m_iDisappearanceProbability;
}

int CvFeatureInfo::getTechReveal() const
{
	return m_iTechReveal;
}

bool CvFeatureInfo::read(CvXMLLoadUtility* pXML)
{
	CvString szTextVal;
	if (!CvInfoBase::read(pXML))
	{
		return false;
	}

	pXML->GetChildXmlValByName( szTextVal, "ArtDefineTag");
	setArtDefineTag(szTextVal);

	if (gDLL->getXMLIFace()->SetToChildByTagName(pXML->GetXML(),"YieldChanges"))
	{
		pXML->SetYields(&m_piYieldChange);
		gDLL->getXMLIFace()->SetToParent(pXML->GetXML());
	}
	else
	{
		pXML->InitList(&m_piYieldChange, NUM_YIELD_TYPES);
	}

	if (gDLL->getXMLIFace()->SetToChildByTagName(pXML->GetXML(),"RiverYieldChange"))
	{
		pXML->SetYields(&m_piRiverYieldChange);
		gDLL->getXMLIFace()->SetToParent(pXML->GetXML());
	}
	else
	{
		pXML->InitList(&m_piRiverYieldChange, NUM_YIELD_TYPES);
	}

	if (gDLL->getXMLIFace()->SetToChildByTagName(pXML->GetXML(),"HillsYieldChange"))
	{
		pXML->SetYields(&m_piHillsYieldChange);
		gDLL->getXMLIFace()->SetToParent(pXML->GetXML());
	}
	else
	{
		pXML->InitList(&m_piHillsYieldChange, NUM_YIELD_TYPES);
	}

	pXML->GetChildXmlValByName(&m_iMovementCost, "iMovement");
	pXML->GetChildXmlValByName(&m_iSeeThroughChange, "iSeeThrough");
	pXML->GetChildXmlValByName(&m_iHealthPercent, "iHealthPercent");
	pXML->GetChildXmlValByName(&m_iDefenseModifier, "iDefense");
	pXML->GetChildXmlValByName(&m_iAdvancedStartRemoveCost, "iAdvancedStartRemoveCost");
	pXML->GetChildXmlValByName(&m_iTurnDamage, "iTurnDamage");
	pXML->GetChildXmlValByName(&m_iAppearanceProbability, "iAppearance");
	pXML->GetChildXmlValByName(&m_iDisappearanceProbability, "iDisappearance");
	pXML->GetChildXmlValByName(&m_iTechReveal, "iTechReveal");






pXML->GetChildXmlValByName( szTextVal, "TechReveal");
	m_iTechReveal = pXML->FindInInfoClass(szTextVal);

Was mir hier noch fehlt ist die CvFeatureInfo::write(CvXMLLoadUtility* pXML)
Aber sowas scheint es nicht in der CvInfo.cpp zu geben...



cvInfo.h

CvFeatureInfo();
	virtual ~CvFeatureInfo();

	int getMovementCost() const;							// Exposed to Python
	int getSeeThroughChange() const;					// Exposed to Python
	int getHealthPercent() const;							// Exposed to Python
	int getAppearanceProbability() const;			// Exposed to Python
	int getDisappearanceProbability() const;	// Exposed to Python
	int getTechReveal() const;					// Exposed to Python

	//---------------------------------------PROTECTED MEMBER VARIABLES---------------------------------
protected:

	int m_iMovementCost;
	int m_iSeeThroughChange;
	int m_iHealthPercent;
	int m_iAppearanceProbability;
	int m_iDisappearanceProbability;
	int m_iTechReveal;

[Flunky]

Das da im dritten Codeblock im Spoiler sollte da glaub ich nicht sein.

pXML->GetChildXmlValByName( szTextVal, "TechReveal");
m_iTechReveal = pXML->FindInInfoClass(szTextVal);

Nee, wozu sollte es auch ein write geben? Features ändern sich ja nicht. Bei der Map wird wohl gespeichert, welches Feature in welcher Variante auf nem Plot liegt