public static int SimplifiedPenguinsToSend(this Iceberg berg, Iceberg sender) { List <PenguinGroup> groups = (from PenguinGroup a in game.GetAllPenguinGroups() where a.Destination == berg select a).ToList(); groups.Sort((x, y) => { return(x.TurnsTillArrival - y.TurnsTillArrival); }); int BergSign = berg.BergSign(); int CurrentTurn = 0; int PenguinAmount = berg.PenguinAmount * BergSign; foreach (PenguinGroup penguins in groups) { int amount = penguins.GroupAmountAfterClash(); PenguinAmount += berg.PenguinsPerTurn * (penguins.TurnsTillArrival - CurrentTurn) * BergSign; PenguinAmount += amount * penguins.GroupSign(); BergSign = System.Math.Sign(PenguinAmount); CurrentTurn = penguins.TurnsTillArrival; } if (CurrentTurn < sender.GetTurnsTillArrival(berg)) { PenguinAmount += berg.PenguinsPerTurn * (sender.GetTurnsTillArrival(berg) - CurrentTurn) * BergSign; } if (BergSign == sender.BergSign()) { return(0); } return(PenguinAmount * sender.BergSign() * -1); }
public static int PredictIcebergStateAfterAll(this Iceberg berg) { List <PenguinGroup> groups = (from PenguinGroup a in game.GetAllPenguinGroups() where a.Destination == berg select a).ToList(); groups.Sort((x, y) => { return(x.TurnsTillArrival - y.TurnsTillArrival); }); int BergSign = berg.BergSign(); int CurrentTurn = 0; int PenguinAmount = berg.PenguinAmount * BergSign; foreach (PenguinGroup penguins in groups) { int amount = penguins.GroupAmountAfterClash(); PenguinAmount += berg.PenguinsPerTurn * (penguins.TurnsTillArrival - CurrentTurn) * BergSign; PenguinAmount += amount * penguins.GroupSign(); BergSign = System.Math.Sign(PenguinAmount); CurrentTurn = penguins.TurnsTillArrival; } return(PenguinAmount); }
public static Iceberg SecondBest(this Iceberg[] bergs) { Iceberg a = bergs.Best(); Iceberg[] temp = (from Iceberg item in bergs where item != a select item).ToArray(); return(temp.Best()); }
public void ShowPropClones() { if (!m_propsCloned) { PropAbstractBehaviour[] props = GameObject.FindObjectsOfType(typeof(PropAbstractBehaviour)) as PropAbstractBehaviour[]; foreach (PropAbstractBehaviour prop in props) { Transform BoundingBox = prop.transform.FindChild("BoundingBoxCollider"); BoxCollider collider = BoundingBox.GetComponent <BoxCollider>(); collider.isTrigger = false; prop.SetAutomaticUpdatesDisabled(true); Renderer propRenderer = prop.GetComponent <MeshRenderer>(); if (propRenderer != null) { Destroy(propRenderer); } Iceberg effect = Instantiate(IcePrefab) as Iceberg; effect.name = "Ice"; effect.transform.parent = BoundingBox; effect.transform.localPosition = new Vector3(0f, 0.032f, 0f); effect.transform.localScale = new Vector3(100, 50, 100); effect.transform.localRotation = Quaternion.identity; } m_propsCloned = true; } }
private void Kill() { if (kraken != null) { kraken.SignalHurt(2f); kraken.ApplyDamage(kraken.TentacleDeathDamage); deathTimer = kraken.RegularTentacleTime; } else { if (throwEngaged && instantiatedIceberg != null) { Iceberg iceberg = instantiatedIceberg.GetComponent <Iceberg>() as Iceberg; iceberg.ApplyDamage(iceberg.HealthPoints); } deathTimer = 0f; } initialPosition = transform.position; destinationPosition = initialPosition - Vector3.up * 80f; Dead = true; deathCounter++; animationTimer = 0f; tentaculeAnim.speed = animationSpeedMod; StartHurtAnimation(); StopHolding(); deathAnimPlaying = true; }
public static int BergSign(this Iceberg a) { if (a.Owner.Equals(game.GetEnemy())) { return(-1); } if (a.Owner.Equals(game.GetNeutral())) { return(0); } return(1); }
public static void DoSimpleStrategy(this Game game) { try { Iceberg[] MyBergs = game.GetMyIcebergs(); Iceberg[] EnemyBergs = game.GetEnemyIcebergs(); Iceberg MyBest = MyBergs.Best(); Iceberg EnemyWorst = EnemyBergs.Worst(); Iceberg[] NeutralBergs = game.GetNeutralIcebergs(); if (NeutralBergs.Length == 0 && !MyBest.CanAttack(EnemyWorst)) { if (MyBergs.SumPenguins() > EnemyWorst.PenguinAmount * 1.3) { foreach (Iceberg i in MyBergs) { i.SendPenguins(EnemyWorst, (int)(i.PenguinAmount / 1.2)); } } } if (MyBergs.Length > 1) { Iceberg MySecondBest = MyBergs.SecondBest(); if (MySecondBest.CanAttack(EnemyWorst)) { MySecondBest.SendPenguins(EnemyWorst, MySecondBest.PenguinsToSendto(EnemyWorst)); } } if (MyBest.CanUpgrade() && !MyBest.AlreadyActed) { MyBest.Upgrade(); } if (MyBest.CanAttack(EnemyWorst)) { MyBest.SendPenguins(EnemyWorst, MyBest.PenguinsToSendto(EnemyWorst)); } else { if (NeutralBergs.Length > 0) { Iceberg NeutralWorst = NeutralBergs.Worst(); if (NeutralWorst.PenguinAmount < MyBest.PenguinAmount && !MyBest.AlreadyActed) { MyBest.SendPenguins(NeutralWorst, NeutralWorst.PenguinAmount + 1); } } } } catch (System.Exception e) { System.Console.WriteLine(e); } }
/*public static int IcebergEndangermentLevel(this Iceberg berg,bool ByEnemy) * { * Player attacker; * if (ByEnemy) * { * attacker = game.GetEnemy(); * } * else * { * attacker = game.GetMyself(); * } * List<Iceberg> EnemyAndMyself = game.GetEnemyIcebergs().Concat(game.GetMyIcebergs()).ToList(); * EnemyAndMyself = * (from Iceberg i in EnemyAndMyself * where !i.Equals(berg) * orderby i.GetTurnsTillArrival(berg) * select i).ToList(); * int endangerment = 0; * foreach(Iceberg i in EnemyAndMyself) * { * * } * }*/ public static double Eval(this Iceberg berg, Player PrespectivePlayer) { Iceberg[] bergs = (from Iceberg i in PrespectivePlayer.Icebergs where !i.Equals(berg) select i).ToArray(); int[] penguinsToSend = (from Iceberg i in bergs let send = berg.SimplifiedPenguinsToSend(i) where send < i.PenguinAmount select send).ToArray(); if (penguinsToSend.Length == 0) { return(int.MaxValue); } int min = penguinsToSend.Min(); return((double)min / berg.PenguinsPerTurn); }
public void OnTriggerEnter(Collider col) { if (!Network.isClient) { if (col.tag == "ThrowingIceberg" && col.rigidbody != null) { icebergHitSource.Play(); this.rigidbody.AddForce(col.rigidbody.velocity / 4.0f); Iceberg iceberg = col.GetComponent <Iceberg>(); if (iceberg != null) { iceberg.ApplyDamage(1); col.tag = "Untagged"; } ApplyDamage(this.Health); } else if (col.tag == "EndOfLevel") { ScreenFader.Instance.SceneEnding = true; Network.RemoveRPCsInGroup(0); Network.RemoveRPCsInGroup(1); Utils.NetworkCommand(GlobalScript.Instance, "LoadKrakenLevel"); } else if (col.tag == "Checkpoint1") { GlobalScript.CheckpointToLoad = 2; } else if (col.tag == "Checkpoint2") { GlobalScript.CheckpointToLoad = 3; } else if (col.tag == "Checkpoint3") { GlobalScript.CheckpointToLoad = 4; } } }
private void MeltIcebergs(IList<Iceberg> icebergsToMelt) { Iceberg meltedIceberg = new Iceberg(); if (icebergsToMelt.Count > 1) { foreach (Iceberg iceberg in icebergsToMelt) { foreach (Vector3 iceVector in iceberg.Ice()) { meltedIceberg.AddIceVector(iceVector); } } _icebergOnBoard.RemoveAll(item => icebergsToMelt.Contains(item)); GameManager.instance.remainingIceberg.RemoveAll(item => icebergsToMelt.Contains(item)); _icebergOnBoard.Add(meltedIceberg); GameManager.instance.remainingIceberg.Add(meltedIceberg); } }
private void calculateIcebergs() { foreach( Vector3 iceVector in icePositions) { IList<Iceberg> adjacents = new List<Iceberg>(); foreach( Iceberg iceberg in _icebergOnBoard ) { if (iceberg.LookUpAdjdacents(iceVector)) { adjacents.Add(iceberg); } } if (adjacents.Count>1) { MeltIcebergs(adjacents); } else if (adjacents.Count == 1) { Iceberg iceberg = adjacents[0]; iceberg.AddIceVector(iceVector); } else{ Iceberg newIceberg = new Iceberg(); newIceberg.AddIceVector(iceVector); _icebergOnBoard.Add(newIceberg); GameManager.instance.remainingIceberg.Add(newIceberg); } } }
public static bool CanAttackSimplified(this Iceberg From, Iceberg To) { int amount = To.SimplifiedPenguinsToSend(From); return(From.PenguinAmount > amount + 1); }
public static bool CanAttack(this Iceberg a, Iceberg b) { return(a.PenguinsToSendto(b) < a.PenguinAmount && !a.AlreadyActed); }
public static int PenguinsToSendto(this Iceberg from, Iceberg to) { return(to.PenguinsInNTurns(from.GetTurnsTillArrival(to)) + 1); }
public static int PenguinsInNTurns(this Iceberg berg, int turn) { return(berg.PenguinAmount + berg.PenguinsPerTurn * turn); }
public IcebergAI(Iceberg i) : base(i) { iceberg = i; }