public void enqueue_network_message(CPacket buffer)
{
lock (this.cs_event)
{
this.network_message_events.Enqueue(buffer);
}
}
public void on_receive_from_client(CPacket msg)
{
msg.record_size();
CPacket clone = CPacket.create(msg.protocol_id);
clone.overwrite(msg.buffer, 0);
clone.pop_int16(); // LocalServer환경에서는 size값이 필요 없으므로 2바이트를 버린다.
this.game_room.on_receive(this.players[0], clone);
}
/// <summary>
/// 메시지를 수신했을 때 호출된다.
/// 파라미터로 넘어온 버퍼는 워커 스레드에서 재사용 되므로 복사한 뒤 어플리케이션으로 넘겨준다.
/// </summary>
/// <param name="buffer"></param>
void IPeer.on_message(Const<byte[]> buffer)
{
// 버퍼를 복사한 뒤 CPacket클래스로 감싼 뒤 넘겨준다.
// CPacket클래스 내부에서는 참조로만 들고 있는다.
byte[] app_buffer = new byte[buffer.Value.Length];
Array.Copy(buffer.Value, app_buffer, buffer.Value.Length);
CPacket msg = new CPacket(app_buffer, this);
(this.freenet_eventmanager.Target as CFreeNetEventManager).enqueue_network_message(msg);
}
public static CPacket pre_send(CPacket msg)
{
msg.record_size();
CPacket clone = CPacket.create(msg.protocol_id);
clone.overwrite(msg.buffer, 0);
clone.pop_int16(); // LocalServer환경에서는 size값이 필요 없으므로 2바이트를 버린다.
return clone;
}
public void send(CPacket msg)
{
try
{
this.gameserver.send(msg);
CPacket.destroy(msg);
}
catch (Exception e)
{
Debug.LogError(e.Message);
}
}
void ON_BEGIN_CARD_INFO(CPacket msg)
{
Queue<CCard> floor_cards = new Queue<CCard>();
this.player_index = msg.pop_byte();
// floor cards.
byte floor_count = msg.pop_byte();
for (byte i = 0; i < floor_count; ++i)
{
byte number = msg.pop_byte();
PAE_TYPE pae_type = (PAE_TYPE)msg.pop_byte();
byte position = msg.pop_byte();
CCard card = new CCard(number, pae_type, position);
floor_cards.Enqueue(card);
this.floor_card_manager.puton_card(card);
}
byte player_count = msg.pop_byte();
for (byte player = 0; player < player_count; ++player)
{
Queue<CCard> cards = new Queue<CCard>();
byte player_index = msg.pop_byte();
byte card_count = msg.pop_byte();
for (byte i = 0; i < card_count; ++i)
{
byte number = msg.pop_byte();
PAE_TYPE pae_type = PAE_TYPE.KWANG;
byte position = byte.MaxValue;
if (number != byte.MaxValue)
{
pae_type = (PAE_TYPE)msg.pop_byte();
position = msg.pop_byte();
// AI플레이어 본인 것만 담는다.
CCard card = new CCard(number, pae_type, position);
this.hand_cards.Add(card);
}
}
}
CPacket finished_msg = CPacket.create((short)PROTOCOL.DISTRIBUTED_ALL_CARDS);
this.local_server.on_receive_from_ai(finished_msg);
}
void on_message(CPacket msg)
{
PROTOCOL protocol_id = (PROTOCOL)msg.pop_protocol_id();
Debug.Log($"Response : {protocol_id}");
switch (protocol_id)
{
case PROTOCOL.ERROR:
{
var error = msg.pop_int32();
var errorCode = (ERROR)error;
OnNetworkCallback(null, errorCode);
break;
}
case PROTOCOL.ENTER_GAME_ROOM_RES:
{
var userId = msg.pop_int32();
var userData = new UserData();
userData.userId = userId;
OnReceiveConnectedOtherUser?.Invoke(userData, ERROR.NONE);
break;
}
case PROTOCOL.CHAT_MSG_ACK:
{
int userId = msg.pop_int32();
string text = msg.pop_string();
var res = new ChatData();
res.userId = userId;
res.message = text;
OnReceiveChatInfoCallback(res, ERROR.NONE);
break;
}
case PROTOCOL.GET_MY_PLAYER_RES:
{
PlayerData data = CreatePlayerData(msg);
OnNetworkCallback(data, ERROR.NONE);
break;
}
case PROTOCOL.DISCONECTED_PLAYER_RES:
{
PlayerData data = new PlayerData();
data.userId = msg.pop_int32();
OnDisconnectedPlayer(data, ERROR.NONE);
break;
}
case PROTOCOL.PLAYER_MOVE_RES:
{
PlayerData data = CreatePlayerData(msg);
if (GameManager.Inst.UserId == data.userId)
{
OnMovePlayer(data, ERROR.NONE);
}
else
{
OnReceiveMoveOtherPlayer?.Invoke(data, ERROR.NONE);
}
break;
}
case PROTOCOL.ADD_NEAR_PLAYER_RES:
{
PlayerData data = CreatePlayerData(msg);
OnReceivedAddNearPlayer?.Invoke(data, ERROR.NONE);
GameManager.Inst.PrintSystemLog($"{data.userId}님이 범위내에 들어왔습니다.");
break;
}
case PROTOCOL.REMOVE_NEAR_PLAYER_RES:
{
PlayerData data = CreatePlayerData(msg);
OnReceivedRemoveNearPlayer?.Invoke(data, ERROR.NONE);
GameManager.Inst.PrintSystemLog($"{data.userId}님이 범위내에서 사라졌습니다.");
break;
}
}
}
void add_choice_card_info_to(CPacket msg)
{
List<CCard> target_cards = this.engine.target_cards_to_choice;
byte count = (byte)target_cards.Count;
msg.push(count);
for (int i = 0; i < count; ++i)
{
CCard card = target_cards[i];
msg.push(card.number);
msg.push((byte)card.pae_type);
msg.push(card.position);
}
}
public static void ROOM_EXIT_REQ_SEND()
{
CPacket msg = CPacket.create((short)PROTOCOL.ROOM_EXIT_REQ);
network_manager.send(msg);
}
public void PickUp(Character pChar, int dwDropId, short pX, short pY, bool bByPet = false)
{
var pDrop = this[dwDropId];
if (pDrop is null)
{
return;
}
switch (pDrop.DropOwnType)
{
case DropOwnType.PartyOwn when pChar.Party?.PartyID != pDrop.DropOwnerID:
case DropOwnType.UserOwn when pChar.dwId != pDrop.DropOwnerID:
pChar.SendMessage("Trying to pick up a drop that doesn't belong to you.");
return;
}
if (pDrop.Item != null)
{
if (InventoryManipulator.CountFreeSlots(pChar, ItemConstants.GetInventoryType(pDrop.Item.nItemID)) <= 0)
{
return;
}
}
if (bByPet)
{
if (Constants.MULTIPET_ACTIVATED)
{
throw new NotImplementedException(); // since we arent checking multiple pet equip slots
}
if (pDrop.bIsMoney == 1)
{
if (InventoryManipulator.GetItem(pChar, BodyPart.BP_PETABIL_MESO, true) is null)
{
return;
}
}
else
{
if (InventoryManipulator.GetItem(pChar, BodyPart.BP_PETABIL_ITEM, true) is null)
{
return;
}
}
pDrop.nLeaveType = DropLeaveType.PetPickup;
}
else
{
pDrop.nLeaveType = DropLeaveType.UserPickup;
}
pDrop.OwnerCharId = pChar.dwId;
if (pDrop.bIsMoney > 0)
{
pChar.Modify.GainMeso(pDrop.nMesoVal);
}
else
{
if (pDrop.Item.Template is CashItemTemplate itemDataTemplate)
{
if (itemDataTemplate.Max > 0 &&
InventoryManipulator.ContainsItem(pChar, pDrop.ItemId, (short)itemDataTemplate.Max))
{
pChar.SendMessage("Can't hold anymore of this item..");
return;
}
}
if (!Field.TryDropPickup(pChar, pDrop))
{
return;
}
pChar.SendPacket(CPacket.DropPickUpMessage_Item(pDrop.ItemId, pDrop.Item.nNumber, false));
if (pDrop.Item.Template.PickupMessage.Length > 0)
{
pChar.SendMessage(pDrop.Item.Template.PickupMessage);
}
}
Remove(dwDropId);
}
void add_turn_result_to(CPacket msg, byte current_turn_player_index)
{
// 점수 정보.
msg.push(this.players[current_turn_player_index].agent.score);
// 기타 정보.
msg.push(this.players[current_turn_player_index].agent.remain_bomb_count);
// 카드 이벤트 정보.
byte count = (byte)this.engine.flipped_card_event_type.Count;
msg.push(count);
for (byte i = 0; i < count; ++i)
{
msg.push((byte)this.engine.flipped_card_event_type[i]);
}
}
public void SendCode(CPacket _packet)
{
Console.WriteLine(this + " SendCode _packet:{0}", _packet);
this.token.SendCode(_packet);
}
public void send(CPacket msg)
{
this.owner.send(msg);
}
void IPeer.process_user_operation(CPacket msg)
{
}
void IPeer.send(CPacket msg)
{
this.token.send(msg);
}
void send(CPacket msg)
{
CPacket clone = CLocalServer.pre_send(msg);
CPacket.destroy(msg);
this.appcallback_on_message(clone);
}
void add_flip_result_to(CPacket msg)
{
// 덱에서 뒤집은 카드 정보.
msg.push(this.engine.card_from_deck.number);
msg.push((byte)this.engine.card_from_deck.pae_type);
msg.push(this.engine.card_from_deck.position);
msg.push(this.engine.same_card_count_with_deck);
}
void add_others_card_result_to(CPacket msg)
{
msg.push((byte)this.engine.other_cards_to_player.Count);
foreach (KeyValuePair<byte, List<CCard>> kvp in this.engine.other_cards_to_player)
{
msg.push(kvp.Key);
byte count = (byte)this.engine.other_cards_to_player[kvp.Key].Count;
msg.push(count);
for (byte card_index = 0; card_index < count; ++card_index)
{
CCard card = this.engine.other_cards_to_player[kvp.Key][card_index];
msg.push(card.number);
msg.push((byte)card.pae_type);
msg.push(card.position);
}
}
}
void add_player_get_cards_info_to(CPacket msg)
{
// 플레이어가 가져갈 카드 정보.
byte count_to_player = (byte)this.engine.cards_to_give_player.Count;
msg.push(count_to_player);
for (byte card_index = 0; card_index < count_to_player; ++card_index)
{
CCard card = this.engine.cards_to_give_player[card_index];
msg.push(card.number);
msg.push((byte)card.pae_type);
msg.push(card.position);
}
}
//--------------------------------------------------------
// Handler.
//--------------------------------------------------------
public void on_receive(CPlayer owner, CPacket msg)
{
PROTOCOL protocol = (PROTOCOL)msg.pop_protocol_id();
if (is_received(owner.player_index, protocol))
{
//error!! already exist!!
return;
}
checked_protocol(owner.player_index, protocol);
//UnityEngine.Debug.Log("protocol " + protocol);
switch (protocol)
{
case PROTOCOL.READY_TO_START:
on_ready_req();
break;
case PROTOCOL.DISTRIBUTED_ALL_CARDS:
{
if (all_received(protocol))
{
CPacket turn_msg = CPacket.create((short)PROTOCOL.START_TURN);
turn_msg.push((byte)0);
this.players[this.engine.current_player_index].send(turn_msg);
}
}
break;
case PROTOCOL.SELECT_CARD_REQ:
{
byte number = msg.pop_byte();
PAE_TYPE pae_type = (PAE_TYPE)msg.pop_byte();
byte position = msg.pop_byte();
byte slot_index = msg.pop_byte();
byte is_shaking = msg.pop_byte();
//UnityEngine.Debug.Log("server. " + slot_index);
on_player_put_card(
owner.player_index,
number, pae_type, position, slot_index,
is_shaking);
}
break;
case PROTOCOL.CHOOSE_CARD:
{
clear_received_protocol();
PLAYER_SELECT_CARD_RESULT client_result = (PLAYER_SELECT_CARD_RESULT)msg.pop_byte();
byte choice_index = msg.pop_byte();
PLAYER_SELECT_CARD_RESULT server_result =
this.engine.on_choose_card(owner.player_index, client_result, choice_index);
if (server_result == PLAYER_SELECT_CARD_RESULT.CHOICE_ONE_CARD_FROM_PLAYER)
{
PLAYER_SELECT_CARD_RESULT choose_result =
this.engine.flip_process(owner.player_index,
TURN_RESULT_TYPE.RESULT_OF_NORMAL_CARD);
send_flip_result(choose_result, this.engine.current_player_index);
}
else
{
send_turn_result(this.engine.current_player_index);
}
//send_turn_result(this.engine.current_player_index, this.engine.selected_slot_index);
}
break;
case PROTOCOL.FLIP_BOMB_CARD_REQ:
{
clear_received_protocol();
if (this.engine.current_player_index != owner.player_index)
{
break;
}
if (!owner.agent.decrease_bomb_count())
{
// error!
UnityEngine.Debug.Log(string.Format("Invalid bomb count!! player {0}", owner.player_index));
break;
}
PLAYER_SELECT_CARD_RESULT choose_result = this.engine.flip_process(owner.player_index, TURN_RESULT_TYPE.RESULT_OF_BOMB_CARD);
send_flip_result(choose_result, this.engine.current_player_index);
}
break;
case PROTOCOL.FLIP_DECK_CARD_REQ:
{
clear_received_protocol();
PLAYER_SELECT_CARD_RESULT result =
this.engine.flip_process(this.engine.current_player_index,
TURN_RESULT_TYPE.RESULT_OF_NORMAL_CARD);
send_flip_result(result, this.engine.current_player_index);
}
break;
case PROTOCOL.TURN_END:
{
if (!all_received(PROTOCOL.TURN_END))
{
break;
}
if (this.engine.has_kookjin(this.engine.current_player_index))
{
CPacket ask_msg = CPacket.create((short)PROTOCOL.ASK_KOOKJIN_TO_PEE);
this.players[this.engine.current_player_index].send(ask_msg);
}
else
{
check_game_finish();
}
}
break;
case PROTOCOL.ANSWER_KOOKJIN_TO_PEE:
{
clear_received_protocol();
owner.agent.kookjin_selected();
byte answer = msg.pop_byte();
if (answer == 1)
{
// 국진을 쌍피로 이동.
owner.agent.move_kookjin_to_pee();
send_player_statistics(owner.player_index);
broadcast_move_kookjin(owner.player_index);
}
check_game_finish();
}
break;
case PROTOCOL.ANSWER_GO_OR_STOP:
{
clear_received_protocol();
// answer가 1이면 GO, 0이면 STOP.
byte answer = msg.pop_byte();
if (answer == 1)
{
owner.agent.plus_go_count();
broadcast_go_count(owner);
next_turn();
}
else
{
broadcast_game_result();
}
}
break;
}
}
void on_message(CPacket msg)
{
this.message_receiver.SendMessage("on_recv", msg);
}
/* 패킷 태스트 코드
* public static void Process_Packet(CPacket packet)
* {
* var protocol = (PROTOCOL)packet.pop_protocol_id();
*
* Console.WriteLine("protocol :" + protocol.ToString());
* switch (protocol)
* {
* case PROTOCOL.SEND_ROOMLIST:
* {
* var List = Utility.RoomListToDictionary(packet);
*
* foreach (KeyValuePair<string, GameRoom> keyValue in List)
* {
* Console.WriteLine(keyValue.Value.RoomTitle);
* }
* }
* break;
*
* case PROTOCOL.DEC_MAKINGROOM:
* {
* var result = Convert.ToBoolean(packet.pop_int16());
*
* Console.WriteLine(result);
* }
* break;
*
* case PROTOCOL.DEC_ENTERROOM:
* {
* var result = Convert.ToBoolean(packet.pop_int16());
*
* Console.WriteLine(result);
* }
* break;
*
* case PROTOCOL.DEC_STARTGAME:
* {
* var result = Convert.ToBoolean(packet.pop_int16());
*
* Console.WriteLine(result);
* }
* break;
*
* case PROTOCOL.DEC_REGISTER:
* {
* var flag = Convert.ToBoolean(packet.pop_byte());
*
* if(!flag)
* {
* var error = (RegisterFailure)packet.pop_int16();
*
* Console.WriteLine($"REGISTER FAIL CAUSE {error}");
* }
* else
* {
* Console.WriteLine($"REGISTER SUCCESS");
* }
* }
* break;
*
* case PROTOCOL.DEC_LOGIN:
* {
* var flag = Convert.ToBoolean(packet.pop_byte());
*
* if (!flag)
* {
* var error = (LoginFailure)packet.pop_int16();
*
* Console.WriteLine($"LOGIN FAIL CAUSE {error}");
* }
* else
* {
* Console.WriteLine($"LOGIN SUCCESS");
* }
* }
* break;
* }
* }
*/
public static void Process_Packet(CPacket msg)
{
var protocol = (PROTOCOL)msg.pop_protocol_id();
//Console.WriteLine("protocol :" + protocol.ToString());
switch (protocol)
{
case PROTOCOL.DEC_REGISTER:
{
var flag = Convert.ToBoolean(msg.pop_byte());
wait = false;
if (!flag)
{
var exist = (RegisterFailure)msg.pop_int16();
Console.WriteLine(exist);
}
else
{
Console.WriteLine("회원가입 성공");
print = Menu;
action = MenuAction;
}
}
break;
case PROTOCOL.DEC_LOGIN:
{
var flag = Convert.ToBoolean(msg.pop_byte());
wait = false;
if (!flag)
{
var exist = (LoginFailure)msg.pop_int16();
Console.WriteLine(exist);
}
else
{
Console.WriteLine("로그인 성공");
print = RoomMenu;
action = RoomMenuAction;
}
}
break;
case PROTOCOL.SEND_ROOMLIST:
{
roomList = Utility.RoomListToDictionary(msg);
wait = false;
}
break;
case PROTOCOL.DEC_MAKINGROOM:
{
var flag = Convert.ToBoolean(msg.pop_byte());
wait = false;
if (flag)
{
IsMaster = true;
print = InRoomMenu;
action = InRoomMenuAction;
Console.WriteLine("방 제작 성공");
}
else
{
Console.WriteLine("방 제작 실패");
}
}
break;
case PROTOCOL.DEC_ENTERROOM:
{
var flag = Convert.ToBoolean(msg.pop_byte());
if (flag)
{
print = InRoomMenu;
action = InRoomMenuAction;
wait = false;
}
else
{
Console.WriteLine("방 입장 실패");
}
}
break;
case PROTOCOL.SEND_ENTERROOM:
{
Names.Add(msg.pop_string());
Master.Add(Convert.ToBoolean(msg.pop_byte()));
}
break;
case PROTOCOL.DEC_STARTGAME:
{
var flag = Convert.ToBoolean(msg.pop_byte());
if (flag)
{
Console.WriteLine("게임 시작");
Console.WriteLine("{0}", masterIP);
}
else
{
Console.WriteLine("인원수 부족");
}
}
break;
case PROTOCOL.SEND_NICKNAME:
{
string name = msg.pop_string();
}
break;
}
}
void IPeer.process_user_operation(CPacket msg)
{
}
public static void Handle_UserSkillLearnItemUseRequest(WvsGameClient c, CInPacket p)
{
int dwTickCount = p.Decode4();
short nPOS = p.Decode2();
int nItemID = p.Decode4();
c.Character.Action.Enable();
if (c.Character.Stats.nHP <= 0)
{
return;
}
if (InventoryManipulator.GetItem(c.Character, ItemConstants.GetInventoryType(nItemID), nPOS) is GW_ItemSlotBundle item &&
item.Template is ConsumeItemTemplate template)
{
var jobroot = Math.Floor(c.Character.Stats.nJob * 0.01); // 3500 -> 35
var bUsed = false;
var bSuccess = false;
var bIsMasterBook = item.nItemID / 10000 == 229;
foreach (var skillId in template.SkillData)
{
var skillJob = (int)Math.Floor(skillId / 10000f); // 35111010 -> 3511
var skillRoot = (int)Math.Floor(skillJob / 100f); // 3511 -> 35
if (skillRoot == jobroot) // this can only be true once
{
if (skillJob > c.Character.Stats.nJob)
{
break;
}
var skill = c.Character.Skills.FirstOrDefault(s => s.nSkillID == skillId);
if (bIsMasterBook)
{
if (skill is null || skill.nSLV < template.ReqSkillLevel || skill.CurMastery >= template.MasterLevel)
{
return;
}
}
else
{
if (skill != null && skill.CurMastery > 0)
{
break;
}
}
bUsed = true;
if (template.SuccessRate != 100)
{
if (Constants.Rand.Next() % 100 > template.SuccessRate)
{
break;
}
}
c.Character.Modify.Skills(mod => mod.AddEntry(skillId, s => s.CurMastery = (byte)template.MasterLevel));
bSuccess = true;
break;
}
}
if (bUsed)
{
InventoryManipulator.RemoveFrom(c.Character, item.InvType, nPOS); // always remove
}
c.Character.Field.Broadcast(CPacket.SkillLearnItemResult(c.dwCharId, bIsMasterBook, bUsed, bSuccess));
}
}
public void SendPacket(CPacket header)
{
byte[] arr = MakePacket(header.GetDataToSend(Console), header.Type);
SendToConsole(arr);
}
/// <summary>
/// 모든 유저들에게 메시지를 전송한다.
/// </summary>
/// <param name="msg"></param>
void broadcast(CPacket msg)
{
this.players.ForEach(player => player.send_for_broadcast(msg));
CPacket.destroy(msg);
}
public void send(CPacket msg)
{
this.token.send(msg);
}
protected override void InsertItem(int index, Character user)
{
try
{
if (user.Party != null)
{
foreach (var buff in user.Buffs)
{
if (buff.dwCharFromId != user.dwId)
{
continue;
}
if (buff.StatType != SecondaryStatFlag.BlueAura &&
buff.StatType != SecondaryStatFlag.DarkAura &&
buff.StatType != SecondaryStatFlag.YellowAura)
{
continue;
}
ForEachPartyMember(user.Party.PartyID,
member => member.Buffs
.AddAura(buff.StatType, buff.dwCharFromId, buff.nSkillID, buff.nSLV));
break;
}
}
//Spawn the player being added to everyone in the room
{
var pPacketEnter = user.MakeEnterFieldPacket();
Field.EncodeFieldSpecificData(pPacketEnter, user);
Field.Broadcast(pPacketEnter);
}
//So i need to fix a bug where when u change map - u dont receive ur own dmg skin lol
//Spawn [other players + ext data] in room to person entering
foreach (var c in this)
{
var pPacketEnter = c.MakeEnterFieldPacket();
Field.EncodeFieldSpecificData(pPacketEnter, c);
user.SendPacket(pPacketEnter);
//var pPacketEnterExt = CPacket.Custom.UserEnter(c.dwId, c.nDamageSkin);
//user.SendPacket(pPacketEnterExt);
}
Field.Drops.Update(); // remove expired drops (required cuz map might be empty and thus not removing drops)
//This must be here !!!!
base.InsertItem(index, user);
//Spawn entering person's extension data to everyone on map
{
//var pPacketEnterExt = CPacket.Custom.UserEnter(user.dwId, user.nDamageSkin);
//Field.Broadcast(pPacketEnterExt);
}
//Spawn entering person's entities to everyone on map
if (JobLogic.IsEvan(user.Stats.nJob) && user.Stats.nJob != 2001)
{
user.Dragon = new CDragon(user);
user.Dragon.SpawnDragonToMap();
}
user.Pets.SpawnPetsToMap();
//Spawn field entities to person entering
Field.SendSpawnDragons(user);
// pets are handled in UserEnterField packet
Field.SendSpawnSummons(user);
Field.Summons.InsertFromStorage(user); // needs to be after SendSpawnSummons
Field.SendSpawnMobs(user);
Field.SendSpawnNpcs(user);
Field.SendSpawnReactors(user);
Field.SendSpawnAffectedAreas(user);
Field.SendSpawnMinirooms(user);
Field.SendSpawnKites(user);
Field.SendSpawnTownPortals(user);
Field.SendSpawnOpenGates(user);
Field.SendSpawnDrops(user);
Field.SendActiveWeatherEffect(user);
Field.AssignControllerMobs();
Field.AssignControllerNpcs();
if (Field.tFieldTimerExpiration.SecondsUntilEnd() > 0)
{
user.SendPacket(CPacket.CreateClock((int)Field.tFieldTimerExpiration.SecondsUntilEnd()));
}
if (Field.nFieldDeathCount > -1)
{
//user.SendPacket(CPacket.Custom.FieldDeathCount(Field.nFieldDeathCount));
}
if (user.Party != null)
{
foreach (var c in this)
{
if (c.Party?.PartyID != user.Party.PartyID)
{
continue;
}
foreach (var buff in c.Buffs)
{
if (buff.dwCharFromId != c.dwId)
{
continue;
}
if (buff.StatType == SecondaryStatFlag.BlueAura ||
buff.StatType == SecondaryStatFlag.DarkAura ||
buff.StatType == SecondaryStatFlag.YellowAura)
{
user.Buffs.AddAura(buff.StatType, buff.dwCharFromId, buff.nSkillID, buff.nSLV);
break;
}
}
}
}
}
catch (Exception ex)
{
Log.Error(ex);
user?.Socket?.Disconnect();
}
}
void ON_FLIP_DECK_CARD_ACK(CPacket msg)
{
byte player_index = msg.pop_byte();
// 덱에서 뒤집은 카드 정보.
byte deck_card_number = msg.pop_byte();
PAE_TYPE deck_card_pae_type = (PAE_TYPE)msg.pop_byte();
byte deck_card_position = msg.pop_byte();
byte same_count_with_deck = msg.pop_byte();
PLAYER_SELECT_CARD_RESULT result = (PLAYER_SELECT_CARD_RESULT)msg.pop_byte();
if (result == PLAYER_SELECT_CARD_RESULT.CHOICE_ONE_CARD_FROM_DECK)
{
if (is_me(player_index))
{
CPacket choose_msg = CPacket.create((short)PROTOCOL.CHOOSE_CARD);
choose_msg.push((byte)result);
choose_msg.push((byte)0);
this.local_server.on_receive_from_ai(choose_msg);
}
}
else
{
CPacket ret = CPacket.create((short)PROTOCOL.TURN_END);
this.local_server.on_receive_from_ai(ret);
}
}
void add_player_select_result_to(CPacket msg, byte slot_index)
{
// 플레이어가 낸 카드 정보.
msg.push(this.engine.card_from_player.number);
msg.push((byte)this.engine.card_from_player.pae_type);
msg.push(this.engine.card_from_player.position);
msg.push(this.engine.same_card_count_with_player);
msg.push(slot_index);
// 카드 이벤트.
msg.push((byte)this.engine.card_event_type);
// 폭탄 카드 정보.
switch (this.engine.card_event_type)
{
case CARD_EVENT_TYPE.BOMB:
{
byte bomb_cards_count = (byte)this.engine.bomb_cards_from_player.Count;
msg.push((byte)bomb_cards_count);
for (byte card_index = 0; card_index < bomb_cards_count; ++card_index)
{
msg.push(this.engine.bomb_cards_from_player[card_index].number);
msg.push((byte)this.engine.bomb_cards_from_player[card_index].pae_type);
msg.push(this.engine.bomb_cards_from_player[card_index].position);
}
}
break;
case CARD_EVENT_TYPE.SHAKING:
{
byte shaking_cards_count = (byte)this.engine.shaking_cards.Count;
msg.push((byte)shaking_cards_count);
for (byte card_index = 0; card_index < shaking_cards_count; ++card_index)
{
msg.push(this.engine.shaking_cards[card_index].number);
msg.push((byte)this.engine.shaking_cards[card_index].pae_type);
msg.push(this.engine.shaking_cards[card_index].position);
}
}
break;
}
}
public static void send(CPacket msg)
{
gameserver.send(msg);
}
void ON_GAME_RESULT(CPacket msg)
{
send_ready_to_start();
}
/// <summary>
/// 클라이언트의 이동 요청.
/// </summary>
/// <param name="sender">요청한 유저</param>
/// <param name="begin_pos">시작 위치</param>
/// <param name="target_pos">이동하고자 하는 위치</param>
public void moving_req(CPlayer sender, short begin_pos, short target_pos)
{
// sender차례인지 체크.
if (this.current_turn_player != sender.player_index)
{
// 현재 턴이 아닌 플레이어가 보낸 요청이라면 무시한다.
// 이런 비정상적인 상황에서는 화면이나 파일로 로그를 남겨두는것이 좋다.
return;
}
// begin_pos에 sender의 세균이 존재하는지 체크.
if (this.gameboard[begin_pos] != sender.player_index)
{
// 시작 위치에 해당 플레이어의 세균이 존재하지 않는다.
return;
}
// 목적지는 EMPTY_SLOT으로 설정된 빈 공간이어야 한다.
// 다른 세균이 자리하고 있는 곳으로는 이동할 수 없다.
if (this.gameboard[target_pos] != EMPTY_SLOT)
{
// 목적지에 다른 세균이 존재한다.
return;
}
// target_pos가 이동 또는 복제 가능한 범위인지 체크.
short distance = CHelper.get_distance(begin_pos, target_pos);
if (distance > 2)
{
// 2칸을 초과하는 거리는 이동할 수 없다.
return;
}
if (distance <= 0)
{
// 자기 자신의 위치로는 이동할 수 없다.
return;
}
// 모든 체크가 정상이라면 이동을 처리한다.
if (distance == 1) // 이동 거리가 한칸일 경우에는 복제를 수행한다.
{
put_virus(sender.player_index, target_pos);
}
else if (distance == 2) // 이동 거리가 두칸일 경우에는 이동을 수행한다.
{
// 이전 위치에 있는 세균은 삭제한다.
remove_virus(sender.player_index, begin_pos);
// 새로운 위치에 세균을 놓는다.
put_virus(sender.player_index, target_pos);
}
// 목적지를 기준으로 주위에 존재하는 상대방 세균을 감염시켜 같은 편으로 만든다.
CPlayer opponent = get_opponent_player();
infect(target_pos, sender, opponent);
// 최종 결과를 broadcast한다.
CPacket msg = CPacket.create((short)PROTOCOL.PLAYER_MOVED);
msg.push(sender.player_index); // 누가
msg.push(begin_pos); // 어디서
msg.push(target_pos); // 어디로 이동 했는지
broadcast(msg);
}
// handler.
void ON_LOCAL_SERVER_STARTED(CPacket msg)
{
send_ready_to_start();
}
public void send(CPacket msg)
{
this.send_function(msg);
}
void on_receive(CPacket msg)
{
PROTOCOL protocol = (PROTOCOL)msg.pop_protocol_id();
//UnityEngine.Debug.Log("AIPlayer received : " + protocol);
if (!this.packet_handler.ContainsKey(protocol))
{
return;
}
this.packet_handler[protocol](msg);
}
public override void Execute(CommandCtx ctx)
{
if (ctx.Empty)
{
ctx.Character.SendMessage("!test <ftype | event | makerskill>");
}
else
{
switch (ctx.NextString().ToLowerInvariant())
{
case "instance":
ctx.Character.SendMessage($"Instance: {ctx.Character.Field.nInstanceID}");
break;
case "potential":
if (ctx.Empty)
{
return;
}
var itemid = ctx.NextInt();
var pots = new int[3];
var i = 0;
while (!ctx.Empty)
{
pots[i] = ctx.NextInt();
i += 1;
}
var pItem = MasterManager.CreateItem(itemid, false) as GW_ItemSlotEquip;
if (pItem is null)
{
return;
}
pItem.nGrade = PotentialGradeCode.Visible_Unique;
pItem.nOption1 = (short)pots[0];
pItem.nOption2 = (short)pots[1];
pItem.nOption3 = (short)pots[2];
InventoryManipulator.InsertInto(ctx.Character, pItem);
break;
case "sheepranch":
ctx.Character.Action.SetFieldInstance(BattlefieldData.BattleMap, 1);
break;
case "sethorns":
ctx.Character.Buffs.AddSkillBuff((int)Skills.BOWMASTER_SHARP_EYES, 30);
ctx.Character.Buffs.AddSkillBuff((int)Skills.DUAL5_THORNS_EFFECT, 30);
break;
case "makerskill":
ctx.Character.Skills.Add(new SkillEntry(1007)
{
nSLV = 1
});
break;
case "ftype":
ctx.Character.SendMessage("Map Field Type: " + Enum.GetName(typeof(FieldType), ctx.Character.Field.Template.FieldType));
break;
case "event":
MasterManager.EventManager.TryDoEvent(true);
break;
case "shop":
{
var pShop = new CShop(69);
pShop.Items.Add(new CShopItem(0));
pShop.AddDefaultItems();
MasterManager.ShopManager.InitUserShop(ctx.Character, 9900000, pShop);
}
break;
case "balloon":
ctx.SendPacket(CPacket.BalloonMessage("Hello World!", 96));
break;
default:
ctx.Character.SendMessage("No test command with that argument.");
break;
}
}
return;
foreach (var mob in ctx.Character.Field.Mobs)
{
ctx.Character.SendMessage($"{mob.nMobTemplateId}");
}
return;
int imob = 0;
foreach (var mob in ctx.Character.Field.Mobs.aMobGen)
{
if (mob.FH == 0)
{
imob += 1;
}
}
ctx.Character.SendMessage($"Mobs with FH 0: {imob}");
ctx.Character.SendMessage($"Mobs In Map: {ctx.Character.Field.Mobs.Count} || Spawns: {ctx.Character.Field.Mobs.aMobGen.Count}");
return;
//foreach(var reactor in ctx.Character.Field.Reactors)
//{
// reactor.IncreaseReactorState(0, 0);
//}
//return;
ctx.Character.Action.SetFieldInstance(240060200, Constants.Rand.Next(), 0);
return;
var drop = new CDrop(ctx.Character.Position, ctx.Character.dwId)
{
ItemId = 100
};
drop.Position.X = drop.StartPosX;
drop.CalculateY(ctx.Character.Field, drop.StartPosY);
ctx.Character.Field.Drops.Add(drop);
return;
ctx.Character.SendMessage("" + Enum.GetName(typeof(FieldType), ctx.Character.Field.Template.FieldType));
return;
var p = new COutPacket(SendOps.LP_Clock);
var type = ctx.NextInt();
p.Encode1((byte)type);
switch (type)
{
case 0: // OnEventTimer
p.Encode4(ctx.NextInt()); // nDuration
break;
case 1: // Clock
p.Encode1((byte)ctx.NextInt()); // nHour
p.Encode1((byte)ctx.NextInt()); // nMin
p.Encode1((byte)ctx.NextInt()); // nSec
break;
case 2: // Timer
p.Encode4(ctx.NextInt()); // tDuration (0 to disable the clock)
break;
case 3: // some kind of event timer also
p.Encode1((byte)ctx.NextInt()); // bool (on/off)
p.Encode4(ctx.NextInt()); // tDuration
break;
case 100: // cakepie event timer
p.Encode1((byte)ctx.NextInt()); // bool (timer on/off)
p.Encode1((byte)ctx.NextInt()); // nTimerType
p.Encode4(ctx.NextInt()); // tDuration
break;
}
ctx.Character.SendPacket(p);
for (int i = 0; i < 2; i++)
{
var p2 = new COutPacket(SendOps.LP_CakePieEventResult);
p2.Encode1(1); // bool -> continue while loop
p2.Encode4(ctx.Character.Field.MapId); // fieldid
p2.Encode4(4220176); // itemid
p2.Encode1(25); // percentage
p2.Encode1((byte)ctx.NextInt()); // eventstatus
p2.Encode1((byte)(i + 1)); // nwinnerteam
p2.Encode1(0); // end while loop
ctx.SendPacket(p2);
}
return;
//var poo = ctx.Character.Pets.Pets[0];
//if (poo != null)
//{
// ctx.Character.SendMessage($"{poo.Position.X} || {poo.Position.Y}");
//}
//var p = new COutPacket(SendOps.LP_AvatarMegaphoneUpdateMessage);
//var x = new AvatarMegaphone
//{
// nItemID = 05390000,
// sName = "pooodop",
// sMsgs = new string[5] { "one", " two", " three", " four", " five" },
// nChannelNumber = 1,
// bWhisper = true,
// alSender = ctx.Character.GetLook()
//};
//x.Encode(p);
//MasterManager.CharacterPool.Broadcast(p);
//var nItemID = ctx.NextInt();
//ctx.Character.Modify.Inventory(inv =>
//{
// for (short i = 1; i <= ctx.Character.InventoryEquip.SlotLimit; i++)
// {
// ctx.Character.InventoryEquip.Remove(i);
// var newItem = MasterManager.CreateItem(nItemID) as GW_ItemSlotEquip;
// newItem.nGrade = PotentialGradeCode.Visible_Unique;
// newItem.nOption1 = (int)PotentialLineIDs.LEARN_SKILL_HASTE;
// ctx.Character.InventoryEquip.Add(i, newItem);
// inv.Add(InventoryType.Equip, i, newItem);
// }
// var magnifyingGlass = MasterManager.CreateItem(02460003) as GW_ItemSlotBundle;
// magnifyingGlass.nNumber = 500; // pretty sure i can override the 100 slotmax lol
// ctx.Character.InventoryConsume.Remove(15);
// ctx.Character.InventoryConsume.Add(15, magnifyingGlass);
// inv.Remove(InventoryType.Consume, 15);
// inv.Add(InventoryType.Consume, 15, magnifyingGlass);
//});
//return;
//foreach (var item in ctx.Character.InventoryEquip)
//{
// ctx.Character.Action.ConsumeItem.UseMagnifyingGlass(15, item.Key);
// item.Value.sTitle = $"{item.Value.nOption1}|{item.Value.nOption2}";
//}
//ctx.Character.InventoryEquip.RemoveAllItems(ctx.Character); // gotta cc for this to take effect so we can look then cc to clean inv
// ctx.Character.SendPacket(CPacket.UserOpenUI((UIWindow)ctx.NextInt()));
//ctx.Character.Field.bPauseSpawn = !ctx.Character.Field.bPauseSpawn;
//ctx.Character.Modify.Stats(mod => mod.SP += (short)ctx.NextInt());
//var p = new COutPacket(SendOps.LP_UserEffectLocal);
//for (int i = 8; i >= 1; i--)
//{
// p.Encode4(i == statup.getPosition() ? statup.getValue() : 0);
//}
//p.Encode1(1); // skill use
//p.Encode4(22160000); // skillID
//p.Encode1(100); // nCharLevel
//p.Encode1(1); // nSLV
//p.Encode1(1);
//ctx.SendPacket(p);
//ctx.Character.SendMessage($"You have {ctx.Character.Buffs.Count} buffs.");
//var pChar = ctx.Character;
//if (pChar.PlayerGuild == null)
//{
// var name = ctx.NextString();
// MasterManager.GuildManager.Add(new Guild(name, pChar.dwId));
//}
//else
//{
// var p = new COutPacket(SendOps.LP_GuildResult);
// p.Encode1((byte)ctx.NextInt());
// pChar.SendPacket(p);
//}
//var storage = ServerApp.Container.Resolve<CenterStorage>();
//var sub = storage.Multiplexer().GetSubscriber();
//sub.Publish("donate", $"{character.AccId}/5000");
// character.Modify.GainNX(1000);
// character.SendPacket(CPacket.OpenClassCompetitionPage());
//var stat = new SecondaryStat();
//var entry = new SecondaryStatEntry()
//{
// nValue = 10,
// rValue = 2001002,
// tValue = 110000,
//};
//stat.Add(SecondaryStatType.MagicGuard, entry);
//stat.Add(SecondaryStatType.Flying, entry);
//character.SendPacket(CPacket.TemporaryStatSetLocal(stat));
//character.Field.Broadcast(CPacket.UserTemporaryStatSet(stat, character.CharId));
//var summon = new CSummon();
//summon.Parent = character;
//summon.dwSummonedId = 2330810;
//summon.nSkillID = 14001005;
//summon.Position.Position.X = character.Position.Position.X;
//summon.Position.Position.Y = character.Position.Position.Y;
//summon.Position.Foothold = character.Position.Foothold;
//summon.nCharLevel = character.Stats.nLevel;
//summon.nSLV = 1;
//summon.bMoveAbility = 1;
//summon.bAssistType = 1;
//summon.nEnterType = 1;
//character.Summons.Add(summon);
//character.SendPacket(CPacket.TradeMoneyLimit(true));
//character.SendPacket(CPacket.WarnMessage("YEOOOOOO THIS IS A WARNING BOY"));
//character.SendPacket(CPacket.AdminShopCommodity(9900000));
//character.SendPacket(CPacket.StandAloneMode(true));
//character.SendPacket(CPacket.LogoutGift());
//character.SendPacket(CPacket.UserHireTutor(true));
//character.SendPacket(CPacket.UserTutorMsg(Constants.ServerMessage2,400,60000));
//character.SendPacket(CPacket.HontaleTimer(0,5));
//character.SendPacket(CPacket.HontaleTimer(1, 5));
//character.SendPacket(CPacket.HontaleTimer(2, 5));
//character.SendPacket(CPacket.HontaleTimer(3, 5));
//character.SendPacket(CPacket.HontailTimer(0,69));
//character.SendPacket(CPacket.HontailTimer(1, 69));
//character.SendPacket(CPacket.HontailTimer(0, 0));
//var town = new CTownPortal();
//town.dwCharacterID = character.dwId;
//town.Position.X = character.Position.X;
//town.Position.Y = character.Position.Y;
//character.Field.TownPortals.Add(town);
//character.SendPacket(CPacket.DragonEnterField(character.dwId, character.Position.X, character.Position.Y, 0, 2218));
//character.Dragon = new CDragon(character);
//character.Dragon.JobCode = 2218;
//character.Dragon.Position.X = character.Position.X;
//character.Dragon.Position.Y = character.Position.Y;
// var gate1 = new COpenGate()
// {
// dwCharacterID = character.dwId,
// };
// gate1.Position.X = character.Position.X;
// gate1.Position.Y = character.Position.Y;
// character.Field.OpenGates1.Add(gate1);
// var gate2 = new COpenGate()
// {
// dwCharacterID = character.dwId,
// };
// gate2.Position.X = character.Position.X;
// gate2.Position.X -= 250;
// gate2.Position.Y = character.Position.Y;
// character.Field.OpenGates2.Add(gate2);
//character.SendPacket(CPacket.StageChange("ThemeBack1.img", 0));
//character.Field.Employees.RemoveAt(0);
//character.SendPacket(CPacket.SetBackgroundEffect(2, 100000000, 1, 30 * 1000));
//character.SendPacket(CPacket.Desc(true));
//character.SendPacket(CPacket.StalkResult(character.dwId, character.Stats.sCharacterName, character.Position.X, character.Position.Y));
//character.SendPacket(CPacket.PlayJukeBox("Hydromorph"));
//character.SendPacket(CPacket.BlowWeather(0, 5120000, "Hello Twitch!!!"));
//character.SendPacket(CPacket.AntiMacroResult(6, "SnitchNigga")); //Crash
//character.SendPacket(CPacket.AntiMacroResult(7, "SnitchNigga")); //This dude reported you !
//Diemension mirror reeeeeeeeeeeeeee
//var p = NpcScript.ScriptMessageHeader(0, 9900000, ScriptMsgType.AskSlideMenu);
//p.Encode4(0); //dlg type
//p.Encode4(0); //index?
//p.EncodeString("Hello World");
//character.SendPacket(p);
//var pet = new CPet(ctx.Character);
//pet.nIdx = 0;
//pet.liPetLockerSN = 9001;
//pet.dwTemplateID = 5000102;
//pet.sName = "Charlie";
//pet.Position.X = character.Position.X;
//pet.Position.Y = character.Position.Y;
//ctx.Character.Pets.Add(pet.liPetLockerSN, pet);
}
void ON_SELECT_CARD_ACK(CPacket msg)
{
byte delay = msg.pop_byte();
byte current_player_index = msg.pop_byte();
//short score = msg.pop_int16();
//byte remain_bomb_card_count = msg.pop_byte();
if (is_me(current_player_index))
{
// 카드 내는 연출을 위해 필요한 변수들.
CARD_EVENT_TYPE card_event = CARD_EVENT_TYPE.NONE;
byte slot_index = byte.MaxValue;
byte player_card_number = byte.MaxValue;
PAE_TYPE player_card_pae_type = PAE_TYPE.PEE;
byte player_card_position = byte.MaxValue;
// 플레이어가 낸 카드 정보.
player_card_number = msg.pop_byte();
player_card_pae_type = (PAE_TYPE)msg.pop_byte();
player_card_position = msg.pop_byte();
byte same_count_with_player = msg.pop_byte();
slot_index = msg.pop_byte();
card_event = (CARD_EVENT_TYPE)msg.pop_byte();
switch (card_event)
{
case CARD_EVENT_TYPE.BOMB:
{
byte bomb_card_count = (byte)msg.pop_byte();
for (byte i = 0; i < bomb_card_count; ++i)
{
byte number = msg.pop_byte();
PAE_TYPE pae_type = (PAE_TYPE)msg.pop_byte();
byte position = msg.pop_byte();
CCard card = this.hand_cards.Find(obj => obj.is_same(number, pae_type, position));
this.hand_cards.Remove(card);
}
}
break;
case CARD_EVENT_TYPE.SHAKING:
{
byte shaking_card_count = (byte)msg.pop_byte();
for (byte i = 0; i < shaking_card_count; ++i)
{
byte number = msg.pop_byte();
PAE_TYPE pae_type = (PAE_TYPE)msg.pop_byte();
byte position = msg.pop_byte();
}
this.hand_cards.RemoveAt(slot_index);
}
break;
default:
this.hand_cards.RemoveAt(slot_index);
break;
}
PLAYER_SELECT_CARD_RESULT select_result = (PLAYER_SELECT_CARD_RESULT)msg.pop_byte();
if (select_result == PLAYER_SELECT_CARD_RESULT.CHOICE_ONE_CARD_FROM_PLAYER)
{
byte count = msg.pop_byte();
for (byte i = 0; i < count; ++i)
{
byte number = msg.pop_byte();
PAE_TYPE pae_type = (PAE_TYPE)msg.pop_byte();
byte position = msg.pop_byte();
}
CPacket choose_msg = CPacket.create((short)PROTOCOL.CHOOSE_CARD);
choose_msg.push((byte)select_result);
choose_msg.push((byte)0);
this.local_server.on_receive_from_ai(choose_msg);
return;
}
CPacket ret = CPacket.create((short)PROTOCOL.FLIP_DECK_CARD_REQ);
this.local_server.on_receive_from_ai(ret);
}
}
void IPeer.process_user_operation(CPacket msg)
{
PROTOCOL protocol = (PROTOCOL)msg.pop_protocol_id();
Console.WriteLine("protocol id " + protocol);
switch (protocol)
{
case PROTOCOL.SERVER_LIST_REQ:
CPacket new_msg = CPacket.create((short)PROTOCOL.SERVER_LIST_SEND);
new_msg.push_int32(Program.game_main.room_manager.rooms.Count);
send(new_msg);
break;
case PROTOCOL.ENTER_GAME_ROOM_REQ:
Program.game_main.matching_req(this);
break;
case PROTOCOL.LOADING_COMPLETED:
byte Job = msg.pop_byte();
this.battle_room.loading_complete(player, Job);
break;
case PROTOCOL.MOVING_REQ:
{
byte player_index = msg.pop_byte();
float px = msg.pop_Single();
float py = msg.pop_Single();
float pz = msg.pop_Single();
float rx = msg.pop_Single();
float ry = msg.pop_Single();
float rz = msg.pop_Single();
byte idle = msg.pop_byte();
byte walk = msg.pop_byte();
byte run = msg.pop_byte();
byte die = msg.pop_byte();
this.battle_room.moving_req(this.player, new Vector3(px, py, pz), new Quaternion(rx, ry, rz), new byte[4] {
idle, walk, run, die
}, player_index);
}
break;
case PROTOCOL.DAMAGED:
{
byte player_index;
float HP;
player_index = msg.pop_byte();
HP = msg.pop_Single();
this.battle_room.damaged(player_index, HP, this);
}
break;
case PROTOCOL.USE_SKILLONE:
{
byte player_index = msg.pop_byte();
this.battle_room.useskill(player_index, PROTOCOL.USE_SKILLONE);
}
break;
case PROTOCOL.USE_SKILLTWO:
{
byte player_index = msg.pop_byte();
this.battle_room.useskill(player_index, PROTOCOL.USE_SKILLTWO);
}
break;
case PROTOCOL.USE_SKILLTHREE:
{
byte player_index = msg.pop_byte();
this.battle_room.useskill(player_index, PROTOCOL.USE_SKILLTHREE);
}
break;
case PROTOCOL.PLAYER_DEAD:
{
byte player_index = msg.pop_byte();
this.battle_room.deadPlayer(player_index);
}
break;
}
}
void ON_START_TURN(CPacket msg)
{
byte remain_bomb_card_count = msg.pop_byte();
update_floor_cards(msg);
if (remain_bomb_card_count > 0)
{
CPacket card_msg = CPacket.create((short)PROTOCOL.FLIP_BOMB_CARD_REQ);
this.local_server.on_receive_from_ai(card_msg);
}
else
{
byte slot_index = this.brain.choice_card_to_put(this.hand_cards, null, this.floor_card_manager);
CPacket card_msg = CPacket.create((short)PROTOCOL.SELECT_CARD_REQ);
CCard card = this.hand_cards[slot_index];
card_msg.push(card.number);
card_msg.push((byte)card.pae_type);
card_msg.push(card.position);
card_msg.push(slot_index);
byte is_shaking = 1;
card_msg.push(is_shaking);
//UnityEngine.Debug.Log(string.Format("sent {0}, {1}, {2}", card.number, card.pae_type, card.position));
this.local_server.on_receive_from_ai(card_msg);
}
}
void IMessageReceiver.on_recv(CPacket msg)
{
}
void ON_TURN_RESULT(CPacket msg)
{
CPacket finish = CPacket.create((short)PROTOCOL.TURN_END);
this.local_server.on_receive_from_ai(finish);
}
public void SendLoad()
{
Parent.SendPacket(CPacket.MacroSysDataInit(this));
}
void update_floor_cards(CPacket msg)
{
this.floor_card_manager.reset();
byte slot_count = msg.pop_byte();
for (byte i = 0; i < slot_count; ++i)
{
byte card_count = msg.pop_byte();
for (byte card_index = 0; card_index < card_count; ++card_index)
{
byte number = msg.pop_byte();
PAE_TYPE pae_type = (PAE_TYPE)msg.pop_byte();
byte position = msg.pop_byte();
this.floor_card_manager.puton_card(new CCard(number, pae_type, position));
}
}
}
public void send(CPacket msg)
{
this.gameserver.send(msg);
}
public void send(CPacket msg)
{
CPacket clone = CLocalServer.pre_send(msg);
CPacket.destroy(msg);
on_receive(clone);
}
void IPeer.send(CPacket msg)
{
msg.record_size();
this.token.send(new ArraySegment <byte>(msg.buffer, 0, msg.position));
}
void ON_ASK_GO_OR_STOP(CPacket msg)
{
CPacket answer_msg = CPacket.create((short)PROTOCOL.ANSWER_GO_OR_STOP);
answer_msg.push((byte)1); // 0:스톱, 1:고.
this.local_server.on_receive_from_ai(answer_msg);
}
//void IPeer.ParseCode(Const<byte[]> _buffer)
public void ParseCode(Const <byte[]> _buffer)
{
Console.WriteLine("======================================");
Console.WriteLine(this + " 패킷 들어옴... 파싱하기. ParseCode");
Console.WriteLine("======================================");
//_packet은 함수 안에서만 유효한것임... 다른데에서는 사용안함...
CPacket _receive = new CPacket(_buffer.Value, this);
LOGIN_PROTO _code = (LOGIN_PROTO)_receive.pop_protocol_id();
Console.WriteLine(" > _code:" + _code);
switch (_code)
{
case LOGIN_PROTO.CREATE_ROOM_REQ:
{
Console.WriteLine("[C -> S] CREATE_ROOM_REQ");
if (myRoom == null)
{
bRoomMaster = true; //방장이여
string _strRoomName = _receive.ReadString();
Program.RoomCreate(this, _strRoomName);
Console.WriteLine(" > _strRoomName:{0}", _strRoomName);
Console.WriteLine("[C <- S] CREATE_ROOM_OK");
CPacket _response = CPacket.Create((short)LOGIN_PROTO.CREATE_ROOM_OK);
_response.WriteInt(m_SN);
SendCode(_response);
}
else
{
Console.WriteLine("[C <- S] CREATE_ROOM_FAILED");
SendCode(CPacket.Create((short)LOGIN_PROTO.CREATE_ROOM_FAILED)); //이미 접속한 방이있어
}
}
break;
case LOGIN_PROTO.ROOM_LIST_REQ:
{
Console.WriteLine("[C -> S] ROOM_LIST_REQ");
CPacket _response = CPacket.Create((short)LOGIN_PROTO.ROOM_LIST_ACK);
int _countRoom = Program.listRoom.Count;
_response.WriteInt(_countRoom);
Console.WriteLine(" > 방수량:{0}", _countRoom);
for (int i = 0; i < _countRoom; i++) // Loop with for.
{
if (Program.listRoom[i] != null)
{
_response.WriteString(Program.listRoom[i].name);
_response.WriteInt(Program.listRoom[i].playerCount);
_response.WriteInt(Program.listRoom[i].playerMax);
}
}
Console.WriteLine("[C <- S] ROOM_LIST_ACK");
SendCode(_response);
}
break;
case LOGIN_PROTO.ROOM_EXIT_REQ:
{
Console.WriteLine("[C -> S] ROOM_EXIT_REQ");
Program.Exit_Room(this);
myRoom = null;
}
break;
case LOGIN_PROTO.ROOM_CONNECT_REQ:
{
Console.WriteLine("[C -> S] ROOM_CONNECT_REQ");
int _roomNum = _receive.ReadInt();
if (Program.RoomConnect(this, _roomNum))
{
//성공
CPacket _response = CPacket.Create((short)LOGIN_PROTO.ROOM_CONNECT_OK);
_response.WriteInt(myRoom.listGameUser.Count);
_response.WriteInt(m_SN);
for (int i = 0; i < myRoom.listGameUser.Count; ++i)
{
_response.WriteInt(myRoom.listGameUser[i].m_SN);
}
Console.WriteLine("[C <- S] ROOM_CONNECT_OK");
SendCode(_response); //잘만들었으
CPacket _response2 = CPacket.Create((short)LOGIN_PROTO.ROOM_CONNECT_OTHER);
_response2.WriteInt(m_SN);
Console.WriteLine("[C <- S] ROOM_CONNECT_OTHER");
myRoom.BroadCast(_response2, this);
}
else
{
//실패
Console.WriteLine("[C <- S] ROOM_CONNECT_FAILED");
SendCode(CPacket.Create((short)LOGIN_PROTO.ROOM_CONNECT_FAILED));
}
}
break;
case LOGIN_PROTO.CHAT_MSG_REQ:
{
Console.WriteLine("[C -> S] CHAT_MSG_REQ");
string _strMsg = _receive.ReadString();
Console.WriteLine(" > _strMsg:{0}", _strMsg);
if (myRoom != null)
{
CPacket _response = CPacket.Create((short)LOGIN_PROTO.CHAT_MSG_REQ);
_response.WriteInt(m_SN);
_response.WriteString(_strMsg);
Console.WriteLine("[C <- S] CHAT_MSG_REQ");
myRoom.BroadCast(_response, this);
}
else
{
CPacket _response = CPacket.Create((short)LOGIN_PROTO.CHAT_MSG_REQ);
_response.WriteInt(0);
_response.WriteString(_strMsg);
Console.WriteLine("[C <- S] CHAT_MSG_REQ");
SendCode(_response);
}
}
break;
case LOGIN_PROTO.LOGIN_REQUEST:
{
Console.WriteLine("[C -> S] LOGIN_REQUEST");
//msg.pop_string();
UserInfo _userInfo = new UserInfo();
_userInfo.Name = _receive.ReadString();
_userInfo.SN = m_SN;
listUserInfo.Add(_userInfo);
//Console.WriteLine(" Connect" + _userInfo.Name);
CPacket _response1 = CPacket.Create((short)LOGIN_PROTO.LOGIN_REPLY);
_response1.WriteInt(m_SN);
_response1.WriteString(_userInfo.Name);
Console.WriteLine("[C <- S] LOGIN_REPLY");
BroadCast(_response1);
CPacket _response = CPacket.Create((short)LOGIN_PROTO.USER_CONNECT);
_response.WriteInt(m_SN);
_response.WriteString(_userInfo.Name);
Console.WriteLine("[C <- S] USER_CONNECT");
SendCode(_response);
for (int i = 0; i < listUserInfo.Count; i++) // Loop with for.
{
if (m_SN != listUserInfo[i].SN)
{
CPacket _response3 = CPacket.Create((short)LOGIN_PROTO.LOGIN_REPLY);
_response3.WriteInt(listUserInfo[i].SN);
_response3.WriteString(listUserInfo[i].Name);
Console.WriteLine("[C <- S] LOGIN_REPLY");
SendCode(_response3);
}
}
++m_SN;
}
break;
case LOGIN_PROTO.MOVING_USER_REQ:
{
Console.WriteLine("[C -> S] MOVING_USER_REQ");
int SN = _receive.ReadInt();
float x = _receive.ReadFloat();
float y = _receive.ReadFloat();
float z = _receive.ReadFloat();
Console.WriteLine(" > SN:{0} x:{1} y:{2}, z:{3}", SN, x, y, z);
Console.WriteLine("[C <- S] MOVING_USER_REQ");
BroadCast(_receive);
}
break;
case LOGIN_PROTO.MOVING_USER_ONLY:
{
Console.WriteLine("[C -> S] MOVING_USER_ONLY");
int SN = _receive.ReadInt();
float x = _receive.ReadFloat();
float y = _receive.ReadFloat();
float z = _receive.ReadFloat();
Console.WriteLine(" > SN:{0} x:{1} y:{2}, z:{3}", SN, x, y, z);
Console.WriteLine("[C <- S] MOVING_USER_ONLY");
CPacket _response = CPacket.Create((short)LOGIN_PROTO.MOVING_USER_ONLY);
_response.WriteInt(SN);
_response.WriteFloat(x);
_response.WriteFloat(y);
_response.WriteFloat(z);
List <CGameUser> _userList = Program.listGameUser;
foreach (CGameUser _client in _userList)
{
_client.token.SendCode(_response);
}
}
break;
case LOGIN_PROTO.ATTACK:
{
Console.WriteLine("[C -> S] ATTACK");
int SN = _receive.ReadInt();
byte Type = _receive.ReadByte();
float x = _receive.ReadFloat();
float y = _receive.ReadFloat();
float z = _receive.ReadFloat();
float w = _receive.ReadFloat();
Console.WriteLine(" > SN:{0} Type:{1} x:{2}, y:{3}, z:{4}, w:{5}", SN, Type, x, y, z, w);
Console.WriteLine("[C <- S] ATTACK");
BroadCast(_receive);
}
break;
case LOGIN_PROTO.PTC_ECHO:
{
Console.WriteLine("[C -> S] PTC_ECHO");
string _strMsg = _receive.ReadString();
Console.WriteLine(" > _strMsg:{0}", _strMsg);
CPacket _response = CPacket.Create((short)LOGIN_PROTO.PTS_ECHO);
_response.WriteString(_strMsg);
Console.WriteLine("[C <- S] PTS_ECHO");
SendCode(_response);
}
break;
default:
{
Console.WriteLine("[C -> S] ####(프로토콜이 지정되지 않았어요.) " + (LOGIN_PROTO)_code);
}
break;
}
//사용하고 남은 것은 해제해준다.
//CPacket.Destroy(_packet);
}
void ON_ASK_KOOKJIN_TO_PEE(CPacket msg)
{
CPacket answer_msg = CPacket.create((short)PROTOCOL.ANSWER_KOOKJIN_TO_PEE);
answer_msg.push((byte)1); // 0:사용하지 않음, 1:쌍피로 사용.
this.local_server.on_receive_from_ai(answer_msg);
}
/// <summary>
/// 클라이언트의 이동 요청.
/// </summary>
/// <param name="sender">요청한 유저</param>
/// <param name="begin_pos">시작 위치</param>
/// <param name="target_pos">이동하고자 하는 위치</param>
public void moving_req(CPlayer sender, CPacket received_data)
{
this.room.clear_received_protocol();
short begin_pos = received_data.pop_int16();
short target_pos = received_data.pop_int16();
// sender차례인지 체크.
if (!this.room.is_current_player(sender))
{
this.room.error(sender);
return;
}
// begin_pos에 sender의 세균이 존재하는지 체크.
if (this.gameboard[begin_pos] != sender.player_index)
{
// 시작 위치에 해당 플레이어의 세균이 존재하지 않는다.
this.room.error(sender);
return;
}
// 목적지는 EMPTY_SLOT으로 설정된 빈 공간이어야 한다.
// 다른 세균이 자리하고 있는 곳으로는 이동할 수 없다.
if (this.gameboard[target_pos] != EMPTY_SLOT)
{
// 목적지에 다른 세균이 존재한다.
this.room.error(sender);
return;
}
// target_pos가 이동 또는 복제 가능한 범위인지 체크.
short distance = CHelper.get_distance(begin_pos, target_pos);
if (distance > 2)
{
// 2칸을 초과하는 거리는 이동할 수 없다.
this.room.error(sender);
return;
}
if (distance <= 0)
{
// 자기 자신의 위치로는 이동할 수 없다.
this.room.error(sender);
return;
}
// 모든 체크가 정상이라면 이동을 처리한다.
if (distance == 1) // 이동 거리가 한칸일 경우에는 복제를 수행한다.
{
put_virus(sender.player_index, target_pos);
}
else if (distance == 2) // 이동 거리가 두칸일 경우에는 이동을 수행한다.
{
// 이전 위치에 있는 세균은 삭제한다.
remove_virus(sender.player_index, begin_pos);
// 새로운 위치에 세균을 놓는다.
put_virus(sender.player_index, target_pos);
}
// 목적지를 기준으로 주위에 존재하는 상대방 세균을 감염시켜 같은 편으로 만든다.
CPlayer opponent = this.room.get_opponent_player();
infect(target_pos, sender, opponent);
// 최종 결과를 broadcast한다.
CPacket msg = CPacket.create((short)PROTOCOL.PLAYER_MOVED);
msg.push(sender.player_index); // 누가
msg.push(begin_pos); // 어디서
msg.push(target_pos); // 어디로 이동 했는지
this.room.broadcast(msg);
}
protected void CloseRegistration()
{
MasterManager.CharacterPool.Broadcast(CPacket.SystemMessage($"[Community Event] {sEventName} has closed for new entrants."));
QR = "1";
tStart = DateTime.Now;
}
public void send_for_broadcast(CPacket msg)
{
this.owner.send(msg);
}
public void SendToClient(RemoteID remote, IRemoteClient client, CMessage msg, CPackOption op)
{
PreparePacket(remote, RemoteID.Remote_Server, msg, op);
client.SendToRemote(CPacket.create(msg));
}
public void Send(CPacket msg)
{
gameserver.send(msg);
}
public void CreateMiniRoom(Character c, MR_Type nType, CInPacket p)
{
switch (nType)
{
case MR_Type.Omok:
// todo
break;
case MR_Type.MemoryGame:
// todo
break;
case MR_Type.TradingRoom:
if (c.CurMiniRoom != null)
{
c.SendPacket(CPacket.SystemMessage("You are already in a trade."));
}
else
{
Log.Debug($"Adding trade mini room to field minirooms.");
Add(new CTradingRoom(c));
}
break;
// Recv [CP_MiniRoom] 90 00 00 05 07 00 70 65 65 66 61 63 65 00 01 00 76 C0 4C 00
case MR_Type.PersonalShop:
c.SendMessage("no");
break;
case MR_Type.EntrustedShop:
{
// TODO check closeness to other shops
var sTitle = p.DecodeString();
p.Skip(3); // TODO what is this
var nShopTemplateId = p.Decode4();
var(nItemSlot, pItem) = InventoryManipulator.GetAnyItem(c, InventoryType.Cash, nShopTemplateId);
Log.Info($"Player [{c.Stats.sCharacterName}] attempting to create a shop with ItemID [{nShopTemplateId}] and Title [{sTitle}]");
if (pItem == null || nItemSlot == 0)
{
c.SendPacket(CPacket.SystemMessage("Invalid item or item slot.")); // packet editing?
}
else if (!c.Field.MapId.InRange(910000000, 910000023))
{
c.SendPacket(CPacket.SystemMessage("Item does not work in this map."));
}
else if (!ItemConstants.is_entrusted_shop_item(pItem.nItemID))
{
c.SendPacket(CPacket.SystemMessage("Invalid shop item.")); // packet editing??
}
else
{
var pMiniRoom = new CEntrustedShop(c, nShopTemplateId, sTitle);
if (pMiniRoom.HasItems())
{
c.SendMessage("Please retrieve items from fredrick before opening a shop.");
}
else
{
//Add(pMiniRoom); // packet is sent in here
}
}
break;
}
case MR_Type.CashTradingRoom:
// todo
break;
default:
break;
}
}
void IPeer.send(CPacket msg)
{
this.token.send(msg);
}
public void send(CPacket msg)
{
this.send_function(msg);
}
