/// <inheritdoc />
public void Execute(IEntity entity, SystemEventArgs args)
{
if (entity == null)
{
this._logger.LogError($"Cannot execute {nameof(SpecialEffectSystem)}. Entity is null.");
return;
}
if (!args.GetCheckArguments())
{
this._logger.LogError($"Cannot execute {nameof(SpecialEffectSystem)} action: {args.GetType()} due to invalid arguments.");
return;
}
switch (args)
{
case SpecialEffectEventArgs e:
this.StartSpecialEffect(entity, e);
break;
case SpecialEffectBaseMotionEventArgs e:
this.SetStateModeBaseMotion(entity, e);
break;
}
}
/// <inheritdoc />
public void Execute(IEntity entity, SystemEventArgs args)
{
if (!(entity is IPlayerEntity player))
{
this._logger.LogError($"Cannot execute Level System. {entity.Object.Name} is not a player.");
return;
}
if (!args.GetCheckArguments())
{
this._logger.LogError($"Cannot execute Level System action: {args.GetType()} due to invalid arguments.");
return;
}
switch (args)
{
case ExperienceEventArgs e:
this.GiveExperience(player, e);
break;
default:
this._logger.LogWarning("Unknown level system action type: {0} for player {1}", args.GetType(), entity.Object.Name);
break;
}
}
/// <inheritdoc />
public void Execute(IEntity entity, SystemEventArgs args)
{
if (args == null)
{
Logger.LogError($"Cannot execute {nameof(DropSystem)}. Arguments are null.");
return;
}
if (!args.CheckArguments())
{
Logger.LogError($"Cannot execute {nameof(DropSystem)} action: {args.GetType()} due to invalid arguments.");
return;
}
switch (args)
{
case DropItemEventArgs dropItemEventArgs:
this.DropItem(entity, dropItemEventArgs);
break;
case DropGoldEventArgs dropGoldEventArgs:
this.DropGold(entity, dropGoldEventArgs);
break;
}
}
/// <summary>
/// Executes the <see cref="VisibilitySystem"/> logic.
/// </summary>
/// <param name="entity">Current entity</param>
public void Execute(IEntity entity, SystemEventArgs args)
{
var currentMap = entity.Context as IMapInstance;
IMapLayer currentMapLayer = currentMap?.GetMapLayer(entity.Object.LayerId);
if (currentMapLayer != null)
{
UpdateEntitiesVisibility(entity, currentMapLayer.Entities);
}
if (currentMap != null)
{
UpdateEntitiesVisibility(entity, currentMap?.Entities);
}
if (entity.Type == WorldEntityType.Player)
{
foreach (var region in currentMapLayer.Regions)
{
if (!region.IsActive && entity.Object.Position.Intersects(region.GetRectangle(), VisibilityRange))
{
region.IsActive = true;
}
if (region.IsActive && region is IMapRespawnRegion respawner)
{
UpdateEntitiesVisibility(entity, respawner.Entities);
}
}
}
}
/// <inheritdoc />
public void Execute(IEntity entity, SystemEventArgs e)
{
if (!(entity is IPlayerEntity player) ||
!e.CheckArguments())
{
Logger.Error("NpcShopSystem: Invalid event arguments.");
return;
}
switch (e)
{
case NpcShopOpenEventArgs npcShopEventArgs:
this.OpenShop(player, npcShopEventArgs);
break;
case NpcShopCloseEventArgs npcShopEventArgs:
this.CloseShop(player);
break;
case NpcShopBuyEventArgs npcShopEventArgs:
this.BuyItem(player, npcShopEventArgs);
break;
case NpcShopSellEventArgs npcShopEventArgs:
this.SellItem(player, npcShopEventArgs);
break;
default:
Logger.Warn("Unknown NpcShop action type: {0} for player {1}", e.GetType(), entity.Object.Name);
break;
}
}
/// <inheritdoc />
public void Execute(IEntity entity, SystemEventArgs args)
{
if (!(entity is IPlayerEntity player))
{
this._logger.LogError($"Cannot execute {nameof(RecoverySystem)}. {entity.Object.Name} is not a player.");
return;
}
if (!args.GetCheckArguments())
{
this._logger.LogError($"Cannot execute {nameof(RecoverySystem)} action: {args.GetType()} due to invalid arguments.");
return;
}
switch (args)
{
case IdleRecoveryEventArgs e:
this.IdleHeal(player, e);
break;
default:
this._logger.LogWarning($"Unknown recovery system action type: {args.GetType()} for player {entity.Object.Name}");
break;
}
}
public override void Execute(IEntity entity, SystemEventArgs e)
{
switch (e)
{
case PlayerChatEventArg playerChatEvent:
PlayerChat(entity, playerChatEvent);
break;
}
}
public void NotifySystems(IEntity sender, SystemEventArgs args)
{
lock (_systems)
{
foreach (var system in _systems)
{
system.Value.OnNotification(sender, args);
}
}
}
public void NotifySystem <TSystem>(IEntity sender, SystemEventArgs args) where TSystem : ISystem
{
lock (_systems)
{
if (_systems.TryGetValue(typeof(TSystem), out ISystem system))
{
system.OnNotification(sender, args);
}
}
}
public void OnNotification(IEntity entity, SystemEventArgs args)
{
switch (args)
{
case ClientConnectedEventArgs ccea:
entity.Send(new ProtocolRequiredMessage());
entity.Send(new HelloGameMessage());
break;
}
}
/// <summary>
/// Executes the <see cref="MobilitySystem"/> logic.
/// </summary>
/// <param name="entity">Current entity</param>
public void Execute(IEntity entity, SystemEventArgs args)
{
var movableEntity = entity as IMovableEntity;
if (movableEntity.MovableComponent.DestinationPosition.IsZero())
{
return;
}
this.Walk(movableEntity);
}
/// <inheritdoc />
public void Execute(IEntity entity, SystemEventArgs args)
{
if (!(entity is IPlayerEntity player))
{
this._logger.LogError($"Cannot execute DeathSystem. {entity.Object.Name} is not a player.");
return;
}
IMapRevivalRegion revivalRegion = player.Object.CurrentMap.GetNearRevivalRegion(player.Object.Position);
if (revivalRegion == null)
{
this._logger.LogError($"Cannot find any revival region for map '{player.Object.CurrentMap.Name}'.");
return;
}
decimal recoveryRate = GameResources.Instance.Penalities.GetRevivalPenality(player.Object.Level) / 100;
var jobData = player.PlayerData.JobData;
int strength = player.Attributes[DefineAttributes.STR];
int stamina = player.Attributes[DefineAttributes.STA];
int dexterity = player.Attributes[DefineAttributes.DEX];
int intelligence = player.Attributes[DefineAttributes.INT];
player.Health.Hp = (int)(HealthFormulas.GetMaxOriginHp(player.Object.Level, stamina, jobData.MaxHpFactor) * recoveryRate);
player.Health.Mp = (int)(HealthFormulas.GetMaxOriginMp(player.Object.Level, intelligence, jobData.MaxMpFactor, true) * recoveryRate);
player.Health.Fp = (int)(HealthFormulas.GetMaxOriginFp(player.Object.Level, stamina, dexterity, strength, jobData.MaxFpFactor, true) * recoveryRate);
if (player.Object.MapId != revivalRegion.MapId)
{
IMapInstance revivalMap = this._mapLoader.GetMapById(revivalRegion.MapId);
if (revivalMap == null)
{
this._logger.LogError($"Cannot find revival map with id '{revivalRegion.MapId}'.");
player.Connection.Server.DisconnectClient(player.Connection.Id);
return;
}
revivalRegion = revivalMap.GetRevivalRegion(revivalRegion.Key);
}
var teleportEvent = new TeleportEventArgs(revivalRegion.MapId, revivalRegion.RevivalPosition.X, revivalRegion.RevivalPosition.Z);
player.NotifySystem <TeleportSystem>(teleportEvent);
WorldPacketFactory.SendMotion(player, ObjectMessageType.OBJMSG_ACC_STOP | ObjectMessageType.OBJMSG_STOP_TURN | ObjectMessageType.OBJMSG_STAND);
WorldPacketFactory.SendPlayerRevival(player);
WorldPacketFactory.SendUpdateAttributes(player, DefineAttributes.HP, player.Health.Hp);
WorldPacketFactory.SendUpdateAttributes(player, DefineAttributes.MP, player.Health.Mp);
WorldPacketFactory.SendUpdateAttributes(player, DefineAttributes.FP, player.Health.Fp);
this.ProcessDeathPenality(player);
}
void SpaceShip_TargetReached(SectorObject sender, SystemEventArgs e)
{
if (State == "TARGET" || State == "BATTLE")
{
SpaceShip ship = this.SpaceShip.Target as SpaceShip;
if (ship != null)
{
//GameManager.Instance.BattleManager.DoBattleCommand(this, ship, "F");
}
}
}
public void OnNotification(IEntity entity, SystemEventArgs args)
{
switch (args)
{
case GameContextCreateRequestEventArgs gccrea:
var breedId = entity.Character().BreedId;
var breedData = GameDataManager <Breed> .Instance.Get(breedId);
CreateRoleplayContext(entity, breedData.SpawnMap);
break;
}
}
public void NotifySystem <T>(IEntity entity, SystemEventArgs e) where T : class, INotifiableSystem
{
try
{
NotifiableSystems[typeof(T)].Execute(entity, e);
}
catch (Exception exception)
{
Log.Error("[NOTIFY_SYSTEM]", exception);
Console.WriteLine(exception);
throw;
}
}
/// <inheritdoc />
public void Execute(IEntity entity, SystemEventArgs e)
{
if (!(entity is IPlayerEntity player))
{
return;
}
if (!e.GetCheckArguments())
{
Logger.LogError("Cannot execute inventory action: {0} due to invalid arguments.", e.GetType());
return;
}
if (player.Health.IsDead)
{
this.Logger.LogWarning($"Cannot execute inventory action {e.GetType()}. Player '{player.Object.Name}' is dead.");
return;
}
switch (e)
{
case InventoryInitializeEventArgs inventoryInitializeEvent:
this.InitializeInventory(player, inventoryInitializeEvent);
break;
case InventoryMoveEventArgs inventoryMoveEvent:
this.ProcessMoveItem(player, inventoryMoveEvent);
break;
case InventoryEquipEventArgs inventoryEquipEvent:
this.ProcessEquipItem(player, inventoryEquipEvent);
break;
case InventoryCreateItemEventArgs inventoryCreateItemEvent:
this.ProcessCreateItem(player, inventoryCreateItemEvent);
break;
case InventoryDropItemEventArgs inventoryDropItemEvent:
this.ProcessDropItem(player, inventoryDropItemEvent);
break;
case InventoryUseItemEventArgs inventoryUseItemEvent:
this.ProcessUseItem(player, inventoryUseItemEvent);
break;
default:
Logger.LogWarning("Unknown inventory action type: {0} for player {1}", e.GetType(), entity.Object.Name);
break;
}
}
public override void Execute(IEntity entity, SystemEventArgs e)
{
switch (e)
{
case VisibilitySetInvisibleEventArgs invisibleEvent:
SetInvisible(entity, invisibleEvent);
break;
case VisibilitySetVisibleEventArgs visibleEvent:
SetVisible(entity, visibleEvent);
break;
}
throw new NotImplementedException();
}
/// <inheritdoc />
public void Execute(IEntity entity, SystemEventArgs e)
{
if (!(entity is IMovableEntity movableEntity) || !e.CheckArguments())
{
Logger.Error("FollowSystem: Invalid arguments");
return;
}
switch (e)
{
case FollowEventArgs followEvent:
this.OnFollow(movableEntity, followEvent);
break;
}
}
public override async Task <SystemEventDto> TriggerSystemEventAsync(SystemEventArgs args)
{
IApiService apiService = new SignalRServerApiService(_bearer);
var result = await apiService.AddSystemEventAsync(new SystemEventDto
{
MachineName = args.MachineName,
MachineId = args.MachineId,
Action = args.Action,
Description = args.Description,
Status = args.Status,
CreateAt = DateTime.UtcNow
});
return(result);
}
/// <inheritdoc />
public void Execute(IEntity entity, SystemEventArgs e)
{
if (!(entity is IPlayerEntity player) || !(e is NpcDialogOpenEventArgs dialogEvent))
{
Logger.Error("DialogSystem: Invalid event arguments.");
return;
}
if (!dialogEvent.CheckArguments())
{
Logger.Error("DialogSystem: Invalid event action arguments.");
return;
}
this.OpenDialog(player, dialogEvent);
}
/// <inheritdoc />
public void Execute(IEntity entity, SystemEventArgs args)
{
switch (entity)
{
case IMonsterEntity monster:
monster.Behavior?.Update(monster);
break;
case INpcEntity npc:
npc.Behavior?.Update(npc);
break;
case IPlayerEntity player:
player.Behavior?.Update(player);
break;
}
}
/// <inheritdoc />
public void Execute(IEntity entity, SystemEventArgs e)
{
if (!e.GetCheckArguments() || !(entity is IPlayerEntity playerEntity))
{
return;
}
switch (e)
{
case TradeRequestEventArgs tradeRequestEventArgs:
TradeRequest(playerEntity, tradeRequestEventArgs);
break;
case TradeRequestCancelEventArgs tradeRequestCancelEventArgs:
TradeRequestCancel(playerEntity, tradeRequestCancelEventArgs);
break;
case TradeBeginEventArgs tradeBeginEventArgs:
Trade(playerEntity, tradeBeginEventArgs);
break;
case TradePutEventArgs tradePutEventArgs:
PutItem(playerEntity, tradePutEventArgs);
break;
case TradePutGoldEventArgs tradePutGoldEventArgs:
PutGold(playerEntity, tradePutGoldEventArgs);
break;
case TradeCancelEventArgs tradeCancelEventArgs:
TradeCancel(playerEntity, tradeCancelEventArgs);
break;
case TradeConfirmEventArgs tradeConfirmEventArgs:
TradeConfirm(playerEntity, tradeConfirmEventArgs);
break;
case TradeOkEventArgs tradeOkEventArgs:
TradeOk(playerEntity, tradeOkEventArgs);
break;
default:
Logger.Warn("Unknown trade action type: {0} for player {1}", e.GetType(), entity.Object.Name);
break;
}
}
private void SystemMapOnSystemAdded(object sender, SystemEventArgs args)
{
var system = args.Source;
var updateableSystem = system as IUpdateableSystem;
if (updateableSystem != null)
{
updateableSystems.Add(updateableSystem);
}
var renderableSystem = system as IRenderableSystem;
if (renderableSystem != null)
{
renderableSystems.Add(renderableSystem);
}
}
public void OnNotification(IEntity entity, SystemEventArgs args)
{
switch (args)
{
case SendInfoMessageEventArgs simea:
var tim = new TextInformationMessage(simea.Type, simea.MessageId, simea.Args.ToArray());
entity.Send(tim);
break;
case ClientChatMessageEventArgs ccmea:
OnClientChat(entity, ccmea);
break;
case ClientEnteringGameEventArgs cegea:
entity.Notify(new SendInfoMessageEventArgs(InfoMessages.WelcomeMessage));
break;
}
}
/// <summary>
/// Executes the <see cref="MobilitySystem"/> logic.
/// </summary>
/// <param name="entity">Current entity</param>
public void Execute(IEntity entity, SystemEventArgs args)
{
if (!entity.Object.Spawned)
{
return;
}
var movableEntity = entity as IMovableEntity;
if (movableEntity.Moves.NextMoveTime > Time.GetElapsedTime())
{
return;
}
movableEntity.Moves.NextMoveTime = Time.GetElapsedTime() + 10;
if (movableEntity.Moves.DestinationPosition.IsZero())
{
return;
}
if (movableEntity.Object.MovingFlags.HasFlag(ObjectState.OBJSTA_STAND))
{
return;
}
if (movableEntity.Follow.IsFollowing)
{
if (!movableEntity.Object.Position.IsInCircle(movableEntity.Follow.Target.Object.Position, movableEntity.Follow.FollowDistance))
{
movableEntity.Moves.DestinationPosition = movableEntity.Follow.Target.Object.Position.Clone();
movableEntity.Object.MovingFlags &= ~ObjectState.OBJSTA_STAND;
movableEntity.Object.MovingFlags |= ObjectState.OBJSTA_FMOVE;
}
if (movableEntity.Object.Position.IsInCircle(movableEntity.Follow.Target.Object.Position, movableEntity.Follow.FollowDistance) &&
!movableEntity.Object.MovingFlags.HasFlag(ObjectState.OBJSTA_STAND))
{
// Arrived
movableEntity.Object.MovingFlags = ObjectState.OBJSTA_STAND;
}
}
this.Walk(movableEntity);
}
public override void Execute(IEntity entity, SystemEventArgs e)
{
var inventory = entity.GetComponent <InventoryComponent>();
switch (e)
{
case InventoryAddItemEventArgs addItemEventArgs:
AddItem(inventory, addItemEventArgs);
break;
case InventoryDropItemEventArgs dropItemEventArgs:
DropItem(inventory, dropItemEventArgs);
break;
case InventoryDestroyItemEventArgs destroyItemEventArgs:
DestroyItem(inventory, destroyItemEventArgs);
break;
}
}
/// <summary>
/// Executes the <see cref="VisibilitySystem"/> logic.
/// </summary>
/// <param name="entity">Current entity</param>
public void Execute(IEntity entity, SystemEventArgs args)
{
if (!entity.Object.Spawned)
{
return;
}
var currentMapLayer = entity.Context as IMapLayer;
if (currentMapLayer == null)
{
throw new RhisisSystemException($"Object {entity.Object.Name}:{entity.Id} doesn't belong to a map layer.");
}
var currentMap = currentMapLayer.Parent;
if (currentMap != null)
{
UpdateEntitiesVisibility(entity, currentMap.Entities);
}
if (currentMapLayer != null)
{
UpdateEntitiesVisibility(entity, currentMapLayer.Entities);
if (entity.Type == WorldEntityType.Player)
{
foreach (var region in currentMapLayer.Regions)
{
if (!region.IsActive && entity.Object.Position.Intersects(region.GetRectangle(), VisibilityRange))
{
region.IsActive = true;
}
if (region.IsActive && region is IMapRespawnRegion respawner)
{
UpdateEntitiesVisibility(entity, respawner.Entities);
}
}
}
}
}
/// <inheritdoc />
public void Execute(IEntity entity, SystemEventArgs args)
{
if (!entity.Object.Spawned)
{
return;
}
if (entity is IPlayerEntity player)
{
var triggerRegion = entity.Object.CurrentMap.Regions.FirstOrDefault(x => x is IMapTriggerRegion region &&
region.IsWrapzone &&
region.GetRectangle().Contains(entity.Object.Position))
as IMapTriggerRegion;
if (triggerRegion != null && triggerRegion.IsWrapzone)
{
player.NotifySystem <TeleportSystem>(new TeleportEventArgs(triggerRegion.DestinationMapId, triggerRegion.DestinationMapPosition));
}
}
}
private void SystemMapOnSystemRemoved(object sender, SystemEventArgs args)
{
var system = args.Source;
var updateableSystem = system as IUpdateableSystem;
if (updateableSystem != null)
{
lock (updateableSystems)
updateableSystems.Remove(updateableSystem);
}
var renderableSystem = system as IRenderableSystem;
if (renderableSystem != null)
{
lock (renderableSystems)
renderableSystems.Remove(renderableSystem);
}
}
public override void Execute(IEntity entity, SystemEventArgs e)
{
if (!Match(entity))
{
return;
}
switch (e)
{
case VisibilitySetInvisibleEventArgs invisibleEvent:
SetInvisible(entity, invisibleEvent);
break;
case VisibilitySetVisibleEventArgs visibleEvent:
SetVisible(entity, visibleEvent);
break;
default:
throw new NotImplementedException();
}
}
