Exemple #1
0
	public static void sTargeting_AsSlot(AsPlayerFsm _playerFsm, Tbl_Skill_Record _skillRecord)// use targetting slot only 
	{
		if(_playerFsm.CheckMap_Village() == true)
			return;
		
		if( null == _playerFsm.Target) // no entity is targeted
		{
			if(_skillRecord.CheckPotencyTargetTypeIncludeEnemy() == true)
			{
				AsBaseEntity target = _playerFsm.HostileEntityExistInRange( AsTableManager.Instance.GetTbl_GlobalWeight_Record( 30).Value * 0.01f);
				_playerFsm.Target = target;
			}
		}
		else // taget is exist
		{
			if( _playerFsm.Target.FsmType == eFsmType.NPC || _playerFsm.Target.FsmType == eFsmType.COLLECTION)
			{
				if(_skillRecord.CheckPotencyTargetTypeIncludeEnemy() == true)
				{
					AsBaseEntity target = _playerFsm.MonsterExistInRange( AsTableManager.Instance.GetTbl_GlobalWeight_Record( 30).Value * 0.01f);
					if( target != null && target.CheckObjectMonster() == false)
						_playerFsm.Target = target;
				}
			}
			else if(_playerFsm.Target.FsmType == eFsmType.OTHER_USER)
			{
				if(CheckOtherUserIsEnemy(_playerFsm.Target) == false)
				{
					if( ( null != _skillRecord) && ( eSkillAutoTarget.Disable != _skillRecord.SkillAutoTarget))
					{
						if(_skillRecord.CheckPotencyTargetTypeIncludeEnemy() == true &&
							_skillRecord.CheckPotencyTypeIncludeHeal() == false)
						{
							AsUserEntity targetUser = _playerFsm.Target as AsUserEntity;
							AsBaseEntity targetUserTarget = targetUser.GetGetterTarget();
							if( targetUserTarget != null && targetUserTarget.FsmType == eFsmType.MONSTER)
								_playerFsm.Target = targetUserTarget;
							else
								_playerFsm.Target = _playerFsm.MonsterExistInRange( AsTableManager.Instance.GetTbl_GlobalWeight_Record( 30).Value * 0.01f);
						}
					}
				}
			}
			else if( _playerFsm.Target.FsmType == eFsmType.MONSTER)
			{
				if( _skillRecord.Skill_Type == eSKILL_TYPE.SlotBase && AsGameMain.GetOptionState(OptionBtnType.OptionBtnType_TargetChange) == true) // target already chose & slot base touched
				{
					float maxDist = AsTableManager.Instance.GetTbl_GlobalWeight_Record( 138).Value * 0.01f;
					float angle = AsTableManager.Instance.GetTbl_GlobalWeight_Record( 139).Value;
					List<AsBaseEntity> listEntities = AsEntityManager.Instance.GetHostileEntityInRange( _playerFsm.transform.position, 0.01f, maxDist);
					Debug.Log("TargetDecider::sTargeting_AsSlot: listEntities.Count = " + listEntities.Count);
					SortedDictionary<float, AsBaseEntity> angledEntities = GetEntityDicInAngleRanged( _playerFsm.transform.forward, _playerFsm.transform.position, angle, listEntities);
					Debug.Log("TargetDecider::sTargeting_AsSlot: angledEntities.Count = " + angledEntities.Count);
					
					foreach(KeyValuePair<float, AsBaseEntity> pair in angledEntities)
					{
						Debug.Log("TargetDecider::sTargeting_AsSlot: angledEntities angle = " + pair.Key);
					}
					
					int count = 0;
					AsBaseEntity selectedEntity = null;
					foreach(KeyValuePair<float, AsBaseEntity> pair in angledEntities)
					{
						if( _playerFsm.Target == pair.Value)
							continue;
						
						if( (count == 0 && pair.Key > 0) ||
							count > 0)
						{
							selectedEntity = pair.Value;
							break;
						}
						
						count++;
					}
					
					if( selectedEntity != null)
					{
						_playerFsm.Target = selectedEntity;
						AsMyProperty.Instance.AlertTargetChanged();
					}
				}
			}
		}
	}
	// target changed
	public void TargetChangeProcess(AsPlayerFsm _player)
	{
		if(m_Activate == true)
		{
			if(/*_player.Target == null && */ CheckEnoughCondition() == false && ConditionEventActivate == false)
			{
				TurnOff();
				
				AsEntityManager.Instance.MessageToPlayer( new Msg_AutoCombat_Off(false));
				
				string title = AsTableManager.Instance.GetTbl_String(2114);
				string str = AsTableManager.Instance.GetTbl_String(2117);
				AsNotify.Instance.MessageBox( title, str,AsNotify.MSG_BOX_TYPE.MBT_OK);
			}
			
			if(_player.Target != null && _player.Target.FsmType != eFsmType.MONSTER)
			{
				TurnOff();
				
				AsEntityManager.Instance.MessageToPlayer( new Msg_AutoCombat_Off(false));
				
				string str = AsTableManager.Instance.GetTbl_String(2116);
				AsEventNotifyMgr.Instance.CenterNotify.AddQuestMessage(str, false);
			}
		}
				
	}
Exemple #3
0
	public static bool CheckDisableSkillByCondition(AsPlayerFsm _player, Tbl_Skill_Record _record) // for auto combat
	{
		bool movable = _record.CheckSkillUsingOnly_Movable();
		
		if( false == _player.Entity.CheckCondition( eSkillIcon_Enable_Condition.Movable) &&
			true == movable)
		{
			AsMyProperty.Instance.AlertState();
			return false;
		}

		if( true == _player.Entity.CheckCondition( eSkillIcon_Enable_Condition.Stun) ||
			true == _player.Entity.CheckCondition( eSkillIcon_Enable_Condition.Freeze) ||
			true == _player.Entity.CheckCondition( eSkillIcon_Enable_Condition.Sleep) ||
			true == _player.Entity.CheckCondition( eSkillIcon_Enable_Condition.Fear))
		{
			AsMyProperty.Instance.AlertState();			
			return false;
		}
		
		return true;
	}
Exemple #4
0
	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;
	}
Exemple #5
0
	public static bool TargetSkillCheck(int _skillIdx, AsPlayerFsm fsm)
	{
		Tbl_Skill_Record skillRecord = AsTableManager.Instance.GetTbl_Skill_Record( _skillIdx);
		if( null == skillRecord)
			return false;
	
		switch( skillRecord.Skill_TargetType)
		{
		case eSkill_TargetType.All:
			{
				if( eFsmType.NPC == fsm.Target.FsmType)
				{
					AsMyProperty.Instance.AlertTarget();
					return false;
				}

				return SkillTargetTypeCheck( skillRecord, fsm);
			}
			break;
		case eSkill_TargetType.Alliance:
			{
				if( eEntityType.NPC == fsm.Target.EntityType)
				{
					AsMyProperty.Instance.AlertTarget();
					return false;
				}
				else if( eFsmType.OTHER_USER == fsm.Target.FsmType)
				{
					if(CheckOtherUserIsEnemy(fsm.Target) == true)
					{
						AsMyProperty.Instance.AlertTarget();
						return false;
					}
				}

				return SkillTargetTypeCheck( skillRecord, fsm);
			}
			break;
		case eSkill_TargetType.Enemy:
			{
				if( eFsmType.OTHER_USER == fsm.Target.FsmType)
				{
					if(CheckOtherUserIsEnemy(fsm.Target) == false)
					{
						AsMyProperty.Instance.AlertTarget();
						return false;
					}
				}
				else if( eFsmType.MONSTER != fsm.Target.FsmType)
				{
					AsMyProperty.Instance.AlertTarget();
					return false;
				}

				return SkillTargetTypeCheck( skillRecord, fsm);
			}
			break;
		case eSkill_TargetType.Party:
			{
				if( eFsmType.OTHER_USER != fsm.Target.FsmType)
				{
					AsMyProperty.Instance.AlertTarget();
					return false;
				}
			
				if( false == AsPartyManager.Instance.IsPartying)
					return false;
				
				AS_PARTY_USER partyUser = AsPartyManager.Instance.GetPartyMember( ( ( AsUserEntity)fsm.Target).UniqueId);
				if( null == partyUser)
				{
					AsMyProperty.Instance.AlertTarget();
					return false;
				}
			}
			break;
		case eSkill_TargetType.Self:
			{
				if( eFsmType.PLAYER != fsm.Target.FsmType)
				{
					AsMyProperty.Instance.AlertTarget();
					return false;
				}

				return SkillTargetTypeCheck( skillRecord, fsm);
			}
		default:
			break;
		}
		
		return true;
	}
Exemple #6
0
	static bool CheckTargetUserIsEnemy(AsPlayerFsm _player)
	{
//#if _PVP
//		return true;
		
		AsUserEntity user = _player.Target as AsUserEntity;
		if(user != null)
			return AsPvpManager.Instance.CheckUsersAreHostile(_player.UserEntity.UniqueId, user.UniqueId);
		return false;
//#else
//		return false;
//#endif
	}
Exemple #7
0
	public static bool CheckValidSkill(AsPlayerFsm _playerFsm, Tbl_Skill_Record _record)// use targetting slot only 
	{
		if( ( _record.Skill_Type == eSKILL_TYPE.Target) || ( _record.Skill_Type == eSKILL_TYPE.SlotBase))
		{
			if( null == _playerFsm.Target)
			{
				if( true == _playerFsm.CheckMap_Village())
					AsMyProperty.Instance.AlertSkillInTown();
				else
					AsMyProperty.Instance.AlertInvalidTarget();
				return false;
			}
			else
				return true;
		}

		return true;
	}
Exemple #8
0
	static bool SkillTargetTypeCheck( Tbl_Skill_Record skillRecord, AsPlayerFsm fsm)
	{
		switch( skillRecord.SkillIcon_Enable_Target)
		{
		case eSkillIcon_Enable_Target.Self:
			return SkillTargetStateCheck( skillRecord, fsm.UserEntity);
		case eSkillIcon_Enable_Target.Target:
			return SkillTargetStateCheck( skillRecord, fsm.Target);
		}
		
		return true;
	}
Exemple #9
0
	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 void SetPlayerFsm( AsPlayerFsm _player)
	{
		player_ = _player;
	}
	public Msg_StartCollect( AsPlayerFsm _playerFsm)
	{
		m_MessageType = eMessageType.COLLECT_START;

		playerFsm = _playerFsm;
	}
	private bool _isPlayerChar_SkillActive()
	{
		if( null == m_PlayerFsmBuf)
		{
			m_PlayerFsmBuf = AsEntityManager.Instance.GetPlayerCharFsm();
			if( null == m_PlayerFsmBuf)
				return false;
		}
		
		if( m_PlayerFsmBuf.CurrnetFsmStateType == AsPlayerFsm.ePlayerFsmStateType.SKILL_HIT
			|| m_PlayerFsmBuf.CurrnetFsmStateType == AsPlayerFsm.ePlayerFsmStateType.SKILL_READY
			|| m_PlayerFsmBuf.CurrnetFsmStateType == AsPlayerFsm.ePlayerFsmStateType.SKILL_FINISH
			|| m_PlayerFsmBuf.CurrnetFsmStateType == AsPlayerFsm.ePlayerFsmStateType.DASH
			|| m_PlayerFsmBuf.CurrnetFsmStateType == AsPlayerFsm.ePlayerFsmStateType.DEATH
			|| m_PlayerFsmBuf.CurrnetFsmStateType == AsPlayerFsm.ePlayerFsmStateType.IDLE
			|| m_PlayerFsmBuf.CurrnetFsmStateType == AsPlayerFsm.ePlayerFsmStateType.BATTLE_RUN
			|| m_PlayerFsmBuf.CurrnetFsmStateType == AsPlayerFsm.ePlayerFsmStateType.PRODUCT)
			return true;
		
		return false;
	}
Exemple #13
0
	public AsUserEntity CreateUserEntity( string _typeName, UserEntityCreationData _data, bool needShadow=true, bool needAutoEffect = false, float _fsize = float.MaxValue )
	{
		if( false == m_dicUserEntity_UniqueId.ContainsKey( _data.uniqKey_) || 0 == string.Compare( "EmptySlot", _typeName))
		{
			AsUserEntity entity;

			if( true == m_dicEntityTemplate.ContainsKey( _typeName))
			{
				GameObject obj = new GameObject( _typeName);
				entity = obj.AddComponent<AsUserEntity>();
				entity.AttachComponent( m_dicEntityTemplate[ _typeName]);
				entity.InitComponents();
				obj.transform.parent = m_RootObject.transform;
				if( float.MaxValue != _fsize )
					obj.transform.localScale = new Vector3( _fsize, _fsize, _fsize);
			}
			else
			{
				Debug.LogError( "[AsEntityManager]CreateEntity: invalid entity name");
				return null;
			}
#if AUTOMOVE_EFFECT
			entity.SetNeedAutoMoveEffect( needAutoEffect);
#endif

			entity.NeedShadow = needShadow;
			entity.SetCreationData( _data);
			entity.InterInitComponents();
			entity.LateInitComponents();
			entity.LastInitComponents();

			entity.SetEnterWorldData( entity.transform.position);

			if( "PlayerChar" == _typeName)
			{
				m_kUserEntity = entity;
				m_PlayerFsm = m_kUserEntity.GetComponent<AsPlayerFsm>();
			}

			return entity;
		}
		else
		{
			AsUserEntity entity = m_dicUserEntity_UniqueId[_data.uniqKey_];
			if( entity.CheckShopOpening() == true)
			{
				entity.SetCreationData( _data);
				entity.InterInitComponents();
				entity.LateInitComponents();
				entity.LastInitComponents();
			}

			//Debug.LogError( "[AsEntityManager]CreateEntity: [" + AsGameMain.s_gameState + "] type:" + _data.creationType_ + " is already registered. invalid id[" + _data.uniqKey_ + "]");
			return entity;
		}
	}