Ryzom

		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;

	}

}

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

		{

			case AUTO_LOGIN:

				InterfaceState = autoLogin (cookie, fsaddr, firstConnection);

			case GLOBAL_MENU:

				if (!ClientCfg.Local)

					}

				}

				InterfaceState = globalMenu();

		}

	}

		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)

 * Constructor

 */

CForageSourceCL::CForageSourceCL() :

	_SafeSource( false ),

	_KnowledgeLevel( 0 ),

	_LastExplosionSwitch( 0 ),

	_ProspectorSlot( 255 ),

	_ExtraTime(0),

	_InclBonusExtraTime(0),

	_InitialQuantity(BarNotInit),

	}

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

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

{

	H_AUTO_USE(RZ_GroundFXManager)

	// Construct

		case EGSPD::CPeople::Matis: return Matis;

		case EGSPD::CPeople::Tryker: return Tryker;

		case EGSPD::CPeople::Zorai: return Zorai;

	}

}

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

	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 */

}

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

{

	H_AUTO_USE(RZ_LightCycleManager)

}

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

		case SLOTTYPE::FEET_SLOT:			return isUserColorSupported(playerSheet.Feet);

		case SLOTTYPE::RIGHT_HAND_SLOT:	return isUserColorSupported(playerSheet.ObjectInRightHand);

		case SLOTTYPE::LEFT_HAND_SLOT:	return isUserColorSupported(playerSheet.ObjectInLeftHand);

	}

}// isUserColorSupported //

			}

		}

		break;

	}

}

// #pragma optimize ("", off)

{

	_Icons[NPC_ICON::IconNone].init("", "");

	_Icons[NPC_ICON::IconNotAMissionGiver].init("", "");

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

{

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

	//

	case DirectMode:

		directMode(x, y);

		break;

	}

}// update //

  }

  if (numargs < 3)

  {

    return 1;

  }

  archiveStream.File = fopen(args[2], "rb");

  if (archiveStream.File == 0)

  {

    return 1;

  }

          outputHandle = fopen(fileName, "wb+");

          if (outputHandle == 0)

          {

            res = SZE_FAIL;

            break;

          }

          processedSize = fwrite(outBuffer + offset, 1, outSizeProcessed, outputHandle);

          if (processedSize != outSizeProcessed)

          {

            res = SZE_FAIL;

            break;

          }

          if (fclose(outputHandle))

          {

            res = SZE_FAIL;

            break;

          }

    }

    else

    {

      res = SZE_FAIL;

    }

  }

    return 0;

  }

  if (res == SZE_OUTOFMEMORY)

  else     

    printf("\nERROR #%d\n", res);

  return 1;

  if (prop0 >= (9 * 5 * 5))

    return LZMA_RESULT_DATA_ERROR;

  {

    propsRes->lc = prop0;

    /*

    unsigned char remainder = (unsigned char)(prop0 / 9);

// constructor

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

CSoundManager::CSoundManager(IProgressCallback * /* progressCallBack */)

{

	_EnableBackgroundMusicAtTime= 0;

	_GameMusicVolume= 1.f;

		_BackgroundFlags.Flags[MORNING] = false;

		_BackgroundFlags.Flags[DUSK] = true;

		break;

	}

	// update the filter for season.

		_BackgroundFlags.Flags[AUTUMN] = false;

		_BackgroundFlags.Flags[WINTER] = true;

		break;

	}

	// TODO : update the filter state for weather effet

	CWeatherState weatherState = WeatherManager.getCurrWeatherState();

						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;

		{

			case CManagedFX::InAddList:	   _FXToAdd.erase(fi.SetHandle); break;

			case CManagedFX::InRemoveList: _FXToRemove.erase(fi.SetHandle); break;

		}

		fi.unlinkFromCandidateFXList();

		fi.unlinkFromInstanciatedFXList();

				case CManagedFX::Permanent: color = (!mf.Instance.empty()) ? CRGBA::Magenta : CRGBA::Cyan; break;

				case CManagedFX::InAddList: color = CRGBA::Blue; break;

				case CManagedFX::InRemoveList: color = (!mf.Instance.empty()) ? CRGBA::Red : CRGBA::Yellow; break;

			}

			drawBox(CVector(- size, - size, - size),

					CVector(size, size, size),

		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),

{

}

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

	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;

/*

 * Constructor

 */

{

	UserData[0] = 0;

	UserData[1] = 0;

using namespace NLNET;

using namespace std;

const string MirrorVersion = string("1.10-")+string(ListRowSizeString); // ADDED: Unidirectional Mode (don't wait for delta)

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

	{

		if ( (*istfar) != InvalidSMId )

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

	}

#endif

protected:

	/// Default constructor

	TSharedListRow		allocateNewCell();

		}

		/// Cons cast into behaviour enum

		{

			return (EBehaviour)Behaviour8;

		}

	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;

namespace EGSPD

{

{

	{ "Spring", CSeason::Spring },

	{ "Summer", CSeason::Summer },

	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;

namespace EGSPD

{

{

	{ "Fight", CSPType::Fight },

	{ "Magic", CSPType::Magic },

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

{

}

												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)