/** * Will set the Target of the Byte and will Deduct any points that will need to be Deducted as a result of the byte * Will Also Set the Animation to move towards the Byte target within the Fist half of the animation ime * @return The super.storedStateChangeObject as the change game state */ private StateChange setByteTarget() { storedStateChangeObject.setToDefualts(); bytePos = 0; if (currentTarget != null) { currentTarget.removeNode(); } if (hostSet != null) { //choosing Target Enemy targetEnemyCollumn = getRandomCollomn(); byteTarget = hostSet.getEnemyAt(currentRow, targetEnemyCollumn); //Deducting Points if (byteTarget != this) { //Byte if (byteTarget != null && byteTarget.type != InteractableObject.ObjectType.CAT) { if (byteTarget.isTypeRevealed) { storedStateChangeObject.changeInPlayerScore = -byteTarget.getScore(); } if (byteTarget.type == InteractableObject.ObjectType.ANGRY) { storedStateChangeObject.add(((Ghost)byteTarget).getExplodeEffects()); } } //Move else if (byteTarget == null) { hostSet.moveEnemy(this, currentRow, targetEnemyCollumn); base.setAnimationTarget(currentRow, targetEnemyCollumn); } //Idle else { targetEnemyCollumn = -1; byteTarget = null; } //is enemy already targeted if (isEnemyAlreadyTargeted(byteTarget)) { targetEnemyCollumn = -1; byteTarget = null; } //targeting enemy else { currentTarget = targetEnemy(byteTarget); } } else { byteTarget = null; } } return(storedStateChangeObject); }
/** * will remove this Enemy From the currentEnemyGrid * Note this does Reset any previous changes to the stored storedStateChangeObject * before making its own changes */ public override StateChange removeThis() { if (currentTarget != null) { currentTarget.removeNode(); currentTarget = null; } byteTarget = null; this.targetEnemyCollumn = -1; return(base.removeThis()); }
/** * Will add the given EnemySubSetNode to the list directly after this one */ public void addNode(EnemySubSetNode newNode) { if (newNode != null) { newNode.previousNode = this; newNode.nextNode = nextNode; if (nextNode != null) { nextNode.previousNode = newNode; } nextNode = newNode; } }
/** Stores previously removed nodes for reuse */ /** * Will remove this node from the list and ling the node before and after this node togther */ public void removeNode() { //removing this node if (nextNode != null) { nextNode.previousNode = previousNode; } if (previousNode != null) { previousNode.nextNode = nextNode; } previousNode = null; nextNode = null; }
/** * Will remove all EnemySubSetNodes from the set * @param destroyData */ public void removeAllEnemies(bool destroyData) { EnemySubSetNode target = firstNode.getNextNode(); while (target != null) { EnemySubSetNode nextTarget = target.getNextNode(); if (target.data != null && destroyData) { target.data.removeThis(); } target.removeNode(); target = nextTarget; } }
/** * Will add a give baseEnemy to this set * Linked List. nothing fancy here * @param newEnemy */ public EnemySubSetNode addEnemy(BaseEnemy newEnemy, bool informEnemy) { if (newEnemy != null) { EnemySubSetNode newNode = new EnemySubSetNode(); newNode.data = newEnemy; if (informEnemy) { newEnemy.hostNode = newNode; } firstNode.addNode(newNode); return(newNode); } return(null); }
/** * Will Bite a Random Enemy on the current Row * @return the Score Decrement as a result of the Bite */ private void BiteTarget(BaseEnemy target) { if (hostSet != null && target != null) { EnemySoundManager.requestSound(EnemySoundManager.SoundType.DRACKULA_ATTACK); //Target is Ghost //Making Angry if (target.type == InteractableObject.ObjectType.GHOST) { //if not revealed if (!target.isTypeRevealed) { target.revealType(0); } ((Ghost)target).MakeAngry(); } //Target is already an angry Ghost else if (target.type == InteractableObject.ObjectType.ANGRY) { //if not revealed if (!target.isTypeRevealed) { target.revealType(0); } ((Ghost)target).explode(); removeThis(); } //Target is not an Angry Ghost //Removing Target and Making it an angry Ghost else if (target != this && target.type != InteractableObject.ObjectType.CAT) { target.removeThis(); Ghost angryGhost = new Ghost(BaseCode.activeLibrary); angryGhost.revealType(0); hostSet.addEnemy(angryGhost, currentRow, targetEnemyCollumn); angryGhost.setCenter(base.getCenterX(), base.getCenterY()); angryGhost.setAnimationTarget(currentRow, targetEnemyCollumn); } } if (currentTarget != null) { currentTarget.removeNode(); currentTarget = null; } targetEnemyCollumn = -1; }
/** * Will attempt to find the given BaseEnemy in the set and if found will return the EnemySubSetNode that contains it. * Otherwise will return null * @param target * @return */ public EnemySubSetNode findEnemy(BaseEnemy target) { EnemySubSetNode retVal = null; if (target != null) { EnemySubSetNode currentNode = firstNode.getNextNode(); while (currentNode != null && retVal == null) { if (currentNode.data == target) { retVal = currentNode; } currentNode = currentNode.getNextNode(); } } return(retVal); }
private void ByteTarget(BaseEnemy target) { if (target != null && hostSet != null) { EnemySoundManager.requestSound(EnemySoundManager.SoundType.CAT_ATTACK); if (target.type == InteractableObject.ObjectType.ANGRY) { ((Ghost)target).explode(); removeThis(); } else { target.removeThis(); } } if (currentTarget != null) { currentTarget.removeNode(); currentTarget = null; } targetEnemyCollumn = -1; }
/** * Will set the Target of the Byte and will Deduct any points that will need to be Deducted as a result of the byte * Will Also Set the Animation to move towards the Byte target within the Fist half of the animation ime * @return The super.storedStateChangeObject as the change game state */ private StateChange setByteTarget() { storedStateChangeObject.setToDefualts(); bytePos = 0; if (currentTarget != null) { currentTarget.removeNode(); } if (hostSet != null) { //initializing targtableGhosts if (targtableGhosts == null) { targtableGhosts = new List <BaseEnemy>(); } targtableGhosts.Clear(); if (targtableGhosts.Capacity < hostSet.getNumberOfCollumns(currentRow)) { targtableGhosts.Capacity = hostSet.getNumberOfCollumns(currentRow); } //Finding Ghosts BaseEnemy target = null; for (int loop = 0; loop < hostSet.getNumberOfCollumns(currentRow); loop++) { target = hostSet.getEnemyAt(currentRow, loop); if (target != null && target.isTypeRevealed && (target.type == InteractableObject.ObjectType.ANGRY || target.type == InteractableObject.ObjectType.GHOST)) { targtableGhosts.Add(target); } } //Choosing Ghost to byte if (targtableGhosts.Count == 0) { targetEnemyCollumn = -1; byteTarget = null; } //single target else if (targtableGhosts.Count == 1) { byteTarget = targtableGhosts[0]; targetEnemyCollumn = byteTarget.currentCollumn; //is enemy already targeted if (isEnemyAlreadyTargeted(byteTarget)) { targetEnemyCollumn = -1; byteTarget = null; } //targeting enemy else { currentTarget = targetEnemy(byteTarget); } } //Multiple targets else { byteTarget = targtableGhosts[((int)(rand.NextDouble() * (targtableGhosts.Count)))]; targetEnemyCollumn = byteTarget.currentCollumn; //is enemy already targeted if (isEnemyAlreadyTargeted(byteTarget)) { targetEnemyCollumn = -1; byteTarget = null; } //targeting enemy else { currentTarget = targetEnemy(byteTarget); } } } return(storedStateChangeObject); }