private void OnContextChanged(Character character, bool infight)
{
// not rdy yet
if (!infight)
{
return;
}
// send it after fight has been fully created
character.Area.AddMessage(() =>
{
if (!character.Fighter.IsTeamLeader())
{
return;
}
var clients = Members.Where(x => x.Fight != character.Fight).ToClients();
if (character.Fight is FightAgression)
{
PartyHandler.SendPartyMemberInFightMessage(clients, this, character,
character.Fighter.Team == character.Fight.ChallengersTeam
? PartyFightReasonEnum.ATTACK_PLAYER
: PartyFightReasonEnum.PLAYER_ATTACK, character.Fight);
}
else if (character.Fight is FightPvM)
{
PartyHandler.SendPartyMemberInFightMessage(clients, this, character, PartyFightReasonEnum.MONSTER_ATTACK, character.Fight);
}
});
}
public void Deny()
{
Target.RemoveInvitation(this);
Party.RemoveGuest(Target);
PartyHandler.SendPartyInvitationCancelledForGuestMessage(Target.Client, Target, this);
PartyHandler.SendPartyRefuseInvitationNotificationMessage(Party.Clients, this);
}
public void Cancel()
{
Target.RemoveInvitation(this);
Party.RemoveGuest(Target);
PartyHandler.SendPartyInvitationCancelledForGuestMessage(Target.Client, Source, this);
PartyHandler.SendPartyCancelInvitationNotificationMessage(Party.Clients, this);
}
protected virtual void OnGroupDisbanded()
{
PartyHandler.SendPartyDeletedMessage(Clients, this);
UnBindEvents();
PartyDeleted?.Invoke(this);
}
internal Party(int id, Character leader)
{
this.Id = id;
this.Restricted = true;
this.m_members.Add(leader);
this.BindEvents(leader);
this.Leader = leader;
PartyHandler.SendPartyJoinMessage(leader.Client, this);
}
public void UpdateMember(Character character)
{
if (!IsInGroup(character))
{
return;
}
PartyHandler.SendPartyUpdateMessage(Clients, this, character);
}
public void Cancel()
{
this.Target.RemoveInvitation(this);
this.Party.RemoveGuest(this.Target);
PartyHandler.SendPartyInvitationCancelledForGuestMessage(this.Target.Client, this.Source, this);
this.Party.ForEach(delegate(Character entry)
{
PartyHandler.SendPartyCancelInvitationNotificationMessage(entry.Client, this);
});
}
public void UpdateMember(Character character)
{
if (this.IsInGroup(character))
{
this.ForEach(delegate(Character entry)
{
PartyHandler.SendPartyUpdateMessage(entry.Client, this, character);
});
}
}
// Start is called before the first frame update
void Start()
{
Party party = new Party();
party.cook = new Assets.Scripts.RobinsonCrusoe_Game.Characters.Cook();
new RoundSystem(new Castaways());
PartyHandler.CreateParty(party, 1);
SceneManager.LoadScene("GameScene");
}
protected virtual void OnGuestAdded(Character groupGuest)
{
this.ForEach(delegate(Character entry)
{
PartyHandler.SendPartyNewGuestMessage(entry.Client, this, groupGuest);
});
Party.MemberAddedHandler guestAdded = this.GuestAdded;
if (guestAdded != null)
{
guestAdded(this, groupGuest);
}
}
protected virtual void OnGuestPromoted(Character groupMember)
{
PartyHandler.SendPartyJoinMessage(groupMember.Client, this);
this.UpdateMember(groupMember);
this.BindEvents(groupMember);
Action <Party, Character> guestPromoted = this.GuestPromoted;
if (guestPromoted != null)
{
guestPromoted(this, groupMember);
}
}
protected virtual void OnGroupDisbanded()
{
this.ForEach(delegate(Character entry)
{
PartyHandler.SendPartyDeletedMessage(entry.Client, this);
});
this.UnBindEvents();
System.Action <Party> partyDeleted = this.PartyDeleted;
if (partyDeleted != null)
{
partyDeleted(this);
}
}
protected virtual void OnLeaderChanged(Character leader)
{
this.ForEach(delegate(Character entry)
{
PartyHandler.SendPartyLeaderUpdateMessage(entry.Client, this, leader);
});
Action <Party, Character> leaderChanged = this.LeaderChanged;
if (leaderChanged != null)
{
leaderChanged(this, leader);
}
}
protected virtual void OnGuestPromoted(Character groupMember)
{
m_clients.Add(groupMember.Client);
GroupLevelSum += groupMember.Level;
GroupLevelAverage = GroupLevelSum / MembersCount;
PartyHandler.SendPartyJoinMessage(groupMember.Client, this);
PartyHandler.SendPartyNewMemberMessage(Clients, this, groupMember);
BindEvents(groupMember);
GuestPromoted?.Invoke(this, groupMember);
}
public bool AddGuest(Character character)
{
if (!CanInvite(character, out var error))
{
PartyHandler.SendPartyCannotJoinErrorMessage(character.Client, this, error);
return(false);
}
lock (m_guestLocker)
m_guests.Add(character);
OnGuestAdded(character);
return(true);
}
public PartyNameErrorEnum?SetPartyName(string name)
{
const string PARTY_NAME_REGEX = @"^[A-z0-9\-\s]{2,24}$";
if (PartyManager.Instance.GetGroup(name) != null)
{
return(PartyNameErrorEnum.PARTY_NAME_ALREADY_USED);
}
if (!Regex.IsMatch(name, PARTY_NAME_REGEX))
{
return(PartyNameErrorEnum.PARTY_NAME_INVALID);
}
Name = name;
PartyHandler.SendPartyNameUpdateMessage(Clients, this);
return(null);
}
protected virtual void OnMemberRemoved(Character groupMember, bool kicked)
{
if (kicked)
{
PartyHandler.SendPartyKickedByMessage(groupMember.Client, this, this.Leader);
}
else
{
groupMember.Client.Send(new PartyLeaveMessage((uint)this.Id));
}
this.ForEach(delegate(Character entry)
{
PartyHandler.SendPartyMemberRemoveMessage(entry.Client, this, groupMember);
});
Party.MemberRemovedHandler memberRemoved = this.MemberRemoved;
this.UnBindEvents(groupMember);
if (memberRemoved != null)
{
memberRemoved(this, groupMember, kicked);
}
}
public void TaskOnClick()
{
if (canStart)
{
PartyHandler.CreateParty(TempoarySettings.Party, TempoarySettings.NumberOfPlayers);
new RoundSystem(new Castaways()); //TODO: add level selection
DifficultyHandler.Value = difficulty.GetComponent <Dropdown>().value;
//Analytics
var param = new Dictionary <string, object>();
int index = 0;
foreach (var character in PartyHandler.PartySession)
{
param.Add(character.CharacterName, index);
index++;
}
Analytics.CustomEvent("Party", param);
SceneManager.LoadScene("GameScene");
}
}
protected virtual void OnMemberRemoved(Character groupMember, bool kicked)
{
m_clients.Remove(groupMember.Client);
GroupLevelSum -= groupMember.Level;
GroupLevelAverage = MembersCount > 0 ? GroupLevelSum / MembersCount : 0;
if (kicked)
{
PartyHandler.SendPartyKickedByMessage(groupMember.Client, this, Leader);
}
else
{
groupMember.Client.Send(new PartyLeaveMessage(Id));
}
PartyHandler.SendPartyMemberRemoveMessage(Clients, this, groupMember);
var handler = MemberRemoved;
UnBindEvents(groupMember);
handler?.Invoke(this, groupMember, kicked);
}
public static void Handle(PacketReader packet, MapleClient c)
{
if (packet.Length >= 2)
{
if (ServerConstants.PrintPackets)
{
ServerConsole.Info("Receiving: {0}", Functions.ByteArrayToStr(packet.ToArray()));
}
RecvHeader header = (RecvHeader)packet.ReadHeader();
if (header <= RecvHeader.ErrorCode)
{
switch (header)
{
#region Miscellaneous
case RecvHeader.ErrorCode:
ErrorCodeHandler.Handle(c, packet);
break;
case RecvHeader.BlackCipher:
BlackCipherHandler.Handle(packet.ReadInt(), c);
break;
case RecvHeader.HandShake:
ReceiveHandShakeHandler.Handle(c, packet);
break;
case RecvHeader.CrashReport:
break;
case RecvHeader.Pong:
PongHandler.Handle(c);
break;
#endregion
#region Login Server
case RecvHeader.EnteredLoginScreen:
EnteredLoginScreenHandler.Handle(c);
break;
case RecvHeader.ClientLoaded:
ClientLoadedHandler.Handle(c);
break;
case RecvHeader.ShowServerList:
case RecvHeader.ReShowServerList:
ServerlistRequestHandler.Handle(c);
break;
case RecvHeader.WorldSelect:
WorldSelectHandler.Handle(packet.ReadShort(), c);
break;
case RecvHeader.CheckCharacterName:
CheckCharnameHandler.Handle(c, packet.ReadMapleString());
break;
case RecvHeader.CreateCharacter:
CreateCharHandler.Handle(c, packet);
break;
case RecvHeader.DeleteCharacter:
DeleteCharacterHandler.Handle(c, packet);
break;
case RecvHeader.SetAccountPic:
SetAccountPicHandler.Handle(c, packet);
break;
case RecvHeader.ChooseCharacterWithPic:
ChooseCharWithPicHandler.Handle(c, packet);
break;
case RecvHeader.EnterMap:
CharacterLoginHandler.Handle(c, packet);
break;
case RecvHeader.AccountLogin:
LoginAccountHandler.Handle(c, packet);
break;
case RecvHeader.ChooseChannel:
ChooseChannelHandler.Handle(c, packet);
break;
#endregion
default:
#if DEBUG
ServerConsole.Debug("Unhandled recv packet: {0}", Functions.ByteArrayToStr(packet.ToArray()));
#endif
break;
}
}
else
{
if (c.Account?.Character?.Map == null)
{
return;
}
switch (header)
{
#region GameServer
// Spam packets:
case RecvHeader.ClickDialog:
case RecvHeader.AttackSpam:
case RecvHeader.FinalPactEnd:
break;
case RecvHeader.PartyResponse:
PartyResponseHandler.Handle(c, packet);
break;
case RecvHeader.PartyOperation:
PartyHandler.Handle(c, packet);
break;
case RecvHeader.RequestRecommendedPartyMembers:
RecommendedPartyMembersHandler.Handle(c, packet);
break;
case RecvHeader.CharacterReceiveDamage:
CharacterReceiveDamage.Handle(c, packet);
break;
case RecvHeader.PlayerChat:
PlayerChatHandler.Handle(c, packet);
break;
case RecvHeader.SpecialChat:
SpecialChatHandler.Handle(c, packet);
break;
case RecvHeader.RequestWeeklyMapleStar:
WeeklyMapleStarHandler.Handle(c, packet);
return;
case RecvHeader.MoveCharacter:
MoveCharacterHandler.Handle(c, packet);
break;
case RecvHeader.EnterMapPortal:
EnterMapPortalHandler.Handle(c, packet);
break;
case RecvHeader.EnterDoor:
EnterDoorHandler.Handle(c, packet);
break;
case RecvHeader.MoveMob:
MoveMobHandler.Handle(c, packet);
break;
case RecvHeader.NpcChat:
NpcChatHandler.Handle(c, packet);
break;
case RecvHeader.NpcShopAction:
NpcShopActionHandler.Handle(c, packet);
break;
case RecvHeader.NpcAnimation:
NpcAnimationHandler.Handle(c, packet);
break;
case RecvHeader.NpcChatMore:
NpcChatMoreHandler.Handle(c, packet);
break;
case RecvHeader.FacialExpression:
FacialExpressionHandler.Handle(c, packet);
break;
case RecvHeader.MeleeAttack:
DealDamageHandler.HandleMelee(c, packet, header);
break;
case RecvHeader.RangedAttack:
DealDamageHandler.HandleRanged(c, packet);
break;
case RecvHeader.PassiveAttack:
case RecvHeader.MagicAttack:
DealDamageHandler.HandleMagic(c, packet);
break;
case RecvHeader.DistributeAp:
DistributeAPHandler.HandleSingle(c, packet);
break;
case RecvHeader.AutoAssignAp:
DistributeAPHandler.HandleDistribute(c, packet);
break;
case RecvHeader.DistributeSp:
DistributeSPHandler.Handle(c, packet);
break;
case RecvHeader.UseSkill:
UseSkillHandler.Handle(c, packet);
break;
case RecvHeader.MoveItem:
MoveItemHandler.Handle(c, packet);
break;
case RecvHeader.SlotMerge:
InventorySortHandler.HandleSlotMerge(c, packet);
break;
case RecvHeader.ItemSort:
InventorySortHandler.HandleItemSort(c, packet);
break;
case RecvHeader.ChangeChannel:
ChangeChannelHandler.Handle(c, packet);
break;
case RecvHeader.EnterCashShop:
EnterCSHandler.Handle(c, packet);
break;
case RecvHeader.AutoAggroMob:
AutoAggroHandler.Handle(c, packet);
break;
case RecvHeader.LootMapItem:
LootItemHandler.HandlePlayer(c, packet);
break;
case RecvHeader.RegenerateHpMp:
RegenerateHPMPHandler.Handle(c, packet);
break;
case RecvHeader.ChangeKeybind:
KeybindHandler.HandleKeyMapChange(c, packet);
break;
case RecvHeader.QuickSlotKeyMap:
KeybindHandler.HandleQuickSlotKeysChange(c, packet);
break;
case RecvHeader.CancelBuff:
CancelBuffHandler.Handle(c, packet);
break;
case RecvHeader.CharacterInfoRequest:
CharacterInfoRequest.Handle(c, packet);
break;
case RecvHeader.QuestAction:
QuestActionHandler.Handle(c, packet);
break;
case RecvHeader.EnterMapPortalSpecial:
EnterMapPortalSpecialHandler.Handle(c, packet);
break;
case RecvHeader.GuildAction:
GuildActionHandler.Handle(c, packet);
break;
case RecvHeader.DropMeso:
DropMesoHandler.Handle(c, packet);
break;
case RecvHeader.Trade:
TradeHandler.Handle(c, packet);
break;
case RecvHeader.UseConsumable:
UseItemHandler.Handle(c, packet);
break;
case RecvHeader.UseReturnScroll:
UseItemHandler.HandleReturnScroll(c, packet);
break;
case RecvHeader.UseEquipScroll:
UseScrollHandler.HandleRegularEquipScroll(c, packet);
break;
case RecvHeader.UseSpecialEquipScroll:
UseScrollHandler.HandleSpecialEquipScroll(c, packet);
break;
case RecvHeader.UseEquipEnhancementScroll:
UseScrollHandler.HandleEquipEnhancementScroll(c, packet);
break;
case RecvHeader.UseCashItem:
UseSpecialItemHandler.Handle(c, packet);
break;
case RecvHeader.UsePotentialScroll:
UseScrollHandler.HandlePotentialScroll(c, packet);
break;
case RecvHeader.UseBonusPotentialScroll:
UseScrollHandler.HandleBonusPotentialScroll(c, packet);
break;
case RecvHeader.UseCube:
UseScrollHandler.HandleCube(c, packet);
break;
case RecvHeader.UseMagnifyGlass:
UseMagnifyingGlassHandler.Handle(c, packet);
break;
case RecvHeader.SetSkillMacro:
SetSkillMacroHandler.Handle(c, packet);
break;
case RecvHeader.ProffesionReactorAction:
ProfessionReactorActionHandler.Handle(c, packet);
break;
case RecvHeader.ProffesionReactorDestroy:
ProfessionReactorActionHandler.HandleDestroy(c, packet);
break;
case RecvHeader.ReactorAction:
ReactorActionHandler.Handle(c, packet);
break;
case RecvHeader.CraftDone:
CraftHandler.HandleCraftDone(c, packet);
break;
case RecvHeader.CraftEffect:
CraftHandler.HandleCraftEffect(c, packet);
break;
case RecvHeader.CraftMake:
CraftHandler.HandleCraftMake(c, packet);
break;
case RecvHeader.CraftUnk:
CraftHandler.HandleUnk(c, packet);
break;
case RecvHeader.GainAranCombo:
AranComboHandler.HandleGain(c);
break;
case RecvHeader.DecayAranCombo:
AranComboHandler.HandleDecay(c);
break;
case RecvHeader.BlackBlessing:
BlackBlessingHandler.Handle(c);
break;
case RecvHeader.RequestHyperskillInfo:
HyperskillInfoRequestHandler.Handle(c, packet);
return;
case RecvHeader.SkillSwipe:
StealSkillHandler.HandleSkillSwipe(c, packet);
break;
case RecvHeader.ChooseStolenSkill:
StealSkillHandler.HandleChooseSkill(c, packet);
break;
case RecvHeader.StealSkill:
StealSkillHandler.HandleStealSkill(c, packet);
break;
case RecvHeader.MessengerOperation:
MapleMessengerHandler.Handle(c, packet);
break;
case RecvHeader.MoveSummon:
SummonHandler.HandleMove(c, packet);
break;
case RecvHeader.SummonAttack:
SummonHandler.HandleAttack(c, packet);
break;
case RecvHeader.SummonUseSkill:
SummonHandler.HandleSkill(c, packet);
break;
case RecvHeader.RemoveSummon:
SummonHandler.HandleRemove(c, packet);
break;
case RecvHeader.FindPlayer:
FindPlayerHandler.Handle(c, packet);
break;
case RecvHeader.BuddyOperation:
BuddyOperationHandler.Handle(c, packet);
break;
case RecvHeader.UseGoldenHammer:
UseGoldenHammerHandler.Handle(c, packet);
break;
#endregion
#region CashShop
case RecvHeader.CashshopSelect:
CashShop.Select(c, packet);
break;
#endregion
default:
#if DEBUG
ServerConsole.Debug("Unhandled recv packet: {0}", Functions.ByteArrayToStr(packet.ToArray()));
#endif
c.Account.Character.EnableActions();
break;
}
}
}
}
public static void ServerHandlerReceive(InPacket ip, Client gc)
{
var Header = ip.ReadShort(); // Read header
ip.ReadInt(); // Original length + CRC
ip.ReadInt();
#if DEBUG
Log.Hex("Received {0}({1}) packet from {2}: ", ip.Array, ((ClientOpcode)Header).ToString(), Header,
gc.Title);
#endif
switch ((ClientOpcode)Header)
{
// Game
case ClientOpcode.COMMAND_REQ:
GameHandler.Command_Req(ip, gc);
break;
case ClientOpcode.GAMELOG_REQ:
GameHandler.Game_Log_Req(ip, gc);
break;
case ClientOpcode.QUICK_SLOT_REQ:
GameHandler.Quick_Slot_Req(ip, gc);
break;
//2019-09-01 16:48 GMT+7
case ClientOpcode.CHARACTER_INFO_REQ: // OPCODE = 76 // Try Change test = E4
GameHandler.Character_Info_Req(ip, gc);
break;
case ClientOpcode.GAME_ISACTIVE:
GameHandler.GameisActive_Ack(ip, gc);
break;
// Shop
case ClientOpcode.NPC_SHOP_BUY_REQ:
NpcShopHandler.Buy_Req(ip, gc);
break;
case ClientOpcode.NPC_SHOP_SELL_REQ:
NpcShopHandler.Sell_Req(ip, gc);
break;
// Status
case ClientOpcode.CHAR_DAMAGE_REQ:
StatusHandler.Char_Damage_Req(ip, gc);
break;
case ClientOpcode.CHAR_DEAD_REQ:
StatusHandler.Char_Dead_Req(ip, gc);
break;
case ClientOpcode.CHAR_STATUP_REQ:
StatusHandler.Char_Statup_Req(ip, gc);
break;
case ClientOpcode.CHAR_FURY:
StatusHandler.Char_Fury_Req(ip, gc);
break;
// Inventory
case ClientOpcode.MOVE_ITEM_REQ:
InventoryHandler.MoveItem_Req(ip, gc);
break;
case ClientOpcode.INVEN_SELECTSLOT_REQ:
InventoryHandler.SelectSlot_Req(ip, gc);
break;
case ClientOpcode.USE_SPEND_REQ:
InventoryHandler.UseSpend_Req(ip, gc);
break;
case ClientOpcode.INVEN_USESPEND_REQ:
InventoryHandler.InvenUseSpendStart_Req(ip, gc);
break;
case ClientOpcode.INVEN_USESPEND_SHOUT_REQ:
case ClientOpcode.INVEN_USESPEND_SHOUT_ALL_REQ:
InventoryHandler.InvenUseSpendShout_Req(ip, gc);
break;
case ClientOpcode.PICKUP_ITEM:
InventoryHandler.PickupItem(ip, gc);
break;
// Skill
case ClientOpcode.SKILL_LEVELUP_REQ:
SkillHandler.SkillLevelUp_Req(ip, gc);
break;
//case ClientOpcode.USE_SKILL_REQ:
// SkillHandler.UseSkill_Req(ip, gc);
// break;
// Quest
case ClientOpcode.QUEST_ALL_REQ:
QuestHandler.Quest_All_Req(ip, gc);
break;
case ClientOpcode.QUEST_GIVEUP_REQ:
QuestHandler.Quest_GiveUp_Req(ip, gc);
break;
case ClientOpcode.QUEST_DONE_REQ:
QuestHandler.Quest_Done_Req(ip, gc);
break;
case ClientOpcode.QUEST_RETURN_REQ:
QuestHandler.Quest_Return_Req(ip, gc);
break;
case ClientOpcode.QUEST_DONE2_REQ:
QuestHandler.Quest_Done2_Req(ip, gc);
break;
case ClientOpcode.QUEST_UPDATE_REQ:
QuestHandler.Quest_Update_Req(ip, gc);
break;
// Map
case ClientOpcode.ENTER_WARP_ACK_REQ:
MapHandler.WarpToMap_Req(ip, gc);
break;
case ClientOpcode.CAN_WARP_ACK_REQ:
MapHandler.WarpToMapAuth_Req(ip, gc);
break;
// Monster
case ClientOpcode.ATTACK_MONSTER_REQ:
MonsterHandler.AttackMonster_Req(ip, gc);
break;
// Storage
case ClientOpcode.MOVE_ITEM_STORAGE_REQ:
StorageHandler.MoveItemToStorage(ip, gc);
break;
case ClientOpcode.MOVE_ITEM_TO_BAG_REQ:
StorageHandler.MoveItemToBag(ip, gc);
break;
case ClientOpcode.SAVE_MONEY_REQ:
StorageHandler.SaveStorageMoney(ip, gc);
break;
case ClientOpcode.GIVE_MONEY_REQ:
StorageHandler.GiveStorageMoney(ip, gc);
break;
// Coupon
case ClientOpcode.CASH_SN:
CouponHandler.Use_Coupon_Req(ip, gc);
break;
// Action
case ClientOpcode.P_WARP_C:
ActionHandler.p_Warp_c(ip, gc);
break;
case ClientOpcode.P_MOVE_C:
ActionHandler.p_Move_c(ip, gc);
break;
case ClientOpcode.P_JUMP_C:
ActionHandler.p_Jump_c(ip, gc);
break;
case ClientOpcode.P_SPEED_C:
ActionHandler.p_Speed_c(ip, gc);
break;
case ClientOpcode.P_ATTACK_C:
ActionHandler.p_Attack_c(ip, gc);
break;
//case ClientOpcode.P_DAMAGE_C:
// ActionHandler.p_Damage_c(ip, gc);
// break;
//case ClientOpcode.P_DEAD_C:
// ActionHandler.p_Dead_c(ip, gc);
// break;
case ClientOpcode.P_MOVE_C_2:
ActionHandler.p_Move_c_2(ip, gc);
break;
//case ClientOpcode.PET_MOVE_C:
// ActionHandler.Pet_Move_C(ip, gc);
// break;
//case ClientOpcode.PET_ATTACK_C:
// ActionHandler.Pet_Attack_C(ip, gc);
// break;
// Trade
case ClientOpcode.TRADE_INVITE_REQ:
TradeHandler.TradeInvite(ip, gc);
break;
case ClientOpcode.TRADE_INVITE_RESPONSE_REQ:
TradeHandler.TradeInviteResponses(ip, gc);
break;
case ClientOpcode.TRADE_READY_REQ:
TradeHandler.TradeReady(ip, gc);
break;
case ClientOpcode.TRADE_CONFIRM_REQ:
TradeHandler.TradeConfirm(ip, gc);
break;
case ClientOpcode.TRADE_CANCEL_REQ:
TradeHandler.TradeCancel(ip, gc);
break;
case ClientOpcode.TRADE_PUT_REQ:
TradeHandler.TradePutItem(ip, gc);
break;
// Party
case ClientOpcode.PARTY_INVITE_REQ:
PartyHandler.PartyInvite(ip, gc);
break;
case ClientOpcode.PARTY_INVITE_RESPONSES_REQ:
PartyHandler.PartyInviteResponses(ip, gc);
break;
case ClientOpcode.PARTY_LEAVE:
PartyHandler.PartyLeave(ip, gc);
break;
// PvP
case ClientOpcode.PVP_REQ:
PvPHandler.PvPInvite(ip, gc);
break;
case ClientOpcode.PVP_ACK_REQ:
PvPHandler.PvPInviteResponses(ip, gc);
break;
// PlayerShop
case ClientOpcode.PSHOP_OPEN_REQ:
PlayerShopHandler.OpenShop_Req(ip, gc);
break;
case ClientOpcode.PSHOP_SELLSTART_REQ:
PlayerShopHandler.SellStart_Req(ip, gc);
break;
case ClientOpcode.PSHOP_SELLEND_REQ:
PlayerShopHandler.SellEnd_Req(ip, gc);
break;
case ClientOpcode.PSHOP_INFO_REQ:
PlayerShopHandler.ShopInfo_Req(ip, gc);
break;
case ClientOpcode.PSHOP_BUYACK_REQ:
PlayerShopHandler.Buy_Req(ip, gc);
break;
// Fish
case ClientOpcode.FISH_REQ:
FishHandler.Fish_Req(ip, gc);
break;
// CashShop
//case ClientOpcode.CASHSHOP_LIST_REQ:
// CashShopHandler.CashShopList_Req(ip, gc);
// break;
case ClientOpcode.CASH_MGAMECASH_REQ:
CashShopHandler.MgameCash_Req(ip, gc);
break;
case ClientOpcode.CASH_BUY_REQ:
CashShopHandler.BuyCommodity_Req(ip, gc);
break;
case ClientOpcode.CASH_GIFT_REQ:
CashShopHandler.Gifts_Req(ip, gc);
break;
case ClientOpcode.CASH_TO_INVEN_REQ:
CashShopHandler.CommodityToInventory_Req(ip, gc);
break;
case ClientOpcode.ABILITY_RECOVER_REQ:
CashShopHandler.AbilityRecover_Req(ip, gc);
break;
case ClientOpcode.CASH_CHECKCHARNAME_REQ:
CashShopHandler.CheckName_Req(ip, gc);
break;
case ClientOpcode.DISMANTLE_REQ:
CashShopHandler.Dismantle_Req(ip, gc);
break;
// Pet
case ClientOpcode.PET_NAME_REQ:
PetHandler.Pet_Name_Req(ip, gc);
break;
case ClientOpcode.SPIRIT_MOVE_REQ:
SpiritHandler.SpiritMove(ip, gc);
break;
case ClientOpcode.EQUIPMENT_COMPOUND_REQ:
SpiritHandler.EquipmentCompound(ip, gc);
break;
case ClientOpcode.EVENTITEM_ACK:
TradeHandler.TradeEventItem(ip, gc);
break;
}
}
public OnlinePartyHub(DatabaseContext context)
{
_partyHandler = new PartyHandler(context);
_dbcontext = context;
}
/*
============================================================================
Init functions
============================================================================
*/
public void Init()
{
this.ClearData();
this.partyHandler = new PartyHandler();
if(Application.isPlaying)
{
if(this.levelHandler == null)
{
GameObject tmp = new GameObject("LevelHandler");
if(GUISystemType.ORK.Equals(DataHolder.GameSettings().guiSystemType))
{
this.levelHandler = (LevelHandler)tmp.AddComponent("LevelHandler");
}
else
{
this.levelHandler = (LevelHandlerGUI)tmp.AddComponent("LevelHandlerGUI");
}
}
if(this.musicHandler == null)
{
GameObject tmp = new GameObject("MusicHandler");
this.musicHandler = (MusicHandler)tmp.AddComponent("MusicHandler");
}
if(this.dropHandler == null)
{
GameObject tmp = new GameObject("DropHandler");
this.dropHandler = (DropHandler)tmp.AddComponent("DropHandler");
this.dropHandler.ClearData();
}
if(this.dragHandler == null)
{
GameObject tmp = new GameObject("DragHandler");
this.dragHandler = (DragHandler)tmp.AddComponent("DragHandler");
}
if(this.windowHandler == null)
{
this.windowHandler = new WindowHandler();
}
if(this.guiHandler == null)
{
GameObject tmp = new GameObject("GUIHandler");
this.guiHandler = (GUIHandler)tmp.AddComponent("GUIHandler");
}
}
}
public override void Display()
{
PartyHandler.SendPartyInvitationMessage(this.Target.Client, this.Party, this.Source);
}
protected virtual void OnLeaderChanged(Character leader)
{
PartyHandler.SendPartyLeaderUpdateMessage(Clients, this, leader);
LeaderChanged?.Invoke(this, leader);
}
public OnlinePartyController(DatabaseContext context)
{
_partyHandler = new PartyHandler(context);
_context = context;
}
public void TogglePartyFightRestriction(bool toggle)
{
RestrictFightToParty = toggle;
PartyHandler.SendPartyRestrictedMessage(Clients, this);
}
protected virtual void OnGuestAdded(Character groupGuest)
{
PartyHandler.SendPartyNewGuestMessage(Clients, this, groupGuest);
GuestAdded?.Invoke(this, groupGuest);
}
