Unified network

CUnifiedNetwork is the handler for all messages between service on Network Layer 5. It handles both sending and receiving of messages and calling the appropriate Callbacks when a message is received. CUnifiedNetwork is a Singleton class and Callbacks are added in arrays of TUnifiedCallbackItem using the addCallbackArray function of CUnifiedNetwork.

Example:

TUnifiedCallbackItem cbArray[] = 
{
    { "MY_NEW_MSG",      cbMyNewMsg}
}

CUnifiedNetwork::getInstance()->addCallbackArray(cbArray, sizeof(cbArray)/sizeof(cbArray[0]))

Initializing the CUnifiedNetwork should be automatically handled when calling getInstance()

I think, might need confirmation/deeper search

Wireshark Protocol

Started working on a Wireshark Protocol Dissector for the Unified Network communications. ~~Header dissection and an example with the “TOCK” message are done for now.~~ All messages in the example .pcap are dissected correctly! Also restructured all the display filters accessible now through nel.<name of message>.<name of field> like nel.gateway.message_type and all header fields under nel.header.<name of field> like nel.header.func.

If anybody got a .tcap of a real working server would speed my task up so I don't have to fix my local server to continue dissecting more messages.

Implemented Messages

Empty messages so nothing to do except headers

BS_PING
BS_PONG
TICK
GOP
FWD_ACKATP_FCO
FS_ACCEPT

Messages including other messages

MOD_OP
UMM
GW_L5_MSG
FWDMSG

Normal messages

TOCK (from mirror_service)
TOCK (from game_share)
GU (graph update in MOD_OP)
HRGU (high resolution graph update in MOD_OP)
SSU (shard service update in MOD_OP)
USU (up service update)
MOD_UPD (receive module update)
ACKATE (acknowledge add entity tracker)
ACKATP (acknowledge add property tracker)
CT_LRC (create local registered class)
FEPA (frontend patch address)
NBPLAYERS2 (number players)
GW_L5_ADDTP (layer5 add transport)
save_file (save backup file)
DATASETS
AP (allocate property)
FWD_ACKATE (forward ackate)
FWD_ACKATP (forward ackatp)
SMIRUB (service mirror ready broadcast) / SMIRUR (service mirror ready)
ATE (add entity tracker)
ATP (add property tracker)
RAP (receive access property)
UN_SIDENT (unified network service identification)
MIRO (all mirrors up)
REGISTER (register for mirror service)
REGISTER (register for tick service)
REGISTERED (mirror_service)
LOP (list other properties)
SC_EI (scan and resync entities except ignored)
R_SH_ID (receive shard id)

Downloads

~~Framadrop link to the Wireshark plugin since I couldn't create a Gitlab account~~

~~New Version of the plugin~~

Update with functions from a new .pcap! (still broken)

.pcap example of a start RC shard (Though the shard is broken, enough to do as a sample for now)

new .pcap still from a broken shard but a bit less

List of callbacks

A list of all callbacks that are used in Ryzom Core server code and in which file they are found is attached as spoiler:

Spoil

//mirror_service/mirror_service.cpp
TUnifiedCallbackItem MirrorCallbackArray[] =
{
	{ "DATASETS", cbDeclareDataSets },
	{ "AP", cbAllocateProperty },
	{ "DET", cbDeclareEntityTypeOwner },
	{ "RG", cbGiveRange },
	//{ "DRG", cbRecvDeclaredRange },
	{ "SDSE", cbRecvDataSetEntitiesSubscription },
	{ "SPROP", cbRecvPropSubscription },
	{ "SYNC_MS", cbRecvSyncMS },
	{ "SYNCMI", cbRecvSyncMi },
	{ "SMIRU", cbRecvServiceMirrorUp },
	{ "FWD_ACKATE", cbForwardACKATE },
	{ "FWD_ACKATP", cbForwardACKATP },
	{ "FWD_ACKATE_FCO", cbForwardACKATE_FCO },
	{ "FWD_ACKATP_FCO", cbForwardACKATP_FCO },
	{ "TOCK", cbTock },
	{ "FWDMSG", cbMessageToForward },
	{ "DELTA", cbRecvDelta },
	{ "MARCS", cbAddRemoveRemoteClientService },
	{ "REIR", cbReleaseEntitiesInRanges },
	{ "TAG_CHG", cbTagChanged },
	{ "BIDG_CNTR", cbRecvBindingCountersByMessage },
	{ "GOP", cbGiveOtherProperties },
	{ "QUIT", cbQuit }
};

//mirror_service/tick_proxy.cpp
TUnifiedCallbackItem cbTickProxyArray[] = 
{
	{ "REGISTER", cbRegisterToTickSystem },
	{ "REGISTERED", cbSyncFromMaster },
	{ "TICK", cbTickFromMaster },
	{ "TOCK", cbTock },
	{ "STEP_TICK", cbStepAndTick },
	{ "DISPLAY_TIME", cbDisplayTime },
};

//input_output_service/input_output_service.cpp
TUnifiedCallbackItem CbArray[]=
{
	{"----",				NULL		}
};

//input_output_service/bot_chat_manager.cpp
TUnifiedCallbackItem ChatBotCbArray[]= //Commented
{
	{ "START_CHAT_BOT", cbStartChatBot },
};

//input_output_service/news_manager.cpp
static TUnifiedCallbackItem CbArray[]= //news_manager
{
	{ "ADD_NEWS", cbAddNews },
};

//input_output_service/messages.cpp
TUnifiedCallbackItem CbIOSArray[]= //IO messages
{
	// Received from clients (via FS)
//	{ "READY_STRING", cbImpulsionReadyString },
	{ "CLIENT:STRING:CHAT", cbImpulsionChat },
	{ "CLIENT:STRING:CHAT_TEAM", cbImpulsionChatTeam },
	{ "CLIENT:STRING:TELL", cbImpulsionTell },	
	{ "CLIENT:STRING:FILTER", cbImpulsionFilter },
	{ "CLIENT:STRING:CHAT_MODE", cbImpulsionChatMode },
	{ "CLIENT:STRING:AFK_TXT", cbImpulsionAfkTxt },
//	{ "STRING_RQ_ID", cbImpulsionStringRqId },
	{ "STRING_RQ_UID", cbImpulsionStringRqUid },

	// Received from the back-end
	{ "STATIC_STRING", cbStaticString },
	{ "CHAT_MESSAGE", cbChatMessage	},
	{ "CHARACTER_NAME",	cbCharacterName },				// receive a character name
	{ "CHARACTER_NAME_ID",	cbCharacterNameId },		// receive a character name with a string manager string Id
	{ "CHARACTER_NAME_LANG", cbCharacterNameAndLang },	// receive a character name and a language code (for player)
	{ "CHARACTER_EVENT_FACTION", cbCharacterEventFaction },
	{ "ADD_GROUP", cbAddGroup },
	{ "ADD_NAMED_GROUP", cbAddNamedGroup },
	{ "REMOVE_GROUP", cbRemoveGroup },
	{ "ADD_TO_GROUP", cbAddToGroup },
	{ "REMOVE_FROM_GROUP", cbRemoveFromGroup },
//	{ "SEND_DYNAMIC_ID", cbSendDynamicId },
	{ "CHAT", cbSysChat },					// talk to a user or a whole group
	
	{ "NPC_CHAT", cbNpcChat },				// Npc talk to a chat group	
	{ "NPC_CHAT_PARAM", cbNpcChatParam },				// Npc talk to a chat group	 (with parameter)

	{ "NPC_TELL", cbNpcTell },				// Npc tell to a player
	{ "GHOST_TELL", cbGhostTell },			// Npc tell to a player, without Npc :)

	{ "NPC_TELL_EX", cbNpcTellEx },			// Extended Npc tell to a player. Receive a stringId (uint32), obtained through the PHRASE message for example
	{ "NPC_CHAT_EX", cbNpcChatEx },			// Extended Npc chat . Receive a stringId (uint32), obtained through the PHRASE message for example
	{ "NPC_CHAT_SENTENCE", cbNpcChatSentence}, //Npc chat. receive the sentence to chat
	{ "NPC_CHAT_SENTENCE_CHANNEL",cbNpcChatSentenceChannel},
	{ "NPC_CHAT_SENTENCE_EX",cbNpcChatSentenceEx},//Npc chat. receive the name of the npc which talks, and the sentence
	
	{ "GROUP_DYN_STRING", cbGroupDynString },	// send a system dynamic string to a group
	{ "PHRASE", cbPhrasePrepare },
	{ "PHRASE_DEBUG", cbPhrasePrepareDebug },
	{ "PHRASE_USER", cbUserPhrasePrepare },
	{ "PHRASE_USER_DEBUG", cbUserPhrasePrepareDebug },
	{ "BROADCAST_SYSTEM_PHRASE", cbBroadcastSystemPhrase },
	{ "BROADCAST_SYSTEM_PHRASE_DEBUG", cbBroadcastSystemPhraseDebug },
	{ "STORE_STRING", cbStoreString },
	{ "GET_STRING", cbGetString },
	{ "RETR_ENTITY_NAMES", cbRetrieveEntityNames },
	{ "USER_LANGUAGE", cbUserLanguage },	// receive an association between a userId and a language
	{ "REMOVE_USER_LANGUAGE", cbRemoveUserLanguage },

	{ "IGNORE_TELL_MODE", cbIgnoreTellMode }, // receive an ignore tell mode command from EGS
	{ "IGNORE", cbImpulsionIgnore },
	{ "UNIGNORE", cbImpulsionUnignore },
	{ "UNIGNORE_ALL", cbImpulsionUnignoreAll },
	{ "MUTE_PLAYER",	cbMutePlayer },		// receive a mute player command from EGS
	{ "UNIVERSE_MODE",	cbUniverseMode },		// receive a universe mode command from EGS
	{ "MUTE_UNIVERSE", cbMuteUniverse },	// received a mute universe channel from EGS

	{ "EMOTE_CROWD", cbEmoteCrowd },			// EGS wants IOS to dispatch an emote texte to all users around the "emoting" player
	{ "EMOTE_PLAYER", cbEmoteSolePlayer },	// EGS wants IOS to dispatch an emote texte to a unique player
	{ "CUSTOM_EMOTE", cbCustomEmote },	// EGS wants IOS to dispatch an emote custom text to all users around
	
	{ "SET_PHRASE", cbSetPhrase },			// AIS wants IOS to change a phrase content
	{ "SET_PHRASE_LANG", cbSetPhraseLang }, // AIS or EGS wants IOS to change a phrase content for a language

	{ "UPDATE_AIALIAS", cbUpdateAIAlias},

	// Dyn chat, received from egs
	{ "DYN_CHAT:ADD_CHAN", cbDynChatAddChan },
	{ "DYN_CHAT:REMOVE_CHAN", cbDynChatRemoveChan },
	{ "DYN_CHAT:ADD_SESSION", cbDynChatAddSession },
	{ "DYN_CHAT:ADD_SESSION_WITH_NAME", cbDynChatAddSessionWithName},//add a session, receive a npc name
	{ "DYN_CHAT:REMOVE_SESSION", cbDynChatRemoveSession },
	{ "DYN_CHAT:REMOVE_SESSION_WITH_NAME", cbDynChatRemoveSessionWithName },//remove a session, receive a npc name
	{ "DYN_CHAT:SET_WRITE_RIGHT", cbDynChatSetWriteRight },

	{ "DYN_CHAT:RESET", cbDynChatReset },
	{ "DYN_CHAT:SET_HISTORIC_SIZE", cbDynChatSetHistoricSize },
	{ "DYN_CHAT:SERVICE_CHAT", cbDynChatServiceChat },		// a service send a chat message in the channel without sender id
	{ "DYN_CHAT:SERVICE_TELL", cbDynChatServiceTell },		// a service send a chat message to a specific client in the channel without sender id
	{ "DYN_CHAT:SET_HIDE_BUBBLE", cbDynChatSetHideBubble },		// a service send a chat message to a specific client in the channel without sender id
	//received from DSS
	{ "REQUEST_DSR", cbRequestDsr},
//	{ "ADD_DM",  cbAddDM	},			// A character enter a ring session that he own
//	{ "REMOVE_DM",  cbRemoveDM	}		// A character leave a DSS
};

//gpm_service/client_messages.cpp
TUnifiedCallbackItem CbClientArray[]=
{
	{ "CLIENT:POSITION",	cbClientPosition },

}; 

//gpm_service/messages.cpp
TUnifiedCallbackItem CbGPMSArray[]=
{
// Callbacks for all service use GPMS
	//{ "ADD_ENTITY",					cbAddEntity },					// create a single entity
	//{ "ADD_ENTITIES",				cbAddEntities },				// create a set of entities
	//{ "ADD_IA_OBJECT",				cbAddIAObject },			// create an object only visible from ia agents
	//{ "REPLACE_ENTITY",				cbReplaceEntity},				// replace an entity by another entity
	//{ "REMOVE_ENTITY",				cbRemoveEntity },				// remove a single entity
	//{ "REMOVE_ENTITIES",			cbRemoveEntities },				// removes a set of entities
/*?DEAD?*/	{ "BAG",						cbBag },						// updates content of an entity (bag only ?)

/*?DEAD?*/	{ "LOAD_CONTINENT",				cbLoadContinent },				// load a continent
/*?DEAD?*/	{ "REMOVE_CONTINENT",			cbRemoveContinent },			// remove a continent
	{ "CREATE_INDOOR_UNIT",			cbCreateIndoorUnit },			// create an indoor unit, for latter teleport
/*?DEAD?*/	{ "CREATE_BUILDING",			cbCreateBuilding },				// create a dynamic outdoor building
/*?DEAD?*/	{ "CREATE_OBSTACLE",			cbCreateObstacle },				// create a dynamic obstacle from a pacs_prim file
/*?DEAD?*/	{ "REMOVE_OBSTACLE",			cbRemoveObstacle },				// remove a dynamic obstacle
/*?DEAD?*/	{ "SET_OBSTACLE",				cbSetObstacle },				// set dynamic obstacle state

/*?DEAD?*/	{ "TRIGGER_SUBSCRIBE",			cbTriggerSubscribe },
/*?DEAD?*/	{ "TRIGGER_UNSUBSCRIBE",		cbTriggerUnsubscribe },

	//{ "UPDATE_ENTITY_POS",			cbUpdateEntityPosition},		// update a single entity position
	//{ "UPDATE_ENTITIES_POSITIONS",  cbUpdateEntitiesPositions},		// update a set of entities positions
	//{ "UPDATE_ENTITIES_POS",		cbUpdateEntitiesPositionsUsingSize },	// update a set of entities positions
	{ "ENTITY_TELEPORTATION",		cbEntityTeleportation},			// teleport a single entity (if no position, remove from cell map)

/*?DEAD?*/	{ "ATTACH",						cbAttach },						// attach an entity (child) to an another (father) using direct local position
/*?DEAD?*/	{ "DETACH",						cbDetach },						// detach an entity of its father
	{ "ACQUIRE_CONTROL",			cbAcquireControl },				// entity acquire control of another entity
	{ "LEAVE_CONTROL",				cbLeaveControl },				// entity leave control of another entity

/*?DEAD?*/	{ "ACTIV_SELF",					cbActivateSelf },
/*?DEAD?*/	{ "DESACTIV_SELF",				cbDesactivateSelf },

// The following removed by Sadge because the entity has been removed from the mirror by the time the message arrives,
// making it redundant
// / *?DEAD?* /	{ "DISABLE_VISION_PROC",		cbDisableVisionProcessing },	// ask for player vision not to be updated any longer

/*?DEAD?*/	{ "ENTITY_POS",					cbEntityPosition },				// ask for position of an entity
	
/*?DEAD?*/	{ "ASK_VISION_ARROUND_ENTITY",	cbEntitiesArroundEntity },		// ask for vision update around an entity
/*?DEAD?*/	{ "UNASK_VISION_ARROUND_ENTITY",cbEndEntitiesArroundEntity },	// remove vision update around an entity

/*?DEAD?*/	{ "VISION_REQUEST",				cbVisionRequest },
	{ "SET_PLAYER_FLAGS",			cbSetPlayerFlags },				// set flags for player (limit speed, etc)
	{ "R2_VISION_REFRESH",			cbR2ForceVisionReset },				// force the update of the vision (because some message must have been discared in Ring (in edition mode the network is not listen)
}; 

//gpm_service/gpm_service.cpp
TUnifiedCallbackItem CbArray[] =
{
	{ "CB_UNUSED",					NULL }
};

//testing_tool_service/testing_tool_service.cpp
TUnifiedCallbackItem CbArray[] = 
{
	{ "ACTOR_START_STATE",			cbActorStartState	},
	{ "TTS_REPORT_ACTOR_DEAD",		cbActorDead			},
	{ "TTS_LOG_REPORT",				cbLogReport			}
};

//server_share/mail_forum_validator.cpp
static TUnifiedCallbackItem CbArray[]=
{
	{ "MAIL_NOTIF",			CMailForumValidator::cbMailNotification },
};

//tick_service/tick_service.cpp
TUnifiedCallbackItem CbArray[] =
{
	{ "REGISTER",		cbRegister },
	{ "TOCK",			cbTock },

	{ "HALT_TICK",		cbHaltTick },
	{ "RESUME_TICK",	cbResumeTick },
};

//tick_service/range_mirror_manager.cpp
TUnifiedCallbackItem RangeMirrorManagerCallbackArray[] =
{
	{ "GRG", cbGetRange },
	{ "RRG", cbReleaseRange },
	{ "RARG", cbReacquireRanges }
};

//ryzom_welcome_service/ryzom_welcome_service.cpp
TUnifiedCallbackItem FESCallbackArray[] =
{
	{ "SCS",				cbFESShardChooseShard },
	{ "CC",					cbFESClientConnected },
	{ "RPC",				cbFESRemovedPendingCookie },
	{ "FEPA",				cbFESPatchAddress },
	{ "NBPLAYERS",			cbFESNbPlayers },
	{ "NBPLAYERS2",			cbFESNbPlayers2 },

	{ "SET_SHARD_OPEN",		cbSetShardOpen },
	{ "RESTORE_SHARD_OPEN",	cbRestoreShardOpen },
};

//ryzom_welcome_service/ryzom_welcome_service.cpp
TUnifiedCallbackItem LSCallbackArray[] =
{
	{ "CS", cbLSChooseShard },
	{ "DC", cbLSDisconnectClient },
	{ "FAILED", cbFailed },
};

//pd_reference_builder/reference_builder_service.cpp
TUnifiedCallbackItem CbArray[] =
{
	{ "RB_GEN_REF",		cbGenerateReference },
	{ "RB_GEN_DELTA",	cbGenerateDelta },
	{ "RB_KILL_TASKS",	cbKillTasks },
};

//entity_view_service/entity_view_service.cpp
TUnifiedCallbackItem CbArray[] = 
{
	{ "TARGET", cbSetTarget },
	{ "EVSPOS", cbSetPos },
};

//ai_service/client_message.cpp
TUnifiedCallbackItem CbClientArray[]=
{
	{ "CLIENT:TARGET:FOLLOW",			cbClientFollowTarget },
	{ "CLIENT:TARGET:NO_FOLLOW",		cbClientNoFollowTarget },
}; 

//ai_service/bot_chat_interface.cpp
static TUnifiedCallbackItem CbArray[]=
{
	{ "BOT_CHAT_START", cbBotChatStart },
	{ "BOT_CHAT_SELECT_ANSWER", cbBotChatSelectAnswer },
};
static TUnifiedCallbackItem CbArray[]= // Exists twice???
{
	{ "BOT_CHAT_START", cbBotChatStart },
	{ "BOT_CHAT_SELECT_ANSWER", cbBotChatSelectAnswer },
};

//ai_service/gpms_interface.cpp
static TUnifiedCallbackItem CbArray[] = //Commented
{
	{	"VISIONS_DELTA_2",		cbVisionDelta,	}
};

//ai_service/messages.cpp
TUnifiedCallbackItem CbArray[] = 
{
	{	"ADDED_ENTITIES",					cbAddEntities,					},
	{	"SRC_SPWN_VLD",						cbValidateSourceSpawn			},
	{	"S_SRC_SPWN_VLD",					cbValidateSimpleSourceSpawn		},
	{	"R2_GOLIVE",						cbR2GoLive						},
	{	"R2_STOPLIVE",						cbR2StopLive					},
	{	"R2_STARTINSTANCE",					cbR2StartInstance				},
	{	"R2_NPC_BOT_SCRIPT_BY_ID",			cbR2NpcBotScriptById			},
	{	"R2_NPC_GROUP_SCRIPT_BY_NAME",		cbR2NpcGroupScriptByName		},
	{	"OUTPOST_CREATE_SQUAD",				cbOutpostCreateSquad			},
	{	"OUTPOST_SPAWN_SQUAD",				cbOutpostSpawnSquad				},
	{	"OUTPOST_DESPAWN_SQUAD",			cbOutpostDespawnSquad			},
	{	"OUTPOST_DELETE_SQUAD",				cbOutpostDeleteSquad			},
	{	"OUTPOST_DESPAWN_ALL_SQUADS",		cbOutpostDespawnAllSquads		},
	{	"OUTPOST_OWNER",					cbOutpostSetOwner				},
	{	"OUTPOST_ATTACKER",					cbOutpostSetAttacker			},
	{	"OUTPOST_STATE",					cbOutpostSetState				},
	{	"OUTPOST_EVENT",					cbOutpostEvent					},
	{	"OUTPOST_SET_BUILDING_BOT_SHEET",	cbOutpostSetBuildingBotSheet	},
	{	"EVENT_CREATE_NPC_GROUP",			cbEventCreateNpcGroup			},
	{	"EVENT_NPC_GROUP_SCRIPT",			cbEventNpcGroupScript			},
	{	"EVENT_FAUNA_BOT_SET_RADII",		cbEventFaunaBotSetRadii			},
	{	"EVENT_FAUNA_BOT_RESET_RADII",		cbEventFaunaBotResetRadii		},
	{	"EVENT_BOT_CAN_AGGRO",				cbEventBotCanAggro				},
	{	"EVENT_BOT_SHEET",					cbEventBotSheet					},
	{	"ASK_BOT_DESPAWN_NOTIFICATION",		cbAskBotDespawnNotification		},
	{	"SPAWN_EASTER_EGG",					cbSpawnEasterEgg				},
	{	"DESPAWN_EASTER_EGG",				cbDespawnEasterEgg				},
};

//ai_service/egs_interface.cpp
NLNET::TUnifiedCallbackItem _cbArray[] =
{
	{ "KAMI_IMPACT",		cbKamiImpact	},
};

//ai_data_service/service_main.cpp
static TUnifiedCallbackItem CallbackArray[] = 
{
	{	"QWERTY",			0,	},
};

//entities_game_service/modules/easter_egg.cpp
NLNET::TUnifiedCallbackItem _cbArray[] =
{
	{ "EASTER_EGG_SPAWNED",				cbEasterEggSpawned },
};

//entities_games_service/outpost_manager/outpost_manager.cpp
NLNET::TUnifiedCallbackItem _cbArray[] =
{
	{ "OUTPOST_SQUAD_CREATED",		cbOutpostSquadCreated		},
	{ "OUTPOST_SQUAD_SPAWNED",		cbOutpostSquadSpawned		},
	{ "OUTPOST_SQUAD_DESPAWNED",	cbOutpostSquadDespawned		},
	{ "OUTPOST_SQUAD_DIED",			cbOutpostSquadDied		},
	{ "OUTPOST_SQUAD_LEADER_DIED",	cbOutpostSquadLeaderDied	},
};

//entities_game_service/client_messages.cpp
TUnifiedCallbackItem CbClientArray[]=
{
	{ "CLIENT:CONNECTION:CLIENT_QUIT_REQUEST",	cbClientQuitGameRequest },
	{ "RET_MAINLAND",							cbClientReturnToMainland },

	{ "CLIENT:ITEM:DROP",					cbClientItemDrop },
	{ "CLIENT:ITEM:PICK_UP_CLOSE",			cbClientItemPickUpClose },
	{ "CLIENT:ITEM:SWAP",					cbClientItemSwap },
	{ "CLIENT:ITEM:HARVEST",				cbClientItemHarvest },
	{ "CLIENT:ITEM:HARVEST_CLOSE",			cbClientItemHarvestClose },
	{ "CLIENT:ITEM:DESTROY",				cbClientItemDestroy },
	{ "CLIENT:ITEM:EQUIP",					cbClientItemEquip },
	{ "CLIENT:ITEM:UNEQUIP",				cbClientItemUnequip },
	{ "CLIENT:ITEM:TEMP_TO_BAG",			cbClientItemTempToBag },
	{ "CLIENT:ITEM:ALL_TEMP",				cbClientItemAllTemp },
	{ "CLIENT:ITEM:NO_TEMP",				cbClientItemNoTemp },
	{ "CLIENT:ITEM:ENCHANT",				cbClientItemEnchant },
	{ "CLIENT:ITEM:USE_ITEM",				cbClientItemUseItem },
	{ "CLIENT:ITEM:STOP_USE_XP_CAT",		cbClientItemStopUseXpCat },


	{ "CLIENT:ITEM_INFO:GET",				cbClientItemInfos },
	{ "CLIENT:MISSION_PREREQ:GET",			cbClientMissionPrereq },

	{ "CLIENT:HARVEST:DEPOSIT",				cbClientHarvestDeposit },

	{ "CLIENT:PHRASE:MEMORIZE",				cbClientPhraseMemorize },
	{ "CLIENT:PHRASE:FORGET",				cbClientPhraseForget },
	{ "CLIENT:PHRASE:LEARN",				cbClientPhraseLearn },
	{ "CLIENT:PHRASE:DELETE",				cbClientPhraseDelete },
	{ "CLIENT:PHRASE:EXECUTE",				cbClientPhraseExecute },
	{ "CLIENT:PHRASE:EXECUTE_CYCLIC",		cbClientPhraseExecuteCyclic },
	{ "CLIENT:PHRASE:EXECUTE_FABER",		cbClientPhraseExecuteFaber },
	{ "CLIENT:PHRASE:BUY",					cbClientPhraseBuyByIndex },
	{ "CLIENT:PHRASE:BUY_SHEET",			cbClientPhraseBuyBySheet },

	{ "CLIENT:PHRASE:CANCEL_TOP",			cbClientPhraseCancelTop },
	{ "CLIENT:PHRASE:CANCEL_ALL",			cbClientPhraseCancelAll },
	{ "CLIENT:PHRASE:CRISTALIZE",			cbClientPhraseCristalize },


	{ "CLIENT:COMBAT:ENGAGE",				cbClientCombatEngage },
	{ "CLIENT:COMBAT:DISENGAGE",			cbClientCombatDisengage },
	{ "CLIENT:COMBAT:DEFAULT_ATTACK",		cbClientCombatDefaultAttack },
	{ "CLIENT:COMBAT:VALIDATE_MELEE",		cbClientValidateMeleeCombat },
	{ "CLIENT:COMBAT:PARRY",				cbClientCombatParry },
	{ "CLIENT:COMBAT:DODGE",				cbClientCombatDodge },
	{ "CLIENT:COMBAT:PROTECTED_SLOT",		cbClientCombatProtectedSlot },

	{ "CLIENT:TEAM:LEAVE",					cbClientTeamLeave },
	{ "CLIENT:TEAM:JOIN",					cbClientTeamJoin },
	{ "CLIENT:TEAM:KICK",					cbClientTeamKick },
	{ "CLIENT:TEAM:JOIN_PROPOSAL",			cbClientTeamJoinProposal },
	{ "CLIENT:TEAM:JOIN_PROPOSAL_DECLINE",	cbClientTeamJoinProposalDecline },
	{ "CLIENT:TEAM:SET_SUCCESSOR",			cbClientTeamSetSuccessor },

	{ "CLIENT:TEAM:SHARE_VALID_ITEM",		cbClientTeamShareValidItem },
	{ "CLIENT:TEAM:SHARE_INVALID_ITEM",		cbClientTeamShareInvalidItem },
	{ "CLIENT:TEAM:SHARE_VALID",			cbClientTeamShareValid },

	{ "CLIENT:TEAM:CONTACT_ADD",			cbClientAddToContactList },
	{ "CLIENT:TEAM:CONTACT_DEL",			cbClientRemoveFromContactList },
	{ "CLIENT:TEAM:CONTACT_MOVE",			cbClientMoveInContactLists },


//	{ "CLIENT:TP:BOT",						cbClientTpBot },
//	{ "CLIENT:TP:WANTED",					cbClientTpWanted },
	{ "CLIENT:TP:ACK",						cbClientTpAck },
//	{ "CLIENT:TP:RESPAWN",					cbClientTpRespawn },

//	{ "CLIENT:ANIMALS:DISBAND_CONVOY",		cbClientAnimalsDisbandConvoy },
	{ "CLIENT:ANIMALS:BEAST",				cbClientAnimalsBeast },
//	{ "CLIENT:ANIMALS:MOUNT",				cbAnimalMount },
//	{ "CLIENT:ANIMALS:UNSEAT",				cbAnimalUnseat },

/*
	{ "CLIENT:TRADE:NEXT_PAGE_ITEM",		cbClientTradeNextPage },
	{ "CLIENT:TRADE:NEXT_PAGE_MISSION_ITEM",cbClientTradeMissionNextPage },
	{ "CLIENT:TRADE:BUY",					cbClientTradeBuy },
	{ "CLIENT:TRADE:QUERY_PRICE",			cbClientTradeQuerySellPrice },
	{ "CLIENT:TRADE:SELL",					cbClientTradeSellItem },
*/

	{ "CLIENT:EXCHANGE:PROPOSAL",			cbClientExchangeProposal },
	{ "CLIENT:EXCHANGE:ACCEPT_INVITATION",	cbClientExchangeAcceptInvitation },
	{ "CLIENT:EXCHANGE:DECLINE_INVITATION",	cbClientExchangeDeclineInvitation },
	{ "CLIENT:EXCHANGE:SEEDS",				cbClientExchangeSeeds },
	{ "CLIENT:EXCHANGE:END",				cbClientExchangeEnd },
	{ "CLIENT:EXCHANGE:VALIDATE",			cbClientExchangeValidate },
	{ "CLIENT:EXCHANGE:INVALIDATE",			cbClientExchangeInvalidate },
	{ "CLIENT:EXCHANGE:ADD",				cbClientExchangeAdd },
	{ "CLIENT:EXCHANGE:REMOVE",				cbClientExchangeRemove },


//	{ "CLIENT:SENTENCE:CANCEL_CURRENT",		cbClientSentenceCancelCurrent },
//	{ "CLIENT:SENTENCE:CANCEL",				cbClientSentenceCancel },
//	{ "CLIENT:SENTENCE:CANCEL_ALL",			cbClientSentenceCancelAll },

	{ "CLIENT:COMMAND:EMOTE",				cbClientSendEmote },
	{ "CLIENT:COMMAND:CUSTOM_EMOTE",		cbClientSendCustomEmote },
	{ "CLIENT:COMMAND:WHERE",				cbClientSendWhere },
	{ "CLIENT:COMMAND:ADMIN",				cbClientAdmin },
	{ "CLIENT:COMMAND:ADMIN_OFFLINE",		cbClientAdminOffline },
	{ "CLIENT:COMMAND:REMOTE_ADMIN_ANSWER",	cbClientRemoteAdmin },
	{ "CLIENT:COMMAND:SIT",					cbClientSit },
	{ "CLIENT:COMMAND:AFK",					cbClientSendAfk },
	{ "CLIENT:COMMAND:RANDOM",				cbClientRollDice },
	{ "CLIENT:COMMAND:GUILDMOTD",			cbClientGuildMotd },


// For all these commented commands, now you have to use the CLIENT:COMMAND:ADMIN message using /a client command

//	{ "CLIENT:CHEAT:GOD",					cbClientCheatGod },
//	{ "CLIENT:CHEAT:CREATE_ITEM_IN_BAG",	cbClientCreateItemInBag	},
//	{ "CLIENT:CHEAT:LEARN_ALL_BRICKS",		cbClientLearnAllBricks },
//	{ "CLIENT:CHEAT:MONEY",					cbClientMoney },
//	{ "CLIENT:CHEAT:SET_TIME",				cbClientRyzomTime },
//	{ "CLIENT:CHEAT:SET_DAY",				cbClientRyzomDay },
//	{ "CLIENT:CHEAT:XP",					cbClientGainXp },
//	{ "CLIENT:CHEAT:CREATE_CHARACTER",		cbClientCreateCharacter },
//	{ "CLIENT:CHEAT:ADD_ROLE",				cbClientAddRole },
//	{ "CLIENT:CHEAT:LEARN_BRICK",			cbClientLearnBrick },
//	{ "CLIENT:CHEAT:LEARN_ALL_FABER_PLANS",	cbClientLearnAllFaberPlans },

	{ "CLIENT:DEBUG:WHERE",					cbClientWhere },
	{ "CLIENT:DEBUG:WHO",					cbClientWho },
	{ "CLIENT:DEBUG:PING",					cbClientPing },

	{ "CLIENT:BOTCHAT:START_CHOOSE_MISSION",	cbClientBotChatChooseStaticMission },
	{ "CLIENT:BOTCHAT:NEXT_PAGE_MISSION",		cbClientBotChatNextMissionPage },
	{ "CLIENT:BOTCHAT:PICK_MISSION",			cbClientBotChatPickStaticMission },
	{ "CLIENT:BOTCHAT:CONTINUE_MISSION",		cbClientContinueMission },
	{ "CLIENT:BOTCHAT:VALIDATE_PLAYER_GIFT",	cbClientValidateMissionGift },


	{ "CLIENT:BOTCHAT:START_TRADE_ITEM",		cbClientBotChatStartTradeItem },
	{ "CLIENT:BOTCHAT:START_TRADE_TELEPORT",	cbClientBotChatStartTradeTp },
	{ "CLIENT:BOTCHAT:START_TRADE_FACTION",		cbClientBotChatStartTradeFaction },

	{ "CLIENT:BOTCHAT:START_TRADE_GUILD_OPTIONS",	cbClientBotChatStartTradeGuildOptions },
	{ "CLIENT:BOTCHAT:BUY_GUILD_OPTION",			cbClientBotChatBuyGuildOptions },
	{ "CLIENT:BOTCHAT:START_GUILD_RESEARCH",		cbClientBotChatStartGuildResearch },


/*	{ "CLIENT:BOTCHAT:START_TRADE_SKILL",		cbClientBotChatStartTradeSkill },
	{ "CLIENT:BOTCHAT:START_TRADE_PACT",		cbClientBotChatStartTradePact },*/
	{ "CLIENT:BOTCHAT:START_TRADE_ACTION",		cbClientBotChatStartTradeAction },

	{ "CLIENT:BOTCHAT:SET_FILTERS",				cbClientBotChatSetFilters },


	{ "CLIENT:BOTCHAT:NEXT_PAGE_ITEM",			cbClientBotChatTradeNextPage },
	{ "CLIENT:BOTCHAT:BUY",						cbClientBotChatTradeBuy },
	{ "CLIENT:BOTCHAT:DESTROY_ITEM",			cbClientBotChatTradeDestroy },
	{ "CLIENT:BOTCHAT:SELL",					cbClientBotChatTradeSell },
	{ "CLIENT:BOTCHAT:REFRESH_TRADE_LIST",		cbRefreshTradeList },

	{ "CLIENT:BOTCHAT:START_CREATE_GUILD",		cbClientBotChatStartGuildCreation },

	{ "CLIENT:BOTCHAT:END",						cbClientBotChatEnd },
	{ "CLIENT:BOTCHAT:END_GIFT",				cbClientBotChatEndGift },

	{ "CLIENT:BOTCHAT:DYNCHAT_SEND",			cbClientBotChatDynChatSend },


	// mission journal related commands
	{ "CLIENT:JOURNAL:MISSION_ABANDON",			cbClientAbandonMission },
	{ "CLIENT:JOURNAL:GROUP_MISSION_ABANDON",	cbClientGroupAbandonMission },

	// guild related messages
	{ "CLIENT:GUILD:CREATE",					cbClientGuildCreate },
	{ "CLIENT:GUILD:INVITATION",				cbClientGuildJoinInvitation },
	{ "CLIENT:GUILD:ACCEPT_INVITATION",			cbClientGuildAcceptJoinInvitation },
	{ "CLIENT:GUILD:REFUSE_INVITATION",			cbClientGuildRefuseJoinInvitation },

	{ "CLIENT:GUILD:SET_GRADE",					cbClientGuildSetGrade },
	{ "CLIENT:GUILD:KICK_MEMBER",				cbClientGuildKickMember },


	{ "CLIENT:GUILD:QUIT",						cbClientGuildQuit },
	{ "CLIENT:GUILD:TELEPORT",					cbClientGuildLiftTeleport },
	{ "CLIENT:GUILD:FIRST_ASCENSOR_PAGE",		cbClientGuildLiftDestAsked },
	{ "CLIENT:GUILD:NEXT_ASCENSOR_PAGE",		cbClientGuildLiftNextPage },
	{ "CLIENT:GUILD:SET_PLAYER_TITLE",			cbClientSetCharacterTitle },
	//{ "CLIENT:GUILD:BAG_TO_GUILD",			cbClientBagToGuild },
	//{ "CLIENT:GUILD:GUILD_TO_BAG",			cbClientGuildToBag },
	{ "CLIENT:GUILD:PUT_MONEY",					cbClientGuildPutMoney },
	{ "CLIENT:GUILD:TAKE_MONEY",				cbClientGuildTakeMoney },

	// outpost related messages
	{ "CLIENT:OUTPOST:SET_SQUAD",				cbClientOutpostSetSquad },
	{ "CLIENT:OUTPOST:SET_SQUAD_SPAWN",			cbClientOutpostSetSquadSpawnZone },
	{ "CLIENT:OUTPOST:INSERT_SQUAD",			cbClientOutpostInsertSquad },
	{ "CLIENT:OUTPOST:REMOVE_SQUAD",			cbClientOutpostRemoveSquad },
	{ "CLIENT:OUTPOST:SET_SQUAD_CAPITAL",		cbClientOutpostSetExpenseLimit },
//	{ "CLIENT:OUTPOST:BUY_BUILDING",			cbClientOutpostBuyBuilding },
//	{ "CLIENT:OUTPOST:DESTROY_BUILDING",		cbClientOutpostDestroyBuilding },
	{ "CLIENT:OUTPOST:SIDE_CHOSEN",				cbClientOutpostSideChosen },
	{ "CLIENT:OUTPOST:SELECT",					cbClientOutpostSelect },
	{ "CLIENT:OUTPOST:UNSELECT",				cbClientOutpostUnselect },
	{ "CLIENT:OUTPOST:DECLARE_WAR_START",		cbClientOutpostWarStart },
	{ "CLIENT:OUTPOST:DECLARE_WAR_VALIDATE",	cbClientOutpostWarValidate },
	{ "CLIENT:OUTPOST:GIVEUP_OUTPOST",			cbClientOutpostGiveup },
	{ "CLIENT:OUTPOST:BANISH_PLAYER",			cbClientOutpostBanishPlayer },
	{ "CLIENT:OUTPOST:BANISH_GUILD",			cbClientOutpostBanishGuild },
	{ "CLIENT:OUTPOST:SET_DEF_PERIOD",			cbClientOutpostSetDefensePeriod },

	// death management messages
	{ "CLIENT:DEATH:ASK_RESPAWN",				cbClientAskRespawn },

	// set compass target
	{ "CLIENT:TARGET:COMPASS_DYNAMIC",			cbClientCompassEnableDynamic },
	{ "CLIENT:TARGET:COMPASS_NOT_DYNAMIC",		cbClientCompassDisableDynamic },

	{ "CLIENT:DUEL:ASK",						cbClientDuelAsked },
	{ "CLIENT:DUEL:ACCEPT",						cbClientDuelAccept },
	{ "CLIENT:DUEL:REFUSE",						cbClientDuelRefuse },
	{ "CLIENT:DUEL:ABANDON",					cbClientDuelAbandon },

	{ "CLIENT:PVP_CHALLENGE:ASK",				cbClientLeagueJoinProposal },
	{ "CLIENT:PVP_CHALLENGE:ACCEPT",			cbClientLeagueJoin },
	{ "CLIENT:PVP_CHALLENGE:REFUSE",			cbClientLeagueJoinProposalDecline },
	{ "CLIENT:PVP_CHALLENGE:ABANDON",			cbClientPVPChallengeAbandon },

//	{ "CLIENT:PVP_VERSUS:CLAN",					cbClientPvpChooseClan },
	{ "CLIENT:PVP:PVP_TAG",						cbClientPvPSetTag },
	{ "CLIENT:PVP:SET_NEUTRAL_ALLEGIANCE",		cbClientPvPSetNeutralAllegiance },
	{ "CLIENT:PVP:SET_NEUTRAL_ALLEGIANCE_GUILD",cbClientPvPSetNeutralAllegianceGuild },

	{ "CLIENT:MISSION:ENTER_CRITICAL",			cbClientMissionEnterCritical },
	{ "CLIENT:MISSION:WAKE",					cbClientMissionWake },
	{ "CLIENT:MISSION:GROUP_WAKE",				cbClientMissionGroupWake },

	{ "CLIENT:EVENT:SET_ITEM_CUSTOM_TEXT",		cbClientEventSetItemCustomText },

	{ "CLIENT:TOTEM:BUILD",						cbTotemBuild },

	{ "CLIENT:DM_GIFT:BEGIN",					cbDMGiftBegin },
	{ "CLIENT:DM_GIFT:VALIDATE",				cbDMGiftValidate },

	{ "CLIENT:RING_MISSION:MISSION_RING_SELECT",cbRingMissionSelectAction },

	{ "CLIENT:NPC_ICON:GET_DESC",				cbGetNpcIconDesc },
}; 

//entities_games_service/creature_manager/creature_manager.cpp
TUnifiedCallbackItem	GenNpcDescCbTable[] =
{
	{	"TGenNpcDescMsg", genNpcDescCb},
};

//entities_game_service/common_shard_callbacks.cpp
TUnifiedCallbackItem array[]= //Commented
{
	{ "STORE_STRING_RESULT",		cbStoreStringResult },
	{ "STALL_SHARD",			cbStallShard		},
	{ "RESUME_SHARD",			cbResumeShard		},
};
TUnifiedCallbackItem array[]=
{
	{ "STALL_MODE",				cbStallMode			},
};

//entities_game_service/dyn_chat_egs.cpp
NLNET::TUnifiedCallbackItem _cbArray[] =
{
	{ "DYN_CHAT:ADD_SERVICE_CHAN",		CDynChatEGS::cbServiceAddChan			},
	{ "DYN_CHAT:SET_HIDE_BUBBLE",		CDynChatEGS::cbServiceSetHideBubble		},
	{ "DYN_CHAT:SET_UNIVERSAL_CHANNEL",	CDynChatEGS::cbServiceSetUniversalChannel},
	{ "DYN_CHAT:SET_CHAN_HISTORY",		CDynChatEGS::cbServiceSetChanHistory	},
	{ "DYN_CHAT:REMOVE_SERVICE_CHAN",	CDynChatEGS::cbServiceRemoveChan		},
	{ "DYN_CHAT:ADD_CLIENT",			CDynChatEGS::cbServiceAddClient			},
	{ "DYN_CHAT:ADD_SESSION",			CDynChatEGS::cbServiceAddSession		},
	{ "DYN_CHAT:ADD_SESSION_ENTITY",	CDynChatEGS::cbServiceAddSessionEntity	},
	{ "DYN_CHAT:REMOVE_SESSION",		CDynChatEGS::cbServiceRemoveSession		},
	{ "DYN_CHAT:REMOVE_SESSION_ENTITY",	CDynChatEGS::cbServiceRemoveSessionEntity}
};

//entities_game_service/entity_manager/entity_manager.cpp
NLNET::TUnifiedCallbackItem _cbArray[] =
{
	{ "SET_VALUE",				cbSetValue				},
	{ "MODIFY_VALUE",			cbModifyValue			},
	{ "TARGET",					cbTarget				},
	{ "FIGHTING_TARGET",		cbFightingTarget		},
		
	{ "ENTITY_POS",				cbEntityPos				},

//	{ "EVENT_REPORTS",			cbActionReport			},

	{ "SET_MODE",				cbChangeMode			},
	{ "SET_BEHAVIOUR",			cbChangeBehaviour		},
		
	//{ "DISENGAGE",				cbDisengage				},
	{ "ENGAGE",					cbEngage				},
	{ "DEFAULT_ATTACK",			cbDefaultAttack			},

	{ "STUN",					cbStun					},
	{ "WAKE",					cbWake					},
//	{ "GOD_MODE",				cbGodMode				},

	{ "SRC_SPWN_VLD_R",			cbRcvValidateSourceSpawnReply },
		
	{ "PLAYER_UNREACHABLE",			cbPlayerUnreachable }
};

//entities_game_service/guild_manager/fame_manager.cpp
NLNET::TUnifiedCallbackItem _cbArray[] =
{
	{ "FAME_DELTA",				cbFameDelta		},
};

//entities_game_service/building_manager/building_manager.cpp
NLNET::TUnifiedCallbackItem _cbArray[] =
{
	{ "PTRIG_IN",				cbLiftIn		},
	{ "PTRIG_OUT",				cbLiftOut		},
};

//entities_game_service/phrase_manager/phrase_manager.cpp
NLNET::TUnifiedCallbackItem _cbArray[] =
{
	{ "REGISTER_EVENT_REPORTS",			cbRegisterService		},
	{ "REGISTER_AI_EVENT_REPORTS",		cbRegisterServiceAI		},
	
	{ "UNREGISTER_EVENT_REPORTS",		cbUnregisterService		},
	{ "UNREGISTER_AI_EVENT_REPORTS",	cbUnregisterServiceAI	},
	
	{ "DISENGAGE_NOTIFICATION",			cbDisengageNotification	},
	{ "DISENGAGE",						cbDisengage				},	
};

//entities_game_service/player_manager/player_manager.cpp
NLNET::TUnifiedCallbackItem _cbArray[] =
{
	{ "CL_CONNECT",				cbClientConnection		}, 
	{ "CL_DISCONNECT",			cbClientDisconnection	},
//	{ "CLIENT:CONNECTION:ENTER",cbClientEnter			},
	{ "RDY",					cbClientReady			},
	{ "SELECT_CHAR",			cbSelectChar			}, 
	{ "CHECK_NAME",				cbCheckName				},
	{ "CREATE_CHAR",			cbCreateChar			},
	{ "CLIENT:CONNECTION:DELETE_CHAR", cbDeleteChar		},

	{ "ITEM_DROP",				cbItemDrop				}, 
	{ "ITEM_PICK_UP",			cbItemPickup			}, 
	{ "ITEM_CLOSE_PICK_UP",		cbItemClosePickup		},
	{ "ITEM_SWAP",				cbItemSwap				}, 
	
	{ "PACK_ANIMAL_COMMAND",	cbAnimalCommand			},
	
//	{ "TRADE_LIST",				cbTradeListReceived		},//deprecated
//	{ "TRADE_CHANGE_PAGE",		cbTradePageSelect		},//deprecated
	{ "TRADE_BUY_SOMETHING",	cbTradeBuySomething		},
//	{ "GIVE_SEED",				cbGiveSeed				},

	{ "JOIN_TEAM",				cbJoinTeam				},
	{ "LEAVE_TEAM",				cbLeaveTeam				},
	{ "JOIN_TEAM_PROPOSAL",		cbJoinTeamProposal		},
	{ "JOIN_TEAM_DECLINE",		cbJoinTeamDecline		},
	{ "KICK_TEAMMATE",			cbKickTeammate			},
								
	{ "HARVEST",				cbHarvest				}, //use (from client)
	{ "HARVEST_CLOSE",			cbHarvestClose			}, //use (from client)
									
//	{ "HARVEST_RESULT",			cbHarvestResult			}, //deprecated

//	{ "HARVEST_MP_DESTOYED",	cbHarvestMPDestroyed	}, //deprecated
//	{ "HARVEST_INTERRUPTED",	cbHarvestInterrupted	}, //deprecated
									
//	{ "HARVEST_DB",				cbHarvestDB				}, //deprecated
//	{ "HARVEST_DB_UPDATE_QTY",	cbHarvestDBUpdateQty	}, //deprecated
//	{ "CLEAR_HARVEST_DB",		cbClearHarvestDB		}, //deprecated
				
//	{ "CREATE_ITEM_IN_BAG",		cbCreateItemInBag		},

	{ "ADD_SURVIVE_PACT",		cbAddSurvivePact		},
	
	{ "EXCHANGE_PROPOSAL",				cbExchangeProposal			},
	{ "EXCHANGE_ACCEPT_INVITATION",		cbAcceptExchangeInvitation	},
	{ "EXCHANGE_DECLINE_INVITATION",	cbDeclineExchangeInvitation	},
	{ "EXCHANGE_ACCEPT",				cbAcceptExchange			},
	{ "EXCHANGE_END",					cbEndExchange				},
	{ "EXCHANGE_SEEDS",					cbExchangeSeeds				},

	{ "SET_PLAYER_WEATHER",					cbSetPlayerWeather		}, // from DSS
	{ "SET_PLAYER_SEASON",					cbSetPlayerSeason		}, // from DSS

	{ "TELEPORT_PLAYER",					cbTeleportPlayer		}, // from AIS
	{ "TRIGGER_WEBIG",						cbTriggerWebig			}, // from AIS
	
	{ "SET_CHAR_AIINSTANCE",			cbSetCharacterAIInstance},

//	{ "FAME_CHANGE",			cbFameChange			}, // deprecated
};

//entities_game_service/player_manager/db_string_updater.cpp
TUnifiedCallbackItem	StringUpdateCbArray[] =
{
	{"STORE_STRING_RESULT", &CDBStringUpdater::cbStoreStringResult },
};

//entities_game_service/egs_dynamic_sheet_manager.cpp
NLNET::TUnifiedCallbackItem _cbArray[] =
{
	{ "USER_MODELS", cbGetUserModels },
	{ "CUSTOM_LOOT_TABLES", cbGetCustomLootTables },
	{ "DELCUSTOM", cbDeleteCustomDataByPrimAlias }
};

//entities_game_service/zone_manager.cpp
NLNET::TUnifiedCallbackItem _cbArray[] =
{
	{ "SET_ZONE_STATE",		cbSetZoneState },
};

//dynamic_scenario_service/dynamic_scenario_service.cpp
TUnifiedCallbackItem CbArray[]=
{
	{"translateAndForward", cbForwardToStringManagerModule},
	{"DYN_CHAT:FORWARD", cbDynChatForward},
	{"DSS_START_ACT", cbDssStartAct},
	{"translateAndForwardArg", cbForwardToStringManagerModuleWithArg},
	{"SESSION_ACK", cbSessionAck},
	{"EXEC_COMMAND_RESULT",	cbExecCommandResult},
	{"BOT_DESPAWN_NOTIFICATION", cbBotDespawnNotification},
	{"BOT_DEATH_NOTIFICATION", cbBotDeathNotification},
	{"BOT_STOPCCONTROL_NOTIFICATION", cbStopNpcControlNotification},
	{"", NULL}
};

//dynamic_scenario_service/service.cpp
TUnifiedCallbackItem CbArray[]=
{
	{"translateAndForward", cbForwardToStringManagerModule},
	{"DYN_CHAT:FORWARD", cbDynChatForward},
	{"DSS_START_ACT", cbDssStartAct},
	{"translateAndForwardArg", cbForwardToStringManagerModuleWithArg},
	{"SESSION_ACK", cbSessionAck},
	{"EXEC_COMMAND_RESULT",	cbExecCommandResult},
	{"BOT_DESPAWN_NOTIFICATION", cbBotDespawnNotification},
	{"BOT_DEATH_NOTIFICATION", cbBotDespawnNotification},
	{"----", NULL}
};

//log_analyser_service/log_analyser_service.cpp
TUnifiedCallbackItem CbArray[] =
{
	{ "",	NULL },
};

//session_browser_server/session_browser_server.cpp
NLNET::TUnifiedCallbackItem cbArraySU[] = 
{ 
	{"", NULL}
};

//monitor_service/messages.cpp
TUnifiedCallbackItem CbArray[] = 
{
	{	"ADDED_ENTITIES",		cbAddEntities,			},
};

//monitor_service/service_main.cpp
TUnifiedCallbackItem CallbackArray5[] =
{
	{ "RECV_STRING", cbReceiveString },
};

//backup_service/backup_service.cpp
TUnifiedCallbackItem CbArray[]=
{
	{ "save_file",			cbSaveFile },
	{ "load_file",			cbLoadFile },
	{ "append_file",		cbAppendFile },
	{ "append_file_check",	cbAppendFileCheck },

	{ "SAVE_CHECK_FILE",	cbSaveCheckFile },
	{ "DELETE_FILE",		cbDeleteFile },
	{ "DELETE_FILE_NO_BACKUP",		cbDeleteFileNoBackup },

	{ "GET_FILE_CLASS",		cbGetFileClass },

	{ "APPEND",				cbAppend },

	{ "BS_PING",			cbBSPing },
	{ "BS_PONG",			cbBSPong },
};

//mail_forum_service/shard_stat_db_manager.cpp
TUnifiedCallbackItem cbClientArray[] =
{
	"SDB:INIT",					cbInit,
	"SDB:CREATE_VALUE",			cbCreateValue,
	"SDB:CREATE_TABLE",			cbCreateTable,
	"SDB:VALUE_SET",			cbValueSet,
	"SDB:VALUE_ADD",			cbValueAdd,
	"SDB:TABLE_PLAYER_ADD",		cbTablePlayerAdd,
	"SDB:TABLE_PLAYER_SET",		cbTablePlayerSet,
	"SDB:TABLE_GUILD_ADD",		cbTableGuildAdd,
	"SDB:TABLE_GUILD_SET",		cbTableGuildSet,
	"SDB:REMOVE_NODE",			cbRemoveNode,
	"SDB:REMOVE_PLAYER",		cbRemovePlayer,
	"SDB:REMOVE_GUILD",			cbRemoveGuild,
};

//mail_forum_service/mail_forum_service.cpp
TUnifiedCallbackItem CbArray[]=
{
	{ "OPEN_SESSION",		CMailForumService::cbOpenSession },
	{ "CLOSE_SESSION",		CMailForumService::cbCloseSession },

	{ "REMOVE_USER",		CMailForumService::cbRemoveUser },
	{ "REMOVE_GUILD",		CMailForumService::cbRemoveGuild },

	{ "CHANGE_UNAME",		CMailForumService::cbChangeUserName },
};

//shard_unifier_service/shard_unifier_service.cpp
NLNET::TUnifiedCallbackItem cbArraySU[] = 
{ 
	{"", NULL}
};

//simulation_service/simulation_service.cpp
NLNET::TUnifiedCallbackItem CallbackArray[] = 
{
	{ "nop",	NULL },
};

//pd_lib/pd_string_manager.cpp
////TUnifiedCallbackItem	PDStringManagerCbArray[] = //Commented
////{
////	{ "STORE_STRING_RESULT", cbStoreStringResult },
////};

//pd_lib/pd_lib.cpp
TUnifiedCallbackItem	PDSCbArray[] =
{
	{ "PD_READY",			cbPDSReady },
	{ "PD_INIT_FAILED",		cbPDSInitFailed },
	{ "PD_FETCH",			cbFetch },
	{ "PD_FETCH_FAILURE",	cbFetchFailure },
	{ "PD_ALLOCS",			cbAllocs },
//	{ "PD_SM_INIT",			cbInitStringManager },
	{ "PD_ACK_UPD",			cbFlushAckUpdates },
};

//general_utilities_service/ss_service_comms_manager.cpp
TUnifiedCallbackItem cbArray[] = 
{
	{	"VIEW",	cbView,	},
};

//general_utilities_service/gus_utils.cpp
TUnifiedCallbackItem cbArray[] = 
{
	{	"EXEC_COMMAND_RESULT",	cbExecCommandResult,	},
};

//general_utilities_service/gus_client_manager.cpp
TUnifiedCallbackItem ClientMgrCbArray[]=
{
	{	"RECV_STRING",					CClientManagerImplementation::cbRecvString}
};

//general_utilities_service/gus_chat.cpp
TUnifiedCallbackItem ChatCbArray[]=
{
	{	"DYN_CHAT:FORWARD",				CChatManagerImplementation::cbDynChatForward},
};

//ags_test/ags_test.cpp
TUnifiedCallbackItem CallbackArray[] = 
{
	{	"AZERTY",	NULL	},
};

//ags_test/command_event_manager.cpp
TUnifiedCallbackItem CbScriptArray[] = 
{
	{	"S_EVENT",			cbProcessScriptEvent,	}
};

//ags_test/messages.cpp
TUnifiedCallbackItem CbArray[] = //Commented
{

	{	"ENGAGE_FIGHT",			cbEngageFight,	},
	{	"U_FIGHT_BEHAVIOUR",	cbUpdateFightBehaviour,	},
	{	"U_FIGHT_POS",			cbUpdateFightPosition,	},
	{	"U_END_FIGHT",			cbUpdateFightEnd,		},
	{	"U_FIGHT_END",			cbUpdateFightEnd,		},

	{	"ACK_VISION_ZONE",		cbAckVisionZone,		},
	{	"AGENT_VISION",			cbAIVision,				},
};

//ags_test/service_main.cpp
static TUnifiedCallbackItem CallbackArray[] = 
{
	{	"QWERTY",			0,	},
};

//persistant_data_service/persistant_data_service.cpp
TUnifiedCallbackItem CbArray[] =
{
	{ "",	NULL },
};

//persistant_data_service/db_manager_messages.cpp
TUnifiedCallbackItem	DbManagerCbArray[] =
{
	{ "PD_INIT",			&cbInitDatabase },
	{ "PD_UPDATE",			&cbUpdateDb },
	{ "PD_SHEETID_MAPPING",	&cbSheetIdMapping },
	//{ "PD_SM_STRING",		&cbAddString },

	{ "RB_TASK_SUCCESS",	&cbRBSTaskSuccess },
	{ "RB_TASK_FAILED",		&cbRBSTaskFailure },
};

//frontend_service/frontend_service.cpp
TUnifiedCallbackItem cbFrontEndArray [] =
{
	{ "IMPULSION_ID", cbImpulsionId },
	{ "IMPULS_CH_ID", cbImpulsionIdChannel },
	{ "CDB_IMPULSION", cbImpulsionDatabase },
	{ "CDB_MULTI_IMPULSION", cbImpulsionMultiDatabase },
	{ "IMPULSION_UID", cbImpulsionUid },
	{ "CL_ID", cbMapIdToUid },
	{ "ENTITY_NAMES", cbSetEntityNames },
	{ "DISCONNECT_CLIENT", cbServerDisconnectClient },		// Called by server to disconnect a client
	{ "DISCONNECT_ALL_CLIENTS", cbDisconnectAllClients },	// Called by server to disconnect all clients at once

	{ "FS_ACCEPT", cbAcceptClients }
};

//frontend_service/vision_receiver.cpp
NLNET::TUnifiedCallbackItem _cbArray[1];
_cbArray[0].Callback = cbDeltaNewVision;
_cbArray[0].Key = "VISIONS_DELTA_2";

//sabrina/phrase_manager.cpp
NLNET::TUnifiedCallbackItem _cbArray[] =
{
	{ "REGISTER_EVENT_REPORTS",			cbRegisterService		},
	{ "REGISTER_AI_EVENT_REPORTS",		cbRegisterServiceAI		},
	
	{ "UNREGISTER_EVENT_REPORTS",		cbUnregisterService		},
	{ "UNREGISTER_AI_EVENT_REPORTS",	cbUnregisterServiceAI	},

	{ "DISENGAGE_NOTIFICATION",			cbDisengageNotification	},
	{ "DISENGAGE",						cbDisengage				},	
};

//sabrina/sabrina_ai_interface.cpp
NLNET::TUnifiedCallbackItem _cbArray[] =
{
	{ "REGISTER_AI_EVENT_REPORTS",		SABRINA::cbRegisterServiceAI	},
	{ "UNREGISTER_AI_EVENT_REPORTS",	SABRINA::cbUnregisterServiceAI	},
};

Serveur, NEL

Table of Contents