protected override bool AKEvent(FC_KEY_BIND ekb, bool isPress)
{
if (!_isFinalAttack)
{
if (ekb > FC_KEY_BIND.DIRECTION && isPress)
{
ekb = _currentBindKey;
if (!_beginToCountTime)
{
_timeCount = 0;
_beginToCountTime = true;
}
_keyCount++;
if (_keyCount >= _keyCountToMaxPower)
{
_currentPortIdx = 0;
}
}
}
else
{
base.AKEvent(ekb, isPress);
}
return(true);
}
public void SetKeyState(FC_KEY_BIND ekb, bool enableKey)
{
if (ekb != FC_KEY_BIND.NONE)
{
if (ekb == FC_KEY_BIND.MAX)
{
_keyCache[0]._beEnable = enableKey;
ClearKeyPress(0);
if (_keyCache != null && _keyCache.Length > 0)
{
for (int i = 1; i < FCConst.FC_KEY_FOR_TOUCH; i++)
{
_owner.ACOwner._enableInputKey((FC_KEY_BIND)i, enableKey);
_keyCache[i]._beEnable = enableKey;
ClearKeyPress(i);
}
}
}
else
{
_keyCache[(int)ekb]._beEnable = enableKey;
ClearKeyPress((int)ekb);
if (ekb > FC_KEY_BIND.DIRECTION)
{
_owner.ACOwner._enableInputKey(ekb, enableKey);
}
}
}
RefreshActiveKey();
}
private void BindSkillKey()
{
int keyCantSee = FCConst.FC_KEY_FOR_TOUCH;
foreach (FCSkillMap skillMap in _skillMaps)
{
foreach (FCSkillConfig config in skillMap._skillConfigs)
{
if (IsSkill(config._skillName))
{
FC_KEY_BIND key = GetSkillKeyBind(config._skillName);
if (key == FC_KEY_BIND.NONE && _owner.IsPlayerSelf)
{
key = (FC_KEY_BIND)keyCantSee;
keyCantSee++;
if (keyCantSee > FCConst.FC_KEY_MAX - 1)
{
break;
}
}
config._keyBind = key;
}
}
}
}
void SetSkillIcon(FC_KEY_BIND pos, Texture2D icon)
{
GameObject skillButton = _skillIcons[(int)pos - 1];
if (icon != null)
{
skillButton.SetActive(true);
UITexture tex = _skillTexes[(int)pos - 1];
tex.mainTexture = icon;
if (_skillTextures[(int)pos - 1] != null)
{
Resources.UnloadAsset(_skillTextures[(int)pos - 1]);
}
_skillTextures[(int)pos - 1] = icon;
}
else // There is no skill in this slot.
{
skillButton.SetActive(false);
if (_skillTextures[(int)pos - 1] != null)
{
Resources.UnloadAsset(_skillTextures[(int)pos - 1]);
}
_skillTextures[(int)pos - 1] = null;
}
}
public void ReleaseKey(FC_KEY_BIND keyb)
{
int keyValue = (int)keyb;
_keyCache[keyValue]._keyPress = false;
_keyCache[keyValue]._curPriority = -1;
RefreshActiveKey();
}
protected override bool AKEvent(FC_KEY_BIND ekb, bool isPress)
{
if (_currentState == AttackBase.ATTACK_STATE.STEP_1 ||
_currentState == AttackBase.ATTACK_STATE.STEP_2)
{
return(true);
}
return(false);
}
protected override bool AKEvent(FC_KEY_BIND ekb, bool isPress)
{
if (ekb == _currentBindKey)
{
_currentCDTime -= Time.deltaTime * _cdDecreaseSpeed;
_keyEffectTimeCounter = _keyEffectTime;
_currentCDTime = Mathf.Clamp(_currentCDTime, _minCDTime, _maxCDTime);
}
return(true);
}
public bool keyIsPress(FC_KEY_BIND keyb)
{
int keyValue = (int)keyb;
if (keyValue < 0)
{
return(false);
}
return(_keyCache[keyValue]._keyPress && _keyCache[keyValue]._beActive);
}
public void UpdateInputKeyState(FC_KEY_BIND keyBind, float timeLast, float timeLastPercent)
{
UILabel label = _skillLabels[(int)keyBind - 1];
label.text = Mathf.RoundToInt(timeLast).ToString();
if (label.text == "0")
{
label.text = "";
}
}
public int CompareTwoSkillPriority(FC_KEY_BIND keya, FC_KEY_BIND keyb)
{
int keyValuea = (int)keya;
int keyValueb = (int)keyb;
if (keyValuea >= 0 && keyValueb >= 0)
{
return(_keyCache[keyValuea]._orgPriority - _keyCache[keyValueb]._orgPriority);
}
return(0);
}
protected override bool AKEvent(FC_KEY_BIND ekb, bool isPress)
{
if (ekb > FC_KEY_BIND.DIRECTION && isPress)
{
ekb = _currentBindKey;
}
else
{
base.AKEvent(ekb, isPress);
}
return(true);
}
protected override bool AKEvent(FC_KEY_BIND ekb, bool isPress)
{
if (_currentState == AttackBase.ATTACK_STATE.STEP_1)
{
if (isPress == true && ekb == _currentBindKey)
{
_owner.AttackCountAgent.NextSkillID = _owner.AttackCountAgent.CurrentSkillID;
}
return(true);
}
return(false);
}
public void PressKey(FC_KEY_BIND keyb)
{
int keyValue = (int)keyb;
if (keyValue == 0 || (_keyCache[keyValue]._skillIdx >= 0 &&
_owner.AttackCountAgent.SkillIsCD(_keyCache[keyValue]._skillIdx)))
{
_keyCache[keyValue]._keyPress = true;
if (_keyCache[keyValue]._curPriority < _keyCache[keyValue]._orgPriority)
{
_keyCache[keyValue]._curPriority = _keyCache[keyValue]._orgPriority;
}
RefreshActiveKey();
}
}
void SetSkillState(FC_KEY_BIND pos, bool active)
{
int skillIndex = (int)pos - 1;
if (pos == FC_KEY_BIND.ATTACK_5)
{
ActionController ac = ObjectManager.Instance.GetMyActionController();
if (null != ac)
{
active = ac.SkillGodDownActive;
}
}
SetState(_skillButton[skillIndex], _skillTexes[skillIndex], _skillLabels[skillIndex], _skillParticles[skillIndex], active);
}
private FC_KEY_BIND GetSkillKeyBind(string skillName)
{
FC_KEY_BIND key = FC_KEY_BIND.NONE;
for (int i = 0; i < _skillMaps.Length; i++)
{
FCSkillConfig[] sc = _skillMaps[i]._skillConfigs;
for (int j = 0; j < sc.Length; j++)
{
if (sc[j]._skillName == skillName)
{
key = sc[j]._keyBind;
}
}
}
return(key);
//List<string> usedSkill = PlayerInfo.Instance.activeSkillList;
//for(int i = 0; i< usedSkill.Count; i++)
//{
// if (usedSkill[i] == skillName)
// {
// if(i == 0)
// {
// return FC_KEY_BIND.ATTACK_2;
// }
// else if( i== 1)
// {
// return FC_KEY_BIND.ATTACK_3;
// }
// else if( i== 2)
// {
// return FC_KEY_BIND.ATTACK_4;
// }
// else if( i== 3)
// {
// return FC_KEY_BIND.ATTACK_5;
// }
// }
//}
//return key;
}
private void ConfigureSkillIcons()
{
for (FC_KEY_BIND key = FC_KEY_BIND.ATTACK_2; key <= FC_KEY_BIND.ATTACK_5; key++)
{
SkillData sd = DataManager.Instance.GetSkillByKey(key);
if (sd != null)
{
Texture2D tex = InJoy.AssetBundles.AssetBundles.Load(sd.iconPath) as Texture2D;
SetSkillIcon(key, tex);
}
else
{
SetSkillIcon(key, null);
}
}
}
public void RefreshActiveKey()
{
int key = -1;
int keyP = 0;
int i = 0;
for (; i < _keyCache.Length; i++)
{
if (_keyCache[i]._beActive &&
_keyCache[i]._beEnable &&
_keyCache[i]._keyPress == true &&
_keyCache[i]._curPriority > keyP)
{
key = i;
keyP = _keyCache[i]._curPriority;
}
}
_activeKey = (FC_KEY_BIND)key;
}
public SkillData GetSkillByKey(FC_KEY_BIND key)
{
int pos = (int)key - 2;
List <string> usedSkills = PlayerInfo.Instance.activeSkillList;
List <SkillData> usedSkillsData = GetCurrentUsedSkill();
if (pos >= usedSkills.Count || usedSkills[pos] == "")
{
return(null);
}
foreach (SkillData sd in usedSkillsData)
{
if (usedSkills[pos] == sd.skillID)
{
return(sd);
}
}
return(null);
}
protected override bool AKEvent(FC_KEY_BIND ekb, bool isPress)
{
if (ekb != FC_KEY_BIND.NONE && ekb != FC_KEY_BIND.DIRECTION && isPress)
{
ekb = _currentBindKey;
}
base.AKEvent(ekb, isPress);
if (_shadowStep == 1 && ekb == _currentBindKey)
{
if (isPress)
{
_countForBolt++;
}
if (_countForBolt >= _countMaxForShowBolt)
{
_boltCount++;
if (_boltCount >= _boltMaxCount)
{
_boltCount = _boltMaxCount;
_strikeCount = _strikeCountMax;
}
UIBattleSkillTips.Instance.NextStar();
_battleCharEffect.ShowEffect(_boltCount);
_countForBolt = 0;
}
if (isPress)
{
_currentCDTime -= _cdTimeChangeSpeed * Time.deltaTime;
_currentCDTime = Mathf.Clamp(_currentCDTime, _skrikeCoolDownTimeMin, _skrikeCoolDownTime);
}
else
{
_currentCDTime += _cdTimeRecoverSpeed * Time.deltaTime;
_currentCDTime = Mathf.Clamp(_currentCDTime, _skrikeCoolDownTimeMin, _skrikeCoolDownTime);
}
}
return(true);
}
protected override bool AKEvent(FC_KEY_BIND ekb, bool isPress)
{
return(true);
}
void EnableInputKey(FC_KEY_BIND keyBind, bool beActive)
{
SetSkillState(keyBind, beActive);
}
protected override bool AKEvent(FC_KEY_BIND ekb, bool isPress)
{
return(base.AKEvent(ekb, isPress));
}
