/// <summary> /// Update this instance. Called once per frame. /// </summary> public void Update() { if (!this.IsActiveOnGrid()) { return; } var myself = this; if (this.Genome.DNA.Execute(ref myself) == 0) { // If no action taken, kill ent this.TakeDamage(this.HealthValue); } else { this.TakeDamage(StaticController.GlobalEnviornmentDamagePerTurn); } if (!StaticController.GlobalForceFlat) { float healthPercent = GameObjectGrid.GetHealthInRegion(GameObjectGrid.WorldToGridPosition(this.transform.position), StaticController.GlobalHeightBlendDistance) / (float)StaticController.GlobalMaxInt; float yScale = healthPercent * StaticController.GlobalMaxHeight; this.transform.localScale = new Vector3( this.transform.localScale.x, yScale, this.transform.localScale.z); } }
public Bolt(int scale, GameObject wielder, GameObject target, float damage, GameObjectGrid grid) : base("spr_Bolt", scale, wielder, target, damage, 6) { //Grid is needed for wall collision this.grid = grid; Reset(); cooldown = 0; }
private bool TryAttack(GeneticGridDirection direction) { GridPosition myPosition = GameObjectGrid.WorldToGridPosition(this.transform.position); GridPosition victimPosition = myPosition.GetPositionInDirection(direction.Value); if (!GameObjectGrid.PositionIsAlive(victimPosition)) { return(false); } GameObject victim = GameObjectGrid.GetObjectAt(victimPosition); EntBehaviorManager victimManager = victim.GetComponent <EntBehaviorManager>(); int damage = (this.AttackStrength.Value * this.Health.Value) / InitialHealth; victimManager.TakeDamage(damage); // Will succeed if we killed the victim if (this.TryMove(direction)) { this.TryAddHealth(victimManager.GrowFoodStrength.Value); } if (this.AttackStrength.Value < StaticController.GlobalMaxInt) { ++this.AttackStrength.Value; } if (this.GrowFoodStrength.Value > 1) { --this.GrowFoodStrength.Value; } return(true); }
/// <summary> /// Returns a string that represents the current object. /// </summary> /// <returns>A string that represents the current object.</returns> /// <filterpriority>2</filterpriority> public override string ToString() { return(string.Format( "[Ent: TeamName={0} {1}]", this.TeamName, GameObjectGrid.WorldToGridPosition(this.transform.position))); }
/// <summary> /// Collision checker for the Penguin /// </summary> public void CheckCollision() { //Take the grid to check for all tiles that are solid or doors, and player list for collision with players GameObjectGrid field = GameWorld.Find("TileField") as GameObjectGrid; GameObjectList players = GameWorld.Find("playerLIST") as GameObjectList; Rectangle tileBoundingBox = new Rectangle((int)this.BoundingBox.X, (int)(this.BoundingBox.Y + 0.75 * Height), this.Width, (int)(this.Height / 4)); //First check if monster collides with player foreach (Character player in players.Children) { if (this.BoundingBox.Intersects(player.BoundingBox) && !playersHit.Contains(player)) { AttackHit(player); } } //Then check if monster collides with solid tile foreach (Tile tile in field.Objects) { if (tile.IsSolid && tileBoundingBox.Intersects(tile.BoundingBox)) { movementVector = new Vector2(0, 0); Position = previousPos; idleCounter = 3; // TargetRandomObject (currently removed but might add back later, but as a local method? } } }
/// <summary> /// Update each GameObject in the GameObjectGrid /// </summary> /// <param name="gameTime">The object used for reacting to timechanges</param> public override void Update(GameTime gameTime) { foreach (GameObject obj in gameObjects) { if (obj is GameObjectGrid) { GameObjectGrid gameObjectGrid = obj as GameObjectGrid; foreach (GameObject gameObject in gameObjectGrid.Objects) { if (gameObject != null) { gameObject.Update(gameTime); if (gameObject is ExitTile) { ExitTile exitTile = gameObject as ExitTile; if (exitTile.isOnTile) { isOnExit = true; } } } } } else { obj.Update(gameTime); } } exitText.Position = new Vector2((GameEnvironment.Screen.X - 300) / 2, 0); noteText.Position = new Vector2((GameEnvironment.Screen.X - 300) / 2, 30); roomCounter.Position = new Vector2(GameEnvironment.Screen.X - 60, 10); }
void Awake() { if (Instance != null && Instance != this) { Destroy(gameObject); } else { Instance = this; rowDeletionOffsetVector = new Vector3Int(WallsTilemap.cellBounds.xMin, WallsTilemap.cellBounds.yMax - rowDeletionOffset, 0); rowCreationOffsetVector = new Vector3Int(WallsTilemap.cellBounds.xMin, WallsTilemap.cellBounds.yMin - rowCreationOffset, 0); tileMapsToClear = new Tilemap[] { WallsTilemap, UpBlockersTilemap, DownBlockersTilemap, DotsTilemap, HorizontalPortalsTilemap, GhostSlowersTilemap }; int numRows = WallsTilemap.cellBounds.yMax - WallsTilemap.cellBounds.yMin; int numCols = WallsTilemap.cellBounds.xMax - WallsTilemap.cellBounds.xMin; ObjectGrid = new GameObjectGrid(numRows, numCols); ObjectGrid.AddGameObject(2, 1, GameObject.Find("power_pill_tl")); ObjectGrid.AddGameObject(2, 19, GameObject.Find("power_pill_tr")); ObjectGrid.AddGameObject(18, 1, GameObject.Find("power_pill_bl")); ObjectGrid.AddGameObject(18, 19, GameObject.Find("power_pill_br")); } }
private bool TryMove(GeneticGridDirection direction) { return(GameObjectGrid.TryMoveObject( this.TeamName, TeamManager.GetTeamColor(this.TeamName), GameObjectGrid.WorldToGridPosition(this.transform.position), direction.Value)); }
private byte TryMove(byte direction) { return(GameObjectGrid.TryMoveObject( this.TeamName, TeamManager.GetTeamColor(this.TeamName), GameObjectGrid.WorldToGridPosition(this.transform.position), direction)); }
// This is the base attack method of the weapon,, which will be also defined as an ability public virtual void Attack(GameObjectList monsterList, GameObjectGrid field) { monsterObjectList = monsterList; fieldList = field; BasicAttack.Use(); idAnimation = idBaseAA; AnimationAttackCheck(); }
public override void AttackHit(Monster monster, GameObjectGrid field) { fieldGrid = field; if (!MonsterHit.Contains(monster) && monster.Attributes.HP > 0 && MonsterHit.Count == 0) { monster.TakeDamage(DamageAA); MonsterAdd(monster, Owner.Mirror); } }
//Method that opens all the affected objects public void ActivateCorrObject(string action) { //Checks which objects has the same objectnumber as this handlenumber and opens or closes the corresponding objects. //give "open" to open the corresponding object. Give "close" to close the corresponding object. GameObjectGrid tileField = GameWorld.Find("TileField") as GameObjectGrid; GameObjectList objects = GameWorld.Find("objectLIST") as GameObjectList; foreach (var openableObject in tileField.Objects) { if (openableObject is OpenableObject) { if (this.ObjectNumberConnected == 99) { ((OpenableObject)openableObject).Open(); continue; } if (((OpenableObject)openableObject).Objectnumber == handlenumber) { if (action == "open") { ((OpenableObject)openableObject).Open(); } if (action == "close") { ((OpenableObject)openableObject).Close(); } } } } foreach (var openableObject in objects.Children) { if (openableObject is OpenableObject) { if (this.ObjectNumberConnected == 99) { ((OpenableObject)openableObject).Open(); continue; } if (((OpenableObject)openableObject).Objectnumber == handlenumber) { if (action == "open") { ((OpenableObject)openableObject).Open(); } if (action == "close") { ((OpenableObject)openableObject).Close(); } } } } }
protected void StopMoving() { GameObjectGrid tileField = GameWorld.Find("tileField") as GameObjectGrid; Velocity = Vector2.Normalize(Velocity); Vector2 oldBlock = new Vector2(GetCurrentBlock().X, GetCurrentBlock().Y) - Velocity; Position = oldBlock * new Vector2(tileField.CellWidth, tileField.CellHeight); Velocity = Vector2.Zero; }
/// <summary> /// Takes the damage. /// </summary> /// <param name="amount">Amount.</param> public void TakeDamage(byte amount) { if (amount >= this.Health) { GameObjectGrid.KillObject(this.gameObject); } else { this.Health = (byte)(this.Health - amount); } }
/// <summary> /// Method that defines what happens when a monster gets hit /// </summary> /// <param name="monster">The affected monster</param> /// <param name="field">The tileField of the level</param> public virtual void AttackHit(Monster monster, GameObjectGrid field) { fieldGrid = field; //Only affects the monster if it has not been affected by the ability already if (!MonsterHit.Contains(monster) && monster.Attributes.HP > 0) { monster.TakeDamage(DamageAA); MonsterAdd(monster, Owner.Mirror); } }
// Uses the main ability public virtual void UseMainAbility(GameObjectList monsterList, GameObjectGrid field) { if (!mainAbility.IsOnCooldown) { mainAbility.Use(); idAnimation = idMainAbility; monsterObjectList = monsterList; fieldList = field; AnimationMainCheck(); } }
private byte TryReproduce(byte direction) { GridPosition myPosition = GameObjectGrid.WorldToGridPosition(this.transform.position); GridPosition childPosition = myPosition.GetPositionInDirection(direction); return(GameObjectGrid.TryReviveObjectAt( this.TeamName, TeamManager.GetTeamColor(this.TeamName), childPosition, false)); }
private GeneticBool DirectionIsOccupied(GeneticGridDirection direction) { GridPosition currentPosition = GameObjectGrid.WorldToGridPosition(this.transform.position); GridPosition testPosition = currentPosition.GetPositionInDirection(direction.Value); if (GameObjectGrid.PositionIsAlive(testPosition)) { return(GeneticBool.True); } return(GeneticBool.False); }
/// <summary> /// Tries the create and place new ent. /// </summary> /// <returns><c>true</c>, if create and place new ent was tryed, <c>false</c> otherwise.</returns> /// <param name="template">Template.</param> /// <param name="position">Position.</param> /// <param name="teamName">Team name.</param> /// <param name="forcePlace">If set to <c>true</c> force place.</param> public static bool TryCreateAndPlaceNewEnt( Color color, GridPosition position, string teamName, bool forcePlace) { if (!GameObjectGrid.TryReviveObjectAt(teamName, color, position, forcePlace)) { return(false); } return(true); }
/// <summary> /// Tries the create and place new ent. /// </summary> /// <returns><c>true</c>, if create and place new ent was tryed, <c>false</c> otherwise.</returns> /// <param name="template">Template.</param> /// <param name="position">Position.</param> /// <param name="teamName">Team name.</param> /// <param name="forcePlace">If set to <c>true</c> force place.</param> public static byte TryCreateAndPlaceNewEnt( Color color, GridPosition position, string teamName, bool forcePlace) { if (GameObjectGrid.TryReviveObjectAt(teamName, color, position, forcePlace) == 0) { return(0); } return(1); }
public SpriteGameObject FindSharkAtPosition(Point p) { GameObjectGrid tileField = GameWorld.Find("tileField") as GameObjectGrid; Vector2 finalPosition = new Vector2(p.X * tileField.CellWidth, p.Y * tileField.CellHeight); foreach (SpriteGameObject s in sharks) { if (s.Position == finalPosition) { return(s); } } return(null); }
private byte DirectionIsOccupied(byte direction) { GridPosition currentPosition = GameObjectGrid.WorldToGridPosition(this.transform.position); GridPosition testPosition = currentPosition.GetPositionInDirection(direction); if (GameObjectGrid.PositionIsAlive(testPosition)) { return(1); } else { return(0); } }
/// <summary> /// Checks whether a character collides with a tile /// </summary> /// <returns>whether the position the character is going is valid</returns> private bool SolidCollisionChecker() { GameObjectGrid Field = GameWorld.Find("TileField") as GameObjectGrid; // Define a quarter bounding box (the feet plus part of the legs) for isometric collision Rectangle quarterBoundingBox = new Rectangle((int)this.BoundingBox.X, (int)(this.BoundingBox.Y + 0.75 * Height), this.Width, (int)(this.Height / 4)); foreach (Tile tile in Field.Objects) { if (tile.IsSolid && quarterBoundingBox.Intersects(tile.BoundingBox)) { return(false); } } return(true); }
public void openUnlockedDoor(Door openDoor) { GameObjectGrid tileField = GameWorld.Find("TileField") as GameObjectGrid; foreach (var door in tileField.Objects) { if (door is Door) { if (((Door)door).Objectnumber == openDoor.Objectnumber && openDoor.DoorOpen) { ((Door)door).DoorOpen = true; } } } }
public Statsscreenbox(GameObjectGrid itemGrid2, int layer = 0, string id = "", float cameraSensitivity = 0) : base(layer, id) { itemGrid2.CellHeight = Tile.TileHeight; itemGrid2.CellWidth = Tile.TileWidth; for (int x = 0; x < itemGrid2.Columns; x++) { for (int y = 0; y < itemGrid2.Rows; y++) { ItemGrid2.Add(new ItemSlot(), x, y); } } Add(itemGrid2); }
public Point GetCurrentBlock() { GameObjectGrid tileField = GameWorld.Find("tileField") as GameObjectGrid; Point p = new Point((int)Math.Floor(Position.X / tileField.CellWidth), (int)Math.Floor(Position.Y / tileField.CellHeight)); if (Velocity.X > 0) { p.X++; } if (Velocity.Y > 0) { p.Y++; } return(p); }
public GameObjectGridState() { GOGrid = new GameObjectGrid(5, 5, 0); Add(GOGrid); GOGrid.CellHeight = 50; GOGrid.CellWidth = 50; for (int i = 0; i < GOGrid.Rows; i++) { for (int x = 0; x < GOGrid.Columns; x++) { GOGrid.Add(new SpriteGameObject("spr_player"), i, x); } } DH = new DrawingHelper(); }
/// <summary> /// Checker that checks whether a character is on ice /// </summary> public bool IsOnIceChecker() { GameObjectGrid Field = GameWorld.Find("TileField") as GameObjectGrid; // Bounding box for only the feet Rectangle feetBoundingBox = new Rectangle((int)(this.BoundingBox.X + 0.33 * Width), (int)(this.BoundingBox.Y + 0.9 * Height), (int)(this.Width / 3), (Height / 10)); foreach (Tile tile in Field.Objects) { if (tile.Type == TileType.Ice && tile.BoundingBox.Intersects(feetBoundingBox)) { return(true); } } blockinput = false; return(false); }
void FixedUpdate() { bool forceEarlyRefresh = GameObjectGrid.EveryoneIsDead() || GameObjectGrid.GridIsMonoChromatic(); if (frameCounter >= this.FramesPerIteration || forceEarlyRefresh) { lock (CommonHelperMethods.GlobalStateLock) { // Everyone wins GenePoolManager.RefreshTeamDNA(); } this.frameCounter = 0; } }
/// <summary> /// Draws the GameObjects of the list /// </summary> /// <param name="gameTime">The object used for reacting to timechanges</param> /// <param name="spriteBatch">The SpriteBatch</param> public override void Draw(GameTime gameTime, SpriteBatch spriteBatch) { foreach (GameObject gameObject in gameObjects) { if (gameObject is Object3D) { Object3D gameObject3D = gameObject as Object3D; if (gameObject3D.Model != null) { gameObject3D.DrawCamera(player); gameObject3D.Draw(gameTime, spriteBatch); } } else if (gameObject is GameObjectGrid) { GameObjectGrid gameObjectGrid = gameObject as GameObjectGrid; foreach (GameObject obj in gameObjectGrid.Objects) { if (obj is Object3D) { Object3D gameObject3D = obj as Object3D; if (gameObject3D.Model != null) { gameObject3D.DrawCamera(player); gameObject3D.Draw(gameTime, spriteBatch); } } } } else { gameObject.Draw(gameTime, spriteBatch); } } if (isOnExit && !NoteInVicinity) { exitText.Draw(gameTime, spriteBatch); isOnExit = false; } else if (NoteInVicinity) { noteText.Draw(gameTime, spriteBatch); } }
private void DrawEndless(int part,GameTime gameTime, SpriteBatch spriteBatch) { level = new Level(); level.player = new Player(new Vector3(200, 200f, 200)); GameObjectGrid grid = new GameObjectGrid(20,20,"grid"); for (int i = 0; i < grid.Rows; i++) { grid.Add(new WallTile("01"), 0, i); grid.Add(new WallTile("01"), 2, i); grid.Add(new PathTile("01"), 1, i); } for (int x = 0; x < grid.Objects.GetLength(0); x++) { for (int y = 0; y < grid.Objects.GetLength(1); y++) { if (grid.Objects[x, y] != null) { grid.Objects[x, y].Position -= new Vector3(0, 0, GameObjectGrid.CellWidth * part / 60); if (grid.Objects[x, y] is WallTile) { grid.Objects[x, y].Position += new Vector3(0, 200, 0); } } } } level.Add(grid); level.Parent = this; foreach (GameObject obj in level.Objects) { obj.Parent = level; } }