public void deletePendingClient(NetComputer client)
{
MessageOut msg=new MessageOut(Protocol.CPMSG_CONNECT_RESPONSE);
msg.writeInt8((int)ErrorMessage.ERRMSG_TIME_OUT);
// The computer will be deleted when the disconnect event is processed
client.disconnect(msg);
}
void increaseClientInput(NetComputer nc, int size)
{
//mAmountClientInput += size;
//// look for an existing client stored
//ClientBandwidth::iterator itr = mClientBandwidth.find(nc);
//// if there isnt one, create it
//if (itr == mClientBandwidth.end())
//{
// std::pair<ClientBandwidth::iterator, bool> retItr;
// retItr = mClientBandwidth.insert(std::pair<NetComputer*, std::pair<int, int> >(nc, std::pair<int, int>(0, 0)));
// itr = retItr.first;
//}
//itr.second.second += size;
}
// internal GameServer getGameServerFromMap(int);
//internal void GameServerHandler::dumpStatistics(std::ostream &);
/// <summary>
/// Processes server messages.
/// </summary>
/// <param name="computer"></param>
/// <param name="message"></param>
protected override void processMessage(NetComputer computer, MessageIn message)
{
MessageOut result=new MessageOut();
GameServer server=(GameServer)(computer);
switch(message.getId())
{
case Protocol.GAMSG_REGISTER:
{
Logger.Write(LogLevel.Debug, "GAMSG_REGISTER");
// TODO: check the credentials of the game server
server.address=message.readString();
server.port=message.readInt16();
string password=message.readString();
// checks the version of the remote item database with our local copy
uint dbversion=(uint)message.readInt32();
Logger.Write(LogLevel.Information, "Game server uses itemsdatabase with version {0}", dbversion);
Logger.Write(LogLevel.Debug, "AGMSG_REGISTER_RESPONSE");
MessageOut outmessage=new MessageOut(Protocol.AGMSG_REGISTER_RESPONSE);
if(dbversion==Program.storage.getItemDatabaseVersion())
{
Logger.Write(LogLevel.Debug, "Item databases between account server and gameserver are in sync");
outmessage.writeInt16((int)DataVersion.DATA_VERSION_OK);
}
else
{
Logger.Write(LogLevel.Debug, "Item database of game server has a wrong version");
outmessage.writeInt16((int)DataVersion.DATA_VERSION_OUTDATED);
}
if(password==Configuration.getValue("net_password", "changeMe"))
{
outmessage.writeInt16((int)Password.PASSWORD_OK);
computer.send(outmessage);
// transmit global world state variables
Dictionary<string, string> variables;
variables=Program.storage.getAllWorldStateVars(0);
foreach(KeyValuePair<string, string> pair in variables)
{
outmessage.writeString(pair.Key);
outmessage.writeString(pair.Value);
}
}
else
{
Logger.Write(LogLevel.Information, "The password given by {0}:{1} was bad.", server.address, server.port);
outmessage.writeInt16((int)Password.PASSWORD_BAD);
computer.disconnect(outmessage);
break;
}
Logger.Write(LogLevel.Information, "Game server {0}:{1} wants to register {2} maps.", server.address, server.port, (message.getUnreadLength()/2));
while(message.getUnreadLength()!=0)
{
int id=message.readInt16();
Logger.Write(LogLevel.Information, "Registering map {0}.", id);
GameServer s=GameServerHandler.getGameServerFromMap(id);
if(s!=null)
{
Logger.Write(LogLevel.Error, "Server Handler: map is already registered by {0}:{1}.", s.address, s.port);
}
else
{
MessageOut tmpOutMsg=new MessageOut(Protocol.AGMSG_ACTIVE_MAP);
// Map variables
tmpOutMsg.writeInt16(id);
Dictionary<string, string> variables;
variables=Program.storage.getAllWorldStateVars(id);
// Map vars number
tmpOutMsg.writeInt16(variables.Count);
foreach(KeyValuePair<string, string> pair in variables)
{
tmpOutMsg.writeString(pair.Key);
tmpOutMsg.writeString(pair.Value);
}
// Persistent Floor Items
List<FloorItem> items=Program.storage.getFloorItemsFromMap(id);
tmpOutMsg.writeInt16(items.Count); //number of floor items
// Send each map item: item_id, amount, pos_x, pos_y
foreach(FloorItem i in items)
{
tmpOutMsg.writeInt32(i.getItemId());
tmpOutMsg.writeInt16(i.getItemAmount());
tmpOutMsg.writeInt16(i.getPosX());
tmpOutMsg.writeInt16(i.getPosY());
}
computer.send(tmpOutMsg);
//MapStatistics m=server.maps[(ushort)id]; //Auskommentiert da nicht klar ist wo dieser Wert gesetzt wird
//m.nbThings=0;
//m.nbMonsters=0;
}
}
} break;
case Protocol.GAMSG_PLAYER_DATA:
{
Logger.Write(LogLevel.Debug, "GAMSG_PLAYER_DATA");
int id=message.readInt32();
try
{
Character ptr=Program.storage.getCharacter(id, null);
CharacterData.deserializeCharacterData(ptr, message);
if(!Program.storage.updateCharacter(ptr))
{
Logger.Write(LogLevel.Error, "Failed to update character {0}.", id);
}
}
catch
{
Logger.Write(LogLevel.Error, "Received data for non-existing character {0}.", id);
}
} break;
case Protocol.GAMSG_PLAYER_SYNC:
{
Logger.Write(LogLevel.Debug, "GAMSG_PLAYER_SYNC");
GameServerHandler.syncDatabase(message);
} break;
case Protocol.GAMSG_REDIRECT:
{
Logger.Write(LogLevel.Debug, "GAMSG_REDIRECT");
int id=message.readInt32();
//string magic_token(utils::getMagicToken());
string magic_token=Various.GetUniqueID();
try
{
Character ptr=Program.storage.getCharacter(id, null);
int mapId=ptr.getMapId();
try
{
GameServer s=GameServerHandler.getGameServerFromMap(mapId);
GameServerHandler.registerGameClient(s, magic_token, ptr);
result.writeInt16((int)Protocol.AGMSG_REDIRECT_RESPONSE);
result.writeInt32(id);
result.writeString(magic_token);
result.writeString(s.address);
result.writeInt16(s.port);
}
catch
{
Logger.Write(LogLevel.Error, "Server Change: No game server for map {0}.", mapId);
}
}
catch
{
Logger.Write(LogLevel.Error, "Received data for non-existing character {0}.", id);
}
} break;
case Protocol.GAMSG_PLAYER_RECONNECT:
{
Logger.Write(LogLevel.Debug, "GAMSG_PLAYER_RECONNECT");
int id=message.readInt32();
string magic_token=message.readString();
//string magic_token=message.readString(ManaServ.MAGIC_TOKEN_LENGTH);
try
{
Character ptr=Program.storage.getCharacter(id, null);
int accountID=ptr.getAccountID();
AccountClientHandler.prepareReconnect(magic_token, accountID);
}
catch
{
Logger.Write(LogLevel.Error, "Received data for non-existing character {0}.", id);
}
} break;
case Protocol.GAMSG_GET_VAR_CHR:
{
int id=message.readInt32();
string name=message.readString();
string value=Program.storage.getQuestVar(id, name);
result.writeInt16((Int16)Protocol.AGMSG_GET_VAR_CHR_RESPONSE);
result.writeInt32(id);
result.writeString(name);
result.writeString(value);
} break;
case Protocol.GAMSG_SET_VAR_CHR:
{
int id=message.readInt32();
string name=message.readString();
string value=message.readString();
Program.storage.setQuestVar(id, name, value);
} break;
case Protocol.GAMSG_SET_VAR_WORLD:
{
string name=message.readString();
string value=message.readString();
// save the new value to the database
Program.storage.setWorldStateVar(name, value);
// relay the new value to all gameservers
foreach(NetComputer client in clients)
{
MessageOut varUpdateMessage=new MessageOut(Protocol.AGMSG_SET_VAR_WORLD);
varUpdateMessage.writeString(name);
varUpdateMessage.writeString(value);
client.send(varUpdateMessage);
}
} break;
case Protocol.GAMSG_SET_VAR_MAP:
{
int mapid=message.readInt32();
string name=message.readString();
string value=message.readString();
Program.storage.setWorldStateVar(name, mapid, value);
} break;
case Protocol.GAMSG_BAN_PLAYER:
{
int id=message.readInt32();
int duration=message.readInt32();
Program.storage.banCharacter(id, duration);
} break;
case Protocol.GAMSG_CHANGE_PLAYER_LEVEL:
{
int id=message.readInt32();
int level=message.readInt16();
Program.storage.setPlayerLevel(id, level);
} break;
case Protocol.GAMSG_CHANGE_ACCOUNT_LEVEL:
{
int id=message.readInt32();
int level=message.readInt16();
// get the character so we can get the account id
Character c=Program.storage.getCharacter(id, null);
if(c!=null)
{
Program.storage.setAccountLevel(c.getAccountID(), level);
}
} break;
case Protocol.GAMSG_STATISTICS:
{
//while (message.getUnreadLength()!=0)
//{
// int mapId = message.readInt16();
// ServerStatistics::iterator i = server.maps.find(mapId);
// if (i == server.maps.end())
// {
// Logger.Add(LogLevel.Error, "Server {0}:{1} should not be sending statistics for map {2}.", server.address, server.port, mapId);
// // Skip remaining data.
// break;
// }
// MapStatistics m = i.second;
// m.nbThings =(ushort) message.readInt16();
// m.nbMonsters=(ushort)message.readInt16();
// int nb = message.readInt16();
// m.players.resize(nb);
// for (int j = 0; j < nb; ++j)
// {
// m.players[j] = message.readInt32();
// }
//}
} break;
case Protocol.GCMSG_REQUEST_POST:
{
// Retrieve the post for user
Logger.Write(LogLevel.Debug, "GCMSG_REQUEST_POST");
result.writeInt16((int)Protocol.CGMSG_POST_RESPONSE);
// get the character id
int characterId=message.readInt32();
// send the character id of sender
result.writeInt32(characterId);
// get the character based on the id
Character ptr=Program.storage.getCharacter(characterId, null);
if(ptr!=null)
{
// Invalid character
Logger.Write(LogLevel.Error, "Error finding character id for post");
break;
}
// get the post for that character
Post post=Program.postalManager.getPost(ptr);
// send the post if valid
if(post!=null)
{
for(int i=0; i<post.getNumberOfLetters(); ++i)
{
// get each letter, send the sender's name,
// the contents and any attachments
Letter letter=post.getLetter(i);
result.writeString(letter.getSender().getName());
result.writeString(letter.getContents());
List<InventoryItem> items=letter.getAttachments();
for(uint j=0; j<items.Count; ++j)
{
result.writeInt16((int)items[(int)j].itemId);
result.writeInt16((int)items[(int)j].amount);
}
}
// clean up
Program.postalManager.clearPost(ptr);
}
} break;
case Protocol.GCMSG_STORE_POST:
{
//// Store the letter for the user
//Logger.Add(LogLevel.Debug, "GCMSG_STORE_POST");
//result.writeInt16((int)Protocol.CGMSG_STORE_POST_RESPONSE);
//// get the sender and receiver
//int senderId = message.readInt32();
//string receiverName = message.readString();
//// for sending it back
//result.writeInt32(senderId);
//// get their characters
//Character sender = Program.storage.getCharacter(senderId, null);
//Character receiver=Program.storage.getCharacter(receiverName);
//if (sender!=null || receiver!=null)
//{
// // Invalid character
// Logger.Add(LogLevel.Error, "Error finding character id for post");
// result.writeInt8(ManaServ.ERRMSG_INVALID_ARGUMENT);
// break;
//}
//// get the letter contents
//string contents = message.readString();
//List<Pair<int>> items;
//while (message.getUnreadLength()!=0)
//{
// items.Add(new Pair<int>(message.readInt16(), message.readInt16()));
//}
//// save the letter
//Logger.Add(LogLevel.Debug, "Creating letter");
//Letter letter = new Letter(0, sender, receiver);
//letter.addText(contents);
//for (uint i = 0; i < items.Count; ++i)
//{
// InventoryItem item;
// item.itemId = items[i].first;
// item.amount = items[i].second;
// letter.addAttachment(item);
//}
//Program.postalManager.addLetter(letter);
//result.writeInt8(ManaServ.ERRMSG_OK);
} break;
case Protocol.GAMSG_TRANSACTION:
{
Logger.Write(LogLevel.Debug, "TRANSACTION");
int id=message.readInt32();
int action=message.readInt32();
string messageS=message.readString();
Transaction trans=new Transaction();
trans.mCharacterId=(uint)id;
trans.mAction=(uint)action;
trans.mMessage=messageS;
Program.storage.addTransaction(trans);
} break;
case Protocol.GCMSG_PARTY_INVITE:
Program.chatHandler.handlePartyInvite(message);
break;
case Protocol.GAMSG_CREATE_ITEM_ON_MAP:
{
int mapId=message.readInt32();
int itemId=message.readInt32();
int amount=message.readInt16();
int posX=message.readInt16();
int posY=message.readInt16();
Logger.Write(LogLevel.Debug, "Gameserver create item {0} on map {1} ", itemId, mapId);
Program.storage.addFloorItem(mapId, itemId, amount, posX, posY);
} break;
case Protocol.GAMSG_REMOVE_ITEM_ON_MAP:
{
int mapId=message.readInt32();
int itemId=message.readInt32();
int amount=message.readInt16();
int posX=message.readInt16();
int posY=message.readInt16();
Logger.Write(LogLevel.Debug, "Gameserver removed item {0} from map {1}", itemId, mapId);
Program.storage.removeFloorItem(mapId, itemId, amount, posX, posY);
} break;
default:
{
Logger.Write(LogLevel.Warning, "ServerHandler::processMessage, Invalid message type: {0}", message.getId());
result.writeInt16((int)Protocol.XXMSG_INVALID);
break;
}
}
// return result
if(result.getLength()>0)
{
computer.send(result);
}
}
/**
* Called when a game server disconnects.
*/
protected override void computerDisconnected(NetComputer comp)
{
Logger.Write(LogLevel.Information, "Game-server disconnected.");
}
protected virtual void computerDisconnected(NetComputer comp)
{
throw new NotImplementedException("These function must be overloaded from derived class.");
}
protected override void foundMatch(NetComputer client, object data)
{
mHandler.tokenMatched(client, data);
}
//protected:
protected virtual void removedClient(NetComputer data)
{
throw new NotImplementedException("These function must be overloaded from derived class.");
}
protected override void processMessage(NetComputer comp, MessageIn message)
{
ChatClient computer=(ChatClient)(comp);
MessageOut result=new MessageOut();
if(computer.characterName==null)
{
if(message.getId()!=Protocol.PCMSG_CONNECT) return;
string magic_token=message.readString();
mTokenCollector.addPendingClient(magic_token, computer);
sendGuildRejoin(computer);
return;
}
switch(message.getId())
{
case Protocol.PCMSG_CHAT:
handleChatMessage(computer, message);
break;
case Protocol.PCMSG_ANNOUNCE:
handleAnnounceMessage(computer, message);
break;
case Protocol.PCMSG_PRIVMSG:
handlePrivMsgMessage(computer, message);
break;
case Protocol.PCMSG_WHO:
handleWhoMessage(computer);
break;
case Protocol.PCMSG_ENTER_CHANNEL:
handleEnterChannelMessage(computer, message);
break;
case Protocol.PCMSG_USER_MODE:
handleModeChangeMessage(computer, message);
break;
case Protocol.PCMSG_KICK_USER:
handleKickUserMessage(computer, message);
break; //TODO hinzugef�gt, evt sollte es durchfallen
case Protocol.PCMSG_QUIT_CHANNEL:
handleQuitChannelMessage(computer, message);
break;
case Protocol.PCMSG_LIST_CHANNELS:
handleListChannelsMessage(computer, message);
break;
case Protocol.PCMSG_LIST_CHANNELUSERS:
handleListChannelUsersMessage(computer, message);
break;
case Protocol.PCMSG_TOPIC_CHANGE:
handleTopicChange(computer, message);
break;
case Protocol.PCMSG_DISCONNECT:
handleDisconnectMessage(computer, message);
break;
case Protocol.PCMSG_GUILD_CREATE:
handleGuildCreate(computer, message);
break;
case Protocol.PCMSG_GUILD_INVITE:
handleGuildInvite(computer, message);
break;
case Protocol.PCMSG_GUILD_ACCEPT:
handleGuildAcceptInvite(computer, message);
break;
case Protocol.PCMSG_GUILD_GET_MEMBERS:
handleGuildGetMembers(computer, message);
break;
case Protocol.PCMSG_GUILD_PROMOTE_MEMBER:
handleGuildMemberLevelChange(computer, message);
break;
case Protocol.PCMSG_GUILD_KICK_MEMBER:
handleGuildKickMember(computer, message);
break; //TODO hinzugef�gt, evt sollte es durchfallen
case Protocol.PCMSG_GUILD_QUIT:
handleGuildQuit(computer, message);
break;
case Protocol.PCMSG_PARTY_INVITE_ANSWER:
handlePartyInviteAnswer(computer, message);
break;
case Protocol.PCMSG_PARTY_QUIT:
handlePartyQuit(computer);
break;
default:
Logger.Write(LogLevel.Warning, "processMessage, Invalid message type {0}", message.getId());
result.writeInt16((int)Protocol.XXMSG_INVALID);
break;
}
if(result.getLength()>0)
computer.send(result);
}
public void tokenMatched(NetComputer computer, object data)
{
int accountID=(int)data;
AccountClient client=(AccountClient)computer;
MessageOut reply=new MessageOut(Protocol.APMSG_RECONNECT_RESPONSE);
// Associate account with connection.
ISL.Server.Account.Account acc=Program.storage.getAccount(accountID);
client.setAccount(acc);
client.status=AccountClientStatus.CLIENT_CONNECTED;
reply.writeInt8((int)ErrorMessage.ERRMSG_OK);
client.send(reply);
// Return information about available characters
Dictionary<uint, Character> chars=acc.getCharacters();
// Send characters list
foreach(KeyValuePair<uint, Character> pair in chars)
{
sendCharacterData(client, pair.Value);
}
}
protected override void processMessage(NetComputer computer, MessageIn message)
{
GameClient client=(GameClient)computer;
if(client.status==(int)AccountClientStatus.CLIENT_LOGIN)
{
if(message.getId()!=Protocol.PGMSG_CONNECT)
return;
string magic_token=message.readString();
client.status=(int)AccountClientStatus.CLIENT_QUEUED; // Before the addPendingClient
mTokenCollector.addPendingClient(magic_token, client);
return;
}
else if(client.status!=(int)AccountClientStatus.CLIENT_CONNECTED)
{
return;
}
switch(message.getId())
{
case Protocol.PGMSG_SAY:
{
handleSay(client, message);
break;
}
case Protocol.PGMSG_NPC_TALK:
case Protocol.PGMSG_NPC_TALK_NEXT:
case Protocol.PGMSG_NPC_SELECT:
case Protocol.PGMSG_NPC_NUMBER:
case Protocol.PGMSG_NPC_STRING:
{
handleNpc(client, message);
break;
}
case Protocol.PGMSG_PICKUP:
{
handlePickup(client, message);
break;
}
case Protocol.PGMSG_USE_ITEM:
{
handleUseItem(client, message);
break;
}
case Protocol.PGMSG_DROP:
{
handleDrop(client, message);
break;
}
case Protocol.PGMSG_WALK:
{
handleWalk(client, message);
break;
}
case Protocol.PGMSG_EQUIP:
{
handleEquip(client, message);
break;
}
case Protocol.PGMSG_UNEQUIP:
{
handleUnequip(client, message);
break;
}
case Protocol.PGMSG_MOVE_ITEM:
{
handleMoveItem(client, message);
break;
}
case Protocol.PGMSG_ATTACK:
{
handleAttack(client, message);
break;
}
case Protocol.PGMSG_USE_SPECIAL:
{
handleUseSpecial(client, message);
break;
}
case Protocol.PGMSG_ACTION_CHANGE:
{
handleActionChange(client, message);
break;
}
case Protocol.PGMSG_DIRECTION_CHANGE:
{
handleDirectionChange(client, message);
break;
}
case Protocol.PGMSG_DISCONNECT:
{
handleDisconnect(client, message);
break;
}
case Protocol.PGMSG_TRADE_REQUEST:
{
handleTradeRequest(client, message);
break;
}
case Protocol.PGMSG_TRADE_CANCEL:
case Protocol.PGMSG_TRADE_AGREED:
case Protocol.PGMSG_TRADE_CONFIRM:
case Protocol.PGMSG_TRADE_ADD_ITEM:
case Protocol.PGMSG_TRADE_SET_MONEY:
{
handleTrade(client, message);
break;
}
case Protocol.PGMSG_NPC_BUYSELL:
{
handleNpcBuySell(client, message);
break;
}
case Protocol.PGMSG_RAISE_ATTRIBUTE:
{
handleRaiseAttribute(client, message);
break;
}
case Protocol.PGMSG_LOWER_ATTRIBUTE:
{
handleLowerAttribute(client, message);
break;
}
case Protocol.PGMSG_RESPAWN:
{
// plausibility check is done by character class
client.character.respawn();
break;
}
case Protocol.PGMSG_NPC_POST_SEND:
{
handleNpcPostSend(client, message);
break;
}
case Protocol.PGMSG_PARTY_INVITE:
{
handlePartyInvite(client, message);
break;
}
default:
{
Logger.Write(LogLevel.Warning, "Invalid message type");
client.send(new MessageOut(Protocol.XXMSG_INVALID));
break;
}
}
}
protected override void computerDisconnected(NetComputer comp)
{
ChatClient computer=(ChatClient)(comp);
if(computer.characterName==null||computer.characterName=="")
{
// Not yet fully logged in, remove it from pending clients.
mTokenCollector.deletePendingClient(computer);
}
else
{
// Remove user from all channels.
Program.chatChannelManager.removeUserFromAllChannels(computer);
// Remove user from party
removeUserFromParty(computer);
// Remove the character from the player map
// need to do this after removing them from party
// as that uses the player map
mPlayerMap.Remove(computer.characterName);
}
//delete computer;
}
protected override void computerDisconnected(NetComputer comp)
{
GameClient computer=(GameClient)comp;
if(computer.status==(int)AccountClientStatus.CLIENT_QUEUED)
{
mTokenCollector.deletePendingClient(computer);
}
else
{
Program.accountHandler.sendCharacterData(computer.character);
GameState.remove(computer.character);
computer.character.disconnected();
computer.character=null; //TODO eigentlich unnötig
}
computer=null; //TODO eigentlich unnötig
}
public void tokenMatched(NetComputer client, object data)
{
GameClient computer=(GameClient)client;
Character character=(Character)data;
computer.character=character;
computer.status=(int)AccountClientStatus.CLIENT_CONNECTED;
character.setClient(computer);
MessageOut result=new MessageOut(Protocol.GPMSG_CONNECT_RESPONSE);
if(!GameState.insert(character))
{
result.writeInt8((int)ErrorMessage.ERRMSG_SERVER_FULL);
kill(character);
//delete character;
computer.disconnect(result);
return;
}
result.writeInt8((int)ErrorMessage.ERRMSG_OK);
computer.send(result);
// Force sending the whole character to the client.
Inventory inv=new Inventory(character);
inv.sendFull();
character.modifiedAllAttribute();
foreach(KeyValuePair<int, int> pair in character.mExperience)
{
character.updateDerivedAttributes((uint)pair.Key);
}
}
public void deletePendingClient(NetComputer client)
{
GameClient computer=(GameClient)client;
// Something might have changed since it was inserted
if(computer.status!=(int)AccountClientStatus.CLIENT_QUEUED)
return;
MessageOut msg=new MessageOut(Protocol.GPMSG_CONNECT_RESPONSE);
msg.writeInt8((int)ErrorMessage.ERRMSG_TIME_OUT);
// The computer will be deleted when the disconnect event is processed
computer.disconnect(msg);
}
//TokenCollector(Handler *h): mHandler(h)
//{
// _TC_CheckData<Client> ClientMustBeSimple;
// (void)&ClientMustBeSimple;
// _TC_CheckData<ServerData> ServerDataMustBeSimple;
// (void)&ServerDataMustBeSimple;
//}
/**
* Checks if the server expected this client token. If so, calls
* Handler::tokenMatched. Otherwise marks the client as pending.
*/
public void addPendingClient(string token, NetComputer data)
{
insertClient(token, data);
}
protected override void computerDisconnected(NetComputer comp)
{
AccountClient client=(AccountClient)(comp);
if(client.status==AccountClientStatus.CLIENT_QUEUED)
{
// Delete it from the pendingClient list
mTokenCollector.deletePendingClient(client);
}
//delete client; // ~AccountClient unsets the account
}
/**
* Removes a pending client.
* @note Does not call destroyPendingClient.
*/
public void deletePendingClient(NetComputer data)
{
removeClient((object)data);
}
protected override void processMessage(NetComputer comp, MessageIn message)
{
AccountClient client=(AccountClient)(comp);
switch(message.getId())
{
case Protocol.PAMSG_LOGIN_RNDTRGR:
{
Logger.Write(LogLevel.Debug, "Received msg ... PAMSG_LOGIN_RANDTRIGGER");
handleLoginRandTriggerMessage(client, message);
break;
}
case Protocol.PAMSG_LOGIN:
{
Logger.Write(LogLevel.Debug, "Received msg ... PAMSG_LOGIN");
handleLoginMessage(client, message);
break;
}
case Protocol.PAMSG_LOGOUT:
{
Logger.Write(LogLevel.Debug, "Received msg ... PAMSG_LOGOUT");
handleLogoutMessage(client);
break;
}
case Protocol.PAMSG_RECONNECT:
{
Logger.Write(LogLevel.Debug, "Received msg ... PAMSG_RECONNECT");
handleReconnectMessage(client, message);
break;
}
case Protocol.PAMSG_REGISTER:
{
Logger.Write(LogLevel.Debug, "Received msg ... PAMSG_REGISTER");
handleRegisterMessage(client, message);
break;
}
case Protocol.PAMSG_UNREGISTER:
{
Logger.Write(LogLevel.Debug, "Received msg ... PAMSG_UNREGISTER");
handleUnregisterMessage(client, message);
break;
}
case Protocol.PAMSG_REQUEST_REGISTER_INFO:
{
Logger.Write(LogLevel.Debug, "Received msg ... REQUEST_REGISTER_INFO");
handleRequestRegisterInfoMessage(client, message);
break;
}
case Protocol.PAMSG_EMAIL_CHANGE:
{
Logger.Write(LogLevel.Debug, "Received msg ... PAMSG_EMAIL_CHANGE");
handleEmailChangeMessage(client, message);
break;
}
case Protocol.PAMSG_PASSWORD_CHANGE:
{
Logger.Write(LogLevel.Debug, "Received msg ... PAMSG_PASSWORD_CHANGE");
handlePasswordChangeMessage(client, message);
break;
}
case Protocol.PAMSG_CHAR_CREATE:
{
Logger.Write(LogLevel.Debug, "Received msg ... PAMSG_CHAR_CREATE");
handleCharacterCreateMessage(client, message);
break;
}
case Protocol.PAMSG_CHAR_SELECT:
{
Logger.Write(LogLevel.Debug, "Received msg ... PAMSG_CHAR_SELECT");
handleCharacterSelectMessage(client, message);
break;
}
case Protocol.PAMSG_CHAR_DELETE:
{
Logger.Write(LogLevel.Debug, "Received msg ... PAMSG_CHAR_DELETE");
handleCharacterDeleteMessage(client, message);
break;
}
default:
{
Logger.Write(LogLevel.Warning, "AccountHandler::processMessage, Invalid message type {0}", message.getId());
MessageOut result=new MessageOut(Protocol.XXMSG_INVALID);
client.send(result);
break;
}
}
}
protected override void removedClient(NetComputer data)
{
mHandler.deletePendingClient(data);
}
void computerDisconnected(NetComputer comp)
{
//GameClient &computer = *static_cast< GameClient * >(comp);
//if (computer.status == CLIENT_QUEUED)
//{
// mTokenCollector.deletePendingClient(&computer);
//}
//else if (Character *ch = computer.character)
//{
// accountHandler.sendCharacterData(ch);
// GameState::remove(ch);
// ch.disconnected();
// delete ch;
//}
//delete &computer;
}
protected virtual void foundMatch(NetComputer client, object data)
{
throw new NotImplementedException("These function must be overloaded from derived class.");
}
void processMessage(NetComputer computer, MessageIn message)
{
//GameClient &client = *static_cast<GameClient *>(computer);
//if (client.status == CLIENT_LOGIN)
//{
// if (message.getId() != PGMSG_CONNECT)
// return;
// std::string magic_token = message.readString(MAGIC_TOKEN_LENGTH);
// client.status = CLIENT_QUEUED; // Before the addPendingClient
// mTokenCollector.addPendingClient(magic_token, &client);
// return;
//}
//else if (client.status != CLIENT_CONNECTED)
//{
// return;
//}
//switch (message.getId())
//{
// case PGMSG_SAY:
// handleSay(client, message);
// break;
// case PGMSG_NPC_TALK:
// case PGMSG_NPC_TALK_NEXT:
// case PGMSG_NPC_SELECT:
// case PGMSG_NPC_NUMBER:
// case PGMSG_NPC_STRING:
// handleNpc(client, message);
// break;
// case PGMSG_PICKUP:
// handlePickup(client, message);
// break;
// case PGMSG_USE_ITEM:
// handleUseItem(client, message);
// break;
// case PGMSG_DROP:
// handleDrop(client, message);
// break;
// case PGMSG_WALK:
// handleWalk(client, message);
// break;
// case PGMSG_EQUIP:
// handleEquip(client, message);
// break;
// case PGMSG_UNEQUIP:
// handleUnequip(client, message);
// break;
// case PGMSG_MOVE_ITEM:
// handleMoveItem(client, message);
// break;
// case PGMSG_ATTACK:
// handleAttack(client, message);
// break;
// case PGMSG_USE_SPECIAL:
// handleUseSpecial(client, message);
// break;
// case PGMSG_ACTION_CHANGE:
// handleActionChange(client, message);
// break;
// case PGMSG_DIRECTION_CHANGE:
// handleDirectionChange(client, message);
// break;
// case PGMSG_DISCONNECT:
// handleDisconnect(client, message);
// break;
// case PGMSG_TRADE_REQUEST:
// handleTradeRequest(client, message);
// break;
// case PGMSG_TRADE_CANCEL:
// case PGMSG_TRADE_AGREED:
// case PGMSG_TRADE_CONFIRM:
// case PGMSG_TRADE_ADD_ITEM:
// case PGMSG_TRADE_SET_MONEY:
// handleTrade(client, message);
// break;
// case PGMSG_NPC_BUYSELL:
// handleNpcBuySell(client, message);
// break;
// case PGMSG_RAISE_ATTRIBUTE:
// handleRaiseAttribute(client, message);
// break;
// case PGMSG_LOWER_ATTRIBUTE:
// handleLowerAttribute(client, message);
// break;
// case PGMSG_RESPAWN:
// // plausibility check is done by character class
// client.character.respawn();
// break;
// case PGMSG_NPC_POST_SEND:
// handleNpcPostSend(client, message);
// break;
// case PGMSG_PARTY_INVITE:
// handlePartyInvite(client, message);
// break;
// default:
// LOG_WARN("Invalid message type");
// client.send(MessageOut(XXMSG_INVALID));
// break;
//}
}
protected virtual void processMessage(NetComputer comp, MessageIn msg)
{
throw new NotImplementedException("These function must be overloaded from derived class.");
}
public void tokenMatched(NetComputer computer, object data)
{
ChatClient client=(ChatClient)computer;
Pending p=(Pending)data;
MessageOut msg=new MessageOut(Protocol.CPMSG_CONNECT_RESPONSE);
client.characterName=p.character;
client.accountLevel=p.level;
Character c=Program.storage.getCharacter(p.character);
if(c==null)
{
// character wasnt found
msg.writeInt8((int)ErrorMessage.ERRMSG_FAILURE);
}
else
{
client.characterId=(uint)c.getDatabaseID();
//delete p;
msg.writeInt8((int)ErrorMessage.ERRMSG_OK);
// Add chat client to player map
mPlayerMap.Add(client.characterName, client);
}
client.send(msg);
}
