vuong dinh hoang
727 lines
30 KiB
C#
727 lines
30 KiB
C#
//#define Applyforalicense
|
|
|
|
using BrewMonster.Assets.PerfectWorld.Scripts.UI.GamePlay;
|
|
using BrewMonster.Network;
|
|
using BrewMonster.Scripts;
|
|
using BrewMonster.Scripts.Managers;
|
|
using BrewMonster.Scripts.Skills;
|
|
using BrewMonster.UI;
|
|
using CSNetwork.GPDataType;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
using UnityEngine.Serialization;
|
|
using UnityEngine.UI;
|
|
using static BrewMonster.PET_EGG_ESSENCE;
|
|
|
|
namespace BrewMonster
|
|
{
|
|
public class DlgAssignSlots : AUIDialog
|
|
{
|
|
//[SerializeField] List<Image> m_aSkillImage = new List<Image>();
|
|
//[SerializeField] List<Button> m_aSkillButton = new List<Button>();
|
|
public const int MAX_SKILL_GROUP = 4;
|
|
[SerializeField] List<AUIToggleAssignSlot> _actionSlots = new List<AUIToggleAssignSlot>();
|
|
[SerializeField] Toggle[] toggleGroup = new Toggle[MAX_SKILL_GROUP];
|
|
[SerializeField] Button acceptButton;
|
|
public int m_nCurPanel1 = 1;
|
|
public int m_nCurPanel2 = 1;
|
|
|
|
int currentListIndex = 0;
|
|
int currentOffsetIndex = 0;
|
|
int currentSelectedSlotIndex = -1;
|
|
CECSkill assignedSkill = null;
|
|
private int _pendingComboGroupIndex = -1;
|
|
private int _pendingActionSetIndex = -1;
|
|
private int _pendingActionShortcutIndex = -1;
|
|
private bool _subscribed;
|
|
/// <summary>
|
|
/// Apply for a license remove later
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
|
|
// public int m_nCurPanel1 = 1;
|
|
// public int m_nCurPanel2 = 1;
|
|
public bool m_bShowAll1 = false;
|
|
public bool m_bShowAll2 = false;
|
|
public int m_nDisplayPanels1 = 0;
|
|
public int m_nDisplayPanels2 = 0;
|
|
|
|
|
|
[ContextMenu("SwitchShowSkillShortcut")]
|
|
public void SwitchShowSkillShortcut(int panelIndex)
|
|
{
|
|
currentListIndex = panelIndex;
|
|
UpdateShortcuts();
|
|
}
|
|
|
|
public override void Awake()
|
|
{
|
|
SwitchShowSkillShortcut(0);
|
|
}
|
|
public override void OnEnable()
|
|
{
|
|
UnSubscribeEvents();
|
|
SubscribeEvents();
|
|
currentListIndex = 0;
|
|
CreateCacheData();
|
|
UpdateShortcuts();
|
|
}
|
|
public override void OnDisable()
|
|
{
|
|
UnSubscribeEvents();
|
|
}
|
|
public void OnDestroy()
|
|
{
|
|
UnSubscribeEvents();
|
|
}
|
|
private List<CECShortcutSet> a_pSCS = new List<CECShortcutSet>();
|
|
public bool CreateCacheData()
|
|
{
|
|
int nCurPanel9 = GetCurPanel1();
|
|
int nCurPanel8 = GetCurPanel2();
|
|
CECHostPlayer pHost = EC_Game.GetGameRun().GetHostPlayer();
|
|
if (pHost == null)
|
|
return false;
|
|
a_pSCS = new List<CECShortcutSet>();
|
|
var a_pSCSTemp = new List<CECShortcutSet>();
|
|
var a_pszPanel = new List<string>();
|
|
GetQuickBarNameAndSC(pHost, a_pszPanel, a_pSCSTemp, nCurPanel9, nCurPanel8);
|
|
foreach (var item in a_pSCSTemp)
|
|
{
|
|
var temp = item.Clone();
|
|
a_pSCS.Add(temp);
|
|
}
|
|
return true;
|
|
}
|
|
public void CreateSkillShortcut()
|
|
{
|
|
ClearPendingActionAssign();
|
|
_pendingComboGroupIndex = -1;
|
|
// CECShortcutSet pSCS = CECGameRun.Instance.GetHostPlayer().GetShortcutSet1(0);
|
|
|
|
a_pSCS[currentListIndex].CreateSkillShortcut(currentSelectedSlotIndex, assignedSkill);
|
|
EventBus.Publish(new OnAssignSkillEvent(assignedSkill.GetSkillID(), currentSelectedSlotIndex));
|
|
currentSelectedSlotIndex = -1;
|
|
assignedSkill = null;
|
|
}
|
|
|
|
private bool IsPendingComboAssign()
|
|
{
|
|
return _pendingComboGroupIndex >= 0;
|
|
}
|
|
|
|
private void ClearPendingComboAssign()
|
|
{
|
|
_pendingComboGroupIndex = -1;
|
|
}
|
|
|
|
private void CreateSkillGroupShortcut()
|
|
{
|
|
if (!IsPendingComboAssign() || currentSelectedSlotIndex < 0)
|
|
return;
|
|
if (a_pSCS == null || currentListIndex < 0 || currentListIndex >= a_pSCS.Count)
|
|
return;
|
|
|
|
if (!a_pSCS[currentListIndex].CreateSkillGroupShortcut(currentSelectedSlotIndex, _pendingComboGroupIndex))
|
|
{
|
|
BMLogger.LogError($"DlgAssignSlots::CreateSkillGroupShortcut failed groupIndex={_pendingComboGroupIndex} slot={currentSelectedSlotIndex}");
|
|
return;
|
|
}
|
|
|
|
int comboGroupIndex = _pendingComboGroupIndex;
|
|
EventBus.Publish(new OnAssignSkillEvent(-(comboGroupIndex + 1), currentSelectedSlotIndex));
|
|
currentSelectedSlotIndex = -1;
|
|
ClearPendingComboAssign();
|
|
assignedSkill = null;
|
|
ClearPendingActionAssign();
|
|
UpdateShortcuts();
|
|
}
|
|
|
|
private bool IsPendingActionAssign()
|
|
{
|
|
return _pendingActionSetIndex >= 0 && _pendingActionShortcutIndex >= 0;
|
|
}
|
|
|
|
private void ClearPendingActionAssign()
|
|
{
|
|
_pendingActionSetIndex = -1;
|
|
_pendingActionShortcutIndex = -1;
|
|
}
|
|
|
|
/// <summary>Resolves shortcut from CECGameRun command sets (same order as CDlgSkillSubAction).</summary>
|
|
public static CECShortcut GetActionPaletteShortcut(int setIndex, int indexInSet)
|
|
{
|
|
var run = CECGameRun.Instance;
|
|
if (run == null) return null;
|
|
CECShortcutSet set = setIndex switch
|
|
{
|
|
0 => run.GetGenCmdShortcuts(),
|
|
1 => run.GetTeamCmdShortcuts(),
|
|
2 => run.GetTradeCmdShortcuts(),
|
|
3 => run.GetPoseCmdShortcuts(),
|
|
_ => null
|
|
};
|
|
if (set == null || indexInSet < 0 || indexInSet >= set.GetShortcutNum())
|
|
return null;
|
|
return set.GetShortcut(indexInSet);
|
|
}
|
|
|
|
private void CreateActionShortcut()
|
|
{
|
|
if (!IsPendingActionAssign() || currentSelectedSlotIndex < 0)
|
|
return;
|
|
if (a_pSCS == null || currentListIndex < 0 || currentListIndex >= a_pSCS.Count)
|
|
return;
|
|
|
|
var src = GetActionPaletteShortcut(_pendingActionSetIndex, _pendingActionShortcutIndex);
|
|
if (src == null)
|
|
{
|
|
BMLogger.LogError("DlgAssignSlots::CreateActionShortcut: source shortcut null");
|
|
return;
|
|
}
|
|
var clone = src.Clone();
|
|
if (clone == null)
|
|
{
|
|
BMLogger.LogError("DlgAssignSlots::CreateActionShortcut: Clone() returned null");
|
|
return;
|
|
}
|
|
|
|
a_pSCS[currentListIndex].SetShortcut(currentSelectedSlotIndex, clone);
|
|
int slotIdx = currentSelectedSlotIndex;
|
|
int setIdx = _pendingActionSetIndex;
|
|
int scIdx = _pendingActionShortcutIndex;
|
|
EventBus.Publish(new OnAssignActionEvent(setIdx, scIdx, slotIdx));
|
|
currentSelectedSlotIndex = -1;
|
|
ClearPendingActionAssign();
|
|
ClearPendingComboAssign();
|
|
UpdateShortcuts();
|
|
}
|
|
public bool UpdateShortcuts()
|
|
{
|
|
CECShortcut pSC;
|
|
CECSCSkill pSCSkill;
|
|
AUIImagePictureBase pCell;
|
|
CECSkill pSkill = new CECSkill(-1, -1);
|
|
|
|
if (a_pSCS == null || a_pSCS.Count < 2)
|
|
return false;
|
|
|
|
if(currentListIndex >= a_pSCS.Count )
|
|
{
|
|
currentListIndex = 0;
|
|
}
|
|
|
|
// currentOffsetIndex = 0;
|
|
// for(int i = 0; i < currentListIndex; i++)
|
|
// {
|
|
// if(i == currentListIndex)
|
|
// {
|
|
// break;
|
|
// }
|
|
// currentOffsetIndex += a_pSCS[i].GetShortcutNum();
|
|
// }
|
|
int nSlots = Mathf.Min(a_pSCS[currentListIndex].GetShortcutNum(), _actionSlots.Count);
|
|
for (int j = 0; j < nSlots; j++)
|
|
{
|
|
pCell = _actionSlots[j];
|
|
pSkill = null;
|
|
pCell.SetSlotIndex(j);
|
|
if (pCell == null || !pCell.gameObject.activeInHierarchy)
|
|
continue;
|
|
pSC = a_pSCS[currentListIndex].GetShortcut(j);
|
|
if (pSC != null)
|
|
{
|
|
if (pSC.GetType() == (int)CECShortcut.ShortcutType.SCT_SKILL)
|
|
{
|
|
pSCSkill = (CECSCSkill)pSC;
|
|
pSkill = pSCSkill.GetSkill();
|
|
if (false/*m_bDelGoblinSkillSC && GNET::ElementSkill::IsGoblinSkill(pSkill->GetSkillID())*/)
|
|
{
|
|
/* a_pSCS[i]->SetShortcut(j, NULL);
|
|
pSC = NULL;*/
|
|
}
|
|
}
|
|
|
|
/*else if (pSC->GetType() == CECShortcut::SCT_ITEM)
|
|
{
|
|
iIconFile = CECGameUIMan::ICONS_INVENTORY;
|
|
pCell->SetColor(A3DCOLORRGB(255, 255, 255));
|
|
pSCItem = (CECSCItem*)pSC;
|
|
pIvtr = GetHostPlayer()->GetPack(pSCItem->GetInventory());
|
|
pItem = pIvtr->GetItem(pSCItem->GetIvtrSlot());
|
|
if (pItem && pItem->GetCoolTime(&nMax) > 0)
|
|
{
|
|
pClock->SetProgressRange(0, nMax);
|
|
pClock->SetProgressPos(nMax - pItem->GetCoolTime());
|
|
pClock->SetColor(A3DCOLORRGBA(0, 0, 0, 128));
|
|
}
|
|
if (pSCItem->GetInventory() == IVTRTYPE_EQUIPPACK)
|
|
pCell->SetColor(A3DCOLORRGBA(128, 128, 255, 128));
|
|
}
|
|
else if (pSC->GetType() == CECShortcut::SCT_PET)
|
|
{
|
|
pSCPet = (CECSCPet*)pSC;
|
|
CECPetData* pPet = pPetCorral->GetPetData(pSCPet->GetPetIndex());
|
|
iIconFile = CECGameUIMan::ICONS_INVENTORY;
|
|
pCell->SetColor(A3DCOLORRGB(255, 255, 255));
|
|
if (pPet)
|
|
{
|
|
// dead combat pet
|
|
if ((pPet->GetClass() == GP_PET_CLASS_COMBAT || pPet->GetClass() == GP_PET_CLASS_EVOLUTION) && pPet->GetHPFactor() == 0.0f)
|
|
{
|
|
pCell->SetColor(A3DCOLORRGB(128, 128, 128));
|
|
}
|
|
// current active pet
|
|
else if (pSCPet->IsActivePet())
|
|
{
|
|
pCell->SetColor(A3DCOLORRGB(255, 255, 0));
|
|
}
|
|
}
|
|
}
|
|
else if (pSC->GetType() == CECShortcut::SCT_AUTOFASHION)
|
|
{
|
|
iIconFile = CECGameUIMan::ICONS_SUITE;
|
|
fashionCoolTime = pHost->GetCoolTime(GP_CT_EQUIP_FASHION_ITEM, &fashionCoolTimeMax);
|
|
pCell->SetColor(A3DCOLORRGB(255, 255, 255));
|
|
if (fashionCoolTimeMax > 0)
|
|
{
|
|
pClock->SetProgressRange(0, fashionCoolTimeMax);
|
|
pClock->SetProgressPos(fashionCoolTimeMax - fashionCoolTime);
|
|
pClock->SetColor(A3DCOLORRGBA(0, 0, 0, 175));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iIconFile = CECGameUIMan::ICONS_ACTION;
|
|
if (pSC->GetType() == CECShortcut::SCT_COMMAND)
|
|
{
|
|
CECSCCommand* pCommandSC = (CECSCCommand*)pSC;
|
|
if (GetHostPlayer()->IsInvisible())
|
|
{
|
|
if (pCommandSC->GetCommandID() == CECSCCommand::CMD_STARTTRADE ||
|
|
pCommandSC->GetCommandID() == CECSCCommand::CMD_SELLBOOTH ||
|
|
pCommandSC->GetCommandID() == CECSCCommand::CMD_BINDBUDDY)
|
|
{
|
|
pCell->SetColor(A3DCOLORRGB(128, 128, 128));
|
|
}
|
|
else
|
|
{
|
|
pCell->SetColor(A3DCOLORRGB(255, 255, 255));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pCell->SetColor(A3DCOLORRGB(255, 255, 255));
|
|
}
|
|
}
|
|
|
|
if (pSC->GetCoolTime(&nMax) > 0)
|
|
{
|
|
pClock->SetProgressRange(0, nMax);
|
|
pClock->SetProgressPos(nMax - pSC->GetCoolTime());
|
|
pClock->SetColor(A3DCOLORRGBA(0, 0, 0, 128));
|
|
}
|
|
}*/
|
|
else if (pSC.GetType() == (int)CECShortcut.ShortcutType.SCT_ITEM)
|
|
{
|
|
pCell.SetColor(new Color(1f, 1f, 1f));
|
|
CECSCItem pSCItem = (CECSCItem)pSC;
|
|
EC_Inventory pIvtr = EC_Game.GetGameRun().GetHostPlayer().GetPack(pSCItem.GetInventory());
|
|
EC_IvtrItem pItem = pIvtr?.GetItem(pSCItem.GetIvtrSlot());
|
|
|
|
//if (pSCItem.GetInventory == InventoryConst.IVTRTYPE_EQUIPPACK)
|
|
//{
|
|
// pCell.SetColor(new Color(128, 128, 255, 128));
|
|
//}
|
|
|
|
if (pItem != null)
|
|
{
|
|
string itemIcon = pItem.GetIconFile();
|
|
GetGameUIMan().SetCover(pCell, itemIcon, EC_GAMEUI_ICONS.ICONS_INVENTORY);
|
|
}
|
|
}
|
|
else if (pSC.GetType() == (int)CECShortcut.ShortcutType.SCT_AUTOFASHION)
|
|
{
|
|
pCell.SetColor(new Color(1f, 1f, 1f));
|
|
}
|
|
else
|
|
{
|
|
if (pSC.GetType() == (int)CECShortcut.ShortcutType.SCT_COMMAND)
|
|
{
|
|
CECSCCommand pCommandSC = (CECSCCommand)pSC;
|
|
if (EC_Game.GetGameRun().GetHostPlayer().IsInvisible())
|
|
{
|
|
if (pCommandSC.GetCommandID() == (int)CECSCCommand.CommandID.CMD_STARTTRADE ||
|
|
pCommandSC.GetCommandID() == (int)CECSCCommand.CommandID.CMD_SELLBOOTH ||
|
|
pCommandSC.GetCommandID() == (int)CECSCCommand.CommandID.CMD_BINDBUDDY)
|
|
{
|
|
pCell.SetColor(new Color(128, 128, 128, 255));
|
|
}
|
|
else
|
|
{
|
|
pCell.SetColor(new Color(1f, 1f, 1f));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pCell.SetColor(new Color(1f, 1f, 1f));
|
|
}
|
|
}
|
|
|
|
string cmdIcon = pSC.GetIconFile();
|
|
GetGameUIMan().SetCover(pCell, cmdIcon, EC_GAMEUI_ICONS.ICONS_ACTION);
|
|
}
|
|
|
|
|
|
if (pSC != null)
|
|
{
|
|
int scType = pSC.GetType();
|
|
bool isSkillGroupShortcut = scType == (int)CECShortcut.ShortcutType.SCT_SKILLGRP;
|
|
if (pCell.GetDataPtr() == pSC && !isSkillGroupShortcut)
|
|
{
|
|
continue;
|
|
}
|
|
pCell.SetDataPtr(pSC);
|
|
if (isSkillGroupShortcut)
|
|
{
|
|
EC_VIDEO_SETTING setting = EC_Game.GetConfigs().GetVideoSettings();
|
|
int groupIndex = ((CECSCSkillGrp)pSC).GetGroupIndex();
|
|
var groupIndexes = new List<int>();
|
|
if (setting.comboSkill != null)
|
|
{
|
|
if (groupIndex >= 0 && groupIndex < setting.comboSkill.Length)
|
|
{
|
|
groupIndexes.Add(groupIndex);
|
|
}
|
|
for (int idx = 0; idx < setting.comboSkill.Length; idx++)
|
|
{
|
|
if (setting.comboSkill[idx].nIcon > 0 && !groupIndexes.Contains(idx))
|
|
{
|
|
groupIndexes.Add(idx);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pCell is AUIToggleAssignSlot assignSlot)
|
|
{
|
|
assignSlot.SetSkillGroupIconsForAssign(groupIndexes, groupIndex);
|
|
}
|
|
else
|
|
{
|
|
if (groupIndexes.Count > 0)
|
|
{
|
|
GetGameUIMan().SetCover(pCell, AUIToggleAssignSlot.DefaultComboIcon, EC_GAMEUI_ICONS.ICONS_SKILLGRP);
|
|
}
|
|
else
|
|
{
|
|
pCell.Clear();
|
|
}
|
|
}
|
|
}
|
|
else if (pSC.GetType() == (int)CECShortcut.ShortcutType.SCT_COMMAND)
|
|
{
|
|
GetGameUIMan().SetCover(pCell, ((CECSCCommand)pSC).GetIconFile(), EC_GAMEUI_ICONS.ICONS_ACTION);
|
|
}
|
|
else
|
|
{
|
|
if (pSkill != null)
|
|
{
|
|
pCell.gameObject.SetActive(true);
|
|
var nameskill = ElementSkill.GetIcon((uint)pSkill.GetSkillID());
|
|
var slot = GetGameUIMan().SetCover(pCell, nameskill, EC_GAMEUI_ICONS.ICONS_SKILL);
|
|
if (slot is AUIImagePicture picture)
|
|
{
|
|
picture.SetSkillId(pSkill.GetSkillID());
|
|
}
|
|
}
|
|
/* af_GetFileTitle(pSC->GetIconFile(), strFile);
|
|
strFile.MakeLower();
|
|
pCell->SetCover(GetGameUIMan()->m_pA2DSpriteIcons[iIconFile],
|
|
GetGameUIMan()->m_IconMap[iIconFile][strFile]); */
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pCell.Clear();
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
private void GetQuickBarNameAndSC(CECHostPlayer pHost, List<string> pszPanel, List<CECShortcutSet> pSCS, int panel9, int panel8)
|
|
{
|
|
string dlgName;
|
|
|
|
dlgName = $"Win_Quickbar{Shortcut.SIZE_HOSTSCSET1}Ha";
|
|
pszPanel.Add(dlgName);
|
|
|
|
for (int i = 0; i < (int)Shortcut.NUM_HOSTSCSETS1; i++)
|
|
{
|
|
dlgName = $"Win_Quickbar{(int)Shortcut.SIZE_HOSTSCSET1}Hb_{i + 1}";
|
|
pSCS?.Add(pHost.GetShortcutSet1(i));
|
|
pszPanel.Add(dlgName);
|
|
}
|
|
|
|
/*// ----- Quickbar 1 Vertical A -----
|
|
dlgName = $"Win_Quickbar{(int)Shortcut.SIZE_HOSTSCSET1}Va";
|
|
pszPanel.Add(dlgName);
|
|
|
|
for (int i = 0; i < (int)Shortcut.NUM_HOSTSCSETS1; i++)
|
|
{
|
|
dlgName = $"Win_Quickbar{(int)Shortcut.SIZE_HOSTSCSET1}Vb_{i + 1}";
|
|
pSCS?.Add(pHost.GetShortcutSet1(i));
|
|
pszPanel.Add(dlgName);
|
|
}*/
|
|
|
|
// ----- Quickbar 2 Horizontal A -----
|
|
dlgName = $"Win_Quickbar{(int)Shortcut.SIZE_HOSTSCSET2}Ha";
|
|
pszPanel.Add(dlgName);
|
|
|
|
for (int i = 0; i < (int)Shortcut.NUM_HOSTSCSETS2; i++)
|
|
{
|
|
dlgName = $"Win_Quickbar{(int)Shortcut.SIZE_HOSTSCSET2}Hb_{i + 1}";
|
|
pSCS?.Add(pHost.GetShortcutSet2(i));
|
|
pszPanel.Add(dlgName);
|
|
}
|
|
|
|
/* // ----- Quickbar 2 Vertical A -----
|
|
dlgName = $"Win_Quickbar{(int)Shortcut.SIZE_HOSTSCSET2}Va";
|
|
pszPanel.Add(dlgName);
|
|
|
|
for (int i = 0; i < (int)Shortcut.NUM_HOSTSCSETS2; i++)
|
|
{
|
|
dlgName = $"Win_Quickbar{(int)Shortcut.SIZE_HOSTSCSET2}Vb_{i + 1}";
|
|
pSCS?.Add(pHost.GetShortcutSet2(i));
|
|
pszPanel.Add(dlgName);
|
|
}*/
|
|
}
|
|
|
|
public int GetCurPanel1()
|
|
{
|
|
return m_nCurPanel1;
|
|
}
|
|
public int GetCurPanel2()
|
|
{
|
|
return m_nCurPanel2;
|
|
}
|
|
|
|
public void OnAssignSkillSelectionChanged(AssignSkillSelectionChangedEvent obj)
|
|
{
|
|
if (obj.selected)
|
|
{
|
|
if (obj.skillID < 0)
|
|
{
|
|
// Combo group is encoded as -(groupIndex + 1).
|
|
_pendingComboGroupIndex = -obj.skillID - 1;
|
|
assignedSkill = null;
|
|
ClearPendingActionAssign();
|
|
if (currentSelectedSlotIndex != -1)
|
|
{
|
|
CreateSkillGroupShortcut();
|
|
}
|
|
return;
|
|
}
|
|
|
|
ClearPendingComboAssign();
|
|
ClearPendingActionAssign();
|
|
assignedSkill = CECGameRun.Instance.GetHostPlayer().GetPositiveSkillByID(obj.skillID);
|
|
if (currentSelectedSlotIndex != -1)
|
|
{
|
|
CreateSkillShortcut();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
assignedSkill = null;
|
|
ClearPendingComboAssign();
|
|
}
|
|
}
|
|
|
|
public void OnAssignActionSelectionChanged(AssignActionSelectionChangedEvent obj)
|
|
{
|
|
if (obj.selected)
|
|
{
|
|
assignedSkill = null;
|
|
ClearPendingComboAssign();
|
|
_pendingActionSetIndex = obj.actionSetIndex;
|
|
_pendingActionShortcutIndex = obj.shortcutIndexInSet;
|
|
if (currentSelectedSlotIndex != -1)
|
|
CreateActionShortcut();
|
|
}
|
|
else
|
|
{
|
|
ClearPendingActionAssign();
|
|
}
|
|
}
|
|
|
|
private void OnAssignSkillCommitted(OnAssignSkillEvent e)
|
|
{
|
|
foreach (var slot in _actionSlots)
|
|
{
|
|
if (slot == null) continue;
|
|
if (slot.GetSlotIndexForAssign() != e.slotIndex) continue;
|
|
if (e.skillID < 0)
|
|
{
|
|
int comboGroupIndex = -e.skillID - 1;
|
|
EC_VIDEO_SETTING? setting = EC_Game.GetConfigs()?.GetVideoSettings();
|
|
int nIcon = 0;
|
|
if (setting.HasValue && setting.Value.comboSkill != null &&
|
|
comboGroupIndex >= 0 && comboGroupIndex < setting.Value.comboSkill.Length)
|
|
{
|
|
nIcon = setting.Value.comboSkill[comboGroupIndex].nIcon;
|
|
}
|
|
slot.SetSkillGroupIconForAssign(comboGroupIndex, nIcon);
|
|
slot.UncheckAfterAssign();
|
|
return;
|
|
}
|
|
var host = CECGameRun.Instance.GetHostPlayer();
|
|
if (host == null) return;
|
|
var processSkill = host.GetPositiveSkillByID(e.skillID);
|
|
if (processSkill == null) return;
|
|
var slotSkill = EC_Game.GetGameRun().GetUIManager().GetInGameUIMan().SetCover(slot, processSkill.GetIconFile(), EC_GAMEUI_ICONS.ICONS_SKILL);
|
|
if (slotSkill is AUIImagePicture picture)
|
|
{
|
|
picture.SetSkillId(e.skillID);
|
|
}
|
|
slot.UncheckAfterAssign();
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void OnAssignActionCommitted(OnAssignActionEvent e)
|
|
{
|
|
if (a_pSCS == null || currentListIndex < 0 || currentListIndex >= a_pSCS.Count)
|
|
return;
|
|
var sc = a_pSCS[currentListIndex].GetShortcut(e.quickbarSlotIndex);
|
|
foreach (var slot in _actionSlots)
|
|
{
|
|
if (slot == null) continue;
|
|
if (slot.GetSlotIndexForAssign() != e.quickbarSlotIndex) continue;
|
|
if (sc != null)
|
|
EC_Game.GetGameRun().GetUIManager().GetInGameUIMan().SetCover(slot, sc.GetIconFile(), EC_GAMEUI_ICONS.ICONS_ACTION);
|
|
slot.UncheckAfterAssign();
|
|
return;
|
|
}
|
|
}
|
|
|
|
private void UnSubscribeEvents()
|
|
{
|
|
acceptButton.onClick.RemoveListener(AcceptSkillChange);
|
|
EventBus.Unsubscribe<AssignSkillSelectionChangedEvent>(OnAssignSkillSelectionChanged);
|
|
EventBus.Unsubscribe<AssignActionSelectionChangedEvent>(OnAssignActionSelectionChanged);
|
|
EventBus.Unsubscribe<OnAssignSkillEvent>(OnAssignSkillCommitted);
|
|
EventBus.Unsubscribe<OnAssignActionEvent>(OnAssignActionCommitted);
|
|
for(int i = 0; i < MAX_SKILL_GROUP; i++)
|
|
{
|
|
toggleGroup[i].onValueChanged.RemoveAllListeners();
|
|
}
|
|
foreach (var auiToggle in _actionSlots)
|
|
{
|
|
auiToggle.OnSetSlot -= OnClickedAssignSlot;
|
|
}
|
|
}
|
|
private void SubscribeEvents()
|
|
{
|
|
acceptButton.onClick.AddListener(AcceptSkillChange);
|
|
EventBus.Subscribe<AssignSkillSelectionChangedEvent>(OnAssignSkillSelectionChanged);
|
|
EventBus.Subscribe<AssignActionSelectionChangedEvent>(OnAssignActionSelectionChanged);
|
|
EventBus.Subscribe<OnAssignSkillEvent>(OnAssignSkillCommitted);
|
|
EventBus.Subscribe<OnAssignActionEvent>(OnAssignActionCommitted);
|
|
for(int i = 0; i < MAX_SKILL_GROUP; i++)
|
|
{
|
|
int capturedIndex = i; // avoid closure capturing loop variable
|
|
if (toggleGroup[capturedIndex] == null) continue;
|
|
toggleGroup[capturedIndex].onValueChanged.AddListener((bool value) => OnToggleSkillGroupChanged(capturedIndex, value));
|
|
}
|
|
|
|
foreach (var auiToggle in _actionSlots)
|
|
{
|
|
auiToggle.OnSetSlot += OnClickedAssignSlot;
|
|
}
|
|
}
|
|
|
|
private void OnClickedAssignSlot(bool isActive, int slotIndex)
|
|
{
|
|
if (isActive)
|
|
{
|
|
currentSelectedSlotIndex = slotIndex;
|
|
if (assignedSkill != null)
|
|
{
|
|
CreateSkillShortcut();
|
|
}
|
|
else if (IsPendingComboAssign())
|
|
{
|
|
CreateSkillGroupShortcut();
|
|
}
|
|
else if (IsPendingActionAssign())
|
|
{
|
|
CreateActionShortcut();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
currentSelectedSlotIndex = -1;
|
|
}
|
|
}
|
|
|
|
private void OnToggleSkillGroupChanged(int index, bool value)
|
|
{
|
|
if (index < 0 || index >= MAX_SKILL_GROUP) return;
|
|
if(value)
|
|
{
|
|
SwitchShowSkillShortcut(index);
|
|
}
|
|
}
|
|
public void AcceptSkillChange()
|
|
{
|
|
int nCurPanel9 = GetCurPanel1();
|
|
int nCurPanel8 = GetCurPanel2();
|
|
CECHostPlayer pHost = EC_Game.GetGameRun().GetHostPlayer();
|
|
if (pHost == null) return;
|
|
var real_pSCS = new List<CECShortcutSet>();
|
|
var a_pszPanel = new List<string>();
|
|
GetQuickBarNameAndSC(pHost, a_pszPanel, real_pSCS, nCurPanel9, nCurPanel8);
|
|
if (a_pSCS == null || a_pSCS.Count == 0 || real_pSCS == null || real_pSCS.Count == 0)
|
|
return;
|
|
|
|
int setCount = Mathf.Min(a_pSCS.Count, real_pSCS.Count);
|
|
for (int i = 0; i < setCount; i++)
|
|
{
|
|
CECShortcutSet cachedSet = a_pSCS[i];
|
|
CECShortcutSet realSet = real_pSCS[i];
|
|
if (cachedSet == null || realSet == null)
|
|
continue;
|
|
|
|
int slotCount = Mathf.Min(cachedSet.GetShortcutNum(), realSet.GetShortcutNum());
|
|
for (int j = 0; j < slotCount; j++)
|
|
{
|
|
CECShortcut cachedSC = cachedSet.GetShortcut(j);
|
|
if (cachedSC == null)
|
|
{
|
|
realSet.SetShortcut(j, null);
|
|
continue;
|
|
}
|
|
|
|
if (cachedSC.GetType() == (int)CECShortcut.ShortcutType.SCT_SKILL)
|
|
{
|
|
CECSkill skill = (cachedSC as CECSCSkill)?.GetSkill();
|
|
if (skill != null)
|
|
realSet.CreateSkillShortcut(j, skill);
|
|
else
|
|
realSet.SetShortcut(j, null);
|
|
}
|
|
else
|
|
{
|
|
// Mirror cached shortcut as-is (including null), for non-skill types.
|
|
realSet.SetShortcut(j, cachedSC);
|
|
}
|
|
}
|
|
}
|
|
|
|
EC_Game.GetGameRun().SaveConfigsToServer();
|
|
CECUIManager.Instance?.UpdateSkillRelatedUI();
|
|
}
|
|
}
|
|
}
|