void OnSoulStone( AsIMessage _msg)
{
Msg_CharSkillSoulStone soul = _msg as Msg_CharSkillSoulStone;
soul.SetPlayerFsm( this);
eGENDER gender = m_Entity.GetProperty<eGENDER>(eComponentProperty.GENDER);
Msg_Player_Skill_Ready ready = new Msg_Player_Skill_Ready( soul.soul_.nSkillTableIdx, soul.soul_.nSkillLevel, gender);
ready.SetCurrentTarget( Target);
if( ready.skillRecord.CheckNonAnimation() == true)
{
TargetDecider.sTargeting_AsSlot( this, ready.skillRecord);
if( TargetDecider.CheckValidSkill( this, ready.skillRecord) == false)
return;
if( TargetDecider.TargetSkillCheck( ready.skillRecord.Index, this) == false)
return;
int mainTargetIdxNpc = 0;
uint mainTargetIdxUser = 0;
TargetDecider decider = new TargetDecider();
if( decider.SetTarget( this, ready) == true)
{
mainTargetIdxNpc = decider.listTargets_Npc[0];
mainTargetIdxUser = decider.listTargets_User[0];
if( mainTargetIdxNpc != int.MaxValue && mainTargetIdxUser != uint.MaxValue)
{
AS_CS_CHAR_ATTACK_NPC attack = new AS_CS_CHAR_ATTACK_NPC( ready.skillLvRecord.Skill_GroupIndex,
ready.skillLvRecord.Skill_Level, ready.actionRecord.Index,
0, false, false, ready.itemSlot,
decider.listTargets_Npc , decider.listTargets_User, ready.picked, transform.forward,
decider.decidedEntities.TargetCount, decider.decidedEntities.CharCount,
decider.decidedEntities.listTarget.ToArray(), decider.decidedEntities.listChar.ToArray());
attack.SetEquipSlot( soul.soul_.eEquipSlot);
// if( showSendingPacket == true)
// {
Tbl_Action_Record action = AsTableManager.Instance.GetTbl_Action_Record( attack.nActionTableIdx);
Debug.Log( "OnActionItem::SendingPacket: action name=" + action.ActionName +
" skill index=" + attack.nSkillTableIdx +
" skill level=" + attack.nSkillLevel + " action index=" + attack.nActionTableIdx +
" charge step=" + attack.nChargeStep + " casting=" + attack.bCasting + " attack.nSlot =" + attack.nSlot +
" main target id=" + attack.nNpcIdx[0] + " skill pos=" + attack.sTargeting +
" transform.forward=" + transform.forward);
// }
byte[] bytes = attack.ClassToPacketBytes();
AsCommonSender.Send( bytes);
}
}
}
}
bool CheckSkillMovable( Msg_Player_Skill_Ready _ready)
{
Tbl_Action_HitAnimation hitAnim = _ready.actionRecord.HitAnimation;
if( hitAnim == null)
return true;
switch( hitAnim.MoveType)
{
case eHitMoveType.Dash:
case eHitMoveType.TargetDash:
case eHitMoveType.TabDash:
float moveDist = hitAnim.MoveDistance * 0.01f;
Vector3 dir = Vector3.zero;
switch( _ready.skillRecord.Attack_Direction)
{
case eATTACK_DIRECTION.Camera:
dir = Camera.mainCamera.transform.position;
break;
case eATTACK_DIRECTION.FingerPoint:
case eATTACK_DIRECTION.LineEnd:
dir = GetWorldPositionFromCamera( _ready.tail);
break;
case eATTACK_DIRECTION.LineMiddle:
dir = GetWorldPositionFromCamera( _ready.center);
break;
case eATTACK_DIRECTION.LineStart:
dir = GetWorldPositionFromCamera( _ready.head);
break;
case eATTACK_DIRECTION.Target:
if( Target != null)
dir = Target.transform.position;
else
return false;
break;
default:
return true;
}
dir = dir - transform.position; dir.Normalize();
Vector3 dest = dir * moveDist + transform.position;
float dist = m_Entity.GetNavPathDistance( transform.position, dest, true);
if( dist > moveDist + 0.1f) // revision
return false;
else
return true;
default:
return true;
}
}
void OnSkillDoubleTap( AsIMessage _msg)
{
Msg_Input_DoubleTab doubleTap = _msg as Msg_Input_DoubleTab;
if( AsPStoreManager.Instance.UnableActionByPStore() == true)
{
if( doubleTap.type_ == Msg_Input_DoubleTab.eDoubleTabType.Player)
m_CurrentFsmState.MessageProcess( new Msg_OpenPrivateShopUI());
return;
}
if( CheckSpecificWindowOpened() == true)
return;
// if( CheckMap_Village() == true)
// {
// string content = AsTableManager.Instance.GetTbl_String(830);
// AsChatManager.Instance.InsertChat( content, eCHATTYPE.eCHATTYPE_SYSTEM, true);
// return;
// }
if( WeaponEquip == false)
{
AsMyProperty.Instance.AlertNoWeapon();
return;
}
eCLASS __class = UserEntity.GetProperty<eCLASS>( eComponentProperty.CLASS);
Tbl_Skill_Record skill = null;
int idx = -1;
eCommandPicking_Type pickingType = eCommandPicking_Type.NONE;
switch( doubleTap.type_)
{
case Msg_Input_DoubleTab.eDoubleTabType.Terrain:
case Msg_Input_DoubleTab.eDoubleTabType.OtherUser:
case Msg_Input_DoubleTab.eDoubleTabType.Monster:
idx = (int)COMMAND_SKILL_TYPE._DOUBLE_TAP_MONSTER;
pickingType = eCommandPicking_Type.FingerPoint;
break;
case Msg_Input_DoubleTab.eDoubleTabType.Player:
idx = (int)COMMAND_SKILL_TYPE._DOUBLE_TAP_PLAYER;
pickingType = eCommandPicking_Type.Self;
break;
// case Msg_Input_DoubleTab.eDoubleTabType.OtherUser:
// idx = (int)COMMAND_SKILL_TYPE._DOUBLE_TAP_OTHERUSER;
// break;
// case Msg_Input_DoubleTab.eDoubleTabType.Monster:
// idx = (int)COMMAND_SKILL_TYPE._DOUBLE_TAP_MONSTER;
// pickingType = eCommandPicking_Type.Enemy;
// break;
}
// skill = AsTableManager.Instance.GetTbl_Skill_RecordByPickingType( __class, pickingType);
skill = SkillBook.Instance.GetLearnedDoubleTapSkill( pickingType);
if( null == skill)
return;
if( SkillBook.Instance.dicCurSkill.ContainsKey( skill.Index) == false)
return;
else if( CheckMap_Village() == true)
{
// string content = AsTableManager.Instance.GetTbl_String(830);
// AsChatManager.Instance.InsertChat( content, eCHATTYPE.eCHATTYPE_SYSTEM, true);
AsMyProperty.Instance.AlertSkillInTown();
return;
}
if( AsUserInfo.Instance.CommandSkillCoolTimeCompletion[idx] == true)
{
if( false == IsAvailableDoubleTapSkill( __class, pickingType))
return;
if( skill == null)
{
Debug.LogError( "AsPlayerFsm::OnSkillDoubleTap: this character[" + __class + "] doesnt have [" + doubleTap.type_ + "]type skill");
return;
}
eGENDER gender = UserEntity.GetProperty<eGENDER>( eComponentProperty.GENDER);
AsBaseEntity entity = AsEntityManager.Instance.GetEntityByInstanceId( doubleTap.input_.inputObject_.GetInstanceID());
Vector3 skillPos = Vector3.zero;
if( entity == null)
skillPos = doubleTap.input_.worldPosition_;
else
skillPos = entity.transform.position;
Msg_Player_Skill_Ready ready = new Msg_Player_Skill_Ready( skill, gender, 1,
entity, skillPos,
doubleTap.input_.screenPosition_, doubleTap.input_.screenPosition_, doubleTap.input_.screenPosition_,
doubleTap.input_.worldPosition_ - m_Entity.transform.position, eClockWise.CW);
// if( ready.constructSucceed == true)
// m_CurrentFsmState.MessageProcess( ready);
if( ready.constructSucceed == true)
{
if( TargetDecider.CheckDisableSkillByMap(ready.skillRecord) == true)
return;
if( AsCommonSender.CheckSkillUseProcessing() == true)
return;
if( m_Entity.CheckCondition( eSkillIcon_Enable_Condition.Movable) == false &&
ready.skillRecord.CheckSkillUsingOnly_Movable() == true)
{
AsMyProperty.Instance.AlertState();
return;
}
if( Vector3.Distance( Entity.transform.position, ready.picked) >
ready.skillLvRecord.Usable_Distance * 0.01f)// * m_Character_Size)
{
Msg_Player_Skill_Target_Move targetMove = new Msg_Player_Skill_Target_Move( ready, AsPlayerState_BattleRun.eRunType.NonTarget);
m_CurrentFsmState.MessageProcess( targetMove);
}
else
m_CurrentFsmState.MessageProcess( ready);
}
}
else
{
AsMyProperty.Instance.AlertCoolTime( ( COMMAND_SKILL_TYPE)idx);
}
}
void OnActionItem( AsIMessage _msg)
{
if( AsPStoreManager.Instance.UnableActionByPStore() == true)
return;
if( CheckSpecificWindowOpened() == true)
return;
Msg_Player_Use_ActionItem msg = _msg as Msg_Player_Use_ActionItem;
ItemData itemData = msg.realItem.item.ItemData;
Tbl_Skill_Record record = AsTableManager.Instance.GetTbl_Skill_Record( itemData.itemSkill);
eGENDER gender = UserEntity.GetProperty<eGENDER>( eComponentProperty.GENDER);
Msg_Player_Skill_Ready ready = new Msg_Player_Skill_Ready( itemData, msg.realItem.getSlot, gender);
ready.SetCurrentTarget( Target);
if( CheckMap_Village() == true && ready.constructSucceed == true)
{
// string content = AsTableManager.Instance.GetTbl_String(830);
// AsChatManager.Instance.InsertChat( content, eCHATTYPE.eCHATTYPE_SYSTEM, true);
AsMyProperty.Instance.AlertSkillInTown();
return;
}
// Msg_Player_Use_ActionItem msg = _msg as Msg_Player_Use_ActionItem;
// ItemData itemData = msg.realItem.item.ItemData;
// Tbl_Skill_Record record = AsTableManager.Instance.GetTbl_Skill_Record( itemData.itemSkill);
bool permit = true;
if( record.Skill_Type == eSKILL_TYPE.SlotBase && m_ElapsedCoolTime_BaseAttack > 0)
permit = false;
if( permit == true)
{
// eGENDER gender = UserEntity.GetProperty<eGENDER>( eComponentProperty.GENDER);
// Msg_Player_Skill_Ready ready = new Msg_Player_Skill_Ready( itemData, msg.realItem.getSlot, gender);
if( ready.constructSucceed == true)
{
if( WeaponEquip == false)
{
AsMyProperty.Instance.AlertNoWeapon();
return;
}
if( null == msg || null == msg.realItem || msg.realItem.CheckSkillUsable() == false)
return;
int iCurLevel = m_Entity.GetProperty<int>( eComponentProperty.LEVEL);
if( iCurLevel < itemData.levelLimit)
{
AsChatManager.Instance.InsertChat( AsTableManager.Instance.GetTbl_String(1651), eCHATTYPE.eCHATTYPE_SYSTEM);
AsEventNotifyMgr.Instance.CenterNotify.AddTradeMessage( AsTableManager.Instance.GetTbl_String(1651));
return;
}
if( AsCommonSender.CheckSkillUseProcessing() == true)
return;
if( m_Entity.CheckCondition( eSkillIcon_Enable_Condition.Movable) == false &&
ready.skillRecord.CheckSkillUsingOnly_Movable() == true)
{
AsMyProperty.Instance.AlertState();
return;
}
// if( SetTargetInActionItem( record) == false)
// return;
TargetDecider.sTargeting_AsSlot( this, ready.skillRecord);
if( TargetDecider.CheckValidSkill( this, ready.skillRecord) == false)
return;
if( m_Target == null &&
( ready.skillRecord.Skill_Type == eSKILL_TYPE.Target ||
ready.skillRecord.Skill_Type == eSKILL_TYPE.SlotBase))
return;
if( TargetDecider.TargetSkillCheck( ready.skillRecord.Index, this) == false)
return;
if( ready.CheckValidTargeting( m_Target) == false)
return;
if( Target != null &&
m_Entity.GetNavPathDistance( Entity.transform.position, Target.transform.position, true) >
ready.skillLvRecord.Usable_Distance * 0.01f)// * m_Character_Size)
{
Debug.Log( "AsPlayerFsm::OnSkillActive: msg.skillIdx_ = " + itemData.itemSkill + ", BattleRun state began [time:" + Time.realtimeSinceStartup + "]");
Msg_Player_Skill_Target_Move targetMove = new Msg_Player_Skill_Target_Move( ready);
m_CurrentFsmState.MessageProcess( targetMove);
}
else
{
Debug.Log( "AsPlayerFsm::OnSkillActive: msg.skillIdx_ = " + itemData.itemSkill + ", SkillReady state began [time:" + Time.realtimeSinceStartup + "]");
m_CurrentFsmState.MessageProcess( ready);
}
}
else if( ready.skillRecord.CheckNonAnimation() == true)
{
if( msg.realItem.CheckSkillUsable() == false)
return;
int iCurLevel = m_Entity.GetProperty<int>( eComponentProperty.LEVEL);
if( iCurLevel < itemData.levelLimit)
{
AsChatManager.Instance.InsertChat( AsTableManager.Instance.GetTbl_String(1651), eCHATTYPE.eCHATTYPE_SYSTEM);
AsEventNotifyMgr.Instance.CenterNotify.AddTradeMessage( AsTableManager.Instance.GetTbl_String(1651));
return;
}
if( AsCommonSender.CheckSkillUseProcessing() == true)
return;
TargetDecider.sTargeting_AsSlot( this, ready.skillRecord);
if( TargetDecider.CheckValidSkill( this, ready.skillRecord) == false)
return;
if( TargetDecider.TargetSkillCheck( ready.skillRecord.Index, this) == false)
return;
int mainTargetIdxNpc = 0;
uint mainTargetIdxUser = 0;
TargetDecider decider = new TargetDecider();
if( decider.SetTarget( this, ready) == true)
{
mainTargetIdxNpc = decider.listTargets_Npc[0];
mainTargetIdxUser = decider.listTargets_User[0];
if( mainTargetIdxNpc != int.MaxValue && mainTargetIdxUser != uint.MaxValue)
{
AS_CS_CHAR_ATTACK_NPC attack = new AS_CS_CHAR_ATTACK_NPC( ready.skillLvRecord.Skill_GroupIndex,
ready.skillLvRecord.Skill_Level, ready.actionRecord.Index,
0, false, false, ready.itemSlot,
decider.listTargets_Npc , decider.listTargets_User, ready.picked, transform.forward,
decider.decidedEntities.TargetCount, decider.decidedEntities.CharCount,
decider.decidedEntities.listTarget.ToArray(), decider.decidedEntities.listChar.ToArray());
if( showSendingPacket == true)
{
Tbl_Action_Record action = AsTableManager.Instance.GetTbl_Action_Record( attack.nActionTableIdx);
Debug.Log( "OnActionItem::SendingPacket: action name=" + action.ActionName +
" skill index=" + attack.nSkillTableIdx +
" skill level=" + attack.nSkillLevel + " action index=" + attack.nActionTableIdx +
" charge step=" + attack.nChargeStep + " casting=" + attack.bCasting + " attack.nSlot =" + attack.nSlot +
" main target id=" + attack.nNpcIdx[0] + " skill pos=" + attack.sTargeting +
" transform.forward=" + transform.forward);
}
// byte[] bytes = attack.ClassToPacketBytes();
// AsCommonSender.Send( bytes);
ePotency_Type potencyType = ready.skillRecord.listSkillPotency[0].Potency_Type;
if( ePotency_Type.NormalHardPlayCount == potencyType || ePotency_Type.HellPlayCount == potencyType || ePotency_Type.HellPlayCountAll == potencyType)
{
if( null != AsHudDlgMgr.Instance && null != AsHudDlgMgr.Instance.invenDlg)
{
AsHudDlgMgr.Instance.invenDlg.ConfirmIndunCountItem( potencyType, attack, itemData, ready.skillRecord.Index);
}
}
else
{
byte[] bytes = attack.ClassToPacketBytes();
AsCommonSender.Send( bytes);
}
}
}
}
}
}
void OnSkillActive( AsIMessage _msg)
{
// Msg_Input_Slot_Active __msg = _msg as Msg_Input_Slot_Active;
// Debug.Log( "AsPlayerFsm::OnSkillActive: __msg.skillIdx_ = " + __msg.skillIdx_);
if( AsPStoreManager.Instance.UnableActionByPStore() == true)
return;
if( CheckSpecificWindowOpened() == true)
return;
if( CheckMap_Village() == true)
{
// string content = AsTableManager.Instance.GetTbl_String(830);
// AsChatManager.Instance.InsertChat( content, eCHATTYPE.eCHATTYPE_SYSTEM, true);
AsMyProperty.Instance.AlertSkillInTown();
return;
}
if( WeaponEquip == false)
{
AsMyProperty.Instance.AlertNoWeapon();
return;
}
Msg_Input_Slot_Active msg = _msg as Msg_Input_Slot_Active;
Tbl_Skill_Record record = AsTableManager.Instance.GetTbl_Skill_Record( msg.skillIdx_);
bool permit = true;
if( record.Skill_Type == eSKILL_TYPE.SlotBase && m_ElapsedCoolTime_BaseAttack > 0)
{
Debug.Log( "AsPlayerFsm::OnSkillActive: SlotBase skill is used in base attack cool time.");
permit = false;
}
// if(record.Skill_Type == eSKILL_TYPE.Stance)
// {
// body_CS_CHAR_SKILL_STANCE stance = new body_CS_CHAR_SKILL_STANCE();
// byte[] bytes = stance.ClassToPacketBytes();
// AsCommonSender.Send(bytes);
//
//// AsCommonSender.BeginSkillUseProcess( record.Index);
// }
if( permit == true)
{
eGENDER gender = UserEntity.GetProperty<eGENDER>( eComponentProperty.GENDER);
Msg_Player_Skill_Ready ready = new Msg_Player_Skill_Ready( record, gender, msg.step_,
null, Vector3.zero, Vector3.zero, Vector3.zero, Vector3.zero,
m_Entity.transform.forward, eClockWise.CW);
if( ready.constructSucceed == true)
{
if( AsCommonSender.CheckSkillUseProcessing() == true)
return;
if( ready.CheckValidTargeting( m_Target) == false)
{
Debug.Log( "AsPlayerFsm::OnSkillActive: m_Target.GetInstanceID() = " + m_Target.GetInstanceID());
Target = null;
return;
}
if( Target != null &&
m_Entity.GetNavPathDistance( Entity.transform.position, Target.transform.position, true) >
ready.skillLvRecord.Usable_Distance * 0.01f)// * m_Character_Size)
{
// Debug.Log( "AsPlayerFsm::OnSkillActive: msg.skillIdx_ = " + msg.skillIdx_ + ", BattleRun state began [time:" + Time.realtimeSinceStartup + "]");
Msg_Player_Skill_Target_Move targetMove = new Msg_Player_Skill_Target_Move( ready);
m_CurrentFsmState.MessageProcess( targetMove);
}
else
{
// Debug.Log( "AsPlayerFsm::OnSkillActive: msg.skillIdx_ = " + msg.skillIdx_ + ", SkillReady state began [time:" + Time.realtimeSinceStartup + "]");
m_CurrentFsmState.MessageProcess( ready);
}
}
}
}
void OnSkillCircle( AsIMessage _msg)
{
if( AsPStoreManager.Instance.UnableActionByPStore() == true)
return;
if( CheckSpecificWindowOpened() == true)
return;
// if( CheckMap_Village() == true)
// {
// string content = AsTableManager.Instance.GetTbl_String(830);
// AsChatManager.Instance.InsertChat( content, eCHATTYPE.eCHATTYPE_SYSTEM, true);
// return;
// }
if( WeaponEquip == false)
{
AsMyProperty.Instance.AlertNoWeapon();
return;
}
Msg_Input_Circle msg = _msg as Msg_Input_Circle;
eCommand_Type commandType = eCommand_Type.CircleCW;
COMMAND_SKILL_TYPE commandSkillType = COMMAND_SKILL_TYPE._CIRCLE_CW;
switch( msg.cw_)
{
case eClockWise.CW:
commandType = eCommand_Type.CircleCW;
commandSkillType = COMMAND_SKILL_TYPE._CIRCLE_CW;
break;
case eClockWise.CCW:
commandType = eCommand_Type.CircleCCW;
commandSkillType = COMMAND_SKILL_TYPE._CIRCLE_CCW;
break;
}
if( AsUserInfo.Instance.CommandSkillCoolTimeCompletion[(int)commandSkillType] == true)
{
eCLASS __class = UserEntity.GetProperty<eCLASS>( eComponentProperty.CLASS);
eGENDER gender = UserEntity.GetProperty<eGENDER>( eComponentProperty.GENDER);
Msg_Player_Skill_Ready ready = new Msg_Player_Skill_Ready(
__class, eSKILL_TYPE.Command, commandType, gender,
null, Vector3.zero,
msg.head_, msg.center_, msg.tail_, msg.direction_, msg.cw_);
if( ready.constructSucceed == true && SkillBook.Instance.dicCurSkill.ContainsKey( ready.skillRecord.Index) == true)
{
if( TargetDecider.CheckDisableSkillByMap(ready.skillRecord) == true)
return;
if( AsCommonSender.CheckSkillUseProcessing() == true)
return;
if( m_Entity.CheckCondition( eSkillIcon_Enable_Condition.Movable) == false &&
ready.skillRecord.CheckSkillUsingOnly_Movable() == true)
{
AsMyProperty.Instance.AlertState();
return;
}
if( CheckMap_Village() == true)
{
// string content = AsTableManager.Instance.GetTbl_String(830);
// AsChatManager.Instance.InsertChat( content, eCHATTYPE.eCHATTYPE_SYSTEM, true);
AsMyProperty.Instance.AlertSkillInTown();
}
else if( false == IsAvailableCommandSkill( __class, commandType))
return;
else
m_CurrentFsmState.MessageProcess( ready);
}
}
else
{
AsMyProperty.Instance.AlertCoolTime( commandSkillType);
}
}
public bool SetTarget(AsPlayerFsm _playerFsm, Msg_Player_Skill_Ready _ready)
{
m_PlayerFsm = _playerFsm;
m_SkillReady = _ready;
#region - main target -
// m_MainTarget_Npc = GetTargetSessionIdNpc();
// if( m_MainTarget_Npc != 0)
// m_listTargets_Npc.Add( m_MainTarget_Npc);
// m_MainTarget_User = GetTargetUniqIdUser();
// if( m_MainTarget_User != 0)
// m_listTargets_User.Add( m_MainTarget_User);
#endregion
m_listTargets_Npc = new int[MAX_SKILL_TARGET];
m_listTargets_User = new uint[MAX_SKILL_TARGET];
m_DecidedEntities.Clear();
// Tbl_Action_HitInfo hitInfo = m_SkillReady.actionRecord.HitAnimation.hitInfo;
// Tbl_Skill_Record skill = AsTableManager.Instance.GetTbl_Skill_Record(m_SkillReady.skillLvRecord.Skill_GroupIndex);
return SetEachTarget();
/*
switch(skill.Skill_Type)
{
#region - eSKILL_TYPE.Base -
case eSKILL_TYPE.Base:
case eSKILL_TYPE.SlotBase:
switch(hitInfo.HitType)
{
case eHitType.Target:
switch(hitInfo.AreaShape)
{
case eHitAreaShape.Point:
SingleTargetDecision();
break;
case eHitAreaShape.Circle:
MultiTargetHitDecision(m_SkillReady.Target.transform.position);
break;
}
break;
case eHitType.ProjectileTarget:
switch(hitInfo.AreaShape)
{
case eHitAreaShape.Point:
SingleTargetDecision();
break;
case eHitAreaShape.Circle:
MultiTargetHitDecision(m_SkillReady.Target.transform.position);
break;
}
break;
default:
Debug.LogError("HitDecision: eSKILL_TYPE.Base doesnt treat hit type[" + hitInfo.HitType + "]");
break;
}
break;
#endregion
#region - eSKILL_TYPE.Active -
case eSKILL_TYPE.Active:
switch(hitInfo.HitType)
{
case eHitType.NonTarget://self
switch(hitInfo.AreaShape)
{
case eHitAreaShape.Point:
SingleTargetDecision("self");
break;
case eHitAreaShape.Circle:
MultiTargetHitDecision(m_PlayerFsm.transform.position);
break;
}
break;
default:
Debug.LogError("HitDecision: eSKILL_TYPE.Active doesnt treat hit type[" + hitInfo.HitType + "]");
break;
}
break;
#endregion
#region - eSKILL_TYPE.Command -
case eSKILL_TYPE.Command:
switch(hitInfo.HitType)
{
case eHitType.NonTarget:
switch(hitInfo.AreaShape)
{
case eHitAreaShape.Point:
SingleTargetDecision("self");
break;
case eHitAreaShape.Circle:
MultiTargetHitDecision(m_PlayerFsm.transform.position);
break;
}
break;
case eHitType.PositionTarget:
switch(hitInfo.AreaShape)
{
// case eHitAreaShape.Point:
// break;
case eHitAreaShape.Circle:
MultiTargetHitDecision(m_SkillReady.picked);
break;
}
break;
default:
Debug.LogError("HitDecision: eSKILL_TYPE.Command cannot treat hit type[" + hitInfo.HitType + "]");
break;
}
break;
#endregion
#region - eSKILL_TYPE.Target -
case eSKILL_TYPE.Target:
switch(hitInfo.HitType)
{
case eHitType.Target:
switch(hitInfo.AreaShape)
{
case eHitAreaShape.Point:
SingleTargetDecision();
break;
case eHitAreaShape.Circle:
MultiTargetHitDecision(m_SkillReady.Target.transform.position);
break;
}
break;
case eHitType.NonTarget:
switch(hitInfo.AreaShape)
{
case eHitAreaShape.Point:
SingleTargetDecision("self");
break;
// case eHitAreaShape.Circle:
// MultiTargetHitDecision(m_SkillReady.Target.transform.position);
// break;
}
break;
case eHitType.PositionTarget:
switch(hitInfo.AreaShape)
{
case eHitAreaShape.Point:
SingleTargetDecision();
break;
case eHitAreaShape.Circle:
MultiTargetHitDecision(m_SkillReady.Target.transform.position);
break;
}
break;
case eHitType.ProjectileTarget:
switch(hitInfo.AreaShape)
{
case eHitAreaShape.Point:
SingleTargetDecision();
break;
case eHitAreaShape.Circle:
MultiTargetHitDecision(m_SkillReady.Target.transform.position);
break;
}
break;
default:
Debug.LogError("HitDecision: eSKILL_TYPE.Target doesnt treat hit type[" + hitInfo.HitType + "]");
break;
}
break;
#endregion
#region - eSKILL_TYPE.Charge -
case eSKILL_TYPE.Charge:
case eSKILL_TYPE.TargetCharge:
switch(hitInfo.HitType)
{
case eHitType.Target:
switch(hitInfo.AreaShape)
{
case eHitAreaShape.Point:
SingleTargetDecision();
break;
case eHitAreaShape.Circle:
MultiTargetHitDecision(m_SkillReady.Target.transform.position);
break;
}
break;
case eHitType.NonTarget:
switch(hitInfo.AreaShape)
{
case eHitAreaShape.Point:
SingleTargetDecision("self");
break;
case eHitAreaShape.Circle:
MultiTargetHitDecision(m_PlayerFsm.transform.position);
break;
}
break;
case eHitType.PositionTarget:
switch(hitInfo.AreaShape)
{
case eHitAreaShape.Point:
SingleTargetDecision();
break;
case eHitAreaShape.Circle:
MultiTargetHitDecision(m_SkillReady.Target.transform.position);
break;
}
break;
case eHitType.ProjectileTarget:
switch(hitInfo.AreaShape)
{
case eHitAreaShape.Point:
SingleTargetDecision();
break;
case eHitAreaShape.Circle:
MultiTargetHitDecision(m_SkillReady.Target.transform.position);
break;
}
break;
default:
Debug.LogError("HitDecision: eSKILL_TYPE.Charge doesnt treat hit type[" + hitInfo.HitType + "]");
break;
}
break;
#endregion
#region - etc -
case eSKILL_TYPE.Stance:
break;
#endregion
default:
Debug.LogError("TargetDecider::SetTarget: invalid eSKILL_TYPE [" + skill.Skill_Type + "]");
break;
}
//*/
return true;
}
//SKILL
#region - charge & active & drag & arc & circle & double tap & action item & stance -
void OnBeginCharge( AsIMessage _msg)
{
if( AsPStoreManager.Instance.UnableActionByPStore() == true)
return;
if( CheckSpecificWindowOpened() == true)
return;
if( CheckMap_Village() == true)
{
// string content = AsTableManager.Instance.GetTbl_String(830);
// AsChatManager.Instance.InsertChat( content, eCHATTYPE.eCHATTYPE_SYSTEM, true);
AsMyProperty.Instance.AlertSkillInTown();
return;
}
if( WeaponEquip == false)
{
AsMyProperty.Instance.AlertNoWeapon();
return;
}
Msg_Input_Begin_Charge msg = _msg as Msg_Input_Begin_Charge;
Tbl_Skill_Record record = AsTableManager.Instance.GetTbl_Skill_Record( msg.skillIdx_);
eGENDER gender = Entity.GetProperty<eGENDER>( eComponentProperty.GENDER);
Msg_Player_Skill_Ready ready = new Msg_Player_Skill_Ready( record, gender);
ready.SetCharging();
if(TargetDecider.sSkillUsable_TargetCharge(this, ready) == false)
return;
if( ready.constructSucceed == true)
m_CurrentFsmState.MessageProcess( ready);
}
public Msg_Player_Skill_Target_Move( Msg_Player_Skill_Ready _ready, AsPlayerState_BattleRun.eRunType _runType)
{
m_MessageType = eMessageType.PLAYER_SKILL_TARGET_MOVE;
m_Ready = _ready;
m_RunType = _runType;
}
public static bool sSkillUsable_TargetCharge(AsPlayerFsm _playerFsm, Msg_Player_Skill_Ready _ready)// use targetting slot only
{
float _range = _ready.skillLvRecord.Usable_Distance * 0.01f;// * _playerFsm.Character_Size;
if( null == _playerFsm.Target) // no entity is targeted
{
if( _ready.skillRecord.CheckPotencyTargetTypeIncludeEnemy() == true)
{
AsBaseEntity target = _playerFsm.HostileEntityExistInRange( _range);
_playerFsm.Target = target;
}
}
else // taget is exist
{
if( _playerFsm.Target.FsmType == eFsmType.NPC || _playerFsm.Target.FsmType == eFsmType.COLLECTION)
{
if(_ready.skillRecord.CheckPotencyTargetTypeIncludeEnemy() == true)
{
AsBaseEntity target = _playerFsm.MonsterExistInRange( _range);
if( target != null && target.CheckObjectMonster() == false)
_playerFsm.Target = target;
}
}
else if(_playerFsm.Target.FsmType == eFsmType.OTHER_USER)
{
if(CheckOtherUserIsEnemy(_playerFsm.Target) == false)
{
if( ( null != _ready.skillRecord) && ( eSkillAutoTarget.Disable != _ready.skillRecord.SkillAutoTarget))
{
if(_ready.skillRecord.CheckPotencyTargetTypeIncludeEnemy() == true &&
_ready.skillRecord.CheckPotencyTypeIncludeHeal() == false)
{
AsUserEntity targetUser = _playerFsm.Target as AsUserEntity;
AsBaseEntity targetUserTarget = targetUser.GetGetterTarget();
if( targetUserTarget != null &&
targetUserTarget.FsmType == eFsmType.MONSTER &&
Vector3.Distance(_playerFsm.transform.position, targetUser.transform.position) < _range)
_playerFsm.Target = targetUserTarget;
else
_playerFsm.Target = _playerFsm.MonsterExistInRange( _range);
}
}
}
}
}
if( null == _playerFsm.Target)
{
AsMyProperty.Instance.AlertInvalidTarget();
return false;
}
else
return TargetSkillCheck( _ready.skillRecord.Index, _playerFsm);
}
public Msg_Player_Skill_Target_Move( Msg_Player_Skill_Ready _ready)
{
m_MessageType = eMessageType.PLAYER_SKILL_TARGET_MOVE;
m_Ready = _ready;
}
public Msg_Player_Skill_Linkaction( Msg_Player_Skill_Ready _ready)
{
m_MessageType = eMessageType.PLAYER_SKILL_LINKACTION;
ready_ = _ready;
}
public Msg_Player_Skill_Finish( Msg_Player_Skill_Ready _ready,
bool _targetReleased)
{
m_MessageType = eMessageType.PLAYER_SKILL_FINISH;
ready_ = _ready;
targetReleased_ = _targetReleased;
}
public Msg_Player_Skill_Hit( Msg_Player_Skill_Ready _ready,
int _chargeStep, bool _casting,
// int _mainTargetNpc, uint _mainTargetUser,
bool _targetReleased)
{
m_MessageType = eMessageType.PLAYER_SKILL_HIT;
ready_ = _ready;
if( _chargeStep == int.MaxValue)
_chargeStep = 0;
chargeStep_ = _chargeStep;
casting_ = _casting;
// mainTargetNpc_ = _mainTargetNpc;
// mainTargetUser_ = _mainTargetUser;
targetReleased_ = _targetReleased;
}
public Msg_Player_Skill_Ready( Msg_Player_Skill_Ready _ready, Tbl_Action_Record _action)
{
skillRecord_ = _ready.skillRecord;
skillLv_ = _ready.skillLv_;
skillLvRecord_ = _ready.skillLvRecord;
actionRecord_ = _action;//IMPORTANT
pickedEntity_ = _ready.pickedEntity;
head_ = _ready.head;
center_ = _ready.center;
tail_ = _ready.tail;
direction_ = _ready.direction;
cw_ = _ready.cw;
constructSucceed_ = true;
}
