void OnEnable()
{
alpha = 0;
prevAlpha = 0;
IsActive = true;
MeshObject = this.gameObject;
var meshRenderer = MeshObject.GetComponentInChildren <MeshRenderer>();
var skinMeshRenderer = MeshObject.GetComponentInChildren <SkinnedMeshRenderer>();
if (meshRenderer != null)
{
startingMaterial = meshRenderer.material;
}
if (skinMeshRenderer != null)
{
startingMaterial = meshRenderer.material;
}
foreach (var comp in ComponentsPS)
{
comp.SetActive(false);
}
spiritSystem = GetComponentInParent <SpiritSystem>();
}
private void Update()
{
if (Input.GetKeyDown(KeyCode.Escape))
{
Time.timeScale = 0;
menuPanel.SetActive(true);
Cursor.visible = true;
Cursor.lockState = CursorLockMode.None;
}
if (cardUISystem == null)
{
cardUISystem = FindObjectOfType <CardUISystem>();
}
if (SceneManager.GetActiveScene() != currentScene)
{
if (spiritSystem == null)
{
spiritSystem = FindObjectOfType <SpiritSystem>();
if (spiritToEquipInDungeon != null && FindObjectOfType <StateManager>())
{
spiritSystem.spiritEquipped = spiritToEquipInDungeon;
spiritSystem.OnEquipSpirit(spiritToEquipInDungeon);
}
}
}
}
public static SpiritSystem Spirit(SpiritData data, Vector3 position, bool isOwnedByPlayer = true)
{
var newSpiritPrefab = U.Instantiate(data.Prefab, position, Quaternion.identity, ReferenceHolder.Instance.SpiritParent);
var newSpirit = new SpiritSystem(newSpiritPrefab, isOwnedByPlayer)
{
Data = data,
UsedCell = null
};
newSpirit.SetSystem(GameData.Instance.Player);
PlaceEffect(newSpirit.Data.Base.Element, newSpiritPrefab.transform.position);
return(newSpirit);
}
void OnUpgrading()
{
if (CheckGradeListOk(out List <SpiritData> grades))
{
var upgradedSpiritPrefab = Instantiate(
grades[ChoosedSpirit.Data.GradeCount + 1].Prefab,
ChoosedSpirit.Prefab.transform.position,
Quaternion.identity,
ReferenceHolder.Instance.SpiritParent);
var upgradedSpirit = new SpiritSystem(upgradedSpiritPrefab, true);
upgradedSpirit.Upgrade(ChoosedSpirit, grades[ChoosedSpirit.Data.GradeCount + 1]);
upgradedSpirit.SetSystem(Owner);
SpiritUpgraded?.Invoke(upgradedSpirit);
SpiritSold?.Invoke(ChoosedSpirit);
ChoosedSpirit = upgradedSpirit;
}
Owner.SpiritUISystem.ActivateUpgradeButton(ChoosedSpirit.Data.GradeCount < grades.Count - 1);
}
void OnCollisionEnter(Collision collision)
{
print(collision.gameObject.name);
SpiritSystem spiritSystem = FindObjectOfType <SpiritSystem>();
if (spiritSystem != null)
{
if (spiritSystem.spiritEquipped.spiritClass == BaseSpirit.SpiritClass.Mage)
{
if (collision.gameObject.GetComponent <Enemy>())
{
collision.gameObject.GetComponent <Enemy>().TakeDamage(spiritSystem.spiritEquipped.DamageModifier);
}
spiritSystem.MageDamage(collision.transform.position);
}
else if (spiritSystem.spiritEquipped.spiritClass == BaseSpirit.SpiritClass.Ranger)
{
if (collision.gameObject.GetComponent <Enemy>())
{
spiritSystem.RangerDamage(collision.gameObject.GetComponent <Enemy>());
}
}
}
if (isCollided && !effectSettings.UseCollisionDetection)
{
return;
}
foreach (ContactPoint contact in collision.contacts)
{
if (!isCollided)
{
isCollided = true;
//offsetColliderPoint = contact.otherCollider.transform.position - contact.point;
// lastCollider = contact.otherCollider;
// lastContactPoint = contact;
if (UseTargetPositionAfterCollision)
{
if (targetAnchor != null)
{
Destroy(targetAnchor);
}
targetAnchor = new GameObject();
targetAnchor.hideFlags = HideFlags.HideAndDontSave;
targetAnchor.transform.parent = contact.otherCollider.transform;
targetAnchor.transform.position = contact.point;
targetAnchor.transform.rotation = transform.rotation;
//targetAnchor.transform.LookAt(contact.normal);
}
}
var handler = CollisionEnter;
if (handler != null)
{
handler(this, new RFX4_CollisionInfo {
HitPoint = contact.point, HitCollider = contact.otherCollider, HitGameObject = contact.otherCollider.gameObject
});
}
if (EffectOnCollision != null)
{
var instance = Instantiate(EffectOnCollision, contact.point, new Quaternion()) as GameObject;
if (HUE > -0.9f)
{
RFX4_ColorHelper.ChangeObjectColorByHUE(instance, HUE);
}
if (LookAtNormal)
{
instance.transform.LookAt(contact.point + contact.normal);
}
else
{
instance.transform.rotation = transform.rotation;
}
if (!CollisionEffectInWorldSpace)
{
instance.transform.parent = contact.otherCollider.transform.parent;
}
Destroy(instance, CollisionEffectDestroyAfter);
}
}
foreach (var obj in DeactivateObjectsAfterCollision)
{
if (obj != null)
{
var ps = obj.GetComponent <ParticleSystem>();
if (ps != null)
{
ps.Stop();
}
else
{
obj.SetActive(false);
}
}
}
if (rigid != null)
{
Destroy(rigid);
}
if (collid != null)
{
Destroy(collid);
}
}
public void SetSystem(PlayerSystem player)
{
Owner = player;
sellButton = Instantiate(sellButton.gameObject, Owner.WorldCanvas.transform).GetComponent <Button>();
upgradeButton = Instantiate(upgradeButton.gameObject, Owner.WorldCanvas.transform).GetComponent <Button>();
Owner.InventoryUISystem.MoveItemToSpirit += OnMoveItemToSpirit;
Owner.PlayerInputSystem.ClickedOnSpirit += OnClickedOnSpirit;
Owner.PlayerInputSystem.ClickedOnCell += OnClickedOnCell;
Owner.PlayerInputSystem.ClikedOnGround += OnClickedOnGround;
Owner.PlayerInputSystem.RMBPresed += OnClickedOnGround;
Owner.ItemDropSystem.ItemUICreated += OnItemUICreated;
sellButton.onClick.AddListener(OnSellButtonClick);
upgradeButton.onClick.AddListener(OnUpgradeButtonClick);
void OnUpgradeButtonClick()
{
Upgrading?.Invoke();
UpdateUI();
}
void OnSellButtonClick()
{
Selling?.Invoke();
ActivateUI(false);
}
void OnItemUICreated(ItemUISystem itemUI)
{
itemUI.DoubleClickedInSpiritInventory += OnItemDoubleClicked;
itemUI.System.StatsApplied += OnStatsApplied;
void OnItemDoubleClicked(ItemUISystem _)
{
if (itemUI.DraggedFrom == DraggedFrom.SpiritInventory)
{
RemoveItemFromSpirit();
MoveItemToPlayer?.Invoke(itemUI);
}
void RemoveItemFromSpirit()
{
if (itemUI.DraggedFrom == DraggedFrom.SpiritInventory)
{
allItemsUIInSpirits.Remove(itemUI);
isSlotEmpty[itemUI.SlotNumber] = true;
itemSlots[itemUI.SlotNumber].gameObject.SetActive(true);
ItemRemovedFromSpirit?.Invoke(new SpiritItemEventArgs(choosedSpirit, itemUI));
UpdateValues();
}
}
}
}
void OnClickedOnSpirit(GameObject spirit) => ActivateUI(true);
void OnClickedOnCell(GameObject spirit) => ActivateUI(false);
void OnClickedOnGround() => ActivateUI(false);
void OnMoveItemToSpirit(ItemUISystem itemUI)
{
var emptySlot = isSlotEmpty.IndexOf(true);
if (emptySlot < 0)
{
MoveItemToPlayer?.Invoke(itemUI);
}
else
{
itemUI.transform.position = itemSlots[emptySlot].transform.position;
itemUI.transform.SetParent(itemSlots[emptySlot].transform.parent);
AddItemToSpirit(emptySlot);
}
void AddItemToSpirit(int slotNumber)
{
allItemsUIInSpirits.Add(itemUI);
isSlotEmpty[slotNumber] = false;
itemSlots[slotNumber].gameObject.SetActive(false);
itemUI.DraggedFrom = DraggedFrom.SpiritInventory;
itemUI.SlotNumber = slotNumber;
ItemAddedToSpirit?.Invoke(new SpiritItemEventArgs(choosedSpirit, itemUI));
UpdateItems();
UpdateValues();
}
}
void ActivateUI(bool activate)
{
if (Owner.PlayerInputSystem.ChoosedSpirit == null)
{
return;
}
UnsubscribeFromSpiritEvents();
if (activate)
{
baseAnimator.SetBool(isOpenBool, true);
choosedSpirit = Owner.PlayerInputSystem.ChoosedSpirit;
if (choosedSpirit.Owner == Owner)
{
sellButton.gameObject.SetActive(true);
sellButton.transform.position = choosedSpirit.Prefab.transform.position + new Vector3(40, 30, 0);
upgradeButton.transform.position = choosedSpirit.Prefab.transform.position + new Vector3(40, 60, 30);
}
HideExpandedStatValues(true);
SubscribeToSpiritEvents();
UpdateUI();
}
else
{
sellButton.gameObject.SetActive(false);
upgradeButton.gameObject.SetActive(false);
baseAnimator.SetBool(isOpenBool, false);
baseAnimator.SetBool(isExpandedBool, false);
UnsubscribeFromSpiritEvents();
}
void SubscribeToSpiritEvents()
{
if (choosedSpirit == null)
{
return;
}
choosedSpirit.AbilityControlSystem.AbilityUsed += OnAbilityUsed;
choosedSpirit.EffectApplied += OnEffectApplied;
choosedSpirit.EffectRemoved += OnEffectRemoved;
choosedSpirit.StatsChanged += OnStatsApplied;
}
void UnsubscribeFromSpiritEvents()
{
if (choosedSpirit == null)
{
return;
}
choosedSpirit.AbilityControlSystem.AbilityUsed -= OnAbilityUsed;
choosedSpirit.EffectApplied -= OnEffectApplied;
choosedSpirit.EffectRemoved -= OnEffectRemoved;
choosedSpirit.StatsChanged -= OnStatsApplied;
}
void OnEffectRemoved(Data.Effect effect)
{
var appliedEffectUI = appliedEffectsUI.Find(effectUI => effectUI.EntityIndex == effect.Index);
if (appliedEffectUI != null)
{
appliedEffectUI.gameObject.SetActive(false);
appliedEffectsUI.Remove(appliedEffectUI);
}
}
void OnEffectApplied(Data.Effect effect)
{
var poolObject = appliedEffectsUIPool.PopObject();
var appliedEffectUI = poolObject.GetComponent <SlotWithCooldown>();
appliedEffectUI.Set(effect.Description, effect.Image, effect.Index);
appliedEffectsUI.Add(appliedEffectUI);
}
void OnAbilityUsed(AbilitySystem e)
{
var slot = abilitySlots.Find(abilitySlot => abilitySlot.EntityIndex == e.Ability.Index);
slot.CooldownImage.fillAmount = 1f;
StartCoroutine(Cooldown());
IEnumerator Cooldown()
{
while (slot.CooldownImage.fillAmount > 0)
{
slot.CooldownImage.fillAmount -= 1 / e.Ability.Cooldown * Time.deltaTime * 2;
yield return(deltaTimeDelay);
}
}
}
}
void UpdateUI()
{
choosedSpirit = Owner.PlayerInputSystem.ChoosedSpirit;
UpdateItems();
UpdateValues();
UpdateSlotsWithCooldown(abilitySlots, choosedSpirit.Data.Abilities);
UpdateSlotsWithCooldown(traitSlots, choosedSpirit.Data.Traits);
void UpdateSlotsWithCooldown <T>(List <SlotWithCooldown> slots, List <T> slotEntities) where T : Entity
{
slots.ForEach(slot => slot.gameObject.SetActive(false));
for (int i = 0; i < slotEntities.Count; i++)
{
slots[i].Set(slotEntities[i].Description, slotEntities[i].Image, slotEntities[i].Index);
}
}
}
void UpdateItems()
{
var choosedSpiritItems = choosedSpirit.Data.Inventory.Items;
var maxSlots = choosedSpirit.Data.Get(Enums.Spirit.MaxInventorySlots).Value;
isSlotEmpty.Clear();
allItemsUIInSpirits.ForEach(item => item.gameObject.SetActive(false));
UpdateSlotsAmount();
choosedSpiritItems.ForEach(itemInInventory =>
{
var itemFromDroppedItems = allItemsUIInSpirits.Find(droppedItem => itemInInventory.Index == droppedItem.System.Index);
if (itemFromDroppedItems != null)
{
itemFromDroppedItems.gameObject.SetActive(true);
isSlotEmpty[itemFromDroppedItems.SlotNumber] = false;
}
});
void UpdateSlotsAmount()
{
for (int i = 0; i < itemSlots.Count; i++)
{
var isInSlotLimit = i < maxSlots;
itemSlots[i].gameObject.SetActive(isInSlotLimit);
isSlotEmpty.Add(isInSlotLimit);
}
}
}
void OnStatsApplied() => UpdateValues();
void UpdateValues()
{
var spirit = choosedSpirit.Data;
spiritName.text = spirit.Name;
image.sprite = spirit.Image;
SetExpBarValue();
SetStatValues();
void SetExpBarValue()
{
var neededExp = (float)ReferenceHolder.ExpToLevelUp[(int)spirit.Get(Numeral.Level).Value];
var currentExp = (float)spirit.Get(Numeral.Exp).Value;
var expBarValue = 1 / (neededExp / currentExp);
expBar.fillAmount = expBarValue;
}
void SetStatValues()
{
numeralStatValuesUI.ForEach(statUI => statUI.Value.text = statUI.NumeralValue.AttributeToString());
spiritStatValuesUI.ForEach(statUI => statUI.Value.text = statUI.SpiritValue.AttributeToString());
}
}
}
void OnSpiritPlaced(SpiritSystem spirit) => ActivateUI(false);
public void OnSpiritLevelUp(SpiritSystem e) => IncreaseStatsPerLevel();
public SpiritDataSystem(SpiritSystem spirit) => ownerSpirit = spirit;
void Update()
{
pointerEventData.position = Input.mousePosition;
if (Input.GetMouseButtonDown(0))
{
WorldRay = Camera.main.ScreenPointToRay(Input.mousePosition);
isHitUI = EventSystem.currentSelectedGameObject != null;
if (!isHitUI)
{
if (Physics.Raycast(WorldRay, out hit, 100000, layerMask))
{
var isMouseOnSpirit = hit.transform.gameObject.layer == 14;
var isMouseOnGround = hit.transform.gameObject.layer == 9;
var isMouseOnCell = hit.transform.gameObject.layer == 15;
var isMouseOnEnemy = hit.transform.gameObject.layer == 12;
if (ChoosedSpirit != null)
{
ChoosedSpirit.ShowRange(false);
}
if (isMouseOnSpirit)
{
GetChoosedSpirit();
ClickedOnSpirit?.Invoke(hit.transform.gameObject);
}
if (isMouseOnEnemy)
{
GetChoosedEnemy();
ClickedOnEnemy?.Invoke(hit.transform.gameObject);
}
if (isMouseOnGround)
{
ClikedOnGround?.Invoke();
ChoosedSpirit = null;
choosedEnemy = null;
SetSelection(false);
}
if (isMouseOnCell)
{
ClickedOnCell?.Invoke(hit.transform.gameObject);
ChoosedSpirit = null;
choosedEnemy = null;
SetSelection(false);
}
}
}
}
if (Input.GetMouseButtonDown(1))
{
RMBPresed?.Invoke();
ChoosedSpirit = null;
choosedEnemy = null;
SetSelection(false);
}
#region Helper functions
void GetChoosedSpirit()
{
ChoosedSpirit = Owner.SpiritControlSystem.AllSpirits.Find(spirit => spirit.Prefab == hit.transform.gameObject);
ChoosedSpirit.ShowRange(true);
Owner.SpiritUISystem.ActivateUpgradeButton(CheckGradeListOk(out _));
ActivateSelection(ChoosedSpirit);
}
void GetChoosedEnemy()
{
choosedEnemy = Owner.EnemyControlSystem.AllEnemies.Find(enemy => enemy.Prefab == hit.transform.gameObject);
ActivateSelection(choosedEnemy);
}
#endregion
}
void OnSpiritPlaced(SpiritSystem spirit) => ChoosedCell = null;
