public void AddNode(PipNode NewNode) { Count++; //if (NewNode == null) // throw new ArgumentNullException(); if (Head == null || (Head.PipState > NewNode.PipState)) { NewNode.NextNode = Head; Head = NewNode; return; } PipNode prevNode = Head; PipNode nextNode = Head.NextNode; // walk through the LinkedList until it reaches the end or the new node is smaller than the next. // This keeps both the priority and integrity of insertion order. while (nextNode != null) { if (nextNode?.PipState > NewNode.PipState) { prevNode.NextNode = NewNode; NewNode.NextNode = nextNode; return; } prevNode = nextNode; nextNode = nextNode.NextNode; } prevNode.NextNode = PositionNode(prevNode, NewNode); }
public void UpdateNodes(PlayerHealth playerHealth) { PipNode nodeWalker = Head; PipNode lastNode = null; Count = 0; nodeWalker = WalkThroughList(nodeWalker, playerHealth, PipNode.StatusKey.Real, ref lastNode); nodeWalker = WalkThroughList(nodeWalker, playerHealth, PipNode.StatusKey.Temp, ref lastNode); CheckStateOfTemp(lastNode); if (lastNode != null && lastNode.PipState == PipNode.StatusKey.Temp) { LastTempPip = lastNode; } nodeWalker = WalkThroughList(nodeWalker, playerHealth, PipNode.StatusKey.Lent, ref lastNode); nodeWalker = WalkThroughList(nodeWalker, playerHealth, PipNode.StatusKey.Damaged, ref lastNode); if (nodeWalker != null) { if (lastNode.NextNode == LastTempPip) { LastTempPip = null; } lastNode.NextNode = null; RemoveNodeRecursive(nodeWalker); } }
private PipNode PositionNode(PipNode PreviousNode, PipNode NewNode) { RectTransform rectTransform = (RectTransform)PreviousNode.gameObject.transform; // unfortunately, something about setting the Vector 3 in the Instantiate is thrown off, and it ends up adding the Canvas transform to the new items transform // instead of the value passed in. Setting the anchored position afterworlds makes it so the Instantiated spawn exactly where they need to. RectTransform newrectTransform = null; if (NewNode == null) { NewNode = Instantiate(PipPrefab, new Vector3(rectTransform.anchoredPosition.x + rectTransform.rect.width + 5f, rectTransform.anchoredPosition.y), rectTransform.transform.rotation, Hp_PipPool.transform).GetComponent <PipNode>(); NewNode.gameObject.name = PipPrefab.name + Count.ToString(); newrectTransform = (RectTransform)NewNode.gameObject.transform; newrectTransform.anchoredPosition = new Vector2(rectTransform.anchoredPosition.x + rectTransform.rect.width + 5f, rectTransform.anchoredPosition.y); return(NewNode); } NewNode.gameObject.transform.position = new Vector3(rectTransform.anchoredPosition.x + rectTransform.rect.width + 5f, rectTransform.anchoredPosition.y); NewNode.gameObject.name = PipPrefab.name + Count.ToString(); newrectTransform = (RectTransform)NewNode.gameObject.transform; newrectTransform.anchoredPosition = new Vector2(rectTransform.anchoredPosition.x + rectTransform.rect.width + 5f, rectTransform.anchoredPosition.y); return(NewNode); }
/// <summary> /// PipPoolDisplay Rulees. There are so far 4 states which need to be taken into consideration. /// 1. Normal - Health is stable and will only changed if funnled to the PipPad or depleted by damaged. Is used after any temnp for damage /// 2. Damaged - Health that is empty and caused by enemy damage. Can be refilled by back to Nomral by killing enemies. /// 3. Funneled - Health that is empty and caused by being funneled to the pippad. Can be filled to normal by returning pips from the pippad. /// Can be filled by a temp by killing an enemy. /// 4. Temp - Health is unstable and cannot be funneled into the pippad. Usually only gained when there is no damaged health and killed an enemy /// while there is funneled Health. When taking damage, used before normal Health. Temp health degrades over time. Degrading time is reset to /// full if an enemy is hit before it is entirely depleted to funneled. If funneled health is returned while temp health exists, the temp stays /// as extra health but will not have its degrade time reset. /// Resets - 4 slots with extra temp NNDTT. one N gets filtered NFDTT and is in turn filled by temp NDTT. Since four slots and both temp are wirhin the max pool cap they can be reset /// Does Not Reset - 4 slots with extra temp NNDTT. one N gets filtered NFDTT and is in turn filled by temp NDTT. Since four slots and both temp are wirhin the max pool cap they can be reset /// </summary> /// <param name="pipModel"></param> public void UpdatePipPoolDisplay(PipNode pipModel) { PipNode walker = pipModel; while (walker != null) { switch (walker.PipState) { case PipNode.StatusKey.Real: walker.PipDisplayImage.sprite = pipFullHPPrefab.GetComponent <Image>().sprite; walker.PipDisplayImage.color = Enabled; break; case PipNode.StatusKey.Temp: walker.PipDisplayImage.sprite = pipFullHPPrefab.GetComponent <Image>().sprite; walker.PipDisplayImage.color = Temp; break; case PipNode.StatusKey.Damaged: walker.PipDisplayImage.sprite = pipFullHPPrefab.GetComponent <Image>().sprite; walker.PipDisplayImage.color = Disabled; break; case PipNode.StatusKey.Lent: walker.PipDisplayImage.sprite = pipLentHPPrefab.GetComponent <Image>().sprite; walker.PipDisplayImage.color = Color.white; break; default: break; } walker = walker.NextNode; } }
private void CheckStateOfTemp(PipNode LastNode) { // The Temp pip has changed set the last temp pip to its original size if (LastTempPip != null && LastTempPip != LastNode) { LastTempPip.gameObject.transform.localScale = new Vector3(1, 1, 1); } }
private void RemoveNodeRecursive(PipNode pipNode) { if (pipNode.NextNode != null) { RemoveNodeRecursive(pipNode.NextNode); } Destroy(pipNode.gameObject); }
public PipLinkedList( PipNode head, GameObject pipPrefab, GameObject hp_PipPool, Queue <GameObject> hpPips) { Head = head; Count++; PipPrefab = pipPrefab; Hp_PipPool = hp_PipPool; HpPips = hpPips; }
private PipNode WalkThroughList(PipNode nodeWalker, PlayerHealth playerHealth, PipNode.StatusKey statusKey, ref PipNode lastNode) { int valueToWalk = 0; switch (statusKey) { case PipNode.StatusKey.Real: valueToWalk = playerHealth.RealHp; break; case PipNode.StatusKey.Temp: valueToWalk = playerHealth.TempHp; break; case PipNode.StatusKey.Lent: // If for every temp hp, use a lent HPs spot valueToWalk = playerHealth.LentHp - playerHealth.TempHp; break; case PipNode.StatusKey.Damaged: valueToWalk = playerHealth.DamagedHealth; break; } for (int walker = 0; walker < valueToWalk; walker++) { if (nodeWalker == null) { AddNode(new PipNode(statusKey)); continue; } // Count is updated in the add node function so other functionality can add nodes and the count will still be updated properly. Count++; nodeWalker.PipState = statusKey; lastNode = nodeWalker; nodeWalker = nodeWalker.NextNode; } return(nodeWalker); }
//public PipNode PreviousNode { get; set; } public PipNode(StatusKey pipState, PipNode nextNode = null)//, PipNode previousNode = null) { PipState = pipState; NextNode = nextNode; //PreviousNode = previousNode; }