/// <summary>
/// This will be called at server to order character to unequip equipments
/// </summary>
/// <param name="fromEquipPosition"></param>
protected virtual void NetFuncUnEquipItem(byte byteInventoryType, short index)
{
if (!CanDoActions())
{
return;
}
EquipWeapons tempEquipWeapons = EquipWeapons;
CharacterItem unEquipItem = CharacterItem.Empty;
switch ((InventoryType)byteInventoryType)
{
case InventoryType.EquipWeaponRight:
unEquipItem = tempEquipWeapons.rightHand;
tempEquipWeapons.rightHand = CharacterItem.Empty;
EquipWeapons = tempEquipWeapons;
break;
case InventoryType.EquipWeaponLeft:
unEquipItem = tempEquipWeapons.leftHand;
tempEquipWeapons.leftHand = CharacterItem.Empty;
EquipWeapons = tempEquipWeapons;
break;
case InventoryType.EquipItems:
unEquipItem = equipItems[index];
equipItems.RemoveAt(index);
UpdateEquipItemIndexes();
break;
}
if (unEquipItem.NotEmptySlot())
{
nonEquipItems.Add(unEquipItem);
}
}
protected virtual void OnSelectCharacterClass(BaseCharacter baseCharacter)
{
eventOnSelectCharacterClass.Invoke(baseCharacter);
PlayerCharacterByDataId.TryGetValue(baseCharacter.DataId, out selectedPlayerCharacter);
if (SelectedPlayerCharacter != null)
{
// Set creating player character data
SelectedDataId = baseCharacter.DataId;
// Prepare equip items
List <CharacterItem> equipItems = new List <CharacterItem>();
foreach (Item armorItem in SelectedPlayerCharacter.armorItems)
{
if (armorItem == null)
{
continue;
}
equipItems.Add(CharacterItem.Create(armorItem));
}
// Set model equip items
SelectedModel.SetEquipItems(equipItems);
// Prepare equip weapons
EquipWeapons equipWeapons = new EquipWeapons();
if (SelectedPlayerCharacter.rightHandEquipItem != null)
{
equipWeapons.rightHand = CharacterItem.Create(SelectedPlayerCharacter.rightHandEquipItem);
}
if (SelectedPlayerCharacter.leftHandEquipItem != null)
{
equipWeapons.leftHand = CharacterItem.Create(SelectedPlayerCharacter.leftHandEquipItem);
}
// Set model equip weapons
SelectedModel.SetEquipWeapons(equipWeapons);
}
}
protected void SetClipBasedOnWeapon(EquipWeapons equipWeapons)
{
Item weaponItem = GameInstance.Singleton.DefaultWeaponItem;
if (equipWeapons.rightHand.NotEmptySlot() && equipWeapons.rightHand.GetWeaponItem() != null)
{
weaponItem = equipWeapons.rightHand.GetWeaponItem();
}
WeaponAnimations weaponAnimations = default(WeaponAnimations);
CacheWeaponAnimations.TryGetValue(weaponItem.WeaponType.DataId, out weaponAnimations);
// Set override animator clips
CacheAnimatorController[CLIP_IDLE] = weaponAnimations.idleClip != null ? weaponAnimations.idleClip : defaultAnimations.idleClip;
CacheAnimatorController[CLIP_MOVE] = weaponAnimations.moveClip != null ? weaponAnimations.moveClip : defaultAnimations.moveClip;
CacheAnimatorController[CLIP_MOVE_BACKWARD] = weaponAnimations.moveBackwardClip != null ? weaponAnimations.moveBackwardClip : defaultAnimations.moveBackwardClip;
CacheAnimatorController[CLIP_MOVE_LEFT] = weaponAnimations.moveLeftClip != null ? weaponAnimations.moveLeftClip : defaultAnimations.moveLeftClip;
CacheAnimatorController[CLIP_MOVE_RIGHT] = weaponAnimations.moveRightClip != null ? weaponAnimations.moveRightClip : defaultAnimations.moveRightClip;
CacheAnimatorController[CLIP_MOVE_FORWARD_LEFT] = weaponAnimations.moveForwardLeftClip != null ? weaponAnimations.moveForwardLeftClip : defaultAnimations.moveForwardLeftClip;
CacheAnimatorController[CLIP_MOVE_FORWARD_RIGHT] = weaponAnimations.moveForwardRightClip != null ? weaponAnimations.moveForwardRightClip : defaultAnimations.moveForwardRightClip;
CacheAnimatorController[CLIP_MOVE_BACKWARD_LEFT] = weaponAnimations.moveBackwardLeftClip != null ? weaponAnimations.moveBackwardLeftClip : defaultAnimations.moveBackwardLeftClip;
CacheAnimatorController[CLIP_MOVE_BACKWARD_RIGHT] = weaponAnimations.moveBackwardRightClip != null ? weaponAnimations.moveBackwardRightClip : defaultAnimations.moveBackwardRightClip;
CacheAnimatorController[CLIP_JUMP] = weaponAnimations.jumpClip != null ? weaponAnimations.jumpClip : defaultAnimations.jumpClip;
CacheAnimatorController[CLIP_FALL] = weaponAnimations.fallClip != null ? weaponAnimations.fallClip : defaultAnimations.fallClip;
CacheAnimatorController[CLIP_HURT] = weaponAnimations.hurtClip != null ? weaponAnimations.hurtClip : defaultAnimations.hurtClip;
CacheAnimatorController[CLIP_DEAD] = weaponAnimations.deadClip != null ? weaponAnimations.deadClip : defaultAnimations.deadClip;
}
public EquipWeapons ReadCharacterEquipWeapons(string characterId)
{
EquipWeapons result = new EquipWeapons();
// Right hand weapon
SQLiteRowsReader reader = ExecuteReader("SELECT * FROM characteritem WHERE characterId=@characterId AND inventoryType=@inventoryType LIMIT 1",
new SqliteParameter("@characterId", characterId),
new SqliteParameter("@inventoryType", (byte)InventoryType.EquipWeaponRight));
CharacterItem rightWeapon;
if (ReadCharacterItem(reader, out rightWeapon))
{
result.rightHand = rightWeapon;
}
// Left hand weapon
reader = ExecuteReader("SELECT * FROM characteritem WHERE characterId=@characterId AND inventoryType=@inventoryType LIMIT 1",
new SqliteParameter("@characterId", characterId),
new SqliteParameter("@inventoryType", (byte)InventoryType.EquipWeaponLeft));
CharacterItem leftWeapon;
if (ReadCharacterItem(reader, out leftWeapon))
{
result.leftHand = leftWeapon;
}
return(result);
}
private void DecreaseEquipShieldsDurability(BaseCharacterEntity entity, float decreaseDurability)
{
bool tempDestroy = false;
EquipWeapons equipWeapons = entity.EquipWeapons;
CharacterItem rightHand = equipWeapons.rightHand;
CharacterItem leftHand = equipWeapons.leftHand;
if (rightHand.GetShieldItem() != null && rightHand.GetMaxDurability() > 0)
{
rightHand = DecreaseDurability(rightHand, decreaseDurability, out tempDestroy);
if (tempDestroy)
{
equipWeapons.rightHand = CharacterItem.Empty;
}
else
{
equipWeapons.rightHand = rightHand;
}
}
if (leftHand.GetShieldItem() != null && leftHand.GetMaxDurability() > 0)
{
leftHand = DecreaseDurability(leftHand, decreaseDurability, out tempDestroy);
if (tempDestroy)
{
equipWeapons.leftHand = CharacterItem.Empty;
}
else
{
equipWeapons.leftHand = leftHand;
}
}
entity.EquipWeapons = equipWeapons;
}
protected void SetupEquipWeapons(EquipWeapons equipWeapons)
{
mustReleaseFireKey = false;
currentCrosshairSetting = PlayerCharacterEntity.GetCrosshairSetting();
rightHandWeapon = equipWeapons.rightHand.GetWeaponItem();
leftHandWeapon = equipWeapons.leftHand.GetWeaponItem();
// Weapon ability will be able to use when equip weapon at main-hand only
if (rightHandWeapon != null && leftHandWeapon == null)
{
if (rightHandWeapon.weaponAbility != weaponAbility)
{
if (weaponAbility != null)
{
weaponAbility.ForceDeactivated();
}
weaponAbility = rightHandWeapon.weaponAbility;
weaponAbility.Setup(this);
weaponAbilityState = WeaponAbilityState.Deactivated;
}
}
else
{
if (weaponAbility != null)
{
weaponAbility.ForceDeactivated();
}
weaponAbility = null;
weaponAbilityState = WeaponAbilityState.Deactivated;
}
}
/// <summary>
/// This will be called at server to order character to equip equipments
/// </summary>
/// <param name="nonEquipIndex"></param>
/// <param name="equipPosition"></param>
protected virtual void NetFuncEquipItem(short nonEquipIndex, byte byteInventoryType, short oldEquipIndex)
{
if (!CanDoActions() ||
nonEquipIndex >= nonEquipItems.Count)
{
return;
}
CharacterItem equippingItem = nonEquipItems[nonEquipIndex];
GameMessage.Type gameMessageType;
bool shouldUnequipRightHand;
bool shouldUnequipLeftHand;
if (!CanEquipItem(equippingItem, (InventoryType)byteInventoryType, oldEquipIndex, out gameMessageType, out shouldUnequipRightHand, out shouldUnequipLeftHand))
{
gameManager.SendServerGameMessage(ConnectionId, gameMessageType);
return;
}
// Unequip equipped item that already equipped
if (shouldUnequipRightHand)
{
NetFuncUnEquipItem((byte)InventoryType.EquipWeaponRight, 0);
}
if (shouldUnequipLeftHand)
{
NetFuncUnEquipItem((byte)InventoryType.EquipWeaponLeft, 0);
}
// Equipping items
EquipWeapons tempEquipWeapons = EquipWeapons;
switch ((InventoryType)byteInventoryType)
{
case InventoryType.EquipWeaponRight:
tempEquipWeapons.rightHand = equippingItem;
EquipWeapons = tempEquipWeapons;
break;
case InventoryType.EquipWeaponLeft:
tempEquipWeapons.leftHand = equippingItem;
EquipWeapons = tempEquipWeapons;
break;
case InventoryType.EquipItems:
if (oldEquipIndex < 0)
{
oldEquipIndex = (short)this.IndexOfEquipItem(equippingItem.GetArmorItem().EquipPosition);
}
if (oldEquipIndex >= 0)
{
NetFuncUnEquipItem((byte)InventoryType.EquipItems, oldEquipIndex);
}
equipItems.Add(equippingItem);
equipItemIndexes.Add(equippingItem.GetArmorItem().EquipPosition, equipItems.Count - 1);
break;
}
nonEquipItems.RemoveAt(nonEquipIndex);
this.FillEmptySlots();
}
protected void OnEquipWeaponsChange(EquipWeapons equipWeapons)
{
if (CharacterEntity.IsOwnerClient && CacheUISceneGameplay != null)
{
CacheUISceneGameplay.UpdateCharacter();
CacheUISceneGameplay.UpdateEquipItems();
}
}
public void UpdateData(ICharacterData character)
{
this.character = character;
// Clear slots data
foreach (UICharacterItem slot in CacheEquipItemSlots.Values)
{
slot.Setup(GetEmptyUIData(slot.InventoryType), character, -1);
slot.Show();
}
if (character == null)
{
return;
}
string tempPosition;
UICharacterItem tempSlot;
IList <CharacterItem> equipItems = character.EquipItems;
for (int i = 0; i < equipItems.Count; ++i)
{
CharacterItem equipItem = equipItems[i];
Item armorItem = equipItem.GetArmorItem();
if (armorItem == null)
{
continue;
}
tempPosition = armorItem.EquipPosition;
if (CacheEquipItemSlots.TryGetValue(tempPosition, out tempSlot))
{
tempSlot.Setup(new CharacterItemTuple(equipItem, equipItem.level, InventoryType.EquipItems), character, i);
}
}
EquipWeapons equipWeapons = character.EquipWeapons;
CharacterItem rightHand = equipWeapons.rightHand;
CharacterItem leftHand = equipWeapons.leftHand;
Item rightHandEquipment = rightHand.GetEquipmentItem();
Item leftHandEquipment = leftHand.GetEquipmentItem();
tempPosition = GameDataConst.EQUIP_POSITION_RIGHT_HAND;
if (CacheEquipItemSlots.TryGetValue(tempPosition, out tempSlot))
{
if (rightHandEquipment != null)
{
tempSlot.Setup(new CharacterItemTuple(rightHand, rightHand.level, InventoryType.EquipWeaponRight), character, 0);
}
}
tempPosition = GameDataConst.EQUIP_POSITION_LEFT_HAND;
if (CacheEquipItemSlots.TryGetValue(tempPosition, out tempSlot))
{
if (leftHandEquipment != null)
{
tempSlot.Setup(new CharacterItemTuple(leftHand, leftHand.level, InventoryType.EquipWeaponLeft), character, 0);
}
}
}
public static void RepairLeftHandItem(IPlayerCharacterData character, out GameMessage.Type gameMessageType)
{
RepairItem(character, character.EquipWeapons.leftHand, (repairedItem) =>
{
EquipWeapons equipWeapon = character.EquipWeapons;
equipWeapon.leftHand = repairedItem;
character.EquipWeapons = equipWeapon;
}, out gameMessageType);
}
public static void EnhanceSocketRightHandItem(IPlayerCharacterData character, int enhancerId, out GameMessage.Type gameMessageType)
{
EnhanceSocketItem(character, character.EquipWeapons.rightHand, enhancerId, (enhancedSocketItem) =>
{
EquipWeapons equipWeapon = character.EquipWeapons;
equipWeapon.rightHand = enhancedSocketItem;
character.EquipWeapons = equipWeapon;
}, out gameMessageType);
}
/// <summary>
/// Override this to do stuffs when equip weapons changes
/// </summary>
/// <param name="equipWeapons"></param>
protected virtual void OnEquipWeaponsChange(bool isInitial, EquipWeapons equipWeapons)
{
if (CharacterModel != null)
{
CharacterModel.SetEquipWeapons(equipWeapons);
}
if (onEquipWeaponsChange != null)
{
onEquipWeaponsChange.Invoke(equipWeapons);
}
}
public static void RefineRightHandItem(IPlayerCharacterData character, out GameMessage.Type gameMessageType)
{
RefineItem(character, character.EquipWeapons.rightHand, (refinedItem) =>
{
EquipWeapons equipWeapon = character.EquipWeapons;
equipWeapon.rightHand = refinedItem;
character.EquipWeapons = equipWeapon;
}, () =>
{
EquipWeapons equipWeapon = character.EquipWeapons;
equipWeapon.rightHand = CharacterItem.Empty;
character.EquipWeapons = equipWeapon;
}, out gameMessageType);
}
/// <summary>
/// Unequips weapon items from the character and drops them to the loot bag according to the rules set.
/// </summary>
protected void DropWeaponItems()
{
for (int i = SelectableWeaponSets.Count - 1; i >= 0; i--)
{
EquipWeapons set = SelectableWeaponSets[i];
var leftHandWeapon = set.leftHand;
var rightHandWeapon = set.rightHand;
if (!leftHandWeapon.IsEmptySlot())
{
if (playerDB.maxLootItems > 0 && lootBagItems.Count >= playerDB.maxLootItems)
{
return;
}
if (ShouldDrop(leftHandWeapon))
{
CharacterItem unEquipItem = leftHandWeapon;
set.leftHand = CharacterItem.Empty;
this.AddOrSetNonEquipItems(unEquipItem);
this.FillEmptySlots();
DropInventoryItem(unEquipItem);
}
}
if (!rightHandWeapon.IsEmptySlot())
{
if (playerDB.maxLootItems > 0 && lootBagItems.Count >= playerDB.maxLootItems)
{
return;
}
if (ShouldDrop(rightHandWeapon))
{
CharacterItem unEquipItem = rightHandWeapon;
set.rightHand = CharacterItem.Empty;
this.AddOrSetNonEquipItems(unEquipItem);
this.FillEmptySlots();
DropInventoryItem(unEquipItem);
}
}
}
this.FillEmptySlots();
}
public void ReduceAmmo(CharacterItem weapon, bool isLeftHand, out Dictionary <DamageElement, MinMaxFloat> increaseDamges)
{
increaseDamges = null;
// Avoid null data
if (weapon == null)
{
return;
}
Item weaponItem = weapon.GetWeaponItem();
if (weaponItem.ammoCapacity <= 0)
{
// Ammo capacity is 0 so reduce ammo from inventory
Dictionary <CharacterItem, short> decreaseAmmoItems;
if (this.DecreaseAmmos(weaponItem.WeaponType.requireAmmoType, 1, out decreaseAmmoItems))
{
KeyValuePair <CharacterItem, short> firstEntry = decreaseAmmoItems.FirstOrDefault();
CharacterItem ammoCharacterItem = firstEntry.Key;
Item ammoItem = ammoCharacterItem.GetItem();
if (ammoItem != null && firstEntry.Value > 0)
{
// Ammo level always 1 and its bonus rate always 1
increaseDamges = ammoItem.GetIncreaseDamages(1, 1f);
}
}
}
else
{
// Ammo capacity more than 0 reduce loaded ammo
if (weapon.ammo > 0)
{
weapon.ammo--;
EquipWeapons equipWeapons = EquipWeapons;
if (isLeftHand)
{
equipWeapons.leftHand = weapon;
}
else
{
equipWeapons.rightHand = weapon;
}
EquipWeapons = equipWeapons;
}
}
}
public static CharacterStats GetEquipmentStats(this ICharacterData data)
{
if (data == null)
{
return(new CharacterStats());
}
CharacterStats result = new CharacterStats();
// Armors
IList <CharacterItem> equipItems = data.EquipItems;
foreach (CharacterItem equipItem in equipItems)
{
if (equipItem.IsEmpty())
{
continue;
}
result += equipItem.GetIncreaseStats();
result += equipItem.GetSocketsIncreaseStats();
result += GameDataHelpers.GetStatsFromAttributes(equipItem.GetIncreaseAttributes());
result += GameDataHelpers.GetStatsFromAttributes(equipItem.GetSocketsIncreaseAttributes());
}
// Weapons
EquipWeapons equipWeapons = data.EquipWeapons;
if (equipWeapons != null)
{
// Right hand equipment
if (!equipWeapons.rightHand.IsEmpty())
{
result += equipWeapons.rightHand.GetIncreaseStats();
result += equipWeapons.rightHand.GetSocketsIncreaseStats();
result += GameDataHelpers.GetStatsFromAttributes(equipWeapons.rightHand.GetIncreaseAttributes());
result += GameDataHelpers.GetStatsFromAttributes(equipWeapons.rightHand.GetSocketsIncreaseAttributes());
}
// Left hand equipment
if (!equipWeapons.leftHand.IsEmpty())
{
result += equipWeapons.leftHand.GetIncreaseStats();
result += equipWeapons.leftHand.GetSocketsIncreaseStats();
result += GameDataHelpers.GetStatsFromAttributes(equipWeapons.leftHand.GetIncreaseAttributes());
result += GameDataHelpers.GetStatsFromAttributes(equipWeapons.leftHand.GetSocketsIncreaseAttributes());
}
}
return(result);
}
public void SetEquipWeapons(EquipWeapons equipWeapons)
{
var rightHandWeapon = equipWeapons.rightHand.GetWeaponItem();
var leftHandWeapon = equipWeapons.leftHand.GetWeaponItem();
var leftHandShield = equipWeapons.leftHand.GetShieldItem();
// Clear equipped item models
var keepingKeys = new List <string>();
if (rightHandWeapon != null)
{
keepingKeys.Add(GameDataConst.EQUIP_POSITION_RIGHT_HAND);
}
if (leftHandWeapon != null || leftHandShield != null)
{
keepingKeys.Add(GameDataConst.EQUIP_POSITION_LEFT_HAND);
}
var keys = new List <string>(cacheModels.Keys);
foreach (var key in keys)
{
if (!keepingKeys.Contains(key) &&
(key.Equals(GameDataConst.EQUIP_POSITION_RIGHT_HAND) ||
key.Equals(GameDataConst.EQUIP_POSITION_LEFT_HAND)))
{
DestroyCacheModel(key);
}
}
if (rightHandWeapon != null)
{
InstantiateEquipModel(GameDataConst.EQUIP_POSITION_RIGHT_HAND, rightHandWeapon.equipmentModels);
}
if (leftHandWeapon != null)
{
InstantiateEquipModel(GameDataConst.EQUIP_POSITION_LEFT_HAND, leftHandWeapon.subEquipmentModels);
}
if (leftHandShield != null)
{
InstantiateEquipModel(GameDataConst.EQUIP_POSITION_LEFT_HAND, leftHandShield.equipmentModels);
}
}
public virtual void SetEquipWeapons(EquipWeapons equipWeapons)
{
Item rightHandWeapon = equipWeapons.rightHand.GetWeaponItem();
Item leftHandWeapon = equipWeapons.leftHand.GetWeaponItem();
Item leftHandShield = equipWeapons.leftHand.GetShieldItem();
// Clear equipped item models
tempAddingKeys.Clear();
if (rightHandWeapon != null)
{
tempAddingKeys.Add(GameDataConst.EQUIP_POSITION_RIGHT_HAND);
}
if (leftHandWeapon != null || leftHandShield != null)
{
tempAddingKeys.Add(GameDataConst.EQUIP_POSITION_LEFT_HAND);
}
tempCachedKeys.Clear();
tempCachedKeys.AddRange(cacheModels.Keys);
foreach (string key in tempCachedKeys)
{
if (!tempAddingKeys.Contains(key) &&
(key.Equals(GameDataConst.EQUIP_POSITION_RIGHT_HAND) ||
key.Equals(GameDataConst.EQUIP_POSITION_LEFT_HAND)))
{
DestroyCacheModel(key);
}
}
if (rightHandWeapon != null)
{
InstantiateEquipModel(GameDataConst.EQUIP_POSITION_RIGHT_HAND, rightHandWeapon.equipmentModels, equipWeapons.rightHand.level, out rightHandEquipmentEntity);
}
if (leftHandWeapon != null)
{
InstantiateEquipModel(GameDataConst.EQUIP_POSITION_LEFT_HAND, leftHandWeapon.subEquipmentModels, equipWeapons.leftHand.level, out leftHandEquipmentEntity);
}
if (leftHandShield != null)
{
InstantiateEquipModel(GameDataConst.EQUIP_POSITION_LEFT_HAND, leftHandShield.equipmentModels, equipWeapons.leftHand.level, out leftHandEquipmentEntity);
}
}
public static Dictionary <DamageElement, MinMaxFloat> GetEquipmentIncreaseDamages(this ICharacterData data)
{
if (data == null)
{
return(new Dictionary <DamageElement, MinMaxFloat>());
}
Dictionary <DamageElement, MinMaxFloat> result = new Dictionary <DamageElement, MinMaxFloat>();
// Armors
IList <CharacterItem> equipItems = data.EquipItems;
foreach (CharacterItem equipItem in equipItems)
{
if (equipItem.IsEmpty())
{
continue;
}
result = GameDataHelpers.CombineDamages(result, equipItem.GetIncreaseDamages());
result = GameDataHelpers.CombineDamages(result, equipItem.GetSocketsIncreaseDamages());
}
// Weapons
EquipWeapons equipWeapons = data.EquipWeapons;
if (equipWeapons != null)
{
// Right hand equipment
if (equipWeapons.rightHand.IsEmpty())
{
result = GameDataHelpers.CombineDamages(result, equipWeapons.rightHand.GetIncreaseDamages());
result = GameDataHelpers.CombineDamages(result, equipWeapons.rightHand.GetSocketsIncreaseDamages());
}
// Left hand equipment
if (equipWeapons.leftHand.IsEmpty())
{
result = GameDataHelpers.CombineDamages(result, equipWeapons.leftHand.GetIncreaseDamages());
result = GameDataHelpers.CombineDamages(result, equipWeapons.leftHand.GetSocketsIncreaseDamages());
}
}
return(result);
}
private IEnumerator ReloadRoutine(
AnimActionType animActionType,
int weaponTypeDataId,
float triggerDuration,
float totalDuration,
bool isLeftHand,
CharacterItem weapon,
short reloadingAmount)
{
// Play animation on clients
RequestPlayActionAnimation(animActionType, weaponTypeDataId, 0);
yield return(new WaitForSecondsRealtime(triggerDuration));
// Prepare data
EquipWeapons equipWeapons = EquipWeapons;
Item weaponItem = weapon.GetWeaponItem();
Dictionary <CharacterItem, short> decreaseItems;
if (this.DecreaseAmmos(weaponItem.WeaponType.requireAmmoType, reloadingAmount, out decreaseItems))
{
weapon.ammo += reloadingAmount;
if (isLeftHand)
{
equipWeapons.leftHand = weapon;
}
else
{
equipWeapons.rightHand = weapon;
}
EquipWeapons = equipWeapons;
}
yield return(new WaitForSecondsRealtime(totalDuration - triggerDuration));
isAttackingOrUsingSkill = false;
}
public override void SetEquipWeapons(EquipWeapons equipWeapons)
{
tempEquipWeapons = equipWeapons;
SetClipBasedOnWeapon(equipWeapons);
if (!IsUmaCharacterCreated)
{
return;
}
ClearObjectsAndSlots(equipWeaponUsedSlots, equipWeaponObjects);
if (CacheUmaAvatar.activeRace == null ||
CacheUmaAvatar.activeRace.racedata == null ||
equipWeapons == null)
{
return;
}
string raceName = CacheUmaAvatar.activeRace.racedata.raceName;
Item tempEquipmentItem;
UMATextRecipe[] receipes;
// Setup right hand weapon
if (equipWeapons.rightHand != null)
{
tempEquipmentItem = equipWeapons.rightHand.GetWeaponItem();
if (tempEquipmentItem != null)
{
SetEquipmentObject(equipWeaponObjects, tempEquipmentItem.equipmentModels, equipWeapons.rightHand.level, out rightHandEquipmentEntity);
if (tempEquipmentItem.CacheUmaRecipeSlot.TryGetValue(raceName, out receipes))
{
SetSlot(equipWeaponUsedSlots, receipes);
}
}
}
// Setup left hand weapon
if (equipWeapons.leftHand != null)
{
// Weapon
tempEquipmentItem = equipWeapons.leftHand.GetWeaponItem();
if (tempEquipmentItem != null)
{
SetEquipmentObject(equipWeaponObjects, tempEquipmentItem.subEquipmentModels, equipWeapons.leftHand.level, out leftHandEquipmentEntity);
if (tempEquipmentItem.CacheUmaRecipeSlot.TryGetValue(raceName, out receipes))
{
SetSlot(equipWeaponUsedSlots, receipes);
}
}
// Shield
tempEquipmentItem = equipWeapons.leftHand.GetShieldItem();
if (tempEquipmentItem != null)
{
SetEquipmentObject(equipWeaponObjects, tempEquipmentItem.equipmentModels, equipWeapons.leftHand.level, out leftHandEquipmentEntity);
if (tempEquipmentItem.CacheUmaRecipeSlot.TryGetValue(raceName, out receipes))
{
SetSlot(equipWeaponUsedSlots, receipes);
}
}
}
// Update avatar
CacheUmaAvatar.BuildCharacter(true);
CacheUmaAvatar.ForceUpdate(true, true, true);
}
public async UniTask CreateCharacterEquipWeapons(MySqlConnection connection, MySqlTransaction transaction, byte equipWeaponSet, string characterId, EquipWeapons equipWeapons)
{
await CreateCharacterItem(connection, transaction, equipWeaponSet, characterId, InventoryType.EquipWeaponRight, equipWeapons.rightHand);
await CreateCharacterItem(connection, transaction, equipWeaponSet, characterId, InventoryType.EquipWeaponLeft, equipWeapons.leftHand);
}
public void CreateCharacterEquipWeapons(string characterId, EquipWeapons equipWeapons)
{
CreateCharacterItem(0, characterId, InventoryType.EquipWeaponRight, equipWeapons.rightHand);
CreateCharacterItem(0, characterId, InventoryType.EquipWeaponLeft, equipWeapons.leftHand);
}
public static T ValidateCharacterData <T>(this T character) where T : IPlayerCharacterData
{
GameInstance gameInstance = GameInstance.Singleton;
PlayerCharacter database;
if (!GameInstance.PlayerCharacters.TryGetValue(character.DataId, out database))
{
return(character);
}
// Validating character attributes
short returningStatPoint = 0;
HashSet <int> validAttributeIds = new HashSet <int>();
IList <CharacterAttribute> characterAttributes = character.Attributes;
for (int i = characterAttributes.Count - 1; i >= 0; --i)
{
CharacterAttribute characterAttribute = characterAttributes[i];
int attributeDataId = characterAttribute.dataId;
// If attribute is invalid
if (characterAttribute.GetAttribute() == null ||
validAttributeIds.Contains(attributeDataId))
{
returningStatPoint += characterAttribute.amount;
character.Attributes.RemoveAt(i);
}
else
{
validAttributeIds.Add(attributeDataId);
}
}
character.StatPoint += returningStatPoint;
// Add character's attributes
foreach (Attribute attribute in GameInstance.Attributes.Values)
{
// This attribute is valid, so not have to add it
if (validAttributeIds.Contains(attribute.DataId))
{
continue;
}
CharacterAttribute characterAttribute = new CharacterAttribute();
characterAttribute.dataId = attribute.DataId;
characterAttribute.amount = 0;
character.Attributes.Add(characterAttribute);
}
// Validating character skills
short returningSkillPoint = 0;
HashSet <int> validSkillIds = new HashSet <int>();
IList <CharacterSkill> characterSkills = character.Skills;
for (int i = characterSkills.Count - 1; i >= 0; --i)
{
CharacterSkill characterSkill = characterSkills[i];
Skill skill = characterSkill.GetSkill();
// If skill is invalid or this character database does not have skill
if (characterSkill.GetSkill() == null ||
!database.CacheSkillLevels.ContainsKey(skill) ||
validSkillIds.Contains(skill.DataId))
{
returningSkillPoint += characterSkill.level;
character.Skills.RemoveAt(i);
}
else
{
validSkillIds.Add(skill.DataId);
}
}
character.SkillPoint += returningSkillPoint;
// Add character's skills
Dictionary <Skill, short> skillLevels = database.CacheSkillLevels;
foreach (KeyValuePair <Skill, short> skillLevel in skillLevels)
{
Skill skill = skillLevel.Key;
// This skill is valid, so not have to add it
if (validSkillIds.Contains(skill.DataId))
{
continue;
}
CharacterSkill characterSkill = new CharacterSkill();
characterSkill.dataId = skill.DataId;
characterSkill.level = skillLevel.Value;
character.Skills.Add(characterSkill);
}
// Validating character equip weapons
List <CharacterItem> returningItems = new List <CharacterItem>();
EquipWeapons equipWeapons = character.EquipWeapons;
CharacterItem rightHand = equipWeapons.rightHand;
CharacterItem leftHand = equipWeapons.leftHand;
if (rightHand.GetEquipmentItem() == null)
{
if (rightHand.NotEmptySlot())
{
returningItems.Add(rightHand);
}
equipWeapons.rightHand = CharacterItem.Empty;
}
if (leftHand.GetEquipmentItem() == null)
{
if (leftHand.NotEmptySlot())
{
returningItems.Add(leftHand);
}
equipWeapons.leftHand = CharacterItem.Empty;
}
// Validating character equip items
IList <CharacterItem> equipItems = character.EquipItems;
for (int i = equipItems.Count - 1; i >= 0; --i)
{
CharacterItem equipItem = equipItems[i];
// If equipment is invalid
if (equipItem.GetEquipmentItem() == null)
{
if (equipItem.NotEmptySlot())
{
returningItems.Add(equipItem);
}
character.EquipItems.RemoveAt(i);
}
}
// Return items to non equip items
foreach (CharacterItem returningItem in returningItems)
{
character.NonEquipItems.Add(returningItem);
}
character.FillEmptySlots();
DevExtUtils.InvokeStaticDevExtMethods(ClassType, "ValidateCharacterData", character);
return(character);
}
public override void SetEquipWeapons(EquipWeapons equipWeapons)
{
base.SetEquipWeapons(equipWeapons);
SetupComponent();
SetClipBasedOnWeapon(equipWeapons);
}
public void CreateCharacterEquipWeapons(SqliteTransaction transaction, byte equipWeaponSet, string characterId, EquipWeapons equipWeapons)
{
CreateCharacterItem(transaction, equipWeaponSet, characterId, InventoryType.EquipWeaponRight, equipWeapons.rightHand);
CreateCharacterItem(transaction, equipWeaponSet, characterId, InventoryType.EquipWeaponLeft, equipWeapons.leftHand);
}
public static T SetNewPlayerCharacterData <T>(this T character, string characterName, int dataId, int entityId) where T : IPlayerCharacterData
{
var gameInstance = GameInstance.Singleton;
PlayerCharacter database;
if (!GameInstance.PlayerCharacters.TryGetValue(dataId, out database))
{
return(character);
}
// Player character database
var playerCharacter = database as PlayerCharacter;
// Attributes
var attributes = GameInstance.Attributes.Values;
foreach (var attribute in attributes)
{
var characterAttribute = new CharacterAttribute();
characterAttribute.dataId = attribute.DataId;
characterAttribute.amount = 0;
character.Attributes.Add(characterAttribute);
}
var skillLevels = playerCharacter.CacheSkillLevels;
foreach (var skillLevel in skillLevels)
{
var characterSkill = new CharacterSkill();
characterSkill.dataId = skillLevel.Key.DataId;
characterSkill.level = skillLevel.Value;
character.Skills.Add(characterSkill);
}
// Right hand & left hand items
var rightHandEquipItem = playerCharacter.rightHandEquipItem;
var leftHandEquipItem = playerCharacter.leftHandEquipItem;
var equipWeapons = new EquipWeapons();
// Right hand equipped item
if (rightHandEquipItem != null)
{
var newItem = CharacterItem.Create(rightHandEquipItem);
equipWeapons.rightHand = newItem;
}
// Left hand equipped item
if (leftHandEquipItem != null)
{
var newItem = CharacterItem.Create(leftHandEquipItem);
equipWeapons.leftHand = newItem;
}
character.EquipWeapons = equipWeapons;
// Armors
var armorItems = playerCharacter.armorItems;
foreach (var armorItem in armorItems)
{
if (armorItem == null)
{
continue;
}
var newItem = CharacterItem.Create(armorItem);
character.EquipItems.Add(newItem);
}
// General data
character.DataId = dataId;
character.EntityId = entityId;
character.CharacterName = characterName;
character.Level = 1;
var stats = character.GetStats();
character.CurrentHp = (int)stats.hp;
character.CurrentMp = (int)stats.mp;
character.CurrentStamina = (int)stats.stamina;
character.CurrentFood = (int)stats.food;
character.CurrentWater = (int)stats.water;
character.Gold = gameInstance.startGold;
// Inventory
var startItems = gameInstance.startItems;
foreach (var startItem in startItems)
{
if (startItem.item == null || startItem.amount <= 0)
{
continue;
}
var amount = startItem.amount;
if (amount > startItem.item.maxStack)
{
amount = startItem.item.maxStack;
}
var newItem = CharacterItem.Create(startItem.item, 1, amount);
character.NonEquipItems.Add(newItem);
}
// Position
var startMap = playerCharacter.StartMap;
character.CurrentMapName = startMap.scene.SceneName;
character.RespawnMapName = startMap.scene.SceneName;
character.CurrentPosition = startMap.startPosition;
character.RespawnPosition = startMap.startPosition;
DevExtUtils.InvokeStaticDevExtMethods(ClassType, "SetNewCharacterData", character, characterName, dataId, entityId);
return(character);
}
public static T DeserializeCharacterData <T>(this T characterData, NetDataReader reader) where T : IPlayerCharacterData
{
var tempCharacterData = new PlayerCharacterData();
tempCharacterData.Id = reader.GetString();
tempCharacterData.DataId = reader.GetInt();
tempCharacterData.EntityId = reader.GetInt();
tempCharacterData.CharacterName = reader.GetString();
tempCharacterData.Level = reader.GetShort();
tempCharacterData.Exp = reader.GetInt();
tempCharacterData.CurrentHp = reader.GetInt();
tempCharacterData.CurrentMp = reader.GetInt();
tempCharacterData.CurrentStamina = reader.GetInt();
tempCharacterData.CurrentFood = reader.GetInt();
tempCharacterData.CurrentWater = reader.GetInt();
tempCharacterData.StatPoint = reader.GetShort();
tempCharacterData.SkillPoint = reader.GetShort();
tempCharacterData.Gold = reader.GetInt();
tempCharacterData.PartyId = reader.GetInt();
tempCharacterData.GuildId = reader.GetInt();
tempCharacterData.GuildRole = reader.GetByte();
tempCharacterData.SharedGuildExp = reader.GetInt();
tempCharacterData.CurrentMapName = reader.GetString();
tempCharacterData.CurrentPosition = new Vector3(reader.GetFloat(), reader.GetFloat(), reader.GetFloat());
tempCharacterData.RespawnMapName = reader.GetString();
tempCharacterData.RespawnPosition = new Vector3(reader.GetFloat(), reader.GetFloat(), reader.GetFloat());
tempCharacterData.LastUpdate = reader.GetInt();
int count = 0;
count = reader.GetByte();
for (var i = 0; i < count; ++i)
{
var entry = new CharacterAttribute();
entry.Deserialize(reader);
tempCharacterData.Attributes.Add(entry);
}
count = reader.GetByte();
for (var i = 0; i < count; ++i)
{
var entry = new CharacterBuff();
entry.Deserialize(reader);
tempCharacterData.Buffs.Add(entry);
}
count = reader.GetByte();
for (var i = 0; i < count; ++i)
{
var entry = new CharacterSkill();
entry.Deserialize(reader);
tempCharacterData.Skills.Add(entry);
}
count = reader.GetByte();
for (var i = 0; i < count; ++i)
{
var entry = new CharacterSkillUsage();
entry.Deserialize(reader);
tempCharacterData.SkillUsages.Add(entry);
}
count = reader.GetByte();
for (var i = 0; i < count; ++i)
{
var entry = new CharacterSummon();
entry.Deserialize(reader);
tempCharacterData.Summons.Add(entry);
}
count = reader.GetByte();
for (var i = 0; i < count; ++i)
{
var entry = new CharacterItem();
entry.Deserialize(reader);
tempCharacterData.EquipItems.Add(entry);
}
count = reader.GetShort();
for (var i = 0; i < count; ++i)
{
var entry = new CharacterItem();
entry.Deserialize(reader);
tempCharacterData.NonEquipItems.Add(entry);
}
count = reader.GetByte();
for (var i = 0; i < count; ++i)
{
var entry = new CharacterHotkey();
entry.Deserialize(reader);
tempCharacterData.Hotkeys.Add(entry);
}
count = reader.GetByte();
for (var i = 0; i < count; ++i)
{
var entry = new CharacterQuest();
entry.Deserialize(reader);
tempCharacterData.Quests.Add(entry);
}
var equipWeapons = new EquipWeapons();
equipWeapons.Deserialize(reader);
tempCharacterData.EquipWeapons = equipWeapons;
DevExtUtils.InvokeStaticDevExtMethods(ClassType, "DeserializeCharacterData", characterData, reader);
tempCharacterData.ValidateCharacterData();
tempCharacterData.CloneTo(characterData);
return(characterData);
}
public void CreateCharacterEquipWeapons(MySqlConnection connection, MySqlTransaction transaction, string characterId, EquipWeapons equipWeapons)
{
CreateCharacterItem(connection, transaction, 0, characterId, InventoryType.EquipWeaponRight, equipWeapons.rightHand);
CreateCharacterItem(connection, transaction, 0, characterId, InventoryType.EquipWeaponLeft, equipWeapons.leftHand);
}
protected void SetClipBasedOnWeapon(EquipWeapons equipWeapons)
{
Item weaponItem = GameInstance.Singleton.DefaultWeaponItem;
if (equipWeapons.rightHand.NotEmptySlot() && equipWeapons.rightHand.GetWeaponItem() != null)
{
weaponItem = equipWeapons.rightHand.GetWeaponItem();
}
WeaponAnimations weaponAnimations = default(WeaponAnimations);
CacheWeaponAnimations.TryGetValue(weaponItem.WeaponType.DataId, out weaponAnimations);
// Remove clips
if (legacyAnimation.GetClip(CLIP_IDLE) != null)
{
legacyAnimation.RemoveClip(CLIP_IDLE);
}
if (legacyAnimation.GetClip(CLIP_MOVE) != null)
{
legacyAnimation.RemoveClip(CLIP_MOVE);
}
if (legacyAnimation.GetClip(CLIP_MOVE_BACKWARD) != null)
{
legacyAnimation.RemoveClip(CLIP_MOVE_BACKWARD);
}
if (legacyAnimation.GetClip(CLIP_MOVE_LEFT) != null)
{
legacyAnimation.RemoveClip(CLIP_MOVE_LEFT);
}
if (legacyAnimation.GetClip(CLIP_MOVE_RIGHT) != null)
{
legacyAnimation.RemoveClip(CLIP_MOVE_RIGHT);
}
if (legacyAnimation.GetClip(CLIP_MOVE_FORWARD_LEFT) != null)
{
legacyAnimation.RemoveClip(CLIP_MOVE_FORWARD_LEFT);
}
if (legacyAnimation.GetClip(CLIP_MOVE_FORWARD_RIGHT) != null)
{
legacyAnimation.RemoveClip(CLIP_MOVE_FORWARD_RIGHT);
}
if (legacyAnimation.GetClip(CLIP_MOVE_BACKWARD_LEFT) != null)
{
legacyAnimation.RemoveClip(CLIP_MOVE_BACKWARD_LEFT);
}
if (legacyAnimation.GetClip(CLIP_MOVE_BACKWARD_RIGHT) != null)
{
legacyAnimation.RemoveClip(CLIP_MOVE_BACKWARD_RIGHT);
}
if (legacyAnimation.GetClip(CLIP_JUMP) != null)
{
legacyAnimation.RemoveClip(CLIP_JUMP);
}
if (legacyAnimation.GetClip(CLIP_FALL) != null)
{
legacyAnimation.RemoveClip(CLIP_FALL);
}
if (legacyAnimation.GetClip(CLIP_HURT) != null)
{
legacyAnimation.RemoveClip(CLIP_HURT);
}
if (legacyAnimation.GetClip(CLIP_DEAD) != null)
{
legacyAnimation.RemoveClip(CLIP_DEAD);
}
// Setup generic clips
legacyAnimation.AddClip(weaponAnimations.idleClip != null ? weaponAnimations.idleClip : defaultAnimations.idleClip, CLIP_IDLE);
legacyAnimation.AddClip(weaponAnimations.moveClip != null ? weaponAnimations.moveClip : defaultAnimations.moveClip, CLIP_MOVE);
legacyAnimation.AddClip(weaponAnimations.moveBackwardClip != null ? weaponAnimations.moveBackwardClip : defaultAnimations.moveBackwardClip, CLIP_MOVE_BACKWARD);
legacyAnimation.AddClip(weaponAnimations.moveLeftClip != null ? weaponAnimations.moveLeftClip : defaultAnimations.moveLeftClip, CLIP_MOVE_LEFT);
legacyAnimation.AddClip(weaponAnimations.moveRightClip != null ? weaponAnimations.moveRightClip : defaultAnimations.moveRightClip, CLIP_MOVE_RIGHT);
legacyAnimation.AddClip(weaponAnimations.moveForwardLeftClip != null ? weaponAnimations.moveForwardLeftClip : defaultAnimations.moveForwardLeftClip, CLIP_MOVE_FORWARD_LEFT);
legacyAnimation.AddClip(weaponAnimations.moveForwardRightClip != null ? weaponAnimations.moveForwardRightClip : defaultAnimations.moveForwardRightClip, CLIP_MOVE_FORWARD_RIGHT);
legacyAnimation.AddClip(weaponAnimations.moveBackwardLeftClip != null ? weaponAnimations.moveBackwardLeftClip : defaultAnimations.moveBackwardLeftClip, CLIP_MOVE_BACKWARD_LEFT);
legacyAnimation.AddClip(weaponAnimations.moveBackwardRightClip != null ? weaponAnimations.moveBackwardRightClip : defaultAnimations.moveBackwardRightClip, CLIP_MOVE_BACKWARD_RIGHT);
legacyAnimation.AddClip(weaponAnimations.jumpClip != null ? weaponAnimations.jumpClip : defaultAnimations.jumpClip, CLIP_JUMP);
legacyAnimation.AddClip(weaponAnimations.fallClip != null ? weaponAnimations.fallClip : defaultAnimations.fallClip, CLIP_FALL);
legacyAnimation.AddClip(weaponAnimations.hurtClip != null ? weaponAnimations.hurtClip : defaultAnimations.hurtClip, CLIP_HURT);
legacyAnimation.AddClip(weaponAnimations.deadClip != null ? weaponAnimations.deadClip : defaultAnimations.deadClip, CLIP_DEAD);
CrossFadeLegacyAnimation(CLIP_IDLE, 0, WrapMode.Loop);
}
