public async Task RemoveItemAsync(Lot lot, uint count, bool silent = false)
{
await using var cdClient = new CdClientContext();
var componentId = await cdClient.ComponentsRegistryTable.FirstOrDefaultAsync(
r => r.Id == lot && r.Componenttype == (int)ComponentId.ItemComponent
);
if (componentId == default)
{
Logger.Error($"{lot} does not have a Item component");
return;
}
var component = await cdClient.ItemComponentTable.FirstOrDefaultAsync(
i => i.Id == componentId.Componentid
);
if (component == default)
{
Logger.Error(
$"{lot} has a corrupted component registry. There is no Item component of Id: {componentId.Componentid}"
);
return;
}
Debug.Assert(component.ItemType != null, "component.ItemType != null");
RemoveItem(lot, count, ((ItemType)component.ItemType).GetInventoryType(), silent);
}
public async Task LoadAsync()
{
await using var cdClient = new CdClientContext();
var clientTasks = await cdClient.MissionTasksTable.Where(
t => t.Id == MissionId
).ToArrayAsync();
var tasks = new List <MissionTaskBase>();
foreach (var clientTask in clientTasks)
{
var taskType = (MissionTaskType)(clientTask.TaskType ?? 0);
if (!TaskTypes.TryGetValue(taskType, out var type))
{
Logger.Error($"No {nameof(MissionTaskBase)} for {taskType} found.");
continue;
}
var instance = (MissionTaskBase)Activator.CreateInstance(type);
Debug.Assert(clientTask.Uid != null, "clientTask.Uid != null");
await instance.LoadAsync(Player, MissionId, clientTask.Uid.Value);
tasks.Add(instance);
}
Tasks = tasks.ToArray();
}
public async Task Buy(Lot lot, uint count, Player player)
{
await using var ctx = new CdClientContext();
var itemComponent = await ctx.ItemComponentTable.FirstAsync(
i => i.Id == lot.GetComponentId(ComponentId.ItemComponent)
);
if (count == default || itemComponent.BaseValue <= 0)
{
return;
}
var cost = (uint)((itemComponent.BaseValue ?? 0) * count);
if (cost > player.Currency)
{
return;
}
player.Currency -= cost;
await player.GetComponent <InventoryManagerComponent>().AddItemAsync(lot, count);
player.Message(new VendorTransactionResultMessage
{
Associate = GameObject,
Result = TransactionResult.Success
});
await OnBuy.InvokeAsync(lot, count, player);
}
private async Task LoadRequirementsAsync()
{
await using var cdClient = new CdClientContext();
var clientTask = await cdClient.MissionTasksTable.FirstAsync(
t => t.Uid == TaskId && t.Id == MissionId
);
Target = clientTask.Target ?? 0;
TargetValue = clientTask.TargetValue ?? 0;
if (clientTask.TargetGroup != default)
{
var targetGroup = clientTask.TargetGroup
.Replace(" ", "")
.Split(',')
.Where(c => !string.IsNullOrEmpty(c)).ToList();
var targets = new List <int>();
foreach (var target in targetGroup)
{
if (int.TryParse(target, out var lot))
{
targets.Add(lot);
}
}
TargetGroup = targets.ToArray();
}
else
{
TargetGroup = new int[0];
}
if (clientTask.TaskParam1 != default)
{
var targetParameters = clientTask.TaskParam1
.Replace(" ", "")
.Split(',')
.Where(c => !string.IsNullOrEmpty(c)).ToList();
var parameters = new List <int>();
foreach (var parameter in targetParameters)
{
if (int.TryParse(parameter, out var lot))
{
parameters.Add(lot);
}
}
Parameters = parameters.ToArray();
}
else
{
Parameters = new int[0];
}
}
protected async Task <BehaviorParameter> GetParameter(string name)
{
await using var cdClient = new CdClientContext();
return(await cdClient.BehaviorParameterTable.FirstOrDefaultAsync(p =>
p.BehaviorID == BehaviorId && p.ParameterID == name
));
}
protected LuaScriptComponent()
{
Listen(OnStart, () =>
{
using var ctx = new CdClientContext();
var scriptId = GameObject.Lot.GetComponentId(ComponentId.ScriptComponent);
var script = ctx.ScriptComponentTable.FirstOrDefault(s => s.Id == scriptId);
if (script == default)
{
Logger.Warning($"{GameObject} has an invalid script component entry: {scriptId}");
return;
}
if (GameObject.Settings.TryGetValue("custom_script_server", out var scriptOverride))
{
ScriptName = (string)scriptOverride;
}
else
{
ScriptName = script.Scriptname;
}
ClientScriptName = script.Clientscriptname;
Logger.Debug($"{GameObject} -> {ScriptName}");
});
}
/// <summary>
/// For an item makes sure that an item set is created if said item is part of one, if this item is not part of
/// an item set or the the item set this item belongs to is already created, this does nothing
/// </summary>
/// <param name="inventory">The inventory to get possible set items from</param>
/// <param name="lot">The lot for which we wish to check if item sets should be tracked</param>
public static async Task CreateIfNewSet(InventoryComponent inventory, Lot lot)
{
await using var context = new CdClientContext();
var clientItemSets = context.ItemSetsTable.Where(
i => i.ItemIDs.Contains(lot.ToString()));
foreach (var clientItemSet in clientItemSets)
{
// Make sure that the item set is valid and that the inventory doesn't already track an item set with this ID
if (clientItemSet.SetID == null ||
inventory.ActiveItemSets.Any(i => i._setId == clientItemSet.SetID.Value))
{
continue;
}
var itemSet = Instantiate(inventory, clientItemSet.SetID.Value);
Start(itemSet);
foreach (var itemSetLot in clientItemSet.ItemIDs.Split(","))
{
itemSet._itemsInSet.Add(new Lot(int.Parse(itemSetLot)));
}
// The skill sets that are unlocked when wearing n items of a set
itemSet._skillSetMap[2] = clientItemSet.SkillSetWith2;
itemSet._skillSetMap[3] = clientItemSet.SkillSetWith3;
itemSet._skillSetMap[4] = clientItemSet.SkillSetWith4;
itemSet._skillSetMap[5] = clientItemSet.SkillSetWith5;
itemSet._skillSetMap[6] = clientItemSet.SkillSetWith6;
}
}
public long EquipUnmanagedItem(Lot lot, uint count = 1, int slot = -1,
InventoryType inventoryType = InventoryType.None)
{
using var cdClient = new CdClientContext();
var cdClientObject = cdClient.ObjectsTable.FirstOrDefault(
o => o.Id == lot
);
var itemRegistryEntry = lot.GetComponentId(ComponentId.ItemComponent);
if (cdClientObject == default || itemRegistryEntry == default)
{
Logger.Error($"{lot} is not a valid item");
return(-1);
}
var itemComponent = cdClient.ItemComponentTable.First(
i => i.Id == itemRegistryEntry
);
var id = IdUtilities.GenerateObjectId();
Items[itemComponent.EquipLocation] = new InventoryItem
{
InventoryItemId = id,
Count = count,
Slot = slot,
LOT = lot,
InventoryType = (int)inventoryType
};
return(id);
}
private static async Task <Lot[]> ParseProxyItemsAsync(Lot item)
{
await using var ctx = new CdClientContext();
var itemInfo = await ctx.ItemComponentTable.FirstOrDefaultAsync(
i => i.Id == item.GetComponentId(ComponentId.ItemComponent)
);
if (itemInfo == default)
{
return(new Lot[0]);
}
if (string.IsNullOrWhiteSpace(itemInfo.SubItems))
{
return(new Lot[0]);
}
var proxies = itemInfo.SubItems
.Replace(" ", "")
.Split(',')
.Select(i => (Lot)int.Parse(i));
return(proxies.ToArray());
}
private async Task <long[]> GenerateProxyItemsAsync(Item item)
{
if (string.IsNullOrWhiteSpace(item?.ItemComponent?.SubItems))
{
return(null);
}
var proxies = item.ItemComponent.SubItems
.Replace(" ", "")
.Split(',')
.Select(int.Parse);
var list = new List <long>();
await using var cdClient = new CdClientContext();
foreach (Lot proxy in proxies)
{
var componentId = proxy.GetComponentId(ComponentId.ItemComponent);
var component = await cdClient.ItemComponentTable.FirstOrDefaultAsync(i => i.Id == componentId);
if (component == default)
{
continue;
}
list.Add(EquipUnmanagedItem(
proxy,
inventoryType: item.Inventory.InventoryType)
);
}
return(list.ToArray());
}
public async Task PlayEmoteHandler(PlayEmoteMessage message, Player player)
{
await using var ctx = new CdClientContext();
var animation = await ctx.EmotesTable.FirstOrDefaultAsync(e => e.Id == message.EmoteId);
player.Zone.BroadcastMessage(new PlayAnimationMessage
{
Associate = player,
AnimationsId = animation.AnimationName
});
player.Zone.ExcludingMessage(new EmotePlayedMessage
{
Associate = player,
EmoteId = message.EmoteId,
Target = message.Target
}, player);
if (player.TryGetComponent <MissionInventoryComponent>(out var missionInventoryComponent))
{
await missionInventoryComponent.UseEmoteAsync(message.Target, message.EmoteId);
}
if (message.Target?.OnEmoteReceived != default)
{
await message.Target.OnEmoteReceived.InvokeAsync(message.EmoteId, player);
}
}
private async Task SetupEntries()
{
var componentId = GameObject.Lot.GetComponentId(ComponentId.VendorComponent);
await using var cdClient = new CdClientContext();
var vendorComponent = await cdClient.VendorComponentTable.FirstAsync(c => c.Id == componentId);
var matrices =
cdClient.LootMatrixTable.Where(l => l.LootMatrixIndex == vendorComponent.LootMatrixIndex);
var shopItems = new List <ShopEntry>();
foreach (var matrix in matrices)
{
shopItems.AddRange(cdClient.LootTableTable.Where(
l => l.LootTableIndex == matrix.LootTableIndex
).ToArray().Select(lootTable =>
{
Debug.Assert(lootTable.Itemid != null, "lootTable.Itemid != null");
Debug.Assert(lootTable.SortPriority != null, "lootTable.SortPriority != null");
return(new ShopEntry
{
Lot = new Lot(lootTable.Itemid.Value),
SortPriority = lootTable.SortPriority.Value
});
}));
}
Entries = shopItems.ToArray();
}
protected QuickBuildComponent()
{
Listen(OnStart, async() =>
{
if (GameObject.Settings.TryGetValue("rebuild_activators", out var rebuildActivators))
{
ActivatorPosition = (Vector3)rebuildActivators;
}
else
{
ActivatorPosition = Transform.Position;
}
Logger.Information($"{GameObject} is a rebuild-able!");
await using var cdClient = new CdClientContext();
var clientComponent = await cdClient.RebuildComponentTable.FirstOrDefaultAsync(
r => r.Id == GameObject.Lot.GetComponentId(ComponentId.QuickBuildComponent)
);
if (clientComponent == default)
{
Logger.Error(
$"{GameObject} does not have a valid {nameof(ComponentId.QuickBuildComponent)} component."
);
return;
}
_completeTime = clientComponent.Completetime ?? 0;
_imaginationCost = clientComponent.Takeimagination ?? 0;
_timeToSmash = clientComponent.Timebeforesmash ?? 0;
_resetTime = clientComponent.Resettime ?? 0;
//if (!GameObject.Settings.TryGetValue("spawnActivator", out var spawnActivator) ||
// !(bool) spawnActivator) return;
//
// This activator is that imagination cost display of the quickbuild.
// It is required to be able to start the quickbuild.
//
Activator = GameObject.Instantiate(new LevelObjectTemplate
{
Lot = 6604,
Position = ActivatorPosition,
Rotation = Quaternion.Identity,
Scale = -1,
LegoInfo = new LegoDataDictionary()
}, GameObject);
Start(Activator);
GameObject.Construct(Activator);
GameObject.Serialize(GameObject);
Listen(GameObject.OnInteract, StartRebuild);
});
public override Task LoadAsync()
{
Listen(Zone.OnPlayerLoad, player =>
{
Listen(player.OnFireServerEvent, async(EventName, message) =>
{
if (EventName == "ZonePlayer")
{
var launchpad = message.Associate.GetComponent <RocketLaunchpadComponent>();
await using var cdClient = new CdClientContext();
var id = launchpad.GameObject.Lot.GetComponentId(ComponentId.RocketLaunchComponent);
var launchpadComponent = await cdClient.RocketLaunchpadControlComponentTable.FirstOrDefaultAsync(
r => r.Id == id
);
if (launchpadComponent == default)
{
return;
}
await using var ctx = new UchuContext();
var character = await ctx.Characters.FirstAsync(c => c.Id == player.Id);
character.LaunchedRocketFrom = Zone.ZoneId;
await ctx.SaveChangesAsync();
if (launchpadComponent.TargetZone != null)
{
var target = (ZoneId)launchpadComponent.TargetZone;
//
// We don't want to lock up the server on a world server request, as it may take time.
//
var _ = Task.Run(async() =>
{
var success = await player.SendToWorldAsync(target);
if (!success)
{
player.SendChatMessage($"Failed to transfer to {target}, please try later.");
}
});
}
}
});
return(Task.CompletedTask);
});
return(Task.CompletedTask);
}
public void Initialize(Player player)
{
Player = player;
using var cdClient = new CdClientContext();
var zone = cdClient.ZoneTableTable.FirstOrDefault(z => z.ZoneID == (int)Player.Zone.ZoneId);
Distance = zone?.Ghostdistance ?? 500;
}
public override async Task ConfigureAsync(string configFile)
{
Logger.Information($"Created WorldServer on PID {Process.GetCurrentProcess().Id.ToString()}");
await base.ConfigureAsync(configFile);
// Update the CDClient database.
await using var cdContext = new CdClientContext();
await cdContext.EnsureUpdatedAsync();
ZoneParser = new ZoneParser(Resources);
Whitelist = new Whitelist(Resources);
await Whitelist.LoadDefaultWhitelist();
GameMessageReceived += HandleGameMessageAsync;
ServerStopped += () =>
{
foreach (var zone in Zones)
{
Object.Destroy(zone);
}
};
var instance = await Api.RunCommandAsync <InstanceInfoResponse>(
Config.ApiConfig.Port, $"instance/target?i={Id}"
).ConfigureAwait(false);
ZoneId = (ZoneId)instance.Info.Zones.First();
#if DEBUG
if (!Config.DebugConfig.StartInstancesAsThreads)
#endif
Logger.SetServerTypeInformation("Z" + ZoneId.Id);
var info = await Api.RunCommandAsync <InstanceInfoResponse>(MasterApi, $"instance/target?i={Id}");
Api.RegisterCommandCollection <WorldCommands>(this);
ManagedScriptEngine.AdditionalPaths = Config.ManagedScriptSources.Paths.ToArray();
_ = Task.Run(async() =>
{
Logger.Information("Loading CDClient cache");
await ClientCache.LoadAsync();
});
_ = Task.Run(async() =>
{
Logger.Information($"Setting up zones for world server {Id}");
foreach (var zone in info.Info.Zones)
{
await ZoneParser.LoadZoneDataAsync(zone);
await LoadZone(zone);
}
});
}
public async Task EquipAsync(EquippedItem item)
{
await using var cdClient = new CdClientContext();
var componentId = item.Lot.GetComponentId(ComponentId.ItemComponent);
var info = await cdClient.ItemComponentTable.FirstAsync(i => i.Id == componentId);
var location = (EquipLocation)info.EquipLocation;
await UpdateSlotAsync(location, item);
var skills = GameObject.TryGetComponent <SkillComponent>(out var skillComponent);
if (skills)
{
await skillComponent.MountItemAsync(item.Lot);
}
await UpdateEquipState(item.Id, true);
var proxies = await GenerateProxiesAsync(item.Id);
foreach (var proxy in proxies)
{
var instance = await proxy.FindItemAsync();
var lot = (Lot)instance.Lot;
componentId = lot.GetComponentId(ComponentId.ItemComponent);
info = await cdClient.ItemComponentTable.FirstOrDefaultAsync(i => i.Id == componentId);
if (info == default)
{
continue;
}
location = (EquipLocation)info.EquipLocation;
await UpdateSlotAsync(location, new EquippedItem
{
Id = proxy,
Lot = lot
});
await UpdateEquipState(proxy, true);
if (skills)
{
await skillComponent.MountItemAsync(lot);
}
}
}
public async Task <bool> CanAcceptAsync(int id)
{
await using var ctx = new CdClientContext();
var mission = await ctx.MissionsTable.FirstAsync(m => m.Id == id);
return(MissionParser.CheckPrerequiredMissions(
mission.PrereqMissionID,
GetCompletedMissions()
));
}
private async Task BuildAsync()
{
await using var ctx = new CdClientContext();
foreach (var skill in BehaviorIds)
{
var root = BehaviorBase.Cache.ToArray().FirstOrDefault(b => b.BehaviorId == skill.BaseBehavior);
if (root == default)
{
var behavior = await ctx.BehaviorTemplateTable.FirstOrDefaultAsync(
t => t.BehaviorID == skill.BaseBehavior
);
if (behavior?.TemplateID == null)
{
continue;
}
var behaviorTypeId = (BehaviorTemplateId)behavior.TemplateID;
if (!Behaviors.TryGetValue(behaviorTypeId, out var behaviorType))
{
Logger.Error($"No behavior type of \"{behaviorTypeId}\" found.");
continue;
}
var instance = (BehaviorBase)Activator.CreateInstance(behaviorType);
instance.BehaviorId = skill.BaseBehavior;
BehaviorBase.Cache.Add(instance);
await instance.BuildAsync();
root = instance;
}
SkillRoots[skill.SkillId] = root;
if (RootBehaviors.TryGetValue(skill.CastType, out var list))
{
list.Add(root);
}
else
{
RootBehaviors[skill.CastType] = new List <BehaviorBase> {
root
};
}
}
}
protected InventoryComponent()
{
Listen(OnDestroyed, () =>
{
OnEquipped.Clear();
OnUnEquipped.Clear();
});
Listen(OnStart, () =>
{
using var cdClient = new CdClientContext();
var component = cdClient.ComponentsRegistryTable.FirstOrDefault(c =>
c.Id == GameObject.Lot && c.Componenttype == (int)ComponentId.InventoryComponent);
var items = cdClient.InventoryComponentTable.Where(i => i.Id == component.Componentid).ToArray();
Items = new Dictionary <EquipLocation, InventoryItem>();
foreach (var item in items)
{
var cdClientObject = cdClient.ObjectsTable.FirstOrDefault(
o => o.Id == item.Itemid
);
var itemRegistryEntry = cdClient.ComponentsRegistryTable.FirstOrDefault(
r => r.Id == item.Itemid && r.Componenttype == 11
);
if (cdClientObject == default || itemRegistryEntry == default)
{
Logger.Error($"{item.Itemid} is not a valid item");
continue;
}
var itemComponent = cdClient.ItemComponentTable.First(
i => i.Id == itemRegistryEntry.Componentid
);
Debug.Assert(item.Itemid != null, "item.Itemid != null");
Debug.Assert(item.Count != null, "item.Count != null");
Items.TryAdd(itemComponent.EquipLocation, new InventoryItem
{
InventoryItemId = IdUtilities.GenerateObjectId(),
Count = (long)item.Count,
LOT = (int)item.Itemid,
Slot = -1,
InventoryType = -1
});
}
});
}
/// <summary>
/// Loads the initial cache
/// </summary>
public static async Task LoadAsync()
{
// Set up the cache tables.
Logger.Debug("Setting up persistent cache tables");
var loadTableTasks = new List <Task>();
foreach (var clientTableType in AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes()).Where(t => (t.GetCustomAttribute <TableAttribute>() != null)))
{
// Determine the index.
var indexPropertyInfo = clientTableType.GetProperties().FirstOrDefault(propertyInfo => propertyInfo.GetCustomAttribute <CacheIndexAttribute>() != null);
if (indexPropertyInfo == null)
{
continue;
}
// Get the cache type.
var cacheType = CacheMethod.Entry;
var cacheMethodAttribute = clientTableType.GetCustomAttribute <CacheMethodAttribute>();
if (cacheMethodAttribute != null)
{
cacheType = cacheMethodAttribute.Method;
}
// Create the cache table if it is persistent.
if (cacheType != CacheMethod.Persistent)
{
continue;
}
Logger.Debug($"Setting up persistent cache table for {clientTableType.Name} with index {indexPropertyInfo.Name}");
loadTableTasks.Add(Task.Run(async() =>
{
await GetCacheTableAsync(clientTableType);
}));
}
await Task.WhenAll(loadTableTasks);
// Set up the mission cache.
Logger.Debug("Setting up missions cache");
await using var cdClient = new CdClientContext();
var missionTasks = (await cdClient.MissionsTable.ToArrayAsync())
.Select(async m =>
{
var instance = new MissionInstance(m.Id ?? 0, default);
await instance.LoadAsync();
return(instance);
}).ToList();
await Task.WhenAll(missionTasks);
Missions = missionTasks.Select(t => t.Result).ToArray();
Achievements = Missions.Where(m => !m.IsMission).ToArray();
}
protected InventoryComponent()
{
Items = new Dictionary <EquipLocation, EquippedItem>();
OnEquipped = new Event <Item>();
OnUnEquipped = new Event <Item>();
Listen(OnDestroyed, () =>
{
OnEquipped.Clear();
OnUnEquipped.Clear();
});
Listen(OnStart, () =>
{
if (GameObject is Player)
{
return;
}
using var cdClient = new CdClientContext();
var component = cdClient.ComponentsRegistryTable.FirstOrDefault(c =>
c.Id == GameObject.Lot && c.Componenttype == (int)ComponentId.InventoryComponent);
var items = cdClient.InventoryComponentTable.Where(i => i.Id == component.Componentid).ToArray();
foreach (var item in items)
{
if (item.Itemid == default)
{
continue;
}
var lot = (Lot)item.Itemid;
var componentId = lot.GetComponentId(ComponentId.ItemComponent);
var info = cdClient.ItemComponentTable.First(i => i.Id == componentId);
var location = (EquipLocation)info.EquipLocation;
Items[location] = new EquippedItem
{
Id = ObjectId.Standalone,
Lot = lot
};
}
});
}
public async Task StartAsync()
{
await using var ctx = new UchuContext();
await using var cdClient = new CdClientContext();
//
// Setup new mission
//
var mission = await ctx.Missions.FirstOrDefaultAsync(
m => m.CharacterId == Player.Id && m.MissionId == MissionId
);
var tasks = await cdClient.MissionTasksTable.Where(
t => t.Id == MissionId
).ToArrayAsync();
if (mission != default)
{
return;
}
await ctx.Missions.AddAsync(new Mission
{
CharacterId = Player.Id,
MissionId = MissionId,
Tasks = tasks.Select(task => new MissionTask
{
TaskId = task.Uid ?? 0
}).ToList()
});
await ctx.SaveChangesAsync();
await UpdateMissionStateAsync(MissionState.Active);
var clientMission = await cdClient.MissionsTable.FirstAsync(
m => m.Id == MissionId
);
MessageMissionTypeState(MissionLockState.New, clientMission.Definedsubtype, clientMission.Definedtype);
await CatchupAsync();
if (Player.TryGetComponent <MissionInventoryComponent>(out var missionInventory))
{
await missionInventory.OnAcceptMission.InvokeAsync(this);
}
}
protected DestructibleComponent()
{
OnSmashed = new Event <GameObject, Player>();
OnResurrect = new Event();
Listen(OnStart, async() =>
{
if (GameObject.Settings.TryGetValue("respawn", out var resTimer))
{
ResurrectTime = resTimer switch
{
uint timer => timer,
float timer => timer,
int timer => timer,
_ => ResurrectTime
};
}
var container = GameObject.AddComponent <LootContainerComponent>();
await container.CollectDetailsAsync();
GameObject.Layer = StandardLayer.Smashable;
await using (var cdClient = new CdClientContext())
{
var entry = GameObject.Lot.GetComponentId(ComponentId.DestructibleComponent);
var cdClientComponent = cdClient.DestructibleComponentTable.FirstOrDefault(
c => c.Id == entry
);
if (cdClientComponent == default)
{
Logger.Error($"{GameObject} has a corrupt Destructible Component of id: {entry}");
}
}
if (GameObject.TryGetComponent(out Stats stats))
{
Stats = stats;
Listen(Stats.OnDeath, async() =>
{
await SmashAsync(
Stats.LatestDamageSource,
Stats.LatestDamageSource is Player player ? player : default,
private static async Task <bool> CheckForDatabaseUpdatesAsync()
{
try
{
await using var uchuContext = new UchuContext();
await uchuContext.EnsureUpdatedAsync();
await using var cdClientContext = new CdClientContext();
await cdClientContext.EnsureUpdatedAsync();
return(true);
}
catch
{
return(false);
}
}
public static async Task AttachmentCollectHandler(MailAttachmentCollected packet, Player player)
{
var response = new AttachmentCollectConfirm
{
MailId = packet.MailId
};
await using var ctx = new UchuContext();
await using var clientContext = new CdClientContext();
var mail = await ctx.Mails.FirstOrDefaultAsync(m => m.Id == packet.MailId);
if (mail == default)
{
response.Code = MailAttachmentCollectCode.MailForFound;
goto sendResponse;
}
if (mail.AttachmentLot == -1 || mail.AttachmentCount == default)
{
response.Code = MailAttachmentCollectCode.InvalidAttachment;
goto sendResponse;
}
await player.GetComponent <InventoryManagerComponent>().AddLotAsync(mail.AttachmentLot, mail.AttachmentCount, lootType: LootType.Mail);
mail.AttachmentLot = -1;
mail.AttachmentCount = 0;
var character = player.GetComponent <CharacterComponent>();
character.Currency += (long)mail.AttachmentCurrency;
response.Code = MailAttachmentCollectCode.Success;
sendResponse:
await ctx.SaveChangesAsync();
player.Message(new ServerMailPacket
{
Id = ServerMailPacketId.AttachmentCollectedConfirm,
MailStruct = response
});
}
public async Task MessageUpdateMissionTaskAsync(float[] updates)
{
await using var cdClient = new CdClientContext();
var clientTasks = await cdClient.MissionTasksTable.Where(
t => t.Id == MissionId
).ToArrayAsync();
var clientTask = clientTasks.First(c => c.Uid == TaskId);
Player.Message(new NotifyMissionTaskMessage
{
Associate = Player,
MissionId = MissionId,
TaskIndex = clientTasks.IndexOf(clientTask),
Updates = updates
});
}
public static async Task <BehaviorBase> BuildBranch(int behaviorId)
{
var cachedBehavior = Cache.ToArray().FirstOrDefault(c => c.BehaviorId == behaviorId);
if (cachedBehavior != default)
{
return(cachedBehavior);
}
await using var ctx = new CdClientContext();
var behavior = await ctx.BehaviorTemplateTable.FirstOrDefaultAsync(
t => t.BehaviorID == behaviorId
);
if (behavior?.TemplateID == null)
{
return(new EmptyBehavior());
}
var behaviorTypeId = (BehaviorTemplateId)behavior.TemplateID;
if (!BehaviorTree.Behaviors.TryGetValue(behaviorTypeId, out var behaviorType))
{
Logger.Error($"No behavior type of \"{behaviorTypeId}\" found.");
return(new EmptyBehavior());
}
var instance = (BehaviorBase)Activator.CreateInstance(behaviorType);
instance.BehaviorId = behaviorId;
instance.EffectId = behavior.EffectID ?? 0;
instance.EffectHandler = behavior.EffectHandle;
Cache.Add(instance);
await instance.BuildAsync();
return(instance);
}
public static Item Instantiate(long itemId, Inventory inventory)
{
using var cdClient = new CdClientContext();
using var ctx = new UchuContext();
var item = ctx.InventoryItems.FirstOrDefault(
i => i.Id == itemId && i.Character.Id == inventory.ManagerComponent.GameObject.Id
);
if (item == default)
{
Logger.Error($"{itemId} is not an item on {inventory.ManagerComponent.GameObject}");
return(null);
}
var cdClientObject = cdClient.ObjectsTable.FirstOrDefault(
o => o.Id == item.Lot
);
var itemRegistryEntry = ((Lot)item.Lot).GetComponentId(ComponentId.ItemComponent);
if (cdClientObject == default || itemRegistryEntry == default)
{
Logger.Error($"{itemId} [{item.Lot}] is not a valid item");
return(null);
}
var instance = Instantiate <Item>
(
inventory.ManagerComponent.Zone, cdClientObject.Name, objectId: itemId, lot: item.Lot
);
if (!string.IsNullOrWhiteSpace(item.ExtraInfo))
{
instance.Settings = LegoDataDictionary.FromString(item.ExtraInfo);
}
instance.Inventory = inventory;
instance.Player = inventory.ManagerComponent.GameObject as Player;
return(instance);
}
protected Item()
{
OnConsumed = new Event();
Listen(OnStart, () =>
{
IsPackage = Lot.GetComponentId(ComponentId.PackageComponent) != default;
using var cdClient = new CdClientContext();
var skills = cdClient.ObjectSkillsTable.Where(
s => s.ObjectTemplate == Lot
).ToArray();
IsConsumable = skills.Any(
s => s.CastOnType == (int)SkillCastType.OnConsumed
);
});
Listen(OnDestroyed, () => Inventory.UnManageItem(this));
}
