public virtual void SendServerGameMessage(long connectionId, GameMessage.Type type)
{
GameMessage message = new GameMessage();
message.type = type;
ServerSendPacket(connectionId, DeliveryMethod.ReliableOrdered, MsgTypes.GameMessage, message);
}
public bool CanCraft(IPlayerCharacterData character, out GameMessage.Type gameMessageType)
{
gameMessageType = GameMessage.Type.None;
if (craftingItem == null)
{
gameMessageType = GameMessage.Type.InvalidItemData;
return(false);
}
if (!GameInstance.Singleton.GameplayRule.CurrenciesEnoughToCraftItem(character, this))
{
gameMessageType = GameMessage.Type.NotEnoughGold;
return(false);
}
if (craftRequirements == null || craftRequirements.Length == 0)
{
// No required items
return(true);
}
foreach (ItemAmount craftRequirement in craftRequirements)
{
if (craftRequirement.item != null && character.CountNonEquipItems(craftRequirement.item.DataId) < craftRequirement.amount)
{
gameMessageType = GameMessage.Type.NotEnoughItems;
return(false);
}
}
return(true);
}
public virtual void SendServerGameMessage(long connectionId, GameMessage.Type type)
{
var message = new GameMessage();
message.type = type;
ServerSendPacket(connectionId, SendOptions.ReliableOrdered, MsgTypes.GameMessage, message);
}
public bool CanCraft(IPlayerCharacterData character, out GameMessage.Type gameMessageType)
{
gameMessageType = GameMessage.Type.None;
if (craftingItem == null)
{
gameMessageType = GameMessage.Type.InvalidItemData;
return(false);
}
if (character.Gold < requireGold)
{
gameMessageType = GameMessage.Type.NotEnoughGold;
return(false);
}
if (craftRequirements == null || craftRequirements.Length == 0)
{
return(true);
}
foreach (var craftRequirement in craftRequirements)
{
if (craftRequirement.item != null && character.CountNonEquipItems(craftRequirement.item.DataId) < craftRequirement.amount)
{
gameMessageType = GameMessage.Type.NotEnoughItems;
return(false);
}
}
return(true);
}
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 bool CanRepair(IPlayerCharacterData character, out GameMessage.Type gameMessageType)
{
gameMessageType = GameMessage.Type.None;
if (!GameInstance.Singleton.GameplayRule.CurrenciesEnoughToRepairItem(character, this))
{
gameMessageType = GameMessage.Type.NotEnoughGold;
return(false);
}
return(true);
}
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);
}
public bool CanRefine(IPlayerCharacterData character, short level, out GameMessage.Type gameMessageType)
{
gameMessageType = GameMessage.Type.CannotRefine;
if (!IsEquipment())
{
// Cannot refine because it's not equipment item
return(false);
}
if (itemRefine == null)
{
// Cannot refine because there is no item refine info
return(false);
}
if (level >= itemRefine.levels.Length)
{
// Cannot refine because item reached max level
gameMessageType = GameMessage.Type.RefineItemReachedMaxLevel;
return(false);
}
return(itemRefine.levels[level - 1].CanRefine(character, out gameMessageType));
}
public bool CanRefine(IPlayerCharacterData character, out GameMessage.Type gameMessageType)
{
gameMessageType = GameMessage.Type.None;
if (character.Gold < requireGold)
{
gameMessageType = GameMessage.Type.NotEnoughGold;
return(false);
}
if (requireItems == null || requireItems.Length == 0)
{
return(true);
}
foreach (var requireItem in requireItems)
{
if (requireItem.item != null && character.CountNonEquipItems(requireItem.item.DataId) < requireItem.amount)
{
gameMessageType = GameMessage.Type.NotEnoughItems;
return(false);
}
}
return(true);
}
public bool CanRefine(IPlayerCharacterData character, out GameMessage.Type gameMessageType)
{
gameMessageType = GameMessage.Type.None;
if (!GameInstance.Singleton.GameplayRule.CurrenciesEnoughToRefineItem(character, this))
{
gameMessageType = GameMessage.Type.NotEnoughGold;
return(false);
}
if (requireItems == null || requireItems.Length == 0)
{
return(true);
}
// Count required items
foreach (ItemAmount requireItem in requireItems)
{
if (requireItem.item != null && character.CountNonEquipItems(requireItem.item.DataId) < requireItem.amount)
{
gameMessageType = GameMessage.Type.NotEnoughItems;
return(false);
}
}
return(true);
}
public bool CanRepair(IPlayerCharacterData character, float durability, out ItemRepairPrice repairPrice, out GameMessage.Type gameMessageType)
{
repairPrice = default(ItemRepairPrice);
gameMessageType = GameMessage.Type.CannotRepair;
if (!IsEquipment())
{
// Cannot repair because it's not equipment item
return(false);
}
if (itemRefine == null)
{
// Cannot repair because there is no item refine info
return(false);
}
float durabilityRate = durability / maxDurability;
for (int i = 0; i < itemRefine.repairPrices.Length; ++i)
{
repairPrice = itemRefine.repairPrices[i];
if (durabilityRate < repairPrice.DurabilityRate)
{
return(repairPrice.CanRepair(character, out gameMessageType));
}
}
return(true);
}
private static void RepairItem(IPlayerCharacterData character, CharacterItem repairingItem, System.Action <CharacterItem> onRepaired, out GameMessage.Type gameMessageType)
{
gameMessageType = GameMessage.Type.CannotRepair;
if (!repairingItem.NotEmptySlot())
{
// Cannot refine because character item is empty
return;
}
Item equipmentItem = repairingItem.GetEquipmentItem();
if (equipmentItem == null)
{
// Cannot refine because it's not equipment item
return;
}
ItemRepairPrice repairPrice;
if (equipmentItem.CanRepair(character, repairingItem.durability, out repairPrice, out gameMessageType))
{
gameMessageType = GameMessage.Type.RepairSuccess;
// Repair item
repairingItem.durability = equipmentItem.maxDurability;
onRepaired.Invoke(repairingItem);
// Decrease required gold
GameInstance.Singleton.GameplayRule.DecreaseCurrenciesWhenRepairItem(character, repairPrice);
}
}
public static void EnhanceSocketNonEquipItem(IPlayerCharacterData character, int index, int enhancerId, out GameMessage.Type gameMessageType)
{
EnhanceSocketItemByList(character, character.NonEquipItems, index, enhancerId, out gameMessageType);
}
private static void EnhanceSocketItemByList(IPlayerCharacterData character, IList <CharacterItem> list, int index, int enhancerId, out GameMessage.Type gameMessageType)
{
EnhanceSocketItem(character, list[index], enhancerId, (enhancedSocketItem) =>
{
list[index] = enhancedSocketItem;
}, out gameMessageType);
}
private static void RefineItem(IPlayerCharacterData character, CharacterItem refiningItem, System.Action <CharacterItem> onRefine, System.Action onDestroy, out GameMessage.Type gameMessageType)
{
gameMessageType = GameMessage.Type.CannotRefine;
if (!refiningItem.NotEmptySlot())
{
// Cannot refine because character item is empty
return;
}
Item equipmentItem = refiningItem.GetEquipmentItem();
if (equipmentItem == null)
{
// Cannot refine because it's not equipment item
return;
}
if (!equipmentItem.CanRefine(character, refiningItem.level, out gameMessageType))
{
// Cannot refine because of some reasons
return;
}
ItemRefineLevel refineLevel = equipmentItem.itemRefine.levels[refiningItem.level - 1];
if (Random.value <= refineLevel.SuccessRate)
{
// If success, increase item level
gameMessageType = GameMessage.Type.RefineSuccess;
++refiningItem.level;
onRefine.Invoke(refiningItem);
}
else
{
// Fail
gameMessageType = GameMessage.Type.RefineFail;
if (refineLevel.RefineFailDestroyItem)
{
// If condition when fail is it has to be destroyed
onDestroy.Invoke();
}
else
{
// If condition when fail is reduce its level
refiningItem.level -= refineLevel.RefineFailDecreaseLevels;
if (refiningItem.level < 1)
{
refiningItem.level = 1;
}
onRefine.Invoke(refiningItem);
}
}
if (refineLevel.RequireItems != null)
{
// Decrease required items
foreach (ItemAmount requireItem in refineLevel.RequireItems)
{
if (requireItem.item != null && requireItem.amount > 0)
{
character.DecreaseItems(requireItem.item.DataId, requireItem.amount);
}
}
}
// Decrease required gold
GameInstance.Singleton.GameplayRule.DecreaseCurrenciesWhenRefineItem(character, refineLevel);
}
private static void RefineItemByList(IPlayerCharacterData character, IList <CharacterItem> list, int index, out GameMessage.Type gameMessageType)
{
RefineItem(character, list[index], (refinedItem) =>
{
list[index] = refinedItem;
}, () =>
{
list.RemoveAt(index);
}, out gameMessageType);
}
public static void RefineNonEquipItem(IPlayerCharacterData character, int index, out GameMessage.Type gameMessageType)
{
RefineItemByList(character, character.NonEquipItems, index, out gameMessageType);
}
private static void EnhanceSocketItem(IPlayerCharacterData character, CharacterItem enhancingItem, int enhancerId, System.Action <CharacterItem> onEnhanceSocket, out GameMessage.Type gameMessageType)
{
gameMessageType = GameMessage.Type.CannotEnhanceSocket;
if (!enhancingItem.NotEmptySlot())
{
// Cannot enhance socket because character item is empty
return;
}
Item equipmentItem = enhancingItem.GetEquipmentItem();
if (equipmentItem == null)
{
// Cannot enhance socket because it's not equipment item
return;
}
if (equipmentItem.maxSocket <= 0)
{
// Cannot enhance socket because equipment has no socket(s)
return;
}
if (enhancingItem.Sockets.Count >= equipmentItem.maxSocket)
{
// Cannot enhance socket because socket is full
return;
}
Item enhancerItem;
if (!GameInstance.Items.TryGetValue(enhancerId, out enhancerItem) || !enhancerItem.IsSocketEnhancer())
{
// Cannot enhance socket because enhancer id is invalid
return;
}
if (!character.DecreaseItems(enhancerItem.DataId, 1))
{
// Cannot enhance socket because there is no item
gameMessageType = GameMessage.Type.NotEnoughSocketEnchaner;
return;
}
enhancingItem.Sockets.Add(enhancerId);
onEnhanceSocket.Invoke(enhancingItem);
}
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);
}
