From 77fc7042e4c79308ba3cbce28a93b7faedcdf065 Mon Sep 17 00:00:00 2001 From: Mili Date: Wed, 19 Oct 2022 23:27:08 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E4=BA=8B=E4=BB=B6?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../{StockFactory.cs => InventoryFactory.cs} | 2 +- FunGame.Core/Entity/Event/BuyItemEvent.cs | 57 +++++++++++++++++++ .../Entity/Event/ChangeAccountSettingEvent.cs | 57 +++++++++++++++++++ .../Entity/Event/ChangeProfileEvent.cs | 57 +++++++++++++++++++ .../Entity/Event/ChangeRoomSettingEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/CreateRoomEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/EndGameEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/IntoRoomEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/LoginEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/LogoutEvent.cs | 57 +++++++++++++++++++ .../Entity/Event/OpenInventoryEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/OpenStoreEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/QuitRoomEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/RegEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/SendTalkEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/ShowRankingEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/SignInEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/StartGameEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/StartMatchEvent.cs | 57 +++++++++++++++++++ FunGame.Core/Entity/Event/UseItemEvent.cs | 57 +++++++++++++++++++ .../Entity/General/{Stock.cs => Inventory.cs} | 2 +- FunGame.Core/Entity/General/User.cs | 2 +- FunGame.Core/Interface/Event/Events.cs | 10 ++-- FunGame.Desktop/Utils/SocketHelper.cs | 3 +- 24 files changed, 1093 insertions(+), 9 deletions(-) rename FunGame.Core/Api/Factory/{StockFactory.cs => InventoryFactory.cs} (86%) create mode 100644 FunGame.Core/Entity/Event/BuyItemEvent.cs create mode 100644 FunGame.Core/Entity/Event/ChangeAccountSettingEvent.cs create mode 100644 FunGame.Core/Entity/Event/ChangeProfileEvent.cs create mode 100644 FunGame.Core/Entity/Event/ChangeRoomSettingEvent.cs create mode 100644 FunGame.Core/Entity/Event/CreateRoomEvent.cs create mode 100644 FunGame.Core/Entity/Event/EndGameEvent.cs create mode 100644 FunGame.Core/Entity/Event/IntoRoomEvent.cs create mode 100644 FunGame.Core/Entity/Event/LoginEvent.cs create mode 100644 FunGame.Core/Entity/Event/LogoutEvent.cs create mode 100644 FunGame.Core/Entity/Event/OpenInventoryEvent.cs create mode 100644 FunGame.Core/Entity/Event/OpenStoreEvent.cs create mode 100644 FunGame.Core/Entity/Event/QuitRoomEvent.cs create mode 100644 FunGame.Core/Entity/Event/RegEvent.cs create mode 100644 FunGame.Core/Entity/Event/SendTalkEvent.cs create mode 100644 FunGame.Core/Entity/Event/ShowRankingEvent.cs create mode 100644 FunGame.Core/Entity/Event/SignInEvent.cs create mode 100644 FunGame.Core/Entity/Event/StartGameEvent.cs create mode 100644 FunGame.Core/Entity/Event/StartMatchEvent.cs create mode 100644 FunGame.Core/Entity/Event/UseItemEvent.cs rename FunGame.Core/Entity/General/{Stock.cs => Inventory.cs} (94%) diff --git a/FunGame.Core/Api/Factory/StockFactory.cs b/FunGame.Core/Api/Factory/InventoryFactory.cs similarity index 86% rename from FunGame.Core/Api/Factory/StockFactory.cs rename to FunGame.Core/Api/Factory/InventoryFactory.cs index bee0ed8..3378d26 100644 --- a/FunGame.Core/Api/Factory/StockFactory.cs +++ b/FunGame.Core/Api/Factory/InventoryFactory.cs @@ -7,7 +7,7 @@ using System.Threading.Tasks; namespace Milimoe.FunGame.Core.Api.Factory { - public class StockFactory + public class InventoryFactory { } diff --git a/FunGame.Core/Entity/Event/BuyItemEvent.cs b/FunGame.Core/Entity/Event/BuyItemEvent.cs new file mode 100644 index 0000000..a9f8a0a --- /dev/null +++ b/FunGame.Core/Entity/Event/BuyItemEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class BuyItemEvent : IBuyItemEvent + { + public event IEvent.BeforeEvent? BeforeBuyItemEvent; + public event IEvent.AfterEvent? AfterBuyItemEvent; + public event IEvent.SucceedEvent? SucceedBuyItemEvent; + public event IEvent.FailedEvent? FailedBuyItemEvent; + + public virtual Enum.EventResult OnBeforeBuyItemEvent(GeneralEventArgs e) + { + if (BeforeBuyItemEvent != null) + { + return BeforeBuyItemEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterBuyItemEvent(GeneralEventArgs e) + { + if (AfterBuyItemEvent != null) + { + return AfterBuyItemEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedBuyItemEvent(GeneralEventArgs e) + { + if (SucceedBuyItemEvent != null) + { + return SucceedBuyItemEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedBuyItemEvent(GeneralEventArgs e) + { + if (FailedBuyItemEvent != null) + { + return FailedBuyItemEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/ChangeAccountSettingEvent.cs b/FunGame.Core/Entity/Event/ChangeAccountSettingEvent.cs new file mode 100644 index 0000000..a38251a --- /dev/null +++ b/FunGame.Core/Entity/Event/ChangeAccountSettingEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class ChangeAccountSettingEvent : IChangeAccountSettingEvent + { + public event IEvent.BeforeEvent? BeforeChangeAccountSettingEvent; + public event IEvent.AfterEvent? AfterChangeAccountSettingEvent; + public event IEvent.SucceedEvent? SucceedChangeAccountSettingEvent; + public event IEvent.FailedEvent? FailedChangeAccountSettingEvent; + + public virtual Enum.EventResult OnBeforeChangeAccountSettingEvent(GeneralEventArgs e) + { + if (BeforeChangeAccountSettingEvent != null) + { + return BeforeChangeAccountSettingEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterChangeAccountSettingEvent(GeneralEventArgs e) + { + if (AfterChangeAccountSettingEvent != null) + { + return AfterChangeAccountSettingEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedChangeAccountSettingEvent(GeneralEventArgs e) + { + if (SucceedChangeAccountSettingEvent != null) + { + return SucceedChangeAccountSettingEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedChangeAccountSettingEvent(GeneralEventArgs e) + { + if (FailedChangeAccountSettingEvent != null) + { + return FailedChangeAccountSettingEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/ChangeProfileEvent.cs b/FunGame.Core/Entity/Event/ChangeProfileEvent.cs new file mode 100644 index 0000000..f39d7e1 --- /dev/null +++ b/FunGame.Core/Entity/Event/ChangeProfileEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class ChangeProfileEvent : IChangeProfileEvent + { + public event IEvent.BeforeEvent? BeforeChangeProfileEvent; + public event IEvent.AfterEvent? AfterChangeProfileEvent; + public event IEvent.SucceedEvent? SucceedChangeProfileEvent; + public event IEvent.FailedEvent? FailedChangeProfileEvent; + + public virtual Enum.EventResult OnBeforeChangeProfileEvent(GeneralEventArgs e) + { + if (BeforeChangeProfileEvent != null) + { + return BeforeChangeProfileEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterChangeProfileEvent(GeneralEventArgs e) + { + if (AfterChangeProfileEvent != null) + { + return AfterChangeProfileEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedChangeProfileEvent(GeneralEventArgs e) + { + if (SucceedChangeProfileEvent != null) + { + return SucceedChangeProfileEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedChangeProfileEvent(GeneralEventArgs e) + { + if (FailedChangeProfileEvent != null) + { + return FailedChangeProfileEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/ChangeRoomSettingEvent.cs b/FunGame.Core/Entity/Event/ChangeRoomSettingEvent.cs new file mode 100644 index 0000000..4dbb581 --- /dev/null +++ b/FunGame.Core/Entity/Event/ChangeRoomSettingEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class ChangeRoomSettingEvent : IChangeRoomSettingEvent + { + public event IEvent.BeforeEvent? BeforeChangeRoomSettingEvent; + public event IEvent.AfterEvent? AfterChangeRoomSettingEvent; + public event IEvent.SucceedEvent? SucceedChangeRoomSettingEvent; + public event IEvent.FailedEvent? FailedChangeRoomSettingEvent; + + public virtual Enum.EventResult OnBeforeChangeRoomSettingEvent(GeneralEventArgs e) + { + if (BeforeChangeRoomSettingEvent != null) + { + return BeforeChangeRoomSettingEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterChangeRoomSettingEvent(GeneralEventArgs e) + { + if (AfterChangeRoomSettingEvent != null) + { + return AfterChangeRoomSettingEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedChangeRoomSettingEvent(GeneralEventArgs e) + { + if (SucceedChangeRoomSettingEvent != null) + { + return SucceedChangeRoomSettingEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedChangeRoomSettingEvent(GeneralEventArgs e) + { + if (FailedChangeRoomSettingEvent != null) + { + return FailedChangeRoomSettingEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/CreateRoomEvent.cs b/FunGame.Core/Entity/Event/CreateRoomEvent.cs new file mode 100644 index 0000000..7e56cf1 --- /dev/null +++ b/FunGame.Core/Entity/Event/CreateRoomEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class CreateRoomEvent : ICreateRoomEvent + { + public event IEvent.BeforeEvent? BeforeCreateRoomEvent; + public event IEvent.AfterEvent? AfterCreateRoomEvent; + public event IEvent.SucceedEvent? SucceedCreateRoomEvent; + public event IEvent.FailedEvent? FailedCreateRoomEvent; + + public virtual Enum.EventResult OnBeforeCreateRoomEvent(GeneralEventArgs e) + { + if (BeforeCreateRoomEvent != null) + { + return BeforeCreateRoomEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterCreateRoomEvent(GeneralEventArgs e) + { + if (AfterCreateRoomEvent != null) + { + return AfterCreateRoomEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedCreateRoomEvent(GeneralEventArgs e) + { + if (SucceedCreateRoomEvent != null) + { + return SucceedCreateRoomEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedCreateRoomEvent(GeneralEventArgs e) + { + if (FailedCreateRoomEvent != null) + { + return FailedCreateRoomEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/EndGameEvent.cs b/FunGame.Core/Entity/Event/EndGameEvent.cs new file mode 100644 index 0000000..cf34c7c --- /dev/null +++ b/FunGame.Core/Entity/Event/EndGameEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class EndGameEvent : IEndGameEvent + { + public event IEvent.BeforeEvent? BeforeEndGameEvent; + public event IEvent.AfterEvent? AfterEndGameEvent; + public event IEvent.SucceedEvent? SucceedEndGameEvent; + public event IEvent.FailedEvent? FailedEndGameEvent; + + public virtual Enum.EventResult OnBeforeEndGameEvent(GeneralEventArgs e) + { + if (BeforeEndGameEvent != null) + { + return BeforeEndGameEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterEndGameEvent(GeneralEventArgs e) + { + if (AfterEndGameEvent != null) + { + return AfterEndGameEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedEndGameEvent(GeneralEventArgs e) + { + if (SucceedEndGameEvent != null) + { + return SucceedEndGameEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedEndGameEvent(GeneralEventArgs e) + { + if (FailedEndGameEvent != null) + { + return FailedEndGameEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/IntoRoomEvent.cs b/FunGame.Core/Entity/Event/IntoRoomEvent.cs new file mode 100644 index 0000000..39d3fd0 --- /dev/null +++ b/FunGame.Core/Entity/Event/IntoRoomEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class IntoRoomEvent : IIntoRoomEvent + { + public event IEvent.BeforeEvent? BeforeIntoRoomEvent; + public event IEvent.AfterEvent? AfterIntoRoomEvent; + public event IEvent.SucceedEvent? SucceedIntoRoomEvent; + public event IEvent.FailedEvent? FailedIntoRoomEvent; + + public virtual Enum.EventResult OnBeforeIntoRoomEvent(GeneralEventArgs e) + { + if (BeforeIntoRoomEvent != null) + { + return BeforeIntoRoomEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterIntoRoomEvent(GeneralEventArgs e) + { + if (AfterIntoRoomEvent != null) + { + return AfterIntoRoomEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedIntoRoomEvent(GeneralEventArgs e) + { + if (SucceedIntoRoomEvent != null) + { + return SucceedIntoRoomEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedIntoRoomEvent(GeneralEventArgs e) + { + if (FailedIntoRoomEvent != null) + { + return FailedIntoRoomEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/LoginEvent.cs b/FunGame.Core/Entity/Event/LoginEvent.cs new file mode 100644 index 0000000..befa93f --- /dev/null +++ b/FunGame.Core/Entity/Event/LoginEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class LoginEvent : ILoginEvent + { + public event IEvent.BeforeEvent? BeforeLoginEvent; + public event IEvent.AfterEvent? AfterLoginEvent; + public event IEvent.SucceedEvent? SucceedLoginEvent; + public event IEvent.FailedEvent? FailedLoginEvent; + + public virtual Enum.EventResult OnBeforeLoginEvent(GeneralEventArgs e) + { + if (BeforeLoginEvent != null) + { + return BeforeLoginEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterLoginEvent(GeneralEventArgs e) + { + if (AfterLoginEvent != null) + { + return AfterLoginEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedLoginEvent(GeneralEventArgs e) + { + if (SucceedLoginEvent != null) + { + return SucceedLoginEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedLoginEvent(GeneralEventArgs e) + { + if (FailedLoginEvent != null) + { + return FailedLoginEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/LogoutEvent.cs b/FunGame.Core/Entity/Event/LogoutEvent.cs new file mode 100644 index 0000000..8adc353 --- /dev/null +++ b/FunGame.Core/Entity/Event/LogoutEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class LogoutEvent : ILogoutEvent + { + public event IEvent.BeforeEvent? BeforeLogoutEvent; + public event IEvent.AfterEvent? AfterLogoutEvent; + public event IEvent.SucceedEvent? SucceedLogoutEvent; + public event IEvent.FailedEvent? FailedLogoutEvent; + + public virtual Enum.EventResult OnBeforeLogoutEvent(GeneralEventArgs e) + { + if (BeforeLogoutEvent != null) + { + return BeforeLogoutEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterLogoutEvent(GeneralEventArgs e) + { + if (AfterLogoutEvent != null) + { + return AfterLogoutEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedLogoutEvent(GeneralEventArgs e) + { + if (SucceedLogoutEvent != null) + { + return SucceedLogoutEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedLogoutEvent(GeneralEventArgs e) + { + if (FailedLogoutEvent != null) + { + return FailedLogoutEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/OpenInventoryEvent.cs b/FunGame.Core/Entity/Event/OpenInventoryEvent.cs new file mode 100644 index 0000000..c566000 --- /dev/null +++ b/FunGame.Core/Entity/Event/OpenInventoryEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class OpenInventoryEvent : IOpenInventoryEvent + { + public event IEvent.BeforeEvent? BeforeOpenInventoryEvent; + public event IEvent.AfterEvent? AfterOpenInventoryEvent; + public event IEvent.SucceedEvent? SucceedOpenInventoryEvent; + public event IEvent.FailedEvent? FailedOpenInventoryEvent; + + public virtual Enum.EventResult OnBeforeOpenInventoryEvent(GeneralEventArgs e) + { + if (BeforeOpenInventoryEvent != null) + { + return BeforeOpenInventoryEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterOpenInventoryEvent(GeneralEventArgs e) + { + if (AfterOpenInventoryEvent != null) + { + return AfterOpenInventoryEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedOpenInventoryEvent(GeneralEventArgs e) + { + if (SucceedOpenInventoryEvent != null) + { + return SucceedOpenInventoryEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedOpenInventoryEvent(GeneralEventArgs e) + { + if (FailedOpenInventoryEvent != null) + { + return FailedOpenInventoryEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/OpenStoreEvent.cs b/FunGame.Core/Entity/Event/OpenStoreEvent.cs new file mode 100644 index 0000000..5f3bab5 --- /dev/null +++ b/FunGame.Core/Entity/Event/OpenStoreEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class OpenStoreEvent : IOpenStoreEvent + { + public event IEvent.BeforeEvent? BeforeOpenStoreEvent; + public event IEvent.AfterEvent? AfterOpenStoreEvent; + public event IEvent.SucceedEvent? SucceedOpenStoreEvent; + public event IEvent.FailedEvent? FailedOpenStoreEvent; + + public virtual Enum.EventResult OnBeforeOpenStoreEvent(GeneralEventArgs e) + { + if (BeforeOpenStoreEvent != null) + { + return BeforeOpenStoreEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterOpenStoreEvent(GeneralEventArgs e) + { + if (AfterOpenStoreEvent != null) + { + return AfterOpenStoreEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedOpenStoreEvent(GeneralEventArgs e) + { + if (SucceedOpenStoreEvent != null) + { + return SucceedOpenStoreEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedOpenStoreEvent(GeneralEventArgs e) + { + if (FailedOpenStoreEvent != null) + { + return FailedOpenStoreEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/QuitRoomEvent.cs b/FunGame.Core/Entity/Event/QuitRoomEvent.cs new file mode 100644 index 0000000..51e7c1b --- /dev/null +++ b/FunGame.Core/Entity/Event/QuitRoomEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class QuitRoomEvent : IQuitRoomEvent + { + public event IEvent.BeforeEvent? BeforeQuitRoomEvent; + public event IEvent.AfterEvent? AfterQuitRoomEvent; + public event IEvent.SucceedEvent? SucceedQuitRoomEvent; + public event IEvent.FailedEvent? FailedQuitRoomEvent; + + public virtual Enum.EventResult OnBeforeQuitRoomEvent(GeneralEventArgs e) + { + if (BeforeQuitRoomEvent != null) + { + return BeforeQuitRoomEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterQuitRoomEvent(GeneralEventArgs e) + { + if (AfterQuitRoomEvent != null) + { + return AfterQuitRoomEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedQuitRoomEvent(GeneralEventArgs e) + { + if (SucceedQuitRoomEvent != null) + { + return SucceedQuitRoomEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedQuitRoomEvent(GeneralEventArgs e) + { + if (FailedQuitRoomEvent != null) + { + return FailedQuitRoomEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/RegEvent.cs b/FunGame.Core/Entity/Event/RegEvent.cs new file mode 100644 index 0000000..62d7e63 --- /dev/null +++ b/FunGame.Core/Entity/Event/RegEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class RegEvent : IRegEvent + { + public event IEvent.BeforeEvent? BeforeRegEvent; + public event IEvent.AfterEvent? AfterRegEvent; + public event IEvent.SucceedEvent? SucceedRegEvent; + public event IEvent.FailedEvent? FailedRegEvent; + + public virtual Enum.EventResult OnBeforeRegEvent(GeneralEventArgs e) + { + if (BeforeRegEvent != null) + { + return BeforeRegEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterRegEvent(GeneralEventArgs e) + { + if (AfterRegEvent != null) + { + return AfterRegEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedRegEvent(GeneralEventArgs e) + { + if (SucceedRegEvent != null) + { + return SucceedRegEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedRegEvent(GeneralEventArgs e) + { + if (FailedRegEvent != null) + { + return FailedRegEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/SendTalkEvent.cs b/FunGame.Core/Entity/Event/SendTalkEvent.cs new file mode 100644 index 0000000..93a6873 --- /dev/null +++ b/FunGame.Core/Entity/Event/SendTalkEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class SendTalkEvent : ISendTalkEvent + { + public event IEvent.BeforeEvent? BeforeSendTalkEvent; + public event IEvent.AfterEvent? AfterSendTalkEvent; + public event IEvent.SucceedEvent? SucceedSendTalkEvent; + public event IEvent.FailedEvent? FailedSendTalkEvent; + + public virtual Enum.EventResult OnBeforeSendTalkEvent(GeneralEventArgs e) + { + if (BeforeSendTalkEvent != null) + { + return BeforeSendTalkEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterSendTalkEvent(GeneralEventArgs e) + { + if (AfterSendTalkEvent != null) + { + return AfterSendTalkEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedSendTalkEvent(GeneralEventArgs e) + { + if (SucceedSendTalkEvent != null) + { + return SucceedSendTalkEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedSendTalkEvent(GeneralEventArgs e) + { + if (FailedSendTalkEvent != null) + { + return FailedSendTalkEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/ShowRankingEvent.cs b/FunGame.Core/Entity/Event/ShowRankingEvent.cs new file mode 100644 index 0000000..05c4d94 --- /dev/null +++ b/FunGame.Core/Entity/Event/ShowRankingEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class ShowRankingEvent : IShowRankingEvent + { + public event IEvent.BeforeEvent? BeforeShowRankingEvent; + public event IEvent.AfterEvent? AfterShowRankingEvent; + public event IEvent.SucceedEvent? SucceedShowRankingEvent; + public event IEvent.FailedEvent? FailedShowRankingEvent; + + public virtual Enum.EventResult OnBeforeShowRankingEvent(GeneralEventArgs e) + { + if (BeforeShowRankingEvent != null) + { + return BeforeShowRankingEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterShowRankingEvent(GeneralEventArgs e) + { + if (AfterShowRankingEvent != null) + { + return AfterShowRankingEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedShowRankingEvent(GeneralEventArgs e) + { + if (SucceedShowRankingEvent != null) + { + return SucceedShowRankingEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedShowRankingEvent(GeneralEventArgs e) + { + if (FailedShowRankingEvent != null) + { + return FailedShowRankingEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/SignInEvent.cs b/FunGame.Core/Entity/Event/SignInEvent.cs new file mode 100644 index 0000000..b084ec4 --- /dev/null +++ b/FunGame.Core/Entity/Event/SignInEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class SignInEvent : ISignInEvent + { + public event IEvent.BeforeEvent? BeforeSignInEvent; + public event IEvent.AfterEvent? AfterSignInEvent; + public event IEvent.SucceedEvent? SucceedSignInEvent; + public event IEvent.FailedEvent? FailedSignInEvent; + + public virtual Enum.EventResult OnBeforeSignInEvent(GeneralEventArgs e) + { + if (BeforeSignInEvent != null) + { + return BeforeSignInEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterSignInEvent(GeneralEventArgs e) + { + if (AfterSignInEvent != null) + { + return AfterSignInEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedSignInEvent(GeneralEventArgs e) + { + if (SucceedSignInEvent != null) + { + return SucceedSignInEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedSignInEvent(GeneralEventArgs e) + { + if (FailedSignInEvent != null) + { + return FailedSignInEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/StartGameEvent.cs b/FunGame.Core/Entity/Event/StartGameEvent.cs new file mode 100644 index 0000000..28f674b --- /dev/null +++ b/FunGame.Core/Entity/Event/StartGameEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class StartGameEvent : IStartGameEvent + { + public event IEvent.BeforeEvent? BeforeStartGameEvent; + public event IEvent.AfterEvent? AfterStartGameEvent; + public event IEvent.SucceedEvent? SucceedStartGameEvent; + public event IEvent.FailedEvent? FailedStartGameEvent; + + public virtual Enum.EventResult OnBeforeStartGameEvent(GeneralEventArgs e) + { + if (BeforeStartGameEvent != null) + { + return BeforeStartGameEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterStartGameEvent(GeneralEventArgs e) + { + if (AfterStartGameEvent != null) + { + return AfterStartGameEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedStartGameEvent(GeneralEventArgs e) + { + if (SucceedStartGameEvent != null) + { + return SucceedStartGameEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedStartGameEvent(GeneralEventArgs e) + { + if (FailedStartGameEvent != null) + { + return FailedStartGameEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/StartMatchEvent.cs b/FunGame.Core/Entity/Event/StartMatchEvent.cs new file mode 100644 index 0000000..fa7d385 --- /dev/null +++ b/FunGame.Core/Entity/Event/StartMatchEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class StartMatchEvent : IStartMatchEvent + { + public event IEvent.BeforeEvent? BeforeStartMatchEvent; + public event IEvent.AfterEvent? AfterStartMatchEvent; + public event IEvent.SucceedEvent? SucceedStartMatchEvent; + public event IEvent.FailedEvent? FailedStartMatchEvent; + + public virtual Enum.EventResult OnBeforeStartMatchEvent(GeneralEventArgs e) + { + if (BeforeStartMatchEvent != null) + { + return BeforeStartMatchEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterStartMatchEvent(GeneralEventArgs e) + { + if (AfterStartMatchEvent != null) + { + return AfterStartMatchEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedStartMatchEvent(GeneralEventArgs e) + { + if (SucceedStartMatchEvent != null) + { + return SucceedStartMatchEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedStartMatchEvent(GeneralEventArgs e) + { + if (FailedStartMatchEvent != null) + { + return FailedStartMatchEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/Event/UseItemEvent.cs b/FunGame.Core/Entity/Event/UseItemEvent.cs new file mode 100644 index 0000000..6d49084 --- /dev/null +++ b/FunGame.Core/Entity/Event/UseItemEvent.cs @@ -0,0 +1,57 @@ +using Milimoe.FunGame.Core.Interface; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Milimoe.FunGame.Core.Entity.Event +{ + public class UseItemEvent : IUseItemEvent + { + public event IEvent.BeforeEvent? BeforeUseItemEvent; + public event IEvent.AfterEvent? AfterUseItemEvent; + public event IEvent.SucceedEvent? SucceedUseItemEvent; + public event IEvent.FailedEvent? FailedUseItemEvent; + + public virtual Enum.EventResult OnBeforeUseItemEvent(GeneralEventArgs e) + { + if (BeforeUseItemEvent != null) + { + return BeforeUseItemEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnAfterUseItemEvent(GeneralEventArgs e) + { + if (AfterUseItemEvent != null) + { + return AfterUseItemEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnSucceedUseItemEvent(GeneralEventArgs e) + { + if (SucceedUseItemEvent != null) + { + return SucceedUseItemEvent(this, e); + } + + return Enum.EventResult.Fail; + } + + public virtual Enum.EventResult OnFailedUseItemEvent(GeneralEventArgs e) + { + if (FailedUseItemEvent != null) + { + return FailedUseItemEvent(this, e); + } + + return Enum.EventResult.Fail; + } + } +} diff --git a/FunGame.Core/Entity/General/Stock.cs b/FunGame.Core/Entity/General/Inventory.cs similarity index 94% rename from FunGame.Core/Entity/General/Stock.cs rename to FunGame.Core/Entity/General/Inventory.cs index 47efa0b..c0ddb81 100644 --- a/FunGame.Core/Entity/General/Stock.cs +++ b/FunGame.Core/Entity/General/Inventory.cs @@ -7,7 +7,7 @@ using System.Threading.Tasks; namespace Milimoe.FunGame.Core.Entity.General { - public class Stock + public class Inventory { public int Id { get; set; } public string Name { get; set; } = ""; diff --git a/FunGame.Core/Entity/General/User.cs b/FunGame.Core/Entity/General/User.cs index 8636672..cca43b6 100644 --- a/FunGame.Core/Entity/General/User.cs +++ b/FunGame.Core/Entity/General/User.cs @@ -24,7 +24,7 @@ namespace Milimoe.FunGame.Core.Entity.General public decimal Materials { get; set; } = 0; public decimal GameTime { get; set; } = 0; public UserStatistics? Statistics { get; set; } = null; - public Stock? Stock { get; set; } = null; + public Inventory? Stock { get; set; } = null; internal User() { diff --git a/FunGame.Core/Interface/Event/Events.cs b/FunGame.Core/Interface/Event/Events.cs index 957491d..1f092cf 100644 --- a/FunGame.Core/Interface/Event/Events.cs +++ b/FunGame.Core/Interface/Event/Events.cs @@ -127,12 +127,12 @@ namespace Milimoe.FunGame.Core.Interface public event FailedEvent FailedChangeAccountSettingEvent; } - public interface IOpenStockEvent : IEvent + public interface IOpenInventoryEvent : IEvent { - public event BeforeEvent BeforeOpenStockEvent; - public event AfterEvent AfterOpenStockEvent; - public event SucceedEvent SucceedOpenStockEvent; - public event FailedEvent FailedOpenStockEvent; + public event BeforeEvent BeforeOpenInventoryEvent; + public event AfterEvent AfterOpenInventoryEvent; + public event SucceedEvent SucceedOpenInventoryEvent; + public event FailedEvent FailedOpenInventoryEvent; } public interface ISignInEvent : IEvent diff --git a/FunGame.Desktop/Utils/SocketHelper.cs b/FunGame.Desktop/Utils/SocketHelper.cs index a67d831..bbee433 100644 --- a/FunGame.Desktop/Utils/SocketHelper.cs +++ b/FunGame.Desktop/Utils/SocketHelper.cs @@ -13,6 +13,7 @@ using Milimoe.FunGame.Core.Entity.Enum; using Milimoe.FunGame.Desktop.Others; using Milimoe.FunGame.Desktop.UI; using Milimoe.FunGame.Core.Api.Utility; +using Milimoe.FunGame.Core.Api.Factory; namespace Milimoe.FunGame.Desktop.Utils { @@ -51,7 +52,7 @@ namespace Milimoe.FunGame.Desktop.Utils case (int)SocketHelperMethod.Login: if (client != null) { - Send((int)SocketMessageType.CheckLogin, new object[] { Main, client, new User("Mili") }); + Send((int)SocketMessageType.CheckLogin, new object[] { Main, client, UserFactory.GetInstance("Mili") }); return true; } return false;