public void MoveGrid() { // Initialize PCSTreeForwardIterator pIterator = new PCSTreeForwardIterator(this); Debug.Assert(pIterator != null); PCSNode pNode = pIterator.First(); while (!pIterator.IsDone()) { // delta GameObject pGameObj = (GameObject)pNode; pGameObj.x += this.delta; // Advance pNode = pIterator.Next(); } this.total += this.delta; if (this.total > 400.0f || this.total < 0.0f) { this.delta *= -1.0f; } }
private void privRemoveNodeNoYoungerSiblings(PCSNode inNode, PCSNode pParent) { Debug.Assert(pParent != null); PCSNode pTmp; // goto eldest child pTmp = pParent.pChild; Debug.Assert(pTmp != null); if (pTmp.pSibling == null) { // delete inNode so it's parent is 0 // in child has no siblings pParent.pChild = null; } else { // now iterate until child while (pTmp.pSibling != inNode) { pTmp = pTmp.pSibling; } // this point we found the sibling PCSNode pPrev = pTmp; pPrev.pSibling = null; } }
protected void updateUnionBox() { PCSNode node = (PCSNode)this; node = node.pChild; if (node == null) { this.cCollisionObj.cCollisionRectangle.Set(0, 0, 0, 0); this.x = 0; this.y = 0; } else { GameObject gameObj = (GameObject)node; CollisionRectangle collisionTotal = this.cCollisionObj.cCollisionRectangle; collisionTotal.Set(gameObj.cCollisionObj.cCollisionRectangle); while (node != null) { gameObj = (GameObject)node; collisionTotal.Union(gameObj.cCollisionObj.cCollisionRectangle); node = node.pSibling; } this.x = this.cCollisionObj.cCollisionRectangle.x; this.y = this.cCollisionObj.cCollisionRectangle.y; } }
private void privRemoveNodeHasYoungerSiblings(PCSNode inNode) { // I have a sibling to the right of me // find the previous child PCSNode pParent; pParent = inNode.pParent; Debug.Assert(pParent != null); PCSNode pTmp; // goto eldest child pTmp = pParent.pChild; Debug.Assert(pTmp != null); if (pTmp == inNode) { // we are deleting a eldest child with siblings pParent.pChild = pTmp.pSibling; } else { // now iterate until child while (pTmp.pSibling != inNode) { pTmp = pTmp.pSibling; } // this point we found the sibling PCSNode pPrev = pTmp; pPrev.pSibling = inNode.pSibling; } }
public WallFactory(PCSTree mPCSTree, SpriteBatch mSpriteBatch) { this.cPCSTree = mPCSTree; // this.cSpriteBatch = SpriteBatchManager.find(mSpriteBatch); this.cSpriteBatch = mSpriteBatch; cParent = null; }
public PCSNode(PCSNode pParent, PCSNode pChild, PCSNode pSibling, PCSNode pForward, PCSNode pReverse) { this.pParent = pParent; this.pChild = pChild; this.pSibling = pSibling; this.pForward = pForward; this.pReverse = pReverse; }
public PCSNode(PCSNode pNode) { this.pParent = pNode.pParent; this.pChild = pNode.pChild; this.pSibling = pNode.pSibling; this.pReverse = pNode.pReverse; this.pForward = pNode.pForward; }
public AlienFactory(PCSTree mPCSTree, SpriteBatch mSpriteBatch) { this.cPCSTree = mPCSTree; //this.cSpriteBatch = SpriteBatchManager.find(mSpriteBatch); this.cSpriteBatch = mSpriteBatch; cParent = null; columnCount = 0; alienCount = 0; }
// Constructors: -------------------------------- public PCSNode() { this.pParent = null; this.pChild = null; this.pSibling = null; this.pForward = null; this.pReverse = null; }
public AlienFactory(SpriteBatch.Name spriteBatchName, PCSTree pTree) { this.pSpriteBatch = SpriteBatchManager.Find(spriteBatchName); Debug.Assert(this.pSpriteBatch != null); Debug.Assert(pTree != null); this.pTree = pTree; //parent is null by default; this.pParent = null; }
// remove public void Remove(PCSNode inNode) { Debug.Assert(inNode != null); if (inNode.pChild == null) { // last node if (inNode.pSibling == null) { // find the previous child PCSNode pParent; pParent = inNode.pParent; // special case root if (pParent == null) { this.pRoot = null; } else { // no children, no younger siblings privRemoveNodeNoYoungerSiblings(inNode, pParent); } } else { // No children, but has other younger siblings privRemoveNodeHasYoungerSiblings(inNode); } inNode.pChild = null; inNode.pParent = null; inNode.pSibling = null; this.privInfoRemoveNode(); return; } else { // If we are here, recursively call PCSNode pTmp = inNode.pChild; Debug.Assert(pTmp != null); this.Remove(pTmp); this.Remove(inNode); } }
private void privMoveGrid() { PCSTreeForwardIterator iterator = new PCSTreeForwardIterator(this); Debug.Assert(iterator != null); PCSNode pNode = iterator.First(); while (!iterator.IsDone()) { Bomb bomb = (Bomb)pNode; if (bomb.active) { bomb.y -= this.delta; } //gameObj.y -= this.delta; pNode = iterator.Next(); } }
private void MoveTree(GameObject pNode) { PCSNode pChild = null; pNode.pProxySprite.x += this.movementXDirection; pNode.pProxySprite.y += this.movementYDirection; if (pNode.pChild == null) { // base case } else { pChild = pNode.pChild; while (pChild != null) { MoveTree((GameObject)pChild); pChild = pChild.pSibling; } } }
public void moveGrid() { PCSTreeForwardIterator pcsIterator = new PCSTreeForwardIterator(this); Debug.Assert(pcsIterator != null); PCSNode node = pcsIterator.First(); GameObject gameObj; while (node != null) { gameObj = (GameObject)node; gameObj.x += this.deltaX; if (this.edgeHit) { gameObj.y -= this.deltaY; } node = pcsIterator.Next(); } this.edgeHit = false; }
// insert public void Insert(PCSNode inNode, PCSNode pParent) { Debug.Assert(inNode != null); // insert to root if (null == pParent) { this.pRoot = inNode; inNode.pChild = null; inNode.pParent = null; inNode.pSibling = null; this.privInfoAddNode(); } else // insert inside the tree { if (pParent.pChild == null) { // child is 0, just add child pParent.pChild = inNode; inNode.pParent = pParent; inNode.pChild = null; inNode.pSibling = null; this.privInfoAddNode(); } else { // add as sibling // Get first child PCSNode first = pParent.pChild; inNode.pParent = pParent; inNode.pChild = null; inNode.pSibling = first; pParent.pChild = inNode; this.privInfoAddNode(); } } }
protected void UpdateBoundingBox() { PCSNode node = (PCSNode)this; node = node.pChild; GameObject go = (GameObject)node; CollisionRect collisionTotal = this.pCollisionObject.pCollisionRect; collisionTotal.Set(go.pCollisionObject.pCollisionRect); while (node != null) { go = (GameObject)node; collisionTotal.Union(go.pCollisionObject.pCollisionRect); node = node.pSibling; } this.x = this.pCollisionObject.pCollisionRect.x; this.y = this.pCollisionObject.pCollisionRect.y; }
public override void Update() { //privMoveGrid // Go to first child PCSNode pNode = (PCSNode)this; pNode = pNode.pChild; // Set ColTotal to first child GameObject pGameObj = (GameObject)pNode; //todo add an AlienRoot to continue game after all aliens are destroyed //without a semi-permenant alien root, system breaks after last alien/column is destroyed, //thus destroying the grid and returning a null game object here; ColRect ColTotal = this.poColObj.poColRect; ColTotal.Set(pGameObj.GetColObject().poColRect); // loop through sliblings while (pNode != null) { pGameObj = (GameObject)pNode; ColTotal.Union(pGameObj.GetColObject().poColRect); // go to next sibling pNode = pNode.pSibling; } //this.pColObj.pColRect.Set(201, 201, 201, 201); this.x = this.poColObj.poColRect.x; this.y = this.poColObj.poColRect.y; //Debug.WriteLine("x:{0} y:{1} w:{2} h:{3}", ColTotal.x, ColTotal.y, ColTotal.width, ColTotal.height); base.baseUpdateBoundingBox(); base.Update(); }
protected void baseUpdateBoundingBox() { //go to the first child in the PCS tree; PCSNode pcsNode = (PCSNode)this; pcsNode = pcsNode.pChild; //cast the pcsNode as a GameObject GameObject gameObject = (GameObject)pcsNode; //check to see if pcsNode is null (has it been removed?) if (pcsNode != null) { Debug.Assert(this.poColObj != null); Debug.Assert(this.poColObj.poColRect != null); ColRect collisionTotal = this.poColObj.poColRect; Debug.Assert(this.poColObj != null); Debug.Assert(this.poColObj.poColRect != null); collisionTotal.Set(gameObject.poColObj.poColRect); //loop through the siblings to get the total collisionRectSize; while (pcsNode != null) { //cast each sibling pcsNode as a GameObject for consistency; gameObject = (GameObject)pcsNode; //total will be the size of the Union / combination of all the collisionRect sizes of the siblings; collisionTotal.Union(gameObject.poColObj.poColRect); //point to the next sibling; //if the next sibling is null, then the loop will break out automatically; pcsNode = pcsNode.pSibling; } this.x = this.poColObj.poColRect.x; this.y = this.poColObj.poColRect.y; } }
private void privDumpTreeDepthFirst(PCSNode pNode) { PCSNode pChild = null; // dump pNode.dumpNode(); // iterate through all of the active children if (pNode.pChild != null) { pChild = pNode.pChild; // make sure that allocation is not a child node while (pChild != null) { privDumpTreeDepthFirst(pChild); // goto next sibling pChild = pChild.pSibling; } } else { // bye bye exit condition } }
public void SetParent(PCSNode pNode) { this.pParent = pNode; }
public void SetParent(GameObject parentNode) { //fine being null (null object) this.pParent = parentNode; }
public void setParent(PCSNode parentNode) { this.cParent = parentNode; Debug.Assert(this.cParent != null); }
public void SetRoot(PCSNode pRoot) { Debug.Assert(pRoot != null); this.pRoot = pRoot; }