548 lines
17 KiB
C#
548 lines
17 KiB
C#
using System.Collections.Generic;
|
|
using Cysharp.Threading.Tasks;
|
|
using SepCore.Event;
|
|
using SepCore.Definition;
|
|
using SepCore.CustomUtility;
|
|
using SepCore.Entity.Weapon;
|
|
using GameFramework.Event;
|
|
using UnityEngine;
|
|
using UnityGameFramework.Runtime;
|
|
|
|
namespace SepCore.UI
|
|
{
|
|
public class ShopController : UIControllerBase<ShopContext, ShopForm>
|
|
{
|
|
private ShopUseCase _useCase;
|
|
private ShopRawData _rawData;
|
|
|
|
protected override UIFormType UIFormType => UIFormType.ShopForm;
|
|
|
|
protected override void RefreshUI(ShopForm form, ShopContext context)
|
|
{
|
|
form.RefreshUI(context);
|
|
}
|
|
|
|
protected override void SubscribeCustomEvents()
|
|
{
|
|
GameEntry.Event.Subscribe(RefreshEventArgs.EventId, Refresh);
|
|
GameEntry.Event.Subscribe(ShopPurchaseEventArgs.EventId, ShopPurchase);
|
|
GameEntry.Event.Subscribe(ShopContinueEventArgs.EventId, ShopContinue);
|
|
GameEntry.Event.Subscribe(DisplayItemShowEventArgs.EventId, DisplayItemShow);
|
|
}
|
|
|
|
protected override void UnsubscribeCustomEvents()
|
|
{
|
|
GameEntry.Event.Unsubscribe(RefreshEventArgs.EventId, Refresh);
|
|
GameEntry.Event.Unsubscribe(ShopPurchaseEventArgs.EventId, ShopPurchase);
|
|
GameEntry.Event.Unsubscribe(ShopContinueEventArgs.EventId, ShopContinue);
|
|
GameEntry.Event.Unsubscribe(DisplayItemShowEventArgs.EventId, DisplayItemShow);
|
|
}
|
|
|
|
#region BuildContext
|
|
|
|
private async UniTask<ShopContext> BuildContext(ShopRawData rawData)
|
|
{
|
|
if (rawData == null)
|
|
{
|
|
Log.Error("ShopFormController.BuildContext() rawData is null.");
|
|
return null;
|
|
}
|
|
|
|
_rawData = rawData;
|
|
|
|
List<GoodsItemContext> goodsItems = new List<GoodsItemContext>();
|
|
foreach (var item in rawData.GoodsItems)
|
|
{
|
|
goodsItems.Add(await GoodsItemContext.CreateAsync(item));
|
|
}
|
|
|
|
return new ShopContext
|
|
{
|
|
CurrentLevel = rawData.CurrentLevel,
|
|
RefreshPrice = rawData.RefreshPrice,
|
|
PlayerCoin = rawData.PlayerCoin,
|
|
GoodsItems = goodsItems,
|
|
PropListContext =
|
|
BuildDisplayListAreaContext(DisplayListAreaType.Prop, rawData.PropItems, rawData.PropMaxCount),
|
|
WeaponListContext = BuildDisplayListAreaContext(DisplayListAreaType.Weapon, rawData.WeaponItems,
|
|
rawData.WeaponMaxCount)
|
|
};
|
|
}
|
|
|
|
private static DisplayListAreaContext BuildDisplayListAreaContext(DisplayListAreaType listType,
|
|
IReadOnlyList<object> items,
|
|
int maxCount)
|
|
{
|
|
string title = GetDisplayListTitle(listType);
|
|
if (items == null)
|
|
{
|
|
return new DisplayListAreaContext
|
|
{
|
|
Title = title,
|
|
CurrentCount = 0,
|
|
MaxCount = maxCount,
|
|
ItemContexts = System.Array.Empty<DisplayItemContext>()
|
|
};
|
|
}
|
|
|
|
DisplayItemContext[] itemContexts = new DisplayItemContext[items.Count];
|
|
switch (listType)
|
|
{
|
|
case DisplayListAreaType.Weapon:
|
|
if (items is IReadOnlyList<WeaponBase> weapons)
|
|
{
|
|
for (int i = 0; i < weapons.Count; i++)
|
|
{
|
|
WeaponBase weapon = weapons[i];
|
|
if (weapon == null) break;
|
|
itemContexts[i] = BuildWeaponItem(weapon);
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case DisplayListAreaType.Prop:
|
|
if (items is IReadOnlyList<PropItem> propItems)
|
|
{
|
|
for (int i = 0; i < propItems.Count; i++)
|
|
{
|
|
PropItem propItem = propItems[i];
|
|
if (propItem == null) break;
|
|
itemContexts[i] = BuildPropItem(propItem);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
int currentCount = itemContexts.Length;
|
|
return new DisplayListAreaContext
|
|
{
|
|
Title = title,
|
|
CurrentCount = currentCount,
|
|
MaxCount = maxCount,
|
|
ItemContexts = itemContexts
|
|
};
|
|
}
|
|
|
|
private static string GetDisplayListTitle(DisplayListAreaType listType)
|
|
{
|
|
return listType switch
|
|
{
|
|
DisplayListAreaType.Weapon => "武器",
|
|
DisplayListAreaType.Prop => "道具",
|
|
_ => string.Empty
|
|
};
|
|
}
|
|
|
|
private static DisplayItemContext BuildPropItem(PropItem propItem)
|
|
{
|
|
string iconAssetName = null;
|
|
ItemRarity rarity = ItemRarity.None;
|
|
|
|
if (propItem != null)
|
|
{
|
|
iconAssetName = propItem.IconAssetName;
|
|
rarity = propItem.Rarity;
|
|
}
|
|
|
|
return new DisplayItemContext
|
|
{
|
|
IconAssetName = iconAssetName,
|
|
Rarity = rarity,
|
|
IsWeapon = false
|
|
};
|
|
}
|
|
|
|
private static DisplayItemContext BuildWeaponItem(WeaponBase weaponBase)
|
|
{
|
|
string iconAssetName = null;
|
|
ItemRarity rarity = ItemRarity.None;
|
|
|
|
if (weaponBase != null && weaponBase.WeaponData != null)
|
|
{
|
|
iconAssetName = weaponBase.WeaponData.IconAssetName;
|
|
rarity = weaponBase.WeaponData.Rarity;
|
|
}
|
|
|
|
return new DisplayItemContext
|
|
{
|
|
IconAssetName = iconAssetName,
|
|
Rarity = rarity,
|
|
IsWeapon = true
|
|
};
|
|
}
|
|
|
|
private static void AppendDisplayItemContext(DisplayListAreaContext listContext, DisplayItemContext newItem)
|
|
{
|
|
if (listContext == null)
|
|
{
|
|
Log.Error("ShopFormController.AppendDisplayItemContext() listContext is null.");
|
|
return;
|
|
}
|
|
|
|
if (newItem == null)
|
|
{
|
|
Log.Warning("ShopFormController.AppendDisplayItemContext() newItem is null.");
|
|
return;
|
|
}
|
|
|
|
int oldCount = listContext.ItemContexts != null ? listContext.ItemContexts.Length : 0;
|
|
DisplayItemContext[] newContexts = new DisplayItemContext[oldCount + 1];
|
|
if (oldCount > 0)
|
|
{
|
|
System.Array.Copy(listContext.ItemContexts, newContexts, oldCount);
|
|
}
|
|
|
|
newContexts[oldCount] = newItem;
|
|
listContext.ItemContexts = newContexts;
|
|
listContext.CurrentCount = oldCount + 1;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region UI Methods
|
|
|
|
public override async UniTask CloseUIAsync(object userData = null, float timeout = 30f)
|
|
{
|
|
GameEntry.Event.Fire(this, DisplayItemInfoHideEventArgs.Create(true));
|
|
_rawData = null;
|
|
await base.CloseUIAsync(userData, timeout);
|
|
}
|
|
|
|
public async UniTask<int?> OpenUIAsync(ShopRawData rawData, float timeout = 30f)
|
|
{
|
|
ShopContext context = await BuildContext(rawData);
|
|
return await OpenFormAsync(context, timeout);
|
|
}
|
|
|
|
public override async UniTask OpenUIAsync(object userData = null, float timeout = 30f)
|
|
{
|
|
if (userData is ShopRawData rawData)
|
|
{
|
|
await OpenUIAsync(rawData, timeout);
|
|
}
|
|
|
|
if (userData != null)
|
|
{
|
|
Log.Warning("ShopController.OpenUIAsync() userData type is invalid.");
|
|
return;
|
|
}
|
|
|
|
if (_useCase == null)
|
|
{
|
|
Log.Error("ShopController.OpenUIAsync() useCase is null.");
|
|
return;
|
|
}
|
|
|
|
ShopRawData initialRawData = _useCase.CreateInitialModel();
|
|
await OpenUIAsync(initialRawData, timeout);
|
|
}
|
|
|
|
public override void BindUseCase(IUIUseCase useCase)
|
|
{
|
|
if (useCase is not ShopUseCase shopFormUseCase)
|
|
{
|
|
Log.Error("ShopForm.BindUseCase() useCase is invalid.");
|
|
return;
|
|
}
|
|
|
|
_useCase = shopFormUseCase;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Service
|
|
|
|
private async UniTask RefreshGoodsItems(ShopRefreshResult result)
|
|
{
|
|
if (result == null)
|
|
{
|
|
Log.Error("ShopFormController.RefreshGoodsItems() result is null.");
|
|
return;
|
|
}
|
|
|
|
if (Context == null)
|
|
{
|
|
Log.Error("ShopFormController.RefreshGoodsItems() Context is null.");
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < result.GoodsItems.Count; i++)
|
|
{
|
|
if (i < Context.GoodsItems.Count)
|
|
Context.GoodsItems[i] = await GoodsItemContext.CreateAsync(result.GoodsItems[i]);
|
|
else Context.GoodsItems.Add(await GoodsItemContext.CreateAsync(result.GoodsItems[i]));
|
|
}
|
|
|
|
if (Context.GoodsItems.Count != result.GoodsItems.Count)
|
|
{
|
|
Context.GoodsItems.RemoveRange(Context.GoodsItems.Count,
|
|
Context.GoodsItems.Count - Context.GoodsItems.Count);
|
|
}
|
|
|
|
Context.RefreshPrice = result.RefreshPrice;
|
|
|
|
if (Form == null)
|
|
{
|
|
Log.Error("ShopFormController.RefreshGoodsItems() Form is null.");
|
|
return;
|
|
}
|
|
|
|
Form.RefreshGoodsItems(Context.GoodsItems);
|
|
Form.RefreshRefreshPrice(Context.RefreshPrice);
|
|
}
|
|
|
|
private void ApplyGoodsPurchased(ShopPurchaseResult result)
|
|
{
|
|
if (result == null)
|
|
{
|
|
Log.Error("ShopFormController.ApplyGoodsPurchased() result is null.");
|
|
return;
|
|
}
|
|
|
|
if (Context == null)
|
|
{
|
|
Log.Error("ShopFormController.ApplyGoodsPurchased() Context is null.");
|
|
return;
|
|
}
|
|
|
|
if (Context.GoodsItems != null && result.GoodsIndex >= 0 && result.GoodsIndex < Context.GoodsItems.Count)
|
|
{
|
|
Context.GoodsItems[result.GoodsIndex] = null;
|
|
}
|
|
|
|
DisplayItemContext context = new DisplayItemContext(result.DisplayItem);
|
|
|
|
if (result.DisplayItem != null)
|
|
{
|
|
if (result.DisplayItem.IsWeapon)
|
|
{
|
|
AppendDisplayItemContext(Context.WeaponListContext, context);
|
|
}
|
|
else
|
|
{
|
|
AppendDisplayItemContext(Context.PropListContext, context);
|
|
}
|
|
}
|
|
|
|
Form?.ApplyGoodsPurchased(result.GoodsIndex, context);
|
|
}
|
|
|
|
private bool IsCurrentFormEventSender(object sender)
|
|
{
|
|
if (sender is ShopForm shopForm)
|
|
{
|
|
return shopForm == Form;
|
|
}
|
|
|
|
if (sender is Component component && Form != null)
|
|
{
|
|
return component.transform.IsChildOf(Form.transform);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private bool TryGetWeaponInfoRawData(int index, Vector3 targetPos, out DisplayItemInfoRawData rawData)
|
|
{
|
|
rawData = null;
|
|
|
|
if (_rawData?.WeaponItems == null)
|
|
{
|
|
Log.Error("ShopFormController.TryGetWeaponInfoRawData() WeaponItems is null.");
|
|
return false;
|
|
}
|
|
|
|
if (Context == null)
|
|
{
|
|
Log.Error("ShopFormController.TryGetWeaponInfoRawData() Context is null.");
|
|
return false;
|
|
}
|
|
|
|
if (index < 0 || index >= _rawData.WeaponItems.Count)
|
|
{
|
|
Log.Error($"ShopFormController.TryGetWeaponInfoRawData() invalid weapon index: {index}.");
|
|
return false;
|
|
}
|
|
|
|
WeaponBase weapon = _rawData.WeaponItems[index];
|
|
if (weapon?.WeaponData == null)
|
|
{
|
|
Log.Error($"ShopFormController.TryGetWeaponInfoRawData() weapon data is null at index {index}.");
|
|
return false;
|
|
}
|
|
|
|
rawData = new DisplayItemInfoRawData
|
|
{
|
|
TargetPos = targetPos,
|
|
Index = index,
|
|
WeaponData = weapon.WeaponData,
|
|
Rarity = weapon.WeaponData.Rarity,
|
|
ItemType = ItemType.Weapon,
|
|
Price = Mathf.FloorToInt(weapon.WeaponData.Price * Context.WeaponRecycleRate),
|
|
OnRecycle = (recycleIndex, recyclePrice) => RecycleWeapon(recycleIndex, recyclePrice),
|
|
};
|
|
return true;
|
|
}
|
|
|
|
private bool TryGetPropInfoRawData(int index, Vector3 targetPos, out DisplayItemInfoRawData rawData)
|
|
{
|
|
rawData = null;
|
|
|
|
if (_rawData?.PropItems == null)
|
|
{
|
|
Log.Error("ShopFormController.TryGetPropInfoRawData() PropItems is null.");
|
|
return false;
|
|
}
|
|
|
|
if (index < 0 || index >= _rawData.PropItems.Count)
|
|
{
|
|
Log.Error($"ShopFormController.TryGetPropInfoRawData() invalid prop index: {index}.");
|
|
return false;
|
|
}
|
|
|
|
PropItem propItem = _rawData.PropItems[index];
|
|
if (propItem == null)
|
|
{
|
|
Log.Error($"ShopFormController.TryGetPropInfoRawData() prop item is null at index {index}.");
|
|
return false;
|
|
}
|
|
|
|
rawData = new DisplayItemInfoRawData
|
|
{
|
|
TargetPos = targetPos,
|
|
Index = index,
|
|
PropData = propItem,
|
|
Rarity = propItem.Rarity,
|
|
ItemType = ItemType.Prop,
|
|
Price = 0
|
|
};
|
|
return true;
|
|
}
|
|
|
|
private void RecycleWeapon(int index, int price)
|
|
{
|
|
if (_useCase == null || Context == null)
|
|
{
|
|
Log.Error("ShopFormController.RecycleWeapon() controller state is invalid.");
|
|
return;
|
|
}
|
|
|
|
bool success = _useCase.TryRecycleWeapon(index, price);
|
|
if (!success)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (Context.WeaponListContext != null)
|
|
{
|
|
int currentCount = Mathf.Max(0, Context.WeaponListContext.CurrentCount - 1);
|
|
Context.WeaponListContext.CurrentCount = currentCount;
|
|
}
|
|
|
|
Form?.RemoveWeaponDisplayItem(index);
|
|
GameEntry.Event.Fire(this, DisplayItemInfoHideEventArgs.Create(true));
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Event Handlers
|
|
|
|
private async void Refresh(object sender, GameEventArgs e)
|
|
{
|
|
if (sender is not ShopForm)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (e is not RefreshEventArgs args)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ShopRefreshResult result = _useCase.TryRefresh(args.Cost);
|
|
if (result == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
await RefreshGoodsItems(result);
|
|
}
|
|
|
|
private void ShopPurchase(object sender, GameEventArgs e)
|
|
{
|
|
ShopPurchaseAsync(sender, e).Forget();
|
|
}
|
|
|
|
private async UniTaskVoid ShopPurchaseAsync(object sender, GameEventArgs e)
|
|
{
|
|
if (sender is not ShopForm)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (e is not ShopPurchaseEventArgs args)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ShopPurchaseResult result = await _useCase.TryPurchaseAsync(args.GoodsIndex);
|
|
if (result == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
ApplyGoodsPurchased(result);
|
|
}
|
|
|
|
private void ShopContinue(object sender, GameEventArgs e)
|
|
{
|
|
if (sender is not ShopForm)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (e is not ShopContinueEventArgs)
|
|
{
|
|
return;
|
|
}
|
|
|
|
_useCase?.Continue();
|
|
}
|
|
|
|
private void DisplayItemShow(object sender, GameEventArgs e)
|
|
{
|
|
if (e is not DisplayItemShowEventArgs args)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!IsCurrentFormEventSender(sender))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (_rawData == null)
|
|
{
|
|
Log.Error("ShopFormController.DisplayItemShow() _rawData is null.");
|
|
return;
|
|
}
|
|
|
|
DisplayItemInfoRawData rawData;
|
|
bool success = args.IsWeapon
|
|
? TryGetWeaponInfoRawData(args.Index, args.TargetPos, out rawData)
|
|
: TryGetPropInfoRawData(args.Index, args.TargetPos, out rawData);
|
|
|
|
if (!success)
|
|
{
|
|
return;
|
|
}
|
|
|
|
GameEntry.UIRouter.OpenUIAsync(UIFormType.DisplayItemInfoForm, rawData).Forget();
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|