internal Response_PvE_EnterDungeon(SecurePacket packet)
: base(packet)
{
if (ResultCodeNo != ResultCode.Ok)
return;
Int32 count = packet.GetInt32();
while (count-- > 0)
{
RoundData round = new RoundData();
round.RoundId = packet.GetInt32();
round.Name = packet.GetStringFromUtf16();
round.IsBossRound = packet.GetBoolean();
round.Monsters = new List<MonsterData>();
Rounds.Add(round);
Int32 monsterCount = packet.GetInt32();
while (monsterCount-- > 0)
{
MonsterData monster = new MonsterData();
monster.MonsterNo = packet.GetInt32();
monster.MonsterId = packet.GetInt32();
monster.Name = packet.GetStringFromUtf16();
monster.GradeId = packet.GetInt32();
monster.PromotionId = packet.GetInt32();
monster.Level = packet.GetInt32();
round.Monsters.Add(monster);
}
}
}
internal Response_CharacterBook(SecurePacket packet)
: base(packet)
{
if (ResultCodeNo != ResultCode.Ok)
return;
Int32 count = packet.GetInt32();
while (count-- > 0)
{
Items.Add(new Data()
{
CharacterId = packet.GetInt32(),
Name = packet.GetStringFromUtf16(),
RaceId = packet.GetInt32(),
CharacterTypeId = packet.GetInt32(),
JobId = packet.GetInt32(),
PositionId = packet.GetInt32(),
DamageTypeId = packet.GetInt32(),
InitGradeId = packet.GetInt32(),
InitPromotionId = packet.GetInt32(),
MaxGradeId = packet.GetInt32(),
MaxPromotionId = packet.GetInt32(),
AP = packet.GetInt32(),
DP = packet.GetInt32(),
HP = packet.GetInt32()
});
}
}
////////////////////////////////////////////////////////////////////////////////
// Game Data
public static void GameData_Codes(APICallbackHandler<Response_GameData_Codes> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_GameData_Codes_Req"));
reqPacket.PutInt32(_userNo);
_request.SendPacket(reqPacket, (resPacket) => { callback(new Response_GameData_Codes(resPacket)); });
}
public static void Auth_LoginGuest(Int32 worldId, String userToken, APICallbackHandler<Response> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_Auth_Guest_Req"));
reqPacket.PutInt32(0); // UserNo
reqPacket.PutInt32(worldId);
reqPacket.PutStringAsUtf16(userToken);
_request.SendPacket(reqPacket, (resPacket) =>
{
Int32 ret = resPacket.GetInt32();
if (ret == ResultCode.Ok)
{
_userNo = resPacket.GetInt32();
_authKey = resPacket.GetInt32();
_request.HostAddress = resPacket.GetStringFromUtf16();
_request.HostPortNo = resPacket.GetInt32();
_request.ConnectionAliveTime = 0;
_request.Disconnect();
Auth_LoginGameServer(callback);
}
else
callback(new Response(ret));
});
}
public void AddPacket(SecurePacket packet)
{
lock (this)
{
_receivedPackets.Enqueue(packet);
}
}
public static void GameData_CharacterBook(Int32 startId, APICallbackHandler<Response_CharacterBook> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_GameData_CharacterBook_Req"));
reqPacket.PutInt32(_userNo);
reqPacket.PutInt32(startId);
_request.SendPacket(reqPacket, (resPacket) => { callback(new Response_CharacterBook(resPacket)); });
}
public static void Auth_RegisterGuest(String userToken, APICallbackHandler<Response> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_Auth_RegisterGuest_Req"));
reqPacket.PutInt32(0); // UserNo
reqPacket.PutStringAsUtf16(userToken);
_request.SendPacket(reqPacket, (resPacket) => { callback(new Response(resPacket)); });
}
internal Response_CacheBox_Value(SecurePacket packet)
: base(packet)
{
if (ResultCodeNo != ResultCode.Ok)
return;
Value = packet.GetStringFromUtf16();
DurationMinutes = packet.GetInt32();
}
internal Response_IMC_ChannelList(SecurePacket packet)
: base(packet)
{
if (ResultCodeNo != ResultCode.Ok)
return;
int count = packet.GetInt32();
while (count-- > 0)
{
Channels.Add(new ChannelInfo()
{
ChannelNo = packet.GetInt32(),
ChannelName = packet.GetStringFromUtf16()
});
}
}
public static void Auth_LoginGuest(string uuid, APICallbackHandler<ResponseBase> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_Auth_LoginGuest_Req"));
reqPacket.PutInt32(0);
reqPacket.PutStringAsUtf16(uuid);
_request.SendPacket(reqPacket,
(resPacket) =>
{
Int32 ret = resPacket.GetInt32();
if (ret == ResultCode.Ok)
_userNo = resPacket.GetInt32();
callback(new ResponseBase(resPacket));
});
}
internal Response_PvE_DungeonList(SecurePacket packet)
: base(packet)
{
if (ResultCodeNo != ResultCode.Ok)
return;
Int32 count = packet.GetInt32();
while (count-- > 0)
{
Items.Add(new Data()
{
DungeonId = packet.GetInt32(),
Name = packet.GetStringFromUtf16(),
Level = packet.GetInt32(),
EnterFee_EnergyId = packet.GetInt32(),
EnterFee_Amount = packet.GetInt32()
});
}
}
internal Response_InvenItem(SecurePacket packet)
: base(packet)
{
if (ResultCodeNo != ResultCode.Ok)
return;
MaxInventoryCount = packet.GetInt32();
Int32 count = packet.GetInt32();
while (count-- > 0)
{
Items.Add(new ItemData()
{
ItemNo = packet.GetInt32(),
ItemId = packet.GetInt32(),
PromotionId = packet.GetInt32(),
Quantity = packet.GetInt32()
});
}
}
private static void OnHello(SecurePacket packet)
{
Int32 seed = packet.GetInt32();
String characterSet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz";
char[] ascii = new char[16];
for (Int32 i = 0; i < 16; ++i)
{
Int32 val = seed & (0x6E << i);
ascii[i] = characterSet[(val % characterSet.Length)];
}
_request.AESIV = new String(ascii);
for (Int32 i = 0; i < 16; ++i)
{
Int32 val = seed & (0xF4 << i);
ascii[i] = characterSet[(val % characterSet.Length)];
}
_request.AESKey = new String(ascii);
_request.EnableSend = true;
}
internal Response_InvenCharacter(SecurePacket packet)
: base(packet)
{
if (ResultCodeNo != ResultCode.Ok)
return;
MainCharacterNo = packet.GetInt32();
MaxInventoryCount = packet.GetInt32();
Int32 count = packet.GetInt32();
while (count-- > 0)
{
Items.Add(new CharacterData()
{
CharacterNo = packet.GetInt32(),
CharacterId = packet.GetInt32(),
Level = packet.GetInt32(),
Exp = packet.GetInt32(),
GradeId = packet.GetInt32(),
PromotionId = packet.GetInt32()
});
}
}
internal Response_WorldList(SecurePacket packet)
: base(packet)
{
if (ResultCodeNo != ResultCode.Ok)
return;
Int32 count = packet.GetInt32();
while (count-- > 0)
{
Items.Add(new WorldInfo()
{
WorldId = packet.GetInt32(),
WorldName = packet.GetStringFromUtf16()
});
}
}
internal Response_UserInfo(SecurePacket packet)
: base(packet)
{
if (ResultCodeNo != ResultCode.Ok)
return;
Int32 count;
Nickname = packet.GetStringFromUtf16();
Level = packet.GetInt32();
Exp = packet.GetInt32();
VIPLevel = packet.GetInt32();
VIPExp = packet.GetInt32();
count = packet.GetInt32();
while (count-- > 0)
{
Energies.Add(new EnergyData()
{
EnergyId = packet.GetInt32(),
Point = packet.GetInt32(),
RemainSecond = packet.GetInt32()
});
}
count = packet.GetInt32();
while (count-- > 0)
{
Resources.Add(new ResourceData()
{
ResourceId = packet.GetInt32(),
Point = packet.GetInt32()
});
}
}
public static void Auth_RegisterMember(string uuid, string userId, string userPwd, APICallbackHandler<ResponseBase> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_Auth_RegisterMember_Req"));
reqPacket.PutInt32(0);
reqPacket.PutStringAsUtf16(uuid);
reqPacket.PutStringAsUtf16(userId);
reqPacket.PutStringAsUtf16(userPwd);
_request.SendPacket(reqPacket,
(resPacket) => { callback(new ResponseBase(resPacket)); });
}
private static void OnRecv_Storage_Sheet_GetSheetList(SecurePacket packet, APICallbackHandler<ResponseBase> callback)
{
int sheetCount = packet.GetInt32();
while (sheetCount-- > 0)
{
string sheetName = packet.GetStringFromUtf16();
int recordCount = packet.GetInt32();
int columnCount = packet.GetInt32();
Sheet sheet = Workbook.AddSheet(sheetName, recordCount, columnCount);
while (columnCount-- > 0)
{
FieldDataType type = (FieldDataType)packet.GetInt32();
string fieldname = packet.GetStringFromUtf16();
sheet.AddField(type, fieldname);
}
}
if (Workbook.Sheets.Count() == 0)
{
callback(new ResponseBase(ResultCode.Ok));
return;
}
_sheetRequestedNo = 0;
_sheetName = Workbook.Sheets[_sheetRequestedNo].Name;
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_CloudSheet_GetRecords_Req"));
reqPacket.PutInt32(_userNo);
reqPacket.PutStringAsUtf16(_sheetFilename);
reqPacket.PutStringAsUtf16(_sheetName);
reqPacket.PutUInt32(0);
_request.SendPacket(reqPacket,
(resPacket) =>
{
ResponseBase response = new ResponseBase(resPacket);
if (response.ResultCodeNo != ResultCode.Ok)
{
callback(response);
return;
}
OnRecv_Storage_Sheet_GetRecords(resPacket, callback);
});
}
private static void OnRecv_Storage_Sheet_GetRecords(SecurePacket packet, APICallbackHandler<ResponseBase> callback)
{
try
{
Boolean hasMore = (packet.GetByte() == 1);
int rowCount = packet.GetInt32();
UInt32 rowNo = 0;
Sheet table = Workbook.GetSheet(_sheetName);
while (rowCount-- > 0)
{
string[] values = new string[table.Fields.Count()];
rowNo = packet.GetUInt32();
for (int i = 0; i < table.Fields.Count(); ++i)
values[i] = packet.GetStringFromUtf16();
table.AddRowData(rowNo, values);
}
if (hasMore)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_CloudSheet_GetRecords_Req"));
reqPacket.PutInt32(_userNo);
reqPacket.PutStringAsUtf16(_sheetFilename);
reqPacket.PutStringAsUtf16(_sheetName);
reqPacket.PutUInt32(rowNo + 1);
_request.SendPacket(reqPacket,
(resPacket) =>
{
ResponseBase response = new ResponseBase(resPacket);
if (response.ResultCodeNo != ResultCode.Ok)
{
callback(response);
return;
}
OnRecv_Storage_Sheet_GetRecords(resPacket, callback);
});
}
else
{
++_sheetRequestedNo;
if (Workbook.Sheets.Count() > _sheetRequestedNo)
{
table = Workbook.Sheets[_sheetRequestedNo];
_sheetName = table.Name;
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_CloudSheet_GetRecords_Req"));
reqPacket.PutInt32(_userNo);
reqPacket.PutStringAsUtf16(_sheetFilename);
reqPacket.PutStringAsUtf16(_sheetName);
reqPacket.PutUInt32(0);
_request.SendPacket(reqPacket,
(resPacket) =>
{
ResponseBase response = new ResponseBase(resPacket);
if (response.ResultCodeNo != ResultCode.Ok)
{
callback(response);
return;
}
OnRecv_Storage_Sheet_GetRecords(resPacket, callback);
});
}
else
{
callback(new ResponseBase(packet));
}
}
}
catch (Exception)
{
callback(new ResponseBase(ResultCode.UnknownError));
}
}
public static void Storage_Sheet_Refresh(string filename, APICallbackHandler<ResponseBase> callback)
{
_sheetFilename = filename;
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_CloudSheet_GetSheetList_Req"));
reqPacket.PutInt32(_userNo);
reqPacket.PutStringAsUtf16(_sheetFilename);
_request.SendPacket(reqPacket,
(resPacket) =>
{
ResponseBase response = new ResponseBase(resPacket);
if (response.ResultCodeNo != ResultCode.Ok)
{
callback(response);
return;
}
Workbook = new Workbook();
OnRecv_Storage_Sheet_GetSheetList(resPacket, callback);
});
}
////////////////////////////////////////////////////////////////////////////////
// CacheBox
public static void CacheBox_SetValue(string key, string value, int durationMinutes, APICallbackHandler<ResponseBase> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_CacheBox_SetValue_Req"));
reqPacket.PutInt32(_userNo);
reqPacket.PutStringAsUtf16(key);
reqPacket.PutStringAsUtf16(value);
reqPacket.PutInt32(durationMinutes);
reqPacket.PutDouble(-1);
_request.SendPacket(reqPacket,
(resPacket) => { callback(new ResponseBase(resPacket)); });
}
public static void Profile_SetData(string nickname, Int16 level, Int16 exp, APICallbackHandler<ResponseBase> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_Profile_SetData_Req"));
reqPacket.PutInt32(_userNo);
reqPacket.PutStringAsUtf16(nickname);
reqPacket.PutInt16(level);
reqPacket.PutInt16(exp);
_request.SendPacket(reqPacket,
(resPacket) => { callback(new ResponseBase(resPacket)); });
}
public static void Profile_GetTextData(APICallbackHandler<Response_Profile_Text> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_Profile_Text_GetData_Req"));
reqPacket.PutInt32(_userNo);
_request.SendPacket(reqPacket,
(resPacket) => { callback(new Response_Profile_Text(resPacket)); });
}
public static void IMC_UserList(APICallbackHandler<Response_IMC_UserList> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_IMC_UserList_Req"));
reqPacket.PutInt32(_userNo);
_request.SendPacket(reqPacket,
(resPacket) => { callback(new Response_IMC_UserList(resPacket)); });
}
public static void IMC_SendMessage(int targetUserNo, StreamBuffer data, APICallbackHandler<ResponseBase> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_IMC_SendMessage_Req"));
reqPacket.PutInt32(_userNo);
reqPacket.PutInt32(targetUserNo);
reqPacket.Write(data.Buffer);
_request.SendPacket(reqPacket,
(resPacket) => { callback(new ResponseBase(resPacket)); });
}
public static void IMC_Enter(int channelNo, APICallbackHandler<Response_IMC_Enter> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_IMC_Enter_Req"));
reqPacket.PutInt32(_userNo);
reqPacket.PutInt32(channelNo);
_request.SendPacket(reqPacket,
(resPacket) => { callback(new Response_IMC_Enter(resPacket)); });
}
public static void CacheBox_SetValue(string key, string value, DateTime expireTime, APICallbackHandler<ResponseBase> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_CacheBox_SetValue_Req"));
reqPacket.PutInt32(_userNo);
reqPacket.PutStringAsUtf16(key);
reqPacket.PutStringAsUtf16(value);
reqPacket.PutInt32(-1);
reqPacket.PutDouble(expireTime.ToUniversalTime().ToOADate());
_request.SendPacket(reqPacket,
(resPacket) => { callback(new ResponseBase(resPacket)); });
}
public static void Profile_SetTextData(string text, APICallbackHandler<ResponseBase> callback)
{
if (text.Length > 32500)
throw new AegisException("The 'text' length must be less than 32500.");
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_Profile_Text_SetData_Req"));
reqPacket.PutInt32(_userNo);
reqPacket.PutStringAsUtf16(text);
_request.SendPacket(reqPacket,
(resPacket) => { callback(new ResponseBase(resPacket)); });
}
public static void IMC_Create(string channelName, APICallbackHandler<Response_IMC_Create> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_IMC_Create_Req"));
reqPacket.PutInt32(_userNo);
reqPacket.PutStringAsUtf16(channelName);
_request.SendPacket(reqPacket,
(resPacket) => { callback(new Response_IMC_Create(resPacket)); });
}
public static void CacheBox_GetValue(string key, APICallbackHandler<Response_CacheBox_Value> callback)
{
SecurePacket reqPacket = new SecurePacket(Protocol.GetID("CS_CacheBox_GetValue_Req"));
reqPacket.PutInt32(_userNo);
reqPacket.PutStringAsUtf16(key);
_request.SendPacket(reqPacket,
(resPacket) => { callback(new Response_CacheBox_Value(resPacket)); });
}
