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;
}
