/**
* If (type == ObjectType.GHOST || type == ObjectType.ANGRY) will set the the number of turns the Ghost will need to progress to the next to the next Stage in its evolution
* @param newTime must be greater then 0 and if (type == ObjectType.GHOST) less than 4, otherwise less than 6
*/
public bool setGhostTimer(short newTime)
{
if (type == InteractableObject.ObjectType.GHOST || type == InteractableObject.ObjectType.ANGRY)
{
if (subject == null)
{
subject = createEnemy(type);
}
if (subject.type != type)
{
if (type == InteractableObject.ObjectType.GHOST && subject.type == InteractableObject.ObjectType.ANGRY)
{
((Ghost)subject).MakeNotAngry();
}
else if (type == InteractableObject.ObjectType.ANGRY && subject.type == InteractableObject.ObjectType.GHOST)
{
((Ghost)subject).MakeAngry();
}
else
{
subject.removeThis();
BaseEnemy newSubject = createEnemy(type);
newSubject.setCenter(subject.getCenterX(), subject.getCenterY());
subject = newSubject;
}
}
return(((Ghost)subject).setAngryTimer(newTime));
}
return(false);
}
/**
* returns true if the given Enemy is currently active within the primeEnemtSet
* @param target
* @return
*/
private bool isActiveEnemy(BaseEnemy target)
{
//information is accurate and up to date
if (target != null && target.hostSet == this && enemySetPrime != null)
{
if (getEnemyAt(target.currentRow, target.currentCollumn) == target)
{
return(true);
}
//searching for target
else if (doesGridPositionExist(target.currentRow, target.currentCollumn))
{
for (int loopRows = 0; loopRows < getNumberOfRows(); loopRows++)
{
for (int loopCollumns = 0; loopCollumns < getNumberOfCollumns(loopRows); loopRows++)
{
if (enemySetPrime[loopRows][loopCollumns] == target)
{
target.setPosition(loopRows, loopCollumns, this);
return(true);
}
}
}
}
//Target is not in set and inactive
}
return(false);
}
//any changes to state as a result of clobber are added to storedStateChangeObject
private void clobber(int row, int collumn, int animationTime)
{
if (hostSet != null)
{
BaseEnemy target = hostSet.getEnemyAt(row, collumn);
if (target != null)
{
if (target.type == InteractableObject.ObjectType.ANGRY)
{
storedStateChangeObject.add(((Ghost)target).explode());
}
else
{
if (target.type != InteractableObject.ObjectType.GHOST)
{
target.removeThis();
Ghost newGhost = new Ghost(BaseCode.activeLibrary);
newGhost.setCenter(target.getCenterX(), target.getCenterY());
newGhost.revealType(0);
hostSet.addEnemy(newGhost, row, collumn);
newGhost.setAnimationTarget(row, collumn);
newGhost.revealType(animationTime);
}
else
{
target.revealType(animationTime);
}
}
}
}
}
/**
* Will set the target of the Animation and the Time for it to take place for a Drop
*/
protected void setMoveTarget()
{
//checking if currentEnemyGrid and position are up to date
if (hostSet != null)
{
//Will set spider to drop down one row
if (dropDistance < MAX_DROP_DISTANCE && hostSet.getNumberOfRows() > (currentRow + dropDistance + 1))
{
dropping = true;
dropStart.X = base.getCenterX();
dropStart.Y = base.getCenterY();
dropDistance++;
BaseEnemy target = hostSet.getEnemyAt(currentRow + dropDistance, currentCollumn);
if (target != null && target != this)
{
dropTarget.X = target.getCenterX();
dropTarget.Y = target.getCenterY();
}
else
{
dropTarget.X = base.getCenterX();
dropTarget.Y = base.getCenterY();
dropTarget = hostSet.getWorldPosition(currentRow + dropDistance, currentCollumn);
}
//setting Web hang point and initializing web
setWebPositionSize();;
}
else
{
dropping = false;
}
}
}
/**
* 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 Destroy this Object call if you are going to remove this from from the array
*/
public void destroy()
{
if (subject != null)
{
storedStateChangeObject.add(subject.scare());
subject = null;
}
} /**
//targeted Enemy Stuff
public EnemySubSetNode targetEnemy(BaseEnemy target)
{
if (currentTargets != null)
{
return(currentTargets.addEnemy(target, false));
}
return(null);
}
/**
* Will deduct points for each Enemy to be eaten and set first target for the spider to drop
* and will Determine how many Rows the Spider will Drop
*/
public override StateChange revealType(int pauseTime)
{
//checking if currentEnemyGrid and position are up to date
storedStateChangeObject.setToDefualts();
if (!isTypeRevealed)
{
base.revealType(pauseTime);
//setting targets to move Towards
dropDistance = 0;
setMoveTarget();
initializeWeb();
//Deducting points as a result of Drop
if (hostSet != null)
{
base.revealType(pauseTime);
//checking if two rows below the spider exist
/*if(hostSet.doesGridPositionExist(currentRow, currentRow + 2)){
* //Jumping Down 1 row
* BaseEnemy target = hostSet.getEnemyAt(currentRow + 1, currentCollumn);
* if(target != null){
* storedStateChangeObject.changeInPlayerScore -= target.getScore();
* }
* //Jumping Down 2 row
* target = hostSet.getEnemyAt(currentRow + 2, currentCollumn);
* if(target != null){
* storedStateChangeObject.changeInPlayerScore -= target.getScore();
* }
* storedStateChangeObject.puaseForAnimation = true;
* dropTime = pauseTime/3;
* }
* //checking if one rows below the spider exist
* else */if (hostSet.doesGridPositionExist(currentRow, currentRow + 1))
{
//Jumping Down 1 row
BaseEnemy target = hostSet.getEnemyAt(currentRow + 1, currentCollumn);
if (target != null)
{
storedStateChangeObject.changeInPlayerScore -= target.getScore();
}
storedStateChangeObject.puaseForAnimation = true;
dropTime = pauseTime / 2;
}
if (dropTime == 0)
{
hostSet.moveEnemy(this, currentRow + dropDistance, currentCollumn);
fillRowWithEnemies(currentRow + dropDistance);
this.setAnimationTarget(currentRow, currentCollumn);
}
}
}
else if (getInfectStatus() <= 0)
{
return(removeThis());
}
return(storedStateChangeObject);
}
/**
* Will remove the given BaseEnemy from the set and the Interactable object will be removed the
* next time getGrid() is used
* @param removeTarget the baseEnemy that will be removed
* @return whether or not the removal was successful
*/
public bool removeEnemy(BaseEnemy removeTarget)
{
if (removeTarget != null && isActiveEnemy(removeTarget))
{
enemySetPrime[removeTarget.currentRow][removeTarget.currentCollumn] = null;
return(true);
}
return(false);
}
/**
* 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 Infect target Enemy for the give timeInfected
*/
public void infect(int row, int collumn, int timeInfected)
{
if (hostSet != null)
{
BaseEnemy target = hostSet.getEnemyAt(row, collumn);
if (target != null)
{
target.setInfectStatus(timeInfected);
}
}
}
/**
* Will eat the Victem at the Given location
* @param row the row the Victem the victem lies in
* @param column the column the Victem the victem lies in
* @return The change in score as a result of the meal
*/
protected void EatVictem(int row, int column)
{
if (hostSet != null)
{
BaseEnemy victem = hostSet.getEnemyAt(row, column);
if (victem != null && victem != this)
{
victem.removeThis();
}
}
}
/**
* Will create the BaseEnemy object associated with the given Enemy type
* @param newType The Type of BaseEnemy requested
* @return The new BseEnemy
*/
internal static BaseEnemy createEnemy(InteractableObject.ObjectType newType)
{
BaseEnemy retVal = null;
switch (newType)
{
case InteractableObject.ObjectType.ANGRY: {
retVal = new Ghost(BaseCode.activeLibrary); //Creating Ghost
((Ghost)retVal).MakeAngry(); //Angering Ghost
break;
}
case InteractableObject.ObjectType.GHOST: {
retVal = (new Ghost(BaseCode.activeLibrary));
break;
}
case InteractableObject.ObjectType.SPIDER: {
retVal = (new Spider(BaseCode.activeLibrary));
break;
}
case InteractableObject.ObjectType.VAMPIRE: {
retVal = (new Vampire(BaseCode.activeLibrary));
break;
}
case InteractableObject.ObjectType.MUMMY: {
retVal = (new Mummy(BaseCode.activeLibrary));
break;
}
case InteractableObject.ObjectType.PUMPKIN: {
retVal = (new Pumpkin(BaseCode.activeLibrary));
break;
}
case InteractableObject.ObjectType.ZOMBIE: {
retVal = (new Zombie(BaseCode.activeLibrary));
break;
}
case InteractableObject.ObjectType.FRANKENSTEIN: {
retVal = (new Frankenstein(BaseCode.activeLibrary));
break;
}
case InteractableObject.ObjectType.CAT: {
retVal = (new Cat(BaseCode.activeLibrary));
break;
}
}
return(retVal);
}
public bool isEnemyAlreadyTargeted(BaseEnemy target)
{
if (currentTargets != null)
{
if (currentTargets.findEnemy(target) != null)
{
return(true);
}
}
return(false);
}
/**
* Will attempt to Remove an enemy at the given location
* Note Does not check if hostSet is set
* @param targetRow
* @param targetCollumn
*/
private void killEnemy(int targetRow, int targetCollumn)
{
if (hostSet != null)
{
BaseEnemy target = hostSet.getEnemyAt(targetRow, targetCollumn);
if (target != null)
{
target.scare();
}
}
}
/**
* Will remove the given Enemy from the grid and add it to the subSet(temporary starage until the Enemy removes Itself)
*/
public void moveEnemytoSubSet(BaseEnemy moveTarget)
{
if (moveTarget != null)
{
if (isActiveEnemy(moveTarget))
{
removeEnemy(moveTarget);
moveTarget.hostSet = null;
}
tempStorage.addEnemy(moveTarget, true);
}
}
/**
* Will Set the IOset Size to match the size of the primeSet
* If the Size must be changed then Enemies will migrate to the upper right hand corrner of the grid
* and enemies are left in position that are outside of the new grid then nothing will be done of them
* It is users responsibility to destroy() enemies they remove
* @return returns the updated primeSet
*/
private BaseEnemy[] CheckArraySizes(InteractableObject[] IOset, BaseEnemy[] primeSet)
{
if (primeSet != null)
{
//Salvage
if (IOset != null)
{
if (IOset.Length != primeSet.Length)
{
BaseEnemy[] newPrime = new BaseEnemy[IOset.Length]; //newSet
int loop = 0;
//Moving over old Elements
while (loop < IOset.Length && loop < primeSet.Length)
{
newPrime[loop] = primeSet[loop];
loop++;
}
//Initializing Excess to null
while (loop < newPrime.Length)
{
newPrime[loop] = null;
loop++;
}
//Removing old enemies
for (int loopRemove = IOset.Length - 1; loopRemove < primeSet.Length; loopRemove++)
{
if (primeSet[loopRemove] != null)
{
primeSet[loopRemove].removeThis();
}
}
primeSet = newPrime;
}
}
//Destroy all
else
{
primeSet = null;
}
}
//Complete Rebuild
else if (IOset != null)
{
primeSet = new BaseEnemy[IOset.Length];
for (int loop = 0; loop < IOset.Length; loop++)
{
primeSet[loop] = null;
}
}
return(primeSet);
}
/**
* 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 insert the given BaseEnemy at the given location if possible and will remove any enemy residing at that location already
* @param newEnemy the given BaseEnemy
* @param row the row the enemy will be placed in
* @param collumn the collumn the enemy will be placed in
* @return whether or not the enemy was successfully added
*/
public bool addEnemy(BaseEnemy newEnemy, int row, int collumn)
{
if (newEnemy != null && doesGridPositionExist(row, collumn) && !isActiveEnemy(newEnemy))
{
if (enemySetPrime[row][collumn] != null)
{
removeEnemy(enemySetPrime[row][collumn]);
}
enemySetPrime[row][collumn] = newEnemy;
newEnemy.setPosition(row, collumn, this);
newEnemy.setAnimationTarget(row, collumn);
BaseCode.activeDrawSet.addToDrawSet(newEnemy);
return(true);
}
return(false);
}
/**
* Will Fill a given Row with a random Set of Enemies
* @param row the given Row
*/
protected void fillRowWithEnemies(int row)
{
if (hostSet != null)
{
for (int loop = 0; loop < hostSet.getNumberOfCollumns(row); loop++)
{
if (hostSet.getEnemyAt(row, loop) == null)
{
BaseEnemy temp = getRandomEnemy();
temp.setCenterX(this.getCenterX());
temp.setCenterY(this.getCenterY());
hostSet.addEnemy(temp, row, loop);
}
}
}
}
/**
* 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;
}
/// <summary>
/// Will load images and other recourses required for the game
/// </summary>
/// <param name="resources"></param>
/// <remarks>Note this function is called automatically once the game has started. and should not b called manualy</remarks>
public static void preLoadResources(ResourceLibrary resources)
{
Life.preLoadResources(resources);
BaseEnemy.preLoadResources(resources);
Frankenstein.preLoadResources(resources);
Cat.preLoadResources(resources);
Ghost.preLoadResources(resources);
Player.preLoadResources(resources);
LightBeam.preLoadResources(resources);
Mummy.preLoadResources(resources);
Pumpkin.preLoadResources(resources);
Spider.preLoadResources(resources);
Vampire.preLoadResources(resources);
Zombie.preLoadResources(resources);
LightButton.preLoadResources(resources);
EnemySoundManager.preLoadResources(resources);
}
/**
* 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);
}
/**
* Will seach a given Enemy grid and will return the Enemy at the greatest index within that collumm
* @param Column The target collumn within the enemyGrid to be searched
* @param hostSet The set of Enemies to be searched
* @return The Enemy within the target collumn at the deapest row. Not if this is null no Enemy was found
*/
private BaseEnemy getClosestEnemy(EnemySet hostSet, int column)
{
if (hostSet != null && column >= 0)
{
for (int loopRow = hostSet.getNumberOfRows() - 1; loopRow >= 0; loopRow--)
{
if (column < hostSet.getNumberOfCollumns(loopRow))
{
BaseEnemy retVal = hostSet.getEnemyAt(loopRow, column);
if (retVal != null)
{
return(retVal);
}
}
}
}
return(null);
}
/**
* Will select Enemies within the current Enemy Set that would be affected by the light
* @param targetSet The current Enemy Set
* @param currentCollumn the Collumn within the Set that the light is on
*/
public void selectTargetableEnemies(EnemySet targetSet, int currentCollumn)
{
if (targetSet != null)
{
BaseEnemy currentTarget = null;
//Reveal
if (type == BeamType.REVEAL)
{
for (int loop = currentCollumn - 1; loop <= currentCollumn + 1 && loop < targetSet.getNumberOfCollumns(); loop++)
{
currentTarget = getClosestEnemy(targetSet, loop);
if (currentTarget != null)
{
currentTarget.select();
}
}
}
//Wide
else if (type == BeamType.WIDE)
{
for (int loop = currentCollumn - 2; loop <= currentCollumn + 2 && loop < targetSet.getNumberOfCollumns(); loop++)
{
currentTarget = getClosestEnemy(targetSet, loop);
if (currentTarget != null)
{
currentTarget.select();
}
}
}
//Laser
else
{
for (int loopRow = 0; loopRow < targetSet.getNumberOfRows(); loopRow++)
{
currentTarget = targetSet.getEnemyAt(loopRow, currentCollumn);
if (currentTarget != null)
{
currentTarget.select();
}
}
}
}
}
public override StateChange revealType(int pauseTime)
{
if (!isTypeRevealed)
{
EnemySoundManager.requestSound(EnemySoundManager.SoundType.MUMMY_INTRO);
base.revealType(pauseTime);
if (hostSet != null)
{
for (int loop = 0; loop < hostSet.getNumberOfCollumns(currentRow); loop++)
{
BaseEnemy target = hostSet.getEnemyAt(currentRow, loop);
if (target != null && target != this)
{
target.unrevealType();
}
}
}
}
return(storedStateChangeObject);
}
/**
* Will Attempt to move the Given Enemy to the given position
* Note this function requires that the Given BaseEnemy be already active in the set
* Enemy enemy already at the target position will be removed from the set;
* Assums that the
* @param moveTarget BaseEnemy you wish to move
* @param row Target row to move too
* @param collumn Target column to move too
* @return True if the Enemy was either moved to a different location in the set or moved into the set for the first time
*/
public bool moveEnemy(BaseEnemy moveTarget, int row, int collumn)
{
if (moveTarget != null && doesGridPositionExist(row, collumn))
{
//Moving Enemy to position
if (isActiveEnemy(moveTarget))
{
//Enemy is not at current position
if (row != moveTarget.currentRow || collumn != moveTarget.currentCollumn)
{
if (enemySetPrime[row][collumn] != null)
{
removeEnemy(enemySetPrime[row][collumn]);
}
enemySetPrime[row][collumn] = moveTarget;
enemySetPrime[moveTarget.currentRow][moveTarget.currentCollumn] = null;
moveTarget.setPosition(row, collumn, this);
moveTarget.setAnimationTarget(row, collumn);
}
//Enemy is already at the desired position
else
{
return(false);
}
}
//adding Enemy
else
{
if (enemySetPrime[row][collumn] != null)
{
removeEnemy(enemySetPrime[row][collumn]);
}
enemySetPrime[row][collumn] = moveTarget;
moveTarget.setPosition(row, collumn, this);
BaseCode.activeDrawSet.addToDrawSet(moveTarget);
}
return(true);
}
return(false);
}
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 update the subject based on the settings in the representative
* @param hostSet the Enemy set that is in change of storing all of the BaseEnemies in use
* @param puasetime the amount of time the game will pause for animations to proceed
* @return whether or not any changes were made that actually require the game to pause
* This includes revealing a Enemy, and Moving an enemy
*/
internal StateChange updateSubject(EnemySet hostSet, int puasetime)
{
if (hostSet != null)
{
//Matching EnemyTypes and moving/Adding Enemy to appropriate array position
if (subject == null)
{
subject = createEnemy(type);
storedStateChangeObject.puaseForAnimation = hostSet.addEnemy(subject, currentRow, currentCollumn);
}
else if (subject.type != type)
{
if (type == InteractableObject.ObjectType.GHOST && subject.type == InteractableObject.ObjectType.ANGRY)
{
((Ghost)subject).MakeNotAngry();
storedStateChangeObject.puaseForAnimation = hostSet.moveEnemy(subject, currentRow, currentCollumn);
}
else if (type == InteractableObject.ObjectType.ANGRY && subject.type == InteractableObject.ObjectType.GHOST)
{
((Ghost)subject).MakeAngry();
storedStateChangeObject.puaseForAnimation = hostSet.moveEnemy(subject, currentRow, currentCollumn);
}
else
{
subject.removeThis();
BaseEnemy newSubject = createEnemy(type);
newSubject.setCenter(subject.getCenterX(), subject.getCenterY());
subject = newSubject;
hostSet.addEnemy(subject, currentRow, currentCollumn);
storedStateChangeObject.puaseForAnimation = false;
}
}
else
{
storedStateChangeObject.puaseForAnimation = hostSet.moveEnemy(subject, currentRow, currentCollumn);
}
//Updating reveal state infect state etc..
subject.representative = (InteractableObject)this;
subject.setInfectStatus(infectedTimer);
subject.getHealth().setMaxSegments(maxHealth);
subject.getHealth().setFilledSegments(currentHealth);
subject.setScore(score);
subject.circleEnemy(highlighted);
//updating animation
subject.setAnimationTarget(currentRow, currentCollumn);
//updating Partial Reveal status
if (subject.isPartialRevealed != partialRevealed && !revealed)
{
if (partialRevealed)
{
subject.partialReveal();
}
else
{
subject.unrevealType();
}
}
//updating reveal state
if (subject.isTypeRevealed != revealed)
{
subject.setToReveal = true;
}
subject.setInvulnerablility(invulnerable);
}
return(storedStateChangeObject);
}
/**
* 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);
}
