SHARE
TWEET

Untitled

a guest Feb 27th, 2020 74 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using PenguinGame;
  2. using System.Linq;
  3.  
  4. namespace MyBot
  5. {
  6.     public class ScriptOS : ISkillzBot
  7.     {
  8.         public static Game game;
  9.         public static int LongestTrip;
  10.         public static PenguinGroup[] groups;
  11.         public void Upgrade()
  12.         {
  13.             foreach (Iceberg iceberg in game.GetMyIcebergs())
  14.             {
  15.                 //Goes on all our icebergs
  16.                 if (iceberg.Level != iceberg.UpgradeLevelLimit)
  17.                 {
  18.                     if (CanUpgrade(iceberg) && iceberg.CanUpgrade())
  19.                     {
  20.                         iceberg.Upgrade();
  21.                     }
  22.                     else
  23.                     {
  24.                         if (!CanUpgrade(iceberg))
  25.                         {
  26.                             GetClosestBattleFront(iceberg).SendPenguins(iceberg, iceberg.UpgradeCost - GetFuturePenguinAmount(iceberg, GetClosestBattleFront(iceberg).GetTurnsTillArrival(iceberg)));
  27.                         }
  28.                     }
  29.                 }
  30.  
  31.             }
  32.         }
  33.         public void SortPenguinGroups(PenguinGroup[] groups)
  34.         {
  35.             PenguinGroup temp;
  36.             for (int i = 0; i < groups.Length - 1; i++)
  37.             {
  38.                 for (int j = i + 1; j < groups.Length; j++)
  39.                 {
  40.                     if (groups[i].TurnsTillArrival > groups[j].TurnsTillArrival)
  41.                     {
  42.                         temp = groups[j];
  43.                         groups[j] = groups[i];
  44.                         groups[i] = temp;
  45.                     }
  46.                 }
  47.             }
  48.         }
  49.         public int GetFuturePenguinAmount(Iceberg source, int turns)
  50.         {
  51.             int penguinAmount = source.PenguinAmount;
  52.             int currTurn = 0;
  53.             int alive = 1;
  54.             foreach (var group in groups)
  55.             {
  56.                 if (group.Destination == source)
  57.                 {
  58.                     penguinAmount += (group.TurnsTillArrival - currTurn) * (source.PenguinsPerTurn * alive);
  59.                     if (group.Owner == source.Owner)
  60.                     {
  61.                         penguinAmount += group.PenguinAmount;
  62.                     }
  63.                     else
  64.                     {
  65.                         penguinAmount -= group.PenguinAmount;
  66.                     }
  67.                     //ok
  68.                     if (penguinAmount < 0)
  69.                     {
  70.                         alive = -1;
  71.                     }
  72.                     else
  73.                     {
  74.                         alive = 1;
  75.                     }
  76.                     //ok
  77.                     currTurn = group.TurnsTillArrival;
  78.                 }
  79.             }
  80.             return penguinAmount + (turns - currTurn) * (source.PenguinsPerTurn * alive);
  81.             //seems ok
  82.         }
  83.         public int GetFuturePenguinAmount(Iceberg source, int turns, int decreaseAmount)
  84.         {
  85.             int penguinAmount = source.PenguinAmount - decreaseAmount;
  86.             int currTurn = 0;
  87.             int alive = 1;
  88.             foreach (var group in groups)
  89.             {
  90.                 if (group.Destination == source)
  91.                 {
  92.                     penguinAmount += (group.TurnsTillArrival - currTurn) * (source.PenguinsPerTurn * alive);
  93.                     if (group.Owner == source.Owner)
  94.                     {
  95.                         penguinAmount += group.PenguinAmount;
  96.                     }
  97.                     else
  98.                     {
  99.                         penguinAmount -= group.PenguinAmount;
  100.                     }
  101.                     //ok
  102.                     if (penguinAmount < 0)
  103.                     {
  104.                         alive = -1;
  105.                     }
  106.                     else
  107.                     {
  108.                         alive = 1;
  109.                     }
  110.                     //ok
  111.                     currTurn = group.TurnsTillArrival;
  112.                 }
  113.             }
  114.             return penguinAmount + (turns - currTurn) * (source.PenguinsPerTurn * alive);
  115.         }
  116.         public int GetUpgradedFuturePenguinAmount(Iceberg source, int turns)
  117.         {
  118.             int penguinAmount = source.PenguinAmount - source.UpgradeCost;
  119.             int currTurn = 0;
  120.             int alive = 1;
  121.             foreach (var group in groups)
  122.             {
  123.                 if (group.Destination == source)
  124.                 {
  125.                     penguinAmount += (group.TurnsTillArrival - currTurn) * (source.PenguinsPerTurn + 1) * alive;
  126.                     if (group.Owner == source.Owner)
  127.                     {
  128.                         penguinAmount += group.PenguinAmount;
  129.                     }
  130.                     else
  131.                     {
  132.                         penguinAmount -= group.PenguinAmount;
  133.                     }
  134.                     if (penguinAmount < 0)
  135.                     {
  136.                         alive = -1;
  137.                     }
  138.                     else
  139.                     {
  140.                         alive = 1;
  141.                     }
  142.                     currTurn = group.TurnsTillArrival;
  143.                 }
  144.             }
  145.             return penguinAmount += (turns - currTurn) * (source.PenguinsPerTurn + 1) * alive;
  146.         }
  147.         public void ReinforceBattlefronts()
  148.         {
  149.             if (GetNonBattleFronts() != null)
  150.             {
  151.                 foreach (var iceberg in GetNonBattleFronts())
  152.                 {
  153.                     if (CanSendSafely(iceberg, iceberg.PenguinAmount))
  154.                     {
  155.                         iceberg.SendPenguins(GetClosestBattleFront(iceberg));
  156.                     }
  157.                 }
  158.             }
  159.         }
  160.         public void Attack()
  161.         {
  162.             Player[] exclude = {game.GetMyself()};
  163.             Iceberg[] battleFronts = GetBattleFronts();
  164.             if (battleFronts.Length > 0)
  165.             {
  166.                 foreach (var battleFront in battleFronts)
  167.                 {
  168.                     if (CanSendSafely(battleFront, GetSendAmount(GetClosest(battleFront, exclude), battleFront)))
  169.                     {
  170.                         battleFront.SendPenguins(GetClosest(battleFront, exclude), GetSendAmount(GetClosest(battleFront, exclude), battleFront));
  171.                     }
  172.                 }
  173.             }
  174.         }
  175.         public bool CanSendSafely(Iceberg sender, int sendAmount)
  176.         {
  177.             return NumOfAttackers(game.GetEnemyPenguinGroups(), sender) == 0;
  178.             //to be changed
  179.         }
  180.         public int NumOfAttackers(PenguinGroup[] attackingGroups, Iceberg target)
  181.         {
  182.             int enemyTotal = 0;
  183.             for (int i = 0; i < attackingGroups.Length; i++)
  184.             {
  185.                 if (attackingGroups[i].Destination == target)
  186.                 {
  187.                     enemyTotal += attackingGroups[i].PenguinAmount;
  188.                 }
  189.             }
  190.             return enemyTotal;
  191.         }
  192.         public Iceberg GetClosest(Iceberg target, Player[] exclude)
  193.         {
  194.             int sDistance = int.MaxValue;
  195.             Iceberg closest = null;
  196.             foreach (var ice in game.GetAllIcebergs())
  197.             {
  198.                 if (!exclude.Contains(ice.Owner) && ice != target)
  199.                 {
  200.                     if (target.GetTurnsTillArrival(ice) < sDistance)
  201.                     {
  202.                         sDistance = target.GetTurnsTillArrival(ice);
  203.                         closest = ice;
  204.                     }
  205.                 }
  206.             }
  207.             return closest;
  208.         }
  209.         public bool HelperAttackOnTitan(Iceberg helper)
  210.         {
  211.             foreach (var enemy in game.GetEnemyPenguinGroups())
  212.             {
  213.                 if (enemy.Destination == helper)
  214.                     return true;
  215.             }
  216.             return false;
  217.         }
  218.         public PenguinGroup GetClosestP(PenguinGroup[] all, Iceberg target)
  219.         {
  220.             int sDistance = int.MaxValue;
  221.             PenguinGroup close = null;
  222.             foreach (var enemy in all)
  223.             {
  224.                 if (enemy.Destination == target)
  225.                 {
  226.                     if (enemy.TurnsTillArrival < sDistance)
  227.                     {
  228.                         sDistance = enemy.TurnsTillArrival;
  229.                         close = enemy;
  230.                     }
  231.                 }
  232.             }
  233.             return close;
  234.         }
  235.         public bool Winning()
  236.         {
  237.             if (game.GetNeutral().Icebergs != null)
  238.             {
  239.                 return game.GetMyIcebergs().Length > game.GetEnemyIcebergs().Length + game.GetNeutralIcebergs().Length;
  240.             }
  241.             return game.GetMyIcebergs().Length > game.GetEnemyIcebergs().Length;
  242.         }
  243.         public void Defend()
  244.         {   //enter term- the method gets the game
  245.             // exit term- the method checks if you can protect the attacked islands if he doesnt have enough to protect himself and sends reinforcemnents from the closest ally
  246.             Player[] exclude = { game.GetEnemy(), game.GetNeutral() };
  247.             foreach (var eGroup in game.GetEnemyPenguinGroups())
  248.             {
  249.                 Iceberg helper = GetClosest(eGroup.Destination, exclude);// get closest ally island
  250.                 if (eGroup.Destination.PenguinAmount + eGroup.Destination.Level * GetClosestP(game.GetEnemyPenguinGroups(), eGroup.Destination).TurnsTillArrival < NumOfAttackers(game.GetEnemyPenguinGroups(), eGroup.Destination)) // cant defend by himself
  251.                 {
  252.                     if ((helper.PenguinAmount - NumOfAttackers(game.GetEnemyPenguinGroups(), helper) - (eGroup.PenguinAmount - eGroup.Destination.PenguinAmount + eGroup.Destination.Level * eGroup.TurnsTillArrival) + NumOfAttackers(game.GetMyPenguinGroups(), helper) > 0)) // can send without abndoned your island
  253.                     {
  254.                         helper.SendPenguins(eGroup.Destination, eGroup.PenguinAmount - eGroup.Destination.PenguinAmount + eGroup.Destination.Level * eGroup.TurnsTillArrival + 1);// helper send
  255.                     }
  256.                     else
  257.                     {
  258.                         if (HelperAttackOnTitan(helper))
  259.                         {
  260.                             eGroup.Destination.SendPenguins(helper, eGroup.Destination.PenguinAmount);
  261.                         }
  262.                     }
  263.                 }
  264.             }
  265.         }
  266.         public Iceberg[] GetEnemyAndNeutral()
  267.         {
  268.             Iceberg[] e = game.GetEnemyIcebergs();
  269.             Iceberg[] n = game.GetNeutralIcebergs();
  270.             Iceberg[] icebergs = new Iceberg[e.Length + n.Length];
  271.             for (int i = 0; i < icebergs.Length; i++)
  272.             {
  273.                 for (int j = 0; j < e.Length; j++)
  274.                 {
  275.                     icebergs[i] = e[j];
  276.                 }
  277.                 for (int j = 0; j < n.Length; j++)
  278.                 {
  279.                     icebergs[i] = n[j];
  280.                 }
  281.             }
  282.             return icebergs;
  283.         }
  284.         public double GetAvgDistance(Player p, Iceberg source)
  285.         {
  286.             double sum = 0;
  287.             Iceberg[] all = p.Icebergs;
  288.             for (int i = 0; i < all.Length; i++)
  289.             {
  290.                 if (all[i] != source)
  291.                 {
  292.                     sum += source.GetTurnsTillArrival(all[i]);
  293.                 }
  294.             }
  295.             return sum / all.Length - 1;
  296.         }
  297.         public bool CanUpgrade(Iceberg source)
  298.         {
  299.             return GetUpgradedFuturePenguinAmount(source, LongestTrip) > 0;
  300.         }
  301.         public int GetSendAmount(Iceberg target, Iceberg source)
  302.         {
  303.             return System.Math.Abs(GetFuturePenguinAmount(target, target.GetTurnsTillArrival(source)) + 1);
  304.         }
  305.         public Iceberg[] GetNonBattleFronts()
  306.         {
  307.             int i = 0;
  308.             Iceberg[] battleFronts = GetBattleFronts();
  309.             Iceberg[] myIcebergs = game.GetMyIcebergs();
  310.             if (myIcebergs.Length - battleFronts.Length > 0)
  311.             {
  312.                 Iceberg[] nonBattleFronts = new Iceberg[myIcebergs.Length - battleFronts.Length];
  313.                 foreach (var iceberg in myIcebergs)
  314.                 {
  315.                     if (!battleFronts.Contains(iceberg))
  316.                     {
  317.                         nonBattleFronts[i] = iceberg;
  318.                         i++;
  319.                     }
  320.                 }
  321.                 return nonBattleFronts;
  322.             }
  323.             return null;
  324.         }
  325.         public Iceberg GetClosestBattleFront(Iceberg source)
  326.         {
  327.             int closest = int.MaxValue;
  328.             Iceberg closestIceberg = null;
  329.             Iceberg[] battleFronts = GetBattleFronts();
  330.             foreach (battleFront in battleFronts)
  331.             {
  332.                 if (source.GetTurnsTillArrival(battleFront) < closest)
  333.                 {
  334.                     closest = source.GetTurnsTillArrival(battleFront);
  335.                     closestIceberg = battleFront;
  336.                 }
  337.             }
  338.             return closestIceberg;
  339.         }
  340.         public Iceberg[] GetBattleFronts()
  341.         {
  342.             Player[] exclude = {game.GetEnemy(), game.GetMyself()};
  343.             int numOfbattlefronts = 0;
  344.             Iceberg[] enemyAndNeutral = GetEnemyAndNeutral();
  345.             Iceberg[] battleFronts = new Iceberg[enemyAndNeutral.Length];
  346.             Iceberg closest = null;
  347.             foreach (var iceberg in enemyAndNeutral)
  348.             {
  349.                 closest = GetClosest(iceberg, exclude)
  350.                 if (!battleFronts.Contains(closest))
  351.                 {
  352.                     battleFronts[numOfbattlefronts] = closest;
  353.                     numOfbattlefronts++;
  354.                 }
  355.             }
  356.             battleFronts = new Iceberg[numOfbattlefronts];
  357.             numOfbattlefronts = 0;
  358.             foreach (var iceberg in enemyAndNeutral)
  359.             {
  360.                 closest = GetClosest(iceberg, exclude)
  361.                 if (!battleFronts.Contains(closest))
  362.                 {
  363.                     battleFronts[numOfbattlefronts] = closest;
  364.                     numOfbattlefronts++;
  365.                 }
  366.             }
  367.             return battleFronts;
  368.         }
  369.         public void DoTurn(Game Ggame)
  370.         {
  371.             game = Ggame;
  372.             groups = game.GetAllPenguinGroups();
  373.             if (groups.Length > 0)
  374.             {
  375.                 SortPenguinGroups(groups);
  376.                 LongestTrip = groups[groups.Length - 1].TurnsTillArrival;
  377.             }
  378.            
  379.            
  380.            
  381.            
  382.             if (game.GetMyIcebergs().Length > 1)
  383.             {
  384.                 Defend(); //Reinforce all our islands.
  385.             }
  386.             ReinforceBattlefronts();
  387.             Upgrade();
  388.             Attack();
  389.  
  390.         }
  391.     }
  392. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top