public void TakeResource()
{
Resource.transform.SetParent(GameObject.transform);
Resource.transform.position = GameObject.transform.position + new Vector3(0,1,0);
Resource.GetComponent<Collider>().enabled = false;
state = AlienState.CARRYING;
Debug.Log("Going back to SpaceShip");
}
private void FixedUpdate()
{
//if we're dead don't do anything
if (currentState == AlienState.dead)
{
return;
}
if (roverTransform == null)
{
currentState = AlienState.dead;
return;
}
//handle movement
switch (currentState)
{
case AlienState.patrolling:
rb.MovePosition(transform.position + directionToMove * Time.fixedDeltaTime * patrolSpeed);
break;
case AlienState.chasing:
rb.MovePosition(transform.position + directionToMove * Time.fixedDeltaTime * chaseSpeed);
break;
}
}
public static void page100_Main()
{
Alien a;
a.x = 50;
a.y = 50;
a.Lives = 4;
Console.WriteLine("a {0}", a.ToString());
Alien x = new Alien(100, 100);
Console.WriteLine("x {0}", x.ToString());
Alien[] swarm = new Alien[100];
Console.WriteLine("swarm [10] {0}", swarm[10].ToString());
Console.WriteLine("Page 101");
AlienState alientstate = AlienState.Attacking;
Console.WriteLine(alientstate);
Console.WriteLine("Page 103");
for (int i = 0; i < swarm.Length; i++)
{
swarm[i] = new Alien(0, 0);
Console.WriteLine("swarm [" + i + "] {0}", swarm[i]);
}
}
// Enumerated types are used in situations where the programmer wants to specify a range of values that a given type can have.
// Unless specified otherwise, an enumerated type is based on the int type and the enumerated values are numbered
// starting at 0. You can modify this by adding extra information to the declaration of the enum.
public void CreateEnum()
{
AlienState a = AlienState.Sleeping;
Console.WriteLine(a); // prints the ToString result returned by the AlienState variable, which will output the string "Sleeping"
// Also can use casting to int to have numeric value printed
}
static void Main(string[] args)
{
AlienState x = AlienState.Attacking;
Console.WriteLine(x);
Console.ReadKey();
}
private void OnCollisionEnter2D(Collision2D other)
{
if (other.transform.tag != "Enemy")
{
state = AlienState.Hit;
}
}
public void StartCommand()
{
StructStore xs, ys;
ys = new StructStore();
ys.Data = 99;
xs = ys;
xs.Data = 100;
Console.WriteLine("xStruct: {0}", xs.Data);
Console.WriteLine("yStruct: {0}", ys.Data);
ClassStore xc, yc;
yc = new ClassStore();
yc.Data = 99;
xc = yc;
xc.Data = 100;
Console.WriteLine("xClass: {0}", xc.Data);
Console.WriteLine("yClass: {0}", yc.Data);
AlienState alienState = AlienState.Attacking;
Console.WriteLine("State of alien {0}", alienState);
AlienBit alienBit = AlienBit.Attacking;
Console.WriteLine("State of alien bit {0}", alienBit);
Console.ReadKey();
}
private static void CreatingAnEnumExample()
{
AlienState x = AlienState.Attacking;
/* The program prints the ToString result returned by the AlienState variable, which will output the
* string "Attacking" in this case. */
Console.WriteLine(x);
}
private void Update()
{
if (prevState != state)
{
faceRenderer.sprite = faceExpressions[state];
}
prevState = state;
}
// constructor
public Alien(int alienWidth, int alienHeight, int screenHeight, int screenWidth, int hitPoints)
{
this.alienWidth = alienWidth;
this.alienHeight = alienHeight;
this.screenHeight = screenHeight;
this.screenWidth = screenWidth;
this.hitPoints = hitPoints;
alienState = AlienState.ACTIVE;
}
public static void executeTest()
{
AlienState x = AlienState.Attacking;
Console.WriteLine(x);
AlienStateNum xn = AlienStateNum.Attacking;
Console.WriteLine(xn);
Console.ReadKey();
}
private void Start()
{
faceExpressions = new Dictionary <AlienState, Sprite>();
faceExpressions.Add(AlienState.HAPPY, faceExpressionSprites.happy);
faceExpressions.Add(AlienState.REGULAR, faceExpressionSprites.regular);
faceExpressions.Add(AlienState.DEAD, faceExpressionSprites.dead);
faceExpressions.Add(AlienState.SCARED, faceExpressionSprites.scared);
state = AlienState.HAPPY;
prevState = AlienState.DEAD;
}
// Update is called once per frame
void Update()
{
if ((gameLastState != GameState.Paused && gameManagerScript.gameState == GameState.Paused) ||
(gameLastState == GameState.Paused && gameManagerScript.gameState != GameState.Paused))
{
PauseToggle();
}
switch (state)
{
case AlienState.Idle:
moveTick++;
if (goUp)
{
rb.velocity = movementDirection * moveSpeed;
if (moveTick > moveTimer * 50)
{
goUp = !goUp;
moveTick = 0;
}
}
else
{
rb.velocity = -movementDirection * moveSpeed;
if (moveTick > moveTimer * 50)
{
goUp = !goUp;
moveTick = 0;
}
}
break;
case AlienState.Hit:
deathSound.Play();
transform.parent.GetComponent <AlienTimedSpawnerScript>().spawnGrid[xPos, yPos] = false;
gameManagerScript.ballSpeed += gameManagerScript.ballSpeedAdded;
gameManagerScript.currentScore += gameManagerScript.alienPoints;
alienTimedSpawnerScript.timerTick = 0;
if (alienTimedSpawnerScript.alienTimer > 1.5f)
{
alienTimedSpawnerScript.alienTimer -= .1f;
}
Destroy(this.gameObject);
break;
case AlienState.Paused:
if (!paused)
{
state = lastState;
}
break;
}
gameLastState = gameManagerScript.gameState;
}
private void Update()
{
switch (_state)
{
case AlienState.Idle:
if (Random.Range(0, 100) < 5)
{
State = AlienState.Walking;
}
break;
case AlienState.Walking:
float distance = Vector3.Distance(transform.position, transform.parent.position);
transform.position = transform.parent.position;
transform.Rotate(new Vector3(0, 0, 10 * Time.deltaTime), Space.Self);
transform.position = transform.parent.position + transform.up * distance;
if (_timer >= _currentTimeToWalk)
{
int rand = Random.Range(0, 10000);
if (rand < 2)
{
Spaceship.Intent intent = GetIntent();
if (intent != Spaceship.Intent.None)
{
OriginPlanet.Data.TechResource -= 10;
GameController.Instance.InstantiateRocketShip(this, intent);
_state = AlienState.InShip;
}
}
else if (rand < 100)
{
State = AlienState.Applauding;
}
else if (rand < 200)
{
State = AlienState.Idle;
}
}
break;
case AlienState.Applauding:
if (_timer >= _timeToApplaud)
{
State = AlienState.Idle;
}
break;
case AlienState.Angry:
break;
}
_timer += Time.deltaTime;
}
public void ChangeState(AlienStates state)
{
if (_state != null)
{
_state.Dispose();
_state = null;
}
_state = _stateFactory.CreateState(state);
_state.Start();
}
public void PauseToggle()
{
if (!paused)
{
lastState = state;
state = AlienState.Paused;
}
else
{
state = lastState;
}
paused = !paused;
}
public Mothership(int motherWidth, int motherHeight, int screenHeight, int screenWidth, float speed)
{
this.motherHeight = motherHeight;
this.motherWidth = motherWidth;
this.screenHeight = screenHeight;
this.screenWidth = screenWidth;
this.SPEED = speed;
alienState = AlienState.ACTIVE;
RandomizeMothershipSpawn();
//Remains the same regardless of which side it spawns on.
position.Y = motherHeight * 2;
}
public override void TakeDamage(int d, object source=null)
{
base.TakeDamage (d, source);
if (source != null && source is Monster)
{
state = AlienState.FLEEING;
if (!GameObject.transform.Find("Fleeing").GetComponent<MeshRenderer>().enabled)
{
GameObject.transform.Find("Fleeing").GetComponent<MeshRenderer>().enabled = true;
GameObject.GetComponent<AlienHelper>().StopSignal();
}
}
}
public void PauseToggle()
{
if (!paused)
{
rb.velocity = Vector2.zero;
lastState = state;
state = AlienState.Paused;
}
else
{
state = lastState;
}
paused = !paused;
}
static void Main(string[] args)
{
AlienState x = AlienState.Attacking;
Console.WriteLine(x);
AlienState2 y = AlienState2.Attacking;
Console.WriteLine((byte)y);
AlienState3 z = AlienState3.Attacking;
Console.WriteLine((byte)z);
Console.ReadKey();
}
public static string GetAlienString(AlienState alienState)
{
switch (alienState)
{
case AlienState.happy:
return("happy");
case AlienState.normal:
return("normal");
case AlienState.sad:
return("sad");
default:
return("unborn");
}
}
private void Die()
{
if (currentState == AlienState.dead)
{
return;
}
currentState = AlienState.dead;
Instantiate(biologyMaterialPrefab, transform.position + (transform.up * 3), Quaternion.identity);
if (spawnIndex != -1)
{
if (GameManager.instance != null)
{
GameManager.instance.GetComponent <AlienSpawner>().AlienDied(spawnIndex);
}
}
PlayerManager.instance.GetComponent <EnergyEquipment>().energy += deathEnergyBonus;
PlayerManager.instance.GetComponent <EnergyEquipment>().energy = Mathf.Clamp(PlayerManager.instance.GetComponent <EnergyEquipment>().energy, 0, PlayerManager.instance.GetComponent <EnergyEquipment>().energyCapacity);
Destroy(this.gameObject);
}
public void Search()
{
state = AlienState.SEARCHING;
// for initialisation
if (target == Vector3.zero)
target = GameObject.transform.position;
if ((GameObject.transform.position - target).magnitude <= 3f)
{
Vector3 rndDir = new Vector3(GameObject.transform.forward.x * Random.Range(-1, 1),
GameObject.transform.forward.y * Random.Range(-1, 1),
GameObject.transform.forward.z * Random.Range(-1, 1));
float distance = Random.Range(25, 60);
target = GameObject.transform.position + ((rndDir) * distance);
target = CoordinateHelper.GroundPosition(target);
waitTimer = Time.time;
MoveTo (target);
}
}
public static void TestAlienStruct()
{
Alien a;
a.X = 50;
a.Y = 50;
a.Lives = 3;
Console.WriteLine("a {0}", a.ToString());
Alien x = new Alien(100, 100);
Console.WriteLine("x {0}", x.ToString());
Alien[] swarm = new Alien[100];
Console.WriteLine("swarm [0] {0}", swarm[0].ToString());
AlienState x1 = AlienState.Attacking;
Console.WriteLine(x1);
}
static void Main(string[] args)
{
AlienStruct myAS;
myAS.X = 50;
myAS.Y = 50;
myAS.Lives = 3;
Console.WriteLine($"myAS has {myAS.ToString()}");
AlienStruct x = new AlienStruct(40, 60);
Console.WriteLine($"myAS has {x.ToString()}");
AlienStruct[] swarm = new AlienStruct[100];
Console.WriteLine($"myAS has {swarm[0].ToString()}");
AlienState X = AlienState.dead;
string cs = Enum.GetName(typeof(AlienState), 2);
Console.WriteLine(X);
Console.WriteLine(cs);
Constructas ca = new Constructas(3);
Console.WriteLine(ca.ToString());
IndexersProp ip = new IndexersProp();
ip[0] = 99;
Console.WriteLine(ip[0]);
var items = Enumerable.Range(0, 10);
foreach (var i in items)
{
Console.WriteLine(i);
}
var stringEnumarator = "Hello Smart".GetEnumerator();
while (stringEnumarator.MoveNext())
{
Console.WriteLine(stringEnumarator.Current);
}
}
public void Flee()
{
state = AlienState.FLEEING;
if(Resource) DropResource ();
movingToResource = false;
ReturnToShip (false);
// Alien is back at SpaceShip, waits for WAITTIME seconds
if ((GameObject.transform.position - target).magnitude <= 5f && waitTimer == -1f)
waitTimer = Time.time;
if (waitTimer != -1f && Time.time - waitTimer > WAITTIME)
{
state = AlienState.SEARCHING;
waitTimer = -1f;
}
}
public override void Update(GameTime gameTime)
{
int x = RandomGenerator.getNextRandomNumber(0, 2000);
int condition = x % 16;//condition variable to fire immune green bullets
if (this.alienType!=0)
{
//code to fire immune green bullets if player opts to play without
//horizontal movement
float change;
if (curPlayerTime == 0)
{
prevPlayerX = SpaceGame.playerX;
}
curPlayerTime += gameTime.ElapsedRealTime.Milliseconds;
if (curPlayerTime > 1000)
{
change = prevPlayerX - SpaceGame.playerX;
if (change < 0)
change *= -1;
if (change < 50)
fireBullet = true;
else
fireBullet = false;
curPlayerTime = 0;
}
if (fireBullet == true)
condition = x % 2;
}
else
{
condition = 1;
}
//if condition == 0 green bullet is fired
if (condition == 0 && bulletSprite.Visible == false && alienType>=1)
{
bulletSprite = new Bullet();
bulletSprite.Load(mContentManager, IMMUNE_BULLET);
}
else if (bulletSprite.Visible == false)
{
bulletSprite = new Bullet();
bulletSprite.Load(mContentManager, NORMAL_BULLET);
}
UpdateBullet(gameTime);
if (state == AlienState.EXPLODED)
{
if (currentTime == 0)
SoundPlayer.soundBank.PlayCue("explosion1");
currentTime += gameTime.ElapsedGameTime.Milliseconds;
explosionSprite.Update(gameTime);
if (currentTime > 1000)
{
state = AlienState.DIE;
currentTime = 0;
}
}
base.Update(gameTime);
}
public void CarryResource()
{
state = AlienState.CARRYING;
ReturnToShip (false);
// Alien is back at SpaceShip, reinit Search
if ((GameObject.transform.position - target).magnitude <= 5f)
ResetTarget ();
}
void BehaviourState()
{
if ((gameLastState != GameState.Paused && gameManagerScript.gameState == GameState.Paused) ||
(gameLastState == GameState.Paused && gameManagerScript.gameState != GameState.Paused))
{
PauseToggle();
}
switch (state)
{
case AlienState.Initiated:
//Transitions
if (initialState == AlienState.Closed)
{
state = AlienState.Closed;
openModel.SetActive(false);
}
if (initialState == AlienState.Open)
{
state = AlienState.Open;
closedModel.SetActive(false);
}
break;
case AlienState.Closed:
closedTick++;
projectileTick++;
if (projectileTick > projectileRate * 50)
{
FireProjectile();
}
//Transitions
if (closedTick > closedTimer * 50)
{
state = AlienState.Open;
closedTick = 0;
}
break;
case AlienState.Open:
openTick++;
//Transitions
if (openTick > openTimer * 50)
{
state = AlienState.Closed;
openTick = 0;
}
if (ballCaptured)
{
GrabBall();
angle = Random.Range(-180, 180);
state = AlienState.BallGrab;
}
break;
case AlienState.BallGrab:
if (angle > 0)
{
transform.Rotate(Vector3.forward, grabSpeed);
}
else
{
transform.Rotate(Vector3.forward, -grabSpeed);
}
//Transitions
if (Mathf.Abs(Mathf.DeltaAngle(angle, transform.rotation.eulerAngles.z)) < 1)
{
state = AlienState.BallRelease;
ReleaseBall();
}
break;
case AlienState.BallRelease:
if (transform.rotation.eulerAngles.z < 180)
{
transform.Rotate(Vector3.forward, -releaseSpeed);
}
else
{
transform.Rotate(Vector3.forward, releaseSpeed);
}
//Transitions
if (Mathf.Abs(Mathf.DeltaAngle(0f, transform.rotation.eulerAngles.z)) < 1)
{
state = AlienState.Open;
}
break;
case AlienState.Hit:
if (ballCaptured)
{
ReleaseBall();
}
Destroy(this.gameObject, deathTimer);
break;
case AlienState.Paused:
if (!paused)
{
state = lastState;
}
break;
}
}
private void OnCollisionEnter2D(Collision2D other)
{
state = AlienState.Hit;
}
public Alien(int health, float speed, int range) : base(health, speed, range){
state = AlienState.SEARCHING;
Infected = false;
}
/// <summary>
/// Calls the Mothership class' SetAlienState method.
/// </summary>
/// <param name="state">The alien state.</param>
public void SetAlienState(AlienState state)
{
mothership.SetAlienState(state);
}
/// <summary>
/// Sets the alien state.
/// </summary>
/// <param name="state">The alien state</param>
public void SetAlienState(AlienState state)
{
this.alienState = state;
}
/// <summary>
/// Calls the Mothership class' SetAlienState method.
/// </summary>
/// <param name="state">The alien state.</param>
public void SetAlienState(AlienState state)
{
alienState = state;
}
public override void Draw(SpriteBatch spriteBatch)
{
int pathIndex;
int spriteX;
int rand;
if (state == AlienState.ALIVE)
{
if (this.SpritePosition.Y >= MAX_Y)
{
pathIndex = this.currentPath;
rand = RandomGenerator.getNextRandomNumber(0, 10);
if (path[rand] == false)
{
int SpriteY;
SpriteY = RandomGenerator.getNextRandomNumber(-200, 20);
path[rand] = true;
spriteX = rand * 80;
this.currentPath = rand;
path[pathIndex] = false;
this.SpritePosition = new Vector2(spriteX, SpriteY);
this.Speed = RandomGenerator.getNextRandomNumber(200, 450);
}
}
if (this.SpritePosition.X >= MAX_X-50)
{
if (alienType == 3)
{
this.Direction = new Vector2(-1, 0);
}
else
{
int x = RandomGenerator.getNextRandomNumber(-200, 200);
this.SpritePosition = new Vector2(x, this.SpritePosition.Y);
}
this.Speed = RandomGenerator.getNextRandomNumber(200, 450);
}
if (alienType == 3 && this.SpritePosition.X < 0)
{
this.Direction = new Vector2(1, 0);
this.Speed = RandomGenerator.getNextRandomNumber(200, 450);
}
base.Draw(spriteBatch);
}
else if (state == AlienState.EXPLODED)
{
explosionSprite.SpritePosition = this.SpritePosition;
explosionSprite.PlayOnlyOnce = true;
explosionSprite.Draw(spriteBatch);
}
else if (state == AlienState.DIE)
{
SpaceGame.playerScore += (10 + ((SpaceGame.gameLevel - 1) * 5));
if (this.alienType == 2)
SpaceGame.playerScore += (25*SpaceGame.gameLevel);
Visible = true;
state = AlienState.ALIVE;
this.SpritePosition = new Vector2(this.SpritePosition.X, 20);
this.SpriteSourceRectangle = new Rectangle(0, 0, 68, 40);
explosionSprite.Reset();
}
bulletSprite.Draw(spriteBatch);
}
public void Explode()
{
Visible = false;
state = AlienState.EXPLODED;
}
// Update is called once per frame
void Update()
{
if (Time.time - lastNoiseTime >= noiseDelay)
{
GetComponent <AudioSource>().Play();
lastNoiseTime = Time.time;
noiseDelay = Random.Range(6f, 20f);
}
//if we're dead don't do anything
if (currentState == AlienState.dead)
{
return;
}
if (roverTransform == null)
{
currentState = AlienState.dead;
return;
}
//if we can see the rover then start chasing
if (Vector3.SqrMagnitude(transform.position - roverTransform.position) <= viewRange * viewRange)
{
if (currentState != AlienState.chasing)
{
currentState = AlienState.chasing;
}
}
else
{
//if we can no longer see the rover then stop chasing
if (currentState == AlienState.chasing)
{
currentState = AlienState.patrolling;
}
}
RaycastHit hit; //this variable is used when checking the surface normal of the ground
switch (currentState)
{
case AlienState.patrolling:
if (hasWaypoint)
{
//if we are close enough to the current waypoint, then generate a new waypoint
if (Vector3.SqrMagnitude(transform.position - currentWaypoint) < patrolWaypointBuffer * patrolWaypointBuffer)
{
hasWaypoint = false;
FindNewWaypoint();
break;
}
directionToMove = (currentWaypoint - transform.position).normalized;
//We want to ensure our move direction is parallel to the surface of the planet
if (Physics.Raycast(transform.position, directionToMove, out hit, 5f, planetLayer))
{
directionToMove = Vector3.ProjectOnPlane(directionToMove, hit.normal);
}
//look where we are going
transform.rotation = Quaternion.LookRotation(directionToMove, Vector3.up);
//this makes sure that we are still aligned with the surface of the planet.
transform.rotation = Quaternion.FromToRotation(transform.up, (transform.position - planet.transform.position).normalized) * transform.rotation;
}
break;
case AlienState.chasing:
//if we are within attack range, then attack the rover
if (Vector3.SqrMagnitude(transform.position - roverTransform.position) <= attackRange * attackRange)
{
//delay the attacks to make it fair for the player
if (Time.time - GameManager.instance.worldStartTime - lastAttackTime >= attackDelay)
{
PlayerManager.instance.TakeDamage(attackDamage);
lastAttackTime = Time.time - GameManager.instance.worldStartTime;
}
}
directionToMove = (roverTransform.position - transform.position).normalized;
//We want to ensure our move direction is parallel to the surface of the planet
if (Physics.Raycast(transform.position, directionToMove, out hit, 5f, planetLayer))
{
directionToMove = Vector3.ProjectOnPlane(directionToMove, hit.normal);
}
//look where we are going
transform.rotation = Quaternion.LookRotation(directionToMove, Vector3.up);
//this makes sure that we are still aligned with the surface of the planet.
transform.rotation = Quaternion.FromToRotation(transform.up, (transform.position - planet.transform.position).normalized) * transform.rotation;
break;
}
}
/// <summary>
/// Calls the Alien class' SetAlienState method.
/// </summary>
/// <param name="state">The alien state.</param>
public void SetAlienState(AlienState state)
{
alien.SetAlienState(state);
}
