Ryzom

    SET(NL_RELEASE_CFLAGS "/Ox /Ob2 /Oi /Ot /Oy /GT /GF")

    SET(NL_RELEASEDEBUG_CFLAGS "/DNL_RELEASE_DEBUG /Ob2 /GF")

  ELSE(WIN32)

    IF(WITH_COVERAGE)

      SET(PLATFORM_CFLAGS "-fprofile-arcs -ftest-coverage ${PLATFORM_CFLAGS}")

    ENDIF(WITH_COVERAGE)

			if ( bitfield[i] )

			{

				if(VerboseDatabase)

					nldebug( "CDB/ATOM: Reading prop[%u] of atom", i );

				atomIndex = i;

				CCDBNodeLeaf *leaf = findLeafAtCount( atomIndex );

				if ( leaf )

		case CAttackIDSheet::Magic: return lhs.SpellInfo == rhs.SpellInfo;

		case CAttackIDSheet::Creature: return lhs.CreatureAttackIndex == rhs.CreatureAttackIndex;

		case CAttackIDSheet::DamageShield: return lhs.DamageShieldType == rhs.DamageShieldType;

	}

}

//*****************************************************************************************

		case CAttackIDSheet::Magic: return lhs.SpellInfo < rhs.SpellInfo;

		case CAttackIDSheet::Creature: return lhs.CreatureAttackIndex < rhs.CreatureAttackIndex;

		case CAttackIDSheet::DamageShield: return lhs.DamageShieldType < rhs.DamageShieldType;

	}

}

//*****************************************************************************************

		case BODY::HHands:  return ClientSheetsStrings.get(side == BODY::Left ? LeftHand : RightHand);

		case BODY::HLegs:   return ClientSheetsStrings.get(side == BODY::Left ? LeftLeg  : RightLeg);

		case BODY::HFeet:   return ClientSheetsStrings.get(side == BODY::Left ? LeftFoot : RightFoot);

	}

}

			return Tool.Skill;

		case ITEMFAMILY::CRAFTING_TOOL:

			return SKILLS::SC;

	}

}

// ***************************************************************************

	NLMISC::clamp(MinDuration, 0.f, CycleDuration /*- startHourMaxInterval*/);

	NLMISC::clamp(MaxDuration, 0.f, CycleDuration /*- startHourMaxInterval*/);

}

//=======================================================

		 item.getValueByName(_CoarseMeshDist, "3D.CoarseMeshDist")

		)

	   )

	// serial fxs by season

	SeasonFX[EGSPD::CSeason::Spring].build(item, Id, "3D.SpringFX.");

	SeasonFX[EGSPD::CSeason::Summer].build(item, Id, "3D.SummerFX.");

		CContinent *pCont = it->second;

		nlinfo("Looking into %s", pCont->SheetName.c_str());

		if (pCont->Zone.VPoints.size() > 0) // Patch because some continent have not been done yet

			{

			}

		}

		it++;

	}

/////////////

#include "stdpch.h"	// First include for pre-compiled headers.

// OS.

#ifdef NL_OS_WINDOWS

#	include <windows.h>

	nlwarning("There are %*lx free %sbytes of virtual memory.\n", WIDTH, stat.dwAvailVirtual/DIV, divisor);

*/

#endif

}

	void sheetId(const NLMISC::CSheetId &id) {_SheetId = id;}

	/// Return the persistent NPC alias of entity (0 if N/A).

	/// Set the persistent NPC alias of the entity.	

	void npcAlias(uint32 alias) {_NPCAlias = alias; }

	/// Return the entity current behaviour.

	/**

	 * Show or Hide the entity.

				SM_EVENT(ev_quit, st_end);

			SM_END_EVENT_TABLE

			break;

		}

	}

}

					throw "Protocol error";

				if (sb._LastJoinSessionResult == 16)

				{

					throw "User ban from the ring";

				}

				if (sb._LastJoinSessionResult != 0)

	}

	// Don't enable anything if index not found (e.g. the character is not the owner of the animal)

		return false;

	// Get animal status and type

			NLMISC::TTime quantum,

			float maxValue, uint page,

			bool lineMode = false)

	{

		if (_Graphs == NULL)

		{

using namespace NLMISC;

//*****************************************************************************

									   _MaxNumFX(10),

									   _NumFX(0),

									   _MaxNumCachedFX(10),

									   _NumCachedFX(0),

									   _NumInstances(0),

{

	H_AUTO_USE(RZ_GroundFXManager)

	// Construct

	virtual void chatWindowRemoved(CChatWindow *cw);

	//

	// copy not supported

};

	void chatWindowRemoved(CChatWindow *cw);

	void msgEntered(const ucstring &msg, CChatWindow *chatWindow);

	// copy not supported

};

#endif

	class CDBForageQQObs : public ICDBNode::IPropertyObserver

	{

	public:

		virtual void update(ICDBNode *node);

		uint	WhichOne;

		float	FullValue;

private:

	// this object isn't intended to be copied

	void				executeScriptInternal(const std::string &code, const std::string &dbgSrc, int numRet = 0);

							SlotType(NULL),

							Quality(NULL),

							SheetIDOrSkill(NULL),

							LogicTextID(NULL),

							DescTextID(NULL),

							MissionDetailText(NULL),

							MissionIcon(NULL),

							MissionPreReqState(NULL),

							Weight(NULL),

private:

	struct CPeople

	{

		NLMISC::CRefPtr<CGroupContainer> Container; // todo : replace this with a CChatWindow one day, for consistency

		NLMISC::CRefPtr<CGroupContainer> Chat;

		uint							GlobalID;

// Here, modify the DTD table to change the HTML parser (add new tags for examples)

#undef HTML_ATTR

HTAttr a_attr[] =

{

		// HTCacheInit(NULL, 20);

		/* Setup up transfer coders */

		/* Setup MIME stream converters */

		HTFormat_addConversion("message/rfc822", "*/*", HTMIMEConvert, 1.0, 0.0, 0.0);

			{"authentication-info", &HTMIME_authenticationInfo},

			{"proxy-authentication-info", &HTMIME_proxyAuthenticationInfo}

		};

			HTHeader_addParser(fixedHandlers[i].string, NO, fixedHandlers[i].pHandler);

		/* Set up default event loop */

public:

	CInstallThreadEntry(){ Timestamp = 0; }

	CInstallThreadEntry(const char* patchName, const char* sourceName, uint32 timestamp, const char* extractPath, uint32 size, uint32 sZipFileSize)

	std::string PatchName;

	std::string SourceName;

	uint32 Timestamp;

					}

					if (newStep)

					{

						{

							break;

						}

					screenShotPNG();

					ScreenshotRequest = ScreenshotRequestNone;

				break;

			}

			// TMP TMP

//============================================================

{

	H_AUTO_USE(RZ_Precipitation)

}

	class CEntityEntry

	{

	public:

		CLFECOMMON::TSheetId							Sheet;

		uint16											AssociationBits;

		bool											EntryUsed;

	uint16&	associationBits( CLFECOMMON::TCLEntityId entity ) { return _Entities[entity].AssociationBits; }

	bool	isUsed(CLFECOMMON::TCLEntityId entity) const { return _Entities[entity].EntryUsed; }

	/** Receives actions from the front end. Actually transmits actions received

	// For editor : Create this object from the CObjectTable it materialize in the editor

	CInstance(const CObjectTable *objectTable, CLuaState &ls);

	// copy not supported

	//

	void executeHandler(const CLuaString &name, int numArgs);

	//

	// Remove all entities.

	if (Driver)

		nldebug("RCSR1: %u textures", Driver->getTotalAsyncTextureSizeAsked());

	EntitiesMngr.release();

	if (Driver)

		nldebug("RCSR2: %u textures", Driver->getTotalAsyncTextureSizeAsked());

	// Reset Fx manager (must be done after EntitiesMngr.release()) Important because may still point to 3D elements

	FXMngr.reset();

	// Release the Entities Animation Manager (Yoyo: fuckingly important because keep a pointer

	// on a _PlayListManager that is created from Scene)

	if (Driver)

		nldebug("RCSR3: %u textures", Driver->getTotalAsyncTextureSizeAsked());

	CEntityAnimationManager::delInstance();

	EAM= NULL;

	if (Driver)

		nldebug("RCSR4: %u textures", Driver->getTotalAsyncTextureSizeAsked());

	// Not necessary I think because owns only static data (string + function ptrs)

	// --releaseContextualCursor();

	case DirectMode:

		directMode(x, y);

		break;

	}

}// update //

						move = dynInfo.String.begin()+param.ReplacementPoint+2;

					}

					break;

				}

			}

			// append the rest of the string

					while(strFindReplace(_SpecItem_TempMap[keyStr].Name, "\\n", "\n"));

					// insert in map of Women Name if OK.

					{

						const ucstring &womenName= ws.getData(j, womenNameColIndex);

						_SpecItem_TempMap[keyStr].WomenName= womenName;

					}

					// insert in map of Description if OK.

					{

						const ucstring &desc= ws.getData(j, descColIndex);

						_SpecItem_TempMap[keyStr].Desc= desc;

					}

					// insert in map of Description2 if OK.

					{

						const ucstring &desc= ws.getData(j, descColIndex2);

						_SpecItem_TempMap[keyStr].Desc2= desc;

		bool				FromIG; // true if the fx comes from an ig, or false if it was generated dynamically

	#endif

public:

	{

#if !FINAL_VERSION

			FromIG = true;

				return true;

			}

		break;

	}

	// Reset Parent, unless we stay in mount mode

	if(_MoveToAction==CUserEntity::CombatPhrase || _MoveToAction==CUserEntity::ExtractRM)

	{

		// the clientExecute has not been called in case of "ExtractRM autoFind"

		if(!autoFindExtractRM)

		{

			CSPhraseManager	*pPM= CSPhraseManager::getInstance();

	case CUserEntity::BuildTotem:

		buildTotem();

		break;

	}

}// moveToAction //

		if ( ((CLFECOMMON::TClientDataSetIndex)uidLeaf->getValue32()) == mountEntity->dataSetId() )

		{

			CCDBNodeLeaf *hungerLeaf = safe_cast<CCDBNodeLeaf*>(beastNode->getNode( ICDBNode::CTextId( "HUNGER" ) ));

		}

	}

	return false;

	CSPhraseManager *pm = CSPhraseManager::getInstance();

	uint index;

	uint memoryLine;

	if ( ! autoFindPhrase )

	{

		// Use clicked phrase

		}

	}

	{

		// Open the forage (but not for care actions). Necessary for the case of redoing an extraction after a Drop All on the same source.

		uint32 phraseId = pm->getMemorizedPhrase( memoryLine, index );

	NL3D::TGlobalAnimationTime CurrTime;

	CSky					   *Sky;

public:

	{

		_CurrCanopyCamPos = CVector::Null;

	}

namespace BGDownloader

{

ucstring getWrittenSize(uint32 nSize)

{

	PROP(uint32,_PatchSize) \

	PROP_VECT(uint32,_HashKey)

#include "persistent_data_template.h"

#undef PERSISTENT_CLASS

	PROP(std::string,_FileName)\

	STRUCT_VECT(_Versions)

#include "persistent_data_template.h"

#undef PERSISTENT_CLASS

#define PERSISTENT_CLASS CBNPFileSet

#define PERSISTENT_DATA\

	STRUCT_VECT(_Files)

#include "persistent_data_template.h"

#undef PERSISTENT_CLASS

	LPROP(bool,				_Hidden,		if(_Hidden))\

	PROP_VECT(std::string,	_Files)\

#include "persistent_data_template.h"

#undef PERSISTENT_CLASS

#define PERSISTENT_CLASS CBNPCategorySet

#define PERSISTENT_DATA\

	STRUCT_VECT(_Category)

#include "persistent_data_template.h"

#undef PERSISTENT_CLASS

	STRUCT(_Files)\

	STRUCT(_Categories)

#include "persistent_data_template.h"

#undef PERSISTENT_CLASS

static unsigned char S[8][64] = {	/* 48->32 bit substitution tables */

					/* S[1]			*/

					/* S[2]			*/

					/* S[3]			*/

					/* S[4]			*/

					/* S[5]			*/

					/* S[6]			*/

					/* S[7]			*/

					/* S[8]			*/

};

static unsigned char P32Tr[] = {	/* 32-bit permutation function */

//-----------------------------------------------

CDirLightSetup::CDirLightSetup() : Ambiant(0, 0, 0),

                                   Specular(0, 0, 0),

				                   Direction(1.f, 0.f, 0.f)

{

}

//-----------------------------------------------

	public:

		virtual ~IServerEditionModule(){}

		virtual void createSessionWithoutSu(uint32 charId, NLMISC::CEntityId clientEid) = 0;

		virtual CScenario* getScenarioById(TSessionId sessionId) const = 0;

		// getEditing position (use AdminModule::getPosition for having a position in editing and animation mode)

		virtual	bool getPosition(TSessionId sessionId, double& x, double& y, double& orient, uint8& season, uint32 locationIndex = 0) = 0;

/////////////////////

//================================================================

CDynChatSession::CDynChatSession(CDynChatClient *client, CDynChatChan *channel)

{

	nlassert(client);

	nlassert(channel);

// CDynChatClient //

////////////////////

//================================================================

{

}

// CDynChatChan //

//////////////////

CDynChatChan::CDynChatChan()

	_FirstSession(NULL),

	_DontBroadcastPlayerInputs(false),

	_ForwardPlayerIntputToOwnerService(false),

{

}

//================================================================

//CDynChatChan::CDynChatChan(TChanID id) : _ID(id), _FirstSession(NULL), HistoricSize(0)

CDynChatChan::CDynChatChan(TChanID id, bool noBroadcast, bool forwardInput, bool unified)

	_FirstSession(NULL),

	_DontBroadcastPlayerInputs(noBroadcast),

	_ForwardPlayerIntputToOwnerService(forwardInput),

{

}

			case DMGTYPE::POISON : return DebuffResistPoison;

			case DMGTYPE::ELECTRICITY : return DebuffResistElectricity;

			case DMGTYPE::SHOCK : return DebuffResistSchock;

		}

	}

	TEffectFamily getCombatDoTEffect( DMGTYPE::EDamageType type)

		case DMGTYPE::POISON : return CombatDoTPoison;

		case DMGTYPE::ELECTRICITY : return CombatDoTElectricity;

		case DMGTYPE::SHOCK : return CombatDoTShock;

		}

	}

/*

 * Constructor

 */

{

	UserData[0] = 0;

	UserData[1] = 0;

using namespace NLNET;

using namespace std;

#endif

	for ( istfar=smidsToFindAndRemove.begin(); istfar!=smidsToFindAndRemove.end(); ++istfar )

	{

		if ( (*istfar) != InvalidSMId )

			MIRROR_INFO( "MIRROR: Need to remove tracker with smid %d", (*istfar) );

	}

#endif

 */

CMirror::CMirror() :

	_PendingEntityTypesRanges(0),

	_ReadyL1Callback(NULL),

	_NotificationCallback(NULL),

	_MirrorGotReadyLevel1(false),

	_MirrorGotReadyLevel2(false),

	_ListOfOtherPropertiesReceived(false),

	_AwaitingAllMirrorsOnline(false),

	_IsExecutingSynchronizedCode(false),

	_ClosureRequested(false),

{

	nlassert( ! MirrorInstance ); // singleton check

	MirrorInstance = this;

protected:

	/// Default constructor

	TSharedListRow		allocateNewCell();

		}

		/// Cons cast into behaviour enum

		{

			return (EBehaviour)Behaviour8;

		}

		sint16		DeltaHP;

		uint16		Unused; /// Keep it, used to make the class size = 64 bits (sizeof(CBehaviour) MUST return 8 (bytes))

		inline CBehaviour( EBehaviour behaviour )

		{

	bool	isMagicResistStat(TRMStatType fs)

	{

		// should have 5 magic resistances. Desert should be the 1st, and PrimRoot the last

		nlctassert(endMResist - startMResist == 5);

		return fs>=startMResist && fs<endMResist;

	bool	isMagicProtectStat(TRMStatType fs)

	{

		// should have 7 magic protection. Acid should be the 1st, and Electricity the last

		nlctassert(endMProt - startMProt == 7);

		return fs>=startMProt && fs<endMProt;

static const struct { char* Name; CSeason::TSeason Value; } TSeasonConvert[] =

{

};

/* -----------------------------------------

* Static Implementation of CSeason

	public:

		CCurrentChar(TCharId charId, uint32 editSlotId, const R2::TUserRole& userRole = R2::TUserRole::ur_editor)

		void setUserRole(const R2::TUserRole& userRole)

		{

	{

	public:

		CTaskUpdateScenarioVision(NLMISC::TTime now, CServerEditionModule* module, TSessionId sessionId)

		virtual void doOperation()

		{

			_Module->updateScenarioVision(_SessionId);

	public:

		CKickPlayerIfStillConnected(NLMISC::TTime taskDate, CServerEditionModule* serverEditionModule, TSessionId sessionId, TCharId charId)

		{

		}

		typedef uint32 TCharId;

	public:

		CVerifyRingAccess(NLMISC::TTime taskDate, CServerEditionModule* serverEditionModule, TSessionId sessionId, TCharId charId)

		{

		}

CEditionSession::CEditionSession(RSMGR::TSessionType sessionType, TSessionId sessionId, CEditionSession* edit)

{

	IsAnimationStopped = false;

	DateSinceNoPlayer = 0;

}

{

	TPioneersSessionsAlloweds::const_iterator found = _PioneersSessionsAllowed.find(charId);

	if (found == _PioneersSessionsAllowed.end()) return NULL;

		TUserRole getRoleByCharId(TCharId charId) const;

		// get the session that is about to be joined by a client, or NULL if not found

		// get the scenario use by the user

		CScenario*  getScenarioByCharId(TCharId charId) const;

static const struct { char* Name; CSPType::TSPType Value; } TSPTypeConvert[] =

{

};

/* -----------------------------------------

* Static Implementation of CSPType

//=======================================================================

{

}

												FogColorDay(NLMISC::CRGBA::Black),

												FogColorDusk(NLMISC::CRGBA::Black),

												FogColorNight(NLMISC::CRGBA::Black),

												Lighting(1.f),

												WindIntensity(0),

{

	for(uint k = 0; k < NumFogType; ++k)

	PROP(sint32, Modifier)\

	PROP2(Type,	std::string,	EGSPD::CClassificationType::toString(Type),	Type=EGSPD::CClassificationType::fromString(val))\

#include "persistent_data_template.h"

	operator std::string() const { return std::string(_Value); }

	bool operator ! () const { return _Value == NULL; }

	operator const unsigned char *() const { return (const unsigned char *)  _Value; }

	/// NB : This remove previous owned pointer with xmlFree

	CXMLAutoPtr &operator = (const char *other);

	CXMLAutoPtr &operator = (const unsigned char *other)