public bool GetAttackDataOrUseNonAttackSkill(bool isLeftHand, out float attackDistance, out float attackFov)
{
attackDistance = PlayerCharacterEntity.GetAttackDistance(isLeftHand);
attackFov = PlayerCharacterEntity.GetAttackFov(isLeftHand);
if (queueUsingSkill.HasValue)
{
Skill skill = null;
if (GameInstance.Skills.TryGetValue(queueUsingSkill.Value.dataId, out skill) && skill != null)
{
if (skill.IsAttack())
{
attackDistance = PlayerCharacterEntity.GetSkillAttackDistance(skill, isLeftHand);
attackFov = PlayerCharacterEntity.GetSkillAttackFov(skill, isLeftHand);
}
else
{
// Stop movement to use non attack skill
PlayerCharacterEntity.StopMove();
RequestUsePendingSkill(false, null);
return(false);
}
}
else
{
queueUsingSkill = null;
}
}
// Return true if going to attack
return(true);
}
public bool GetAttackDistanceAndFov(out float attackDistance, out float attackFov)
{
attackDistance = PlayerCharacterEntity.GetAttackDistance();
attackFov = PlayerCharacterEntity.GetAttackFov();
if (queueUsingSkill.HasValue)
{
var queueUsingSkillValue = queueUsingSkill.Value;
Skill skill = null;
if (GameInstance.Skills.TryGetValue(queueUsingSkillValue.dataId, out skill) && skill != null)
{
if (skill.IsAttack())
{
attackDistance = PlayerCharacterEntity.GetSkillAttackDistance(skill);
attackFov = PlayerCharacterEntity.GetSkillAttackFov(skill);
}
else
{
// Stop movement to use non attack skill
PlayerCharacterEntity.StopMove();
RequestUsePendingSkill();
return(false);
}
}
else
{
queueUsingSkill = null;
}
}
return(true);
}
public static bool IsDebuff(this Skill skill)
{
if (skill == null)
{
return(false);
}
return(skill.IsAttack() && skill.isDebuff);
}
public static KeyValuePair <DamageElement, MinMaxFloat> GetDamageAmount(this Skill skill, short level, ICharacterData character)
{
if (!skill.IsAttack() || skill.skillAttackType != SkillAttackType.Normal)
{
return(new KeyValuePair <DamageElement, MinMaxFloat>());
}
return(GameDataHelpers.MakeDamage(skill.damageAmount, level, 1f, skill.GetEffectivenessDamage(character)));
}
public static Dictionary <DamageElement, MinMaxFloat> GetAdditionalDamageAmounts(this Skill skill, short level)
{
if (!skill.IsAttack())
{
return(new Dictionary <DamageElement, MinMaxFloat>());
}
level = skill.GetAdjustedLevel(level);
return(GameDataHelpers.CombineDamages(skill.additionalDamageAmounts, new Dictionary <DamageElement, MinMaxFloat>(), level, 1f));
}
public static Dictionary <DamageElement, float> GetWeaponDamageInflictions(this Skill skill, short level)
{
if (!skill.IsAttack())
{
return(new Dictionary <DamageElement, float>());
}
level = skill.GetAdjustedLevel(level);
return(GameDataHelpers.CombineDamageInflictions(skill.weaponDamageInflictions, new Dictionary <DamageElement, float>(), level));
}
protected override void Update()
{
if (PlayerCharacterEntity == null || !PlayerCharacterEntity.IsOwnerClient)
{
return;
}
base.Update();
UpdateLookAtTarget();
tempDeltaTime = Time.deltaTime;
turnTimeCounter += tempDeltaTime;
// Hide construction UI
if (CurrentBuildingEntity == null)
{
if (CacheUISceneGameplay.uiConstructBuilding.IsVisible())
{
CacheUISceneGameplay.uiConstructBuilding.Hide();
}
}
if (ActiveBuildingEntity == null)
{
if (CacheUISceneGameplay.uiCurrentBuilding.IsVisible())
{
CacheUISceneGameplay.uiCurrentBuilding.Hide();
}
}
IsBlockController = CacheUISceneGameplay.IsBlockController();
// Lock cursor when not show UIs
Cursor.lockState = !IsBlockController ? CursorLockMode.Locked : CursorLockMode.None;
Cursor.visible = IsBlockController;
CacheGameplayCameraControls.updateRotation = !IsBlockController;
// Clear selected entity
SelectedEntity = null;
// Update crosshair (with states from last update)
if (isDoingAction)
{
UpdateCrosshair(currentCrosshairSetting, currentCrosshairSetting.expandPerFrameWhileAttacking);
}
else if (movementState.HasFlag(MovementState.Forward) ||
movementState.HasFlag(MovementState.Backward) ||
movementState.HasFlag(MovementState.Left) ||
movementState.HasFlag(MovementState.Right) ||
movementState.HasFlag(MovementState.IsJump))
{
UpdateCrosshair(currentCrosshairSetting, currentCrosshairSetting.expandPerFrameWhileMoving);
}
else
{
UpdateCrosshair(currentCrosshairSetting, -currentCrosshairSetting.shrinkPerFrame);
}
// Clear controlling states from last update
isDoingAction = false;
movementState = MovementState.None;
UpdateActivatedWeaponAbility(tempDeltaTime);
if (IsBlockController || GenericUtils.IsFocusInputField())
{
mustReleaseFireKey = false;
PlayerCharacterEntity.KeyMovement(Vector3.zero, MovementState.None);
DeactivateWeaponAbility();
return;
}
// Find target character
Ray ray = CacheGameplayCameraControls.CacheCamera.ViewportPointToRay(new Vector3(0.5f, 0.5f, 0));
Vector3 forward = CacheGameplayCameraControls.CacheCameraTransform.forward;
Vector3 right = CacheGameplayCameraControls.CacheCameraTransform.right;
float distanceFromOrigin = Vector3.Distance(ray.origin, PlayerCharacterEntity.CacheTransform.position);
float aimDistance = distanceFromOrigin;
// Calculating aim distance, also read attack inputs here
// Attack inputs will be used to calculate attack distance
if (CurrentBuildingEntity == null)
{
// Attack with right hand weapon
tempPressAttackRight = InputManager.GetButton("Fire1");
if (weaponAbility == null && leftHandWeapon != null)
{
// Attack with left hand weapon if left hand weapon not empty
tempPressAttackLeft = InputManager.GetButton("Fire2");
}
else if (weaponAbility != null)
{
// Use weapon ability if it can
tempPressWeaponAbility = InputManager.GetButtonDown("Fire2");
}
// Is left hand attack when not attacking with right hand
// So priority is right > left
isLeftHandAttacking = !tempPressAttackRight && tempPressAttackLeft;
// Calculate aim distance by skill or weapon
if (queueSkill != null && queueSkill.IsAttack())
{
// Increase aim distance by skill attack distance
aimDistance += PlayerCharacterEntity.GetSkillAttackDistance(queueSkill, isLeftHandAttacking);
}
else
{
// Increase aim distance by attack distance
aimDistance += PlayerCharacterEntity.GetAttackDistance(isLeftHandAttacking);
}
}
actionLookDirection = aimPosition = ray.origin + ray.direction * aimDistance;
actionLookDirection.y = PlayerCharacterEntity.CacheTransform.position.y;
actionLookDirection = actionLookDirection - PlayerCharacterEntity.CacheTransform.position;
actionLookDirection.Normalize();
// Prepare variables to find nearest raycasted hit point
float tempDistance;
float tempNearestDistance = float.MaxValue;
// Find for enemy character
if (CurrentBuildingEntity == null)
{
int tempCount = Physics.RaycastNonAlloc(ray, raycasts, aimDistance);
for (int tempCounter = 0; tempCounter < tempCount; ++tempCounter)
{
tempHitInfo = raycasts[tempCounter];
tempEntity = tempHitInfo.collider.GetComponent <BaseGameEntity>();
// Find building entity from building material
if (tempEntity == null)
{
tempBuildingMaterial = tempHitInfo.collider.GetComponent <BuildingMaterial>();
if (tempBuildingMaterial != null)
{
tempEntity = tempBuildingMaterial.buildingEntity;
}
}
if (tempEntity == null || tempEntity == PlayerCharacterEntity)
{
continue;
}
// Target must be alive
if (tempEntity is IDamageableEntity && (tempEntity as IDamageableEntity).IsDead())
{
continue;
}
// Target must be in front of player character
if (!PlayerCharacterEntity.IsPositionInFov(15f, tempEntity.CacheTransform.position, forward))
{
continue;
}
// Set aim position and found target
tempDistance = Vector3.Distance(CacheGameplayCameraControls.CacheCameraTransform.position, tempHitInfo.point);
if (tempDistance < tempNearestDistance)
{
tempNearestDistance = tempDistance;
aimPosition = tempHitInfo.point;
if (tempEntity != null)
{
SelectedEntity = tempEntity;
}
}
}
// Show target hp/mp
CacheUISceneGameplay.SetTargetEntity(SelectedEntity);
}
else
{
// Clear area before next find
CurrentBuildingEntity.buildingArea = null;
// Find for position to construction building
bool foundSnapBuildPosition = false;
int tempCount = Physics.RaycastNonAlloc(ray, raycasts, gameInstance.buildDistance);
BuildingArea buildingArea = null;
for (int tempCounter = 0; tempCounter < tempCount; ++tempCounter)
{
tempHitInfo = raycasts[tempCounter];
tempEntity = tempHitInfo.collider.GetComponentInParent <BuildingEntity>();
if (tempEntity == null || tempEntity == CurrentBuildingEntity)
{
continue;
}
buildingArea = tempHitInfo.transform.GetComponent <BuildingArea>();
if (buildingArea == null ||
(buildingArea.buildingEntity != null && buildingArea.buildingEntity == CurrentBuildingEntity) ||
!CurrentBuildingEntity.buildingType.Equals(buildingArea.buildingType))
{
continue;
}
// Set aim position
tempDistance = Vector3.Distance(CacheGameplayCameraControls.CacheCameraTransform.position, tempHitInfo.point);
if (tempDistance < tempNearestDistance)
{
aimPosition = tempHitInfo.point;
CurrentBuildingEntity.buildingArea = buildingArea;
if (buildingArea.snapBuildingObject)
{
foundSnapBuildPosition = true;
break;
}
}
}
// Update building position
if (!foundSnapBuildPosition)
{
CurrentBuildingEntity.CacheTransform.position = aimPosition;
// Rotate to camera
Vector3 direction = (aimPosition - CacheGameplayCameraControls.CacheCameraTransform.position).normalized;
direction.y = 0;
CurrentBuildingEntity.transform.rotation = Quaternion.LookRotation(direction);
}
}
// If mobile platforms, don't receive input raw to make it smooth
bool raw = !InputManager.useMobileInputOnNonMobile && !Application.isMobilePlatform;
Vector3 moveDirection = Vector3.zero;
forward.y = 0f;
right.y = 0f;
forward.Normalize();
right.Normalize();
float inputV = InputManager.GetAxis("Vertical", raw);
float inputH = InputManager.GetAxis("Horizontal", raw);
moveDirection += forward * inputV;
moveDirection += right * inputH;
// Set movement state by inputs
switch (mode)
{
case Mode.Adventure:
if (inputV > 0.5f || inputV < -0.5f || inputH > 0.5f || inputH < -0.5f)
{
movementState = MovementState.Forward;
}
moveLookDirection = moveDirection;
break;
case Mode.Combat:
moveDirection += forward * inputV;
moveDirection += right * inputH;
if (inputV > 0.5f)
{
movementState |= MovementState.Forward;
}
else if (inputV < -0.5f)
{
movementState |= MovementState.Backward;
}
if (inputH > 0.5f)
{
movementState |= MovementState.Right;
}
else if (inputH < -0.5f)
{
movementState |= MovementState.Left;
}
moveLookDirection = actionLookDirection;
break;
}
// normalize input if it exceeds 1 in combined length:
if (moveDirection.sqrMagnitude > 1)
{
moveDirection.Normalize();
}
if (CurrentBuildingEntity != null)
{
mustReleaseFireKey = false;
// Building
tempPressAttackRight = InputManager.GetButtonUp("Fire1");
if (tempPressAttackRight)
{
if (showConfirmConstructionUI)
{
// Show confirm UI
if (!CacheUISceneGameplay.uiConstructBuilding.IsVisible())
{
CacheUISceneGameplay.uiConstructBuilding.Show();
}
}
else
{
// Build when click
ConfirmBuild();
}
}
else
{
// Update move direction
if (moveDirection.magnitude != 0f)
{
targetLookDirection = moveLookDirection;
}
}
}
else
{
// Have to release fire key, then check press fire key later on next frame
if (mustReleaseFireKey)
{
tempPressAttackRight = false;
tempPressAttackLeft = false;
if (!isLeftHandAttacking &&
(InputManager.GetButtonUp("Fire1") ||
!InputManager.GetButton("Fire1")))
{
mustReleaseFireKey = false;
}
if (isLeftHandAttacking &&
(InputManager.GetButtonUp("Fire2") ||
!InputManager.GetButton("Fire2")))
{
mustReleaseFireKey = false;
}
}
// Not building so it is attacking
tempPressActivate = InputManager.GetButtonDown("Activate");
tempPressPickupItem = InputManager.GetButtonDown("PickUpItem");
tempPressReload = InputManager.GetButtonDown("Reload");
if (queueSkill != null || tempPressAttackRight || tempPressAttackLeft || tempPressActivate || PlayerCharacterEntity.IsPlayingActionAnimation())
{
// Find forward character / npc / building / warp entity from camera center
targetPlayer = null;
targetNpc = null;
targetBuilding = null;
if (tempPressActivate && !tempPressAttackRight && !tempPressAttackLeft)
{
if (SelectedEntity is BasePlayerCharacterEntity)
{
targetPlayer = SelectedEntity as BasePlayerCharacterEntity;
}
if (SelectedEntity is NpcEntity)
{
targetNpc = SelectedEntity as NpcEntity;
}
if (SelectedEntity is BuildingEntity)
{
targetBuilding = SelectedEntity as BuildingEntity;
}
}
// While attacking turn to camera forward
tempCalculateAngle = Vector3.Angle(PlayerCharacterEntity.CacheTransform.forward, actionLookDirection);
if (tempCalculateAngle > 15f)
{
if (queueSkill != null && queueSkill.IsAttack())
{
turningState = TurningState.UseSkill;
}
else if (tempPressAttackRight || tempPressAttackLeft)
{
turningState = TurningState.Attack;
}
else if (tempPressActivate)
{
turningState = TurningState.Activate;
}
turnTimeCounter = ((180f - tempCalculateAngle) / 180f) * turnToTargetDuration;
targetLookDirection = actionLookDirection;
// Set movement state by inputs
if (inputV > 0.5f)
{
movementState |= MovementState.Forward;
}
else if (inputV < -0.5f)
{
movementState |= MovementState.Backward;
}
if (inputH > 0.5f)
{
movementState |= MovementState.Right;
}
else if (inputH < -0.5f)
{
movementState |= MovementState.Left;
}
}
else
{
// Attack immediately if character already look at target
if (queueSkill != null && queueSkill.IsAttack())
{
UseSkill(isLeftHandAttacking, aimPosition);
isDoingAction = true;
}
else if (tempPressAttackRight || tempPressAttackLeft)
{
Attack(isLeftHandAttacking);
isDoingAction = true;
}
else if (tempPressActivate)
{
Activate();
}
}
// If skill is not attack skill, use it immediately
if (queueSkill != null && !queueSkill.IsAttack())
{
UseSkill(false);
}
queueSkill = null;
}
else if (tempPressWeaponAbility)
{
switch (weaponAbilityState)
{
case WeaponAbilityState.Activated:
case WeaponAbilityState.Activating:
DeactivateWeaponAbility();
break;
case WeaponAbilityState.Deactivated:
case WeaponAbilityState.Deactivating:
ActivateWeaponAbility();
break;
}
}
else if (tempPressPickupItem)
{
// Find for item to pick up
if (SelectedEntity != null)
{
PlayerCharacterEntity.RequestPickupItem((SelectedEntity as ItemDropEntity).ObjectId);
}
}
else if (tempPressReload)
{
// Reload ammo when press the button
ReloadAmmo();
}
else
{
// Update move direction
if (moveDirection.magnitude != 0f)
{
targetLookDirection = moveLookDirection;
}
}
// Setup releasing state
if (tempPressAttackRight && rightHandWeapon != null && rightHandWeapon.fireType == FireType.SingleFire)
{
// The weapon's fire mode is single fire, so player have to release fire key for next fire
mustReleaseFireKey = true;
}
else if (tempPressAttackLeft && leftHandWeapon != null && leftHandWeapon.fireType == FireType.SingleFire)
{
// The weapon's fire mode is single fire, so player have to release fire key for next fire
mustReleaseFireKey = true;
}
// Auto reload
if (!tempPressAttackRight && !tempPressAttackLeft && !tempPressReload &&
(PlayerCharacterEntity.EquipWeapons.rightHand.IsAmmoEmpty() ||
PlayerCharacterEntity.EquipWeapons.leftHand.IsAmmoEmpty()))
{
// Reload ammo when empty and not press any keys
ReloadAmmo();
}
}
SetAimPosition(aimPosition);
// Hide Npc UIs when move
if (moveDirection.magnitude != 0f)
{
HideNpcDialogs();
PlayerCharacterEntity.StopMove();
PlayerCharacterEntity.SetTargetEntity(null);
}
// If jumping add jump state
if (InputManager.GetButtonDown("Jump"))
{
movementState |= MovementState.IsJump;
}
PlayerCharacterEntity.KeyMovement(moveDirection, movementState);
}
public override void UseHotkey(int hotkeyIndex)
{
if (hotkeyIndex < 0 || hotkeyIndex >= PlayerCharacterEntity.Hotkeys.Count)
{
return;
}
CancelBuild();
buildingItemIndex = -1;
CurrentBuildingEntity = null;
CharacterHotkey hotkey = PlayerCharacterEntity.Hotkeys[hotkeyIndex];
Skill skill = hotkey.GetSkill();
if (skill != null)
{
short skillLevel;
if (PlayerCharacterEntity.CacheSkills.TryGetValue(skill, out skillLevel))
{
BaseCharacterEntity attackingCharacter;
if (TryGetAttackingCharacter(out attackingCharacter))
{
// If attacking any character, will use skill later
queueUsingSkill = new UsingSkillData(null, skill.DataId);
}
else if (skill.CanUse(PlayerCharacterEntity, skillLevel))
{
// If not attacking any character, use skill immediately
if (skill.IsAttack())
{
if (IsLockTarget())
{
// If attacking any character, will use skill later
queueUsingSkill = new UsingSkillData(null, skill.DataId);
if (SelectedEntity != null && SelectedEntity is BaseCharacterEntity)
{
// Attacking selected target
PlayerCharacterEntity.SetTargetEntity(SelectedEntity);
}
else
{
// Attacking nearest target
BaseCharacterEntity nearestTarget = PlayerCharacterEntity.FindNearestAliveCharacter <BaseCharacterEntity>(PlayerCharacterEntity.GetSkillAttackDistance(skill, isLeftHandAttacking) + lockAttackTargetDistance, false, true, false);
if (nearestTarget != null)
{
PlayerCharacterEntity.SetTargetEntity(nearestTarget);
}
}
}
else
{
// Not lock target, use it immediately
destination = null;
PlayerCharacterEntity.StopMove();
PlayerCharacterEntity.RequestUseSkill(skill.DataId, isLeftHandAttacking);
isLeftHandAttacking = !isLeftHandAttacking;
}
}
else
{
// This is not attack skill, use it immediately
destination = null;
PlayerCharacterEntity.StopMove();
PlayerCharacterEntity.RequestUseSkill(skill.DataId, isLeftHandAttacking);
}
}
}
}
Item item = hotkey.GetItem();
if (item != null)
{
int itemIndex = PlayerCharacterEntity.IndexOfNonEquipItem(item.DataId);
if (itemIndex >= 0)
{
if (item.IsEquipment())
{
RequestEquipItem((short)itemIndex);
}
else if (item.IsPotion() || item.IsPet())
{
RequestUseItem((short)itemIndex);
}
else if (item.IsBuilding())
{
destination = null;
PlayerCharacterEntity.StopMove();
buildingItemIndex = itemIndex;
CurrentBuildingEntity = Instantiate(item.buildingEntity);
CurrentBuildingEntity.SetupAsBuildMode();
CurrentBuildingEntity.CacheTransform.parent = null;
FindAndSetBuildingAreaFromCharacterDirection();
}
}
}
}
protected virtual void UpdateWASDInput()
{
if (controllerMode != PlayerCharacterControllerMode.WASD &&
controllerMode != PlayerCharacterControllerMode.Both)
{
return;
}
// If mobile platforms, don't receive input raw to make it smooth
bool raw = !InputManager.useMobileInputOnNonMobile && !Application.isMobilePlatform;
Vector3 moveDirection = GetMoveDirection(InputManager.GetAxis("Horizontal", raw), InputManager.GetAxis("Vertical", raw));
if (moveDirection.magnitude != 0f)
{
HideNpcDialogs();
queueUsingSkill = null;
FindAndSetBuildingAreaFromCharacterDirection();
}
// For WASD mode, Using skill when player pressed hotkey
if (queueUsingSkill.HasValue)
{
UsingSkillData queueUsingSkillValue = queueUsingSkill.Value;
destination = null;
PlayerCharacterEntity.StopMove();
Skill skill = null;
if (GameInstance.Skills.TryGetValue(queueUsingSkillValue.dataId, out skill) && skill != null)
{
if (skill.IsAttack())
{
BaseCharacterEntity targetEntity;
if (TryGetSelectedTargetAsAttackingCharacter(out targetEntity))
{
SetTarget(targetEntity);
}
if (wasdLockAttackTarget && !TryGetAttackingCharacter(out targetEntity))
{
BaseCharacterEntity nearestTarget = PlayerCharacterEntity.FindNearestAliveCharacter <BaseCharacterEntity>(PlayerCharacterEntity.GetSkillAttackDistance(skill, isLeftHandAttacking) + lockAttackTargetDistance, false, true, false);
if (nearestTarget != null)
{
// Set target, then use skill later when moved nearby target
PlayerCharacterEntity.SetTargetEntity(nearestTarget);
}
else
{
// No nearby target, so use skill immediately
if (RequestUsePendingSkill(isLeftHandAttacking, null))
{
isLeftHandAttacking = !isLeftHandAttacking;
}
}
}
else if (!wasdLockAttackTarget)
{
// Not lock target, so not finding target and use skill immediately
if (RequestUsePendingSkill(isLeftHandAttacking, null))
{
isLeftHandAttacking = !isLeftHandAttacking;
}
}
}
else
{
// Not attack skill, so use skill immediately
RequestUsePendingSkill(isLeftHandAttacking, null);
}
}
else
{
queueUsingSkill = null;
}
}
// Attack when player pressed attack button
else if (InputManager.GetButton("Attack"))
{
destination = null;
PlayerCharacterEntity.StopMove();
BaseCharacterEntity targetEntity;
if (TryGetSelectedTargetAsAttackingCharacter(out targetEntity))
{
SetTarget(targetEntity);
}
if (wasdLockAttackTarget && !TryGetAttackingCharacter(out targetEntity))
{
// Find nearest target and move to the target
BaseCharacterEntity nearestTarget = PlayerCharacterEntity
.FindNearestAliveCharacter <BaseCharacterEntity>(
PlayerCharacterEntity.GetAttackDistance(isLeftHandAttacking) + lockAttackTargetDistance,
false,
true,
false);
SelectedEntity = nearestTarget;
if (nearestTarget != null)
{
// Set target, then attack later when moved nearby target
PlayerCharacterEntity.SetTargetEntity(nearestTarget);
}
else
{
// No nearby target, so attack immediately
if (PlayerCharacterEntity.RequestAttack(isLeftHandAttacking))
{
isLeftHandAttacking = !isLeftHandAttacking;
}
}
}
else if (!wasdLockAttackTarget)
{
// Find nearest target and set selected target to show character hp/mp UIs
BaseCharacterEntity nearestTarget = PlayerCharacterEntity
.FindNearestAliveCharacter <BaseCharacterEntity>(
PlayerCharacterEntity.GetAttackDistance(isLeftHandAttacking),
false,
true,
false,
true,
PlayerCharacterEntity.GetAttackFov(isLeftHandAttacking));
SelectedEntity = nearestTarget;
// Not lock target, so not finding target and attack immediately
if (PlayerCharacterEntity.RequestAttack(isLeftHandAttacking))
{
isLeftHandAttacking = !isLeftHandAttacking;
}
}
}
// Move
if (moveDirection.magnitude != 0f)
{
PlayerCharacterEntity.StopMove();
destination = null;
ClearTarget();
targetLookDirection = moveDirection.normalized;
}
// Always forward
MovementState movementState = MovementState.Forward;
if (InputManager.GetButtonDown("Jump"))
{
movementState |= MovementState.IsJump;
}
PlayerCharacterEntity.KeyMovement(moveDirection, movementState);
}
protected override void UpdateData()
{
if (Level <= 0)
{
onSetLevelZeroData.Invoke();
}
else
{
onSetNonLevelZeroData.Invoke();
}
if (uiTextTitle != null)
{
uiTextTitle.text = string.Format(titleFormat, Skill == null ? "Unknow" : Skill.title);
}
if (uiTextDescription != null)
{
uiTextDescription.text = string.Format(descriptionFormat, Skill == null ? "N/A" : Skill.description);
}
if (uiTextLevel != null)
{
uiTextLevel.text = string.Format(levelFormat, Level.ToString("N0"));
}
if (imageIcon != null)
{
var iconSprite = Skill == null ? null : Skill.icon;
imageIcon.gameObject.SetActive(iconSprite != null);
imageIcon.sprite = iconSprite;
}
if (uiTextSkillType != null)
{
switch (Skill.skillType)
{
case SkillType.Active:
uiTextSkillType.text = string.Format(skillTypeFormat, activeSkillType);
break;
case SkillType.Passive:
uiTextSkillType.text = string.Format(skillTypeFormat, passiveSkillType);
break;
case SkillType.CraftItem:
uiTextSkillType.text = string.Format(skillTypeFormat, craftItemSkillType);
break;
}
}
if (uiTextAvailableWeapons != null)
{
if (Skill.availableWeapons == null || Skill.availableWeapons.Length == 0)
{
uiTextAvailableWeapons.gameObject.SetActive(false);
}
else
{
var str = string.Empty;
foreach (var availableWeapon in Skill.availableWeapons)
{
if (!string.IsNullOrEmpty(str))
{
str += "/";
}
str += availableWeapon.title;
}
uiTextAvailableWeapons.text = string.Format(availableWeaponsFormat, str);
uiTextAvailableWeapons.gameObject.SetActive(true);
}
}
if (uiTextConsumeMp != null)
{
uiTextConsumeMp.text = string.Format(consumeMpFormat, Skill == null || Level <= 0 ? "N/A" : Skill.GetConsumeMp(Level).ToString("N0"));
}
if (uiRequirement != null)
{
if (Skill == null || (Skill.GetRequireCharacterLevel(Level) == 0 && Skill.CacheRequireSkillLevels.Count == 0))
{
uiRequirement.Hide();
}
else
{
uiRequirement.Show();
uiRequirement.Data = new SkillTuple(Skill, Level);
}
}
if (uiCraftItem != null)
{
if (Skill == null || Skill.skillType != SkillType.CraftItem)
{
uiCraftItem.Hide();
}
else
{
uiCraftItem.Show();
uiCraftItem.Data = Skill.itemCraft;
}
}
var isAttack = Skill != null && Skill.IsAttack();
var isOverrideWeaponDamage = isAttack && Skill.skillAttackType == SkillAttackType.Normal;
if (uiDamageAmount != null)
{
if (!isOverrideWeaponDamage)
{
uiDamageAmount.Hide();
}
else
{
uiDamageAmount.Show();
var keyValuePair = Skill.GetDamageAmount(Level, null);
uiDamageAmount.Data = new DamageElementAmountTuple(keyValuePair.Key, keyValuePair.Value);
}
}
if (uiDamageInflictions != null)
{
var damageInflictionRates = Skill.GetWeaponDamageInflictions(Level);
if (!isAttack || damageInflictionRates == null || damageInflictionRates.Count == 0)
{
uiDamageInflictions.Hide();
}
else
{
uiDamageInflictions.Show();
uiDamageInflictions.Data = damageInflictionRates;
}
}
if (uiAdditionalDamageAmounts != null)
{
var additionalDamageAmounts = Skill.GetAdditionalDamageAmounts(Level);
if (!isAttack || additionalDamageAmounts == null || additionalDamageAmounts.Count == 0)
{
uiAdditionalDamageAmounts.Hide();
}
else
{
uiAdditionalDamageAmounts.Show();
uiAdditionalDamageAmounts.Data = additionalDamageAmounts;
}
}
if (uiSkillBuff != null)
{
if (!Skill.IsBuff())
{
uiSkillBuff.Hide();
}
else
{
uiSkillBuff.Show();
uiSkillBuff.Data = new BuffTuple(Skill.buff, Level);
}
}
if (uiSkillDebuff != null)
{
if (!Skill.IsDebuff())
{
uiSkillDebuff.Hide();
}
else
{
uiSkillDebuff.Show();
uiSkillDebuff.Data = new BuffTuple(Skill.debuff, Level);
}
}
if (uiNextLevelSkill != null)
{
if (Level + 1 > Skill.maxLevel)
{
uiNextLevelSkill.Hide();
}
else
{
uiNextLevelSkill.Setup(new SkillTuple(Skill, (short)(Level + 1)), character, indexOfData);
uiNextLevelSkill.Show();
}
}
}
protected void UpdateWASDInput()
{
if (controllerMode != PlayerCharacterControllerMode.WASD &&
controllerMode != PlayerCharacterControllerMode.Both)
{
return;
}
if (PlayerCharacterEntity.IsPlayingActionAnimation())
{
PlayerCharacterEntity.StopMove();
return;
}
// If mobile platforms, don't receive input raw to make it smooth
var raw = !InputManager.useMobileInputOnNonMobile && !Application.isMobilePlatform;
var moveDirection = GetMoveDirection(InputManager.GetAxis("Horizontal", raw), InputManager.GetAxis("Vertical", raw));
if (moveDirection.magnitude != 0f)
{
if (CacheUISceneGameplay != null && CacheUISceneGameplay.uiNpcDialog != null)
{
CacheUISceneGameplay.uiNpcDialog.Hide();
}
FindAndSetBuildingAreaFromCharacterDirection();
}
// For WASD mode, Using skill when player pressed hotkey
if (queueUsingSkill.HasValue)
{
var queueUsingSkillValue = queueUsingSkill.Value;
destination = null;
PlayerCharacterEntity.StopMove();
Skill skill = null;
if (GameInstance.Skills.TryGetValue(queueUsingSkillValue.dataId, out skill) && skill != null)
{
if (skill.IsAttack())
{
BaseCharacterEntity targetEntity;
if (wasdLockAttackTarget && !TryGetAttackingCharacter(out targetEntity))
{
var nearestTarget = PlayerCharacterEntity.FindNearestAliveCharacter <BaseCharacterEntity>(PlayerCharacterEntity.GetSkillAttackDistance(skill) + lockAttackTargetDistance, false, true, false);
if (nearestTarget != null)
{
PlayerCharacterEntity.SetTargetEntity(nearestTarget);
}
else
{
RequestUsePendingSkill();
}
}
else if (!wasdLockAttackTarget)
{
RequestUsePendingSkill();
}
}
else
{
RequestUsePendingSkill();
}
}
else
{
queueUsingSkill = null;
}
}
// Attack when player pressed attack button
else if (InputManager.GetButton("Attack"))
{
destination = null;
PlayerCharacterEntity.StopMove();
BaseCharacterEntity targetEntity;
if (wasdLockAttackTarget && !TryGetAttackingCharacter(out targetEntity))
{
var nearestTarget = PlayerCharacterEntity.FindNearestAliveCharacter <BaseCharacterEntity>(PlayerCharacterEntity.GetAttackDistance() + lockAttackTargetDistance, false, true, false);
if (nearestTarget != null)
{
PlayerCharacterEntity.SetTargetEntity(nearestTarget);
}
else
{
RequestAttack();
}
}
else if (!wasdLockAttackTarget)
{
RequestAttack();
}
}
// Move
else
{
if (moveDirection.magnitude != 0f)
{
destination = null;
PlayerCharacterEntity.StopMove();
PlayerCharacterEntity.SetTargetEntity(null);
}
PlayerCharacterEntity.KeyMovement(moveDirection, InputManager.GetButtonDown("Jump"));
}
}