☰

VGA Bot-Core

Library of functions for NU bot library

此脚本不应直接安装，它是一个供其他脚本使用的外部库。如果您需要使用该库，请在脚本元属性加入：// @require https://update.cn-greasyfork.org/scripts/47367/762362/VGA%20Bot-Core.js 

  1. // ==UserScript==
  2. // @name          VGA Bot-Core
  3. // @namespace     daunting/bot
  4. // @version       0.1
  5. // @date          2018-04-01
  6. // @author        Daunting
  7. // @description   Library of functions for NU bot library
  8. // @include       http://planets.nu/*
  9. // @include       http://play.planets.nu/*
  10. // @include       http://test.planets.nu/*
  11. // @include				userscript
  12. // @resource      userscript https://greasyfork.org/en/scripts/35354-planets-nu-build-plan-plugin
  13. // @homepage      http://planets.nu
  14. // ==/UserScript==
  15. function wrapper () { // wrapper for injection
  16.     
  17.    if (vgap.version < 3.0) 
  18.    {
  19.       console.log("VGABot-Core plugin requires at least NU version 3.0. Plugin disabled." );
  20.       return;	
  21.    }
  22. 	
  23.    var plugin_version = 0.1;
  24.    
  25.    console.log("VGABot-Core plugin version: v" + plugin_version );
  26.     
  27.    /**
  28.    *  Specify your plugin
  29.    *  You need to have all those methods defined or errors will be thrown. 
  30.    *  I inserted the print-outs in order to demonstrate when each method is 
  31.    *  being called. Just comment them out once you know your way around.
  32.    *  
  33.    *  For any access to plugin class variables and methods, 
  34.    *  "vgap.plugins["vgaBot"].my_variable" has to be used 
  35.    *  instead of "this.my_variable".
  36.    */
  37.    var vgaBotCore = 
  38.    {			
  39.  
  40.       /**
  41.        * processload: executed whenever a turn is loaded: either the current turn or
  42.        * an older turn through time machine 
  43.        */
  44.       processload: function() 
  45.       {
  46. 	 			console.log("ProcessLoad: plugin called.");
  47.       },
  48. 			
  49.       /**
  50.        * loaddashboard: executed to rebuild the dashboard content after a turn is loaded
  51.        */
  52.       loaddashboard: function() 
  53.       {
  54.    			console.log("LoadDashboard: plugin called.");
  55.       },
  56.  
  57.       /**
  58.        * showdashboard: executed when switching from starmap to dashboard
  59.        */
  60.       showdashboard: function() 
  61.       {
  62. 	 			console.log("ShowDashboard: plugin called.");
  63.       },
  64. 			
  65.       /**
  66.        * showsummary: executed when returning to the main screen of the dashboard
  67.        */
  68.       showsummary: function() 
  69.       {
  70. 	 			console.log("ShowSummary: plugin called.");
  71.       },
  72. 			
  73.       /**
  74.        * loadmap: executed after the first turn has been loaded to create the map
  75.        * as far as I can tell not executed again when using time machine
  76.        */
  77.       loadmap: function() 
  78.       {
  79. 	 			console.log("LoadMap: plugin called.");
  80.       },
  81. 			
  82.       /**
  83.        * showmap: executed when switching from dashboard to starmap
  84.        */
  85.       showmap: function() 
  86.       {
  87. 	 			console.log("ShowMap: plugin called.");
  88.       },
  89. 			
  90.       /**
  91.        * draw: executed on any click or drag on the starmap
  92.        */			
  93.       draw: function() 
  94.       {
  95. 	 			console.log("Draw: plugin called.");
  96.       },		
  97. 			
  98.       /**
  99.        * loadplanet: executed a planet is selected on dashboard or starmap
  100.        */
  101.       loadplanet: function() 
  102.       {
  103. 	 			console.log("LoadPlanet: plugin called.");
  104.       },
  105. 			
  106.       /**
  107.        * loadstarbase: executed a planet is selected on dashboard or starmap
  108.        */
  109.       loadstarbase: function() 
  110.       {
  111.         console.log("LoadStarbase: plugin called.");
  112.       },
  113. 			
  114.       /**
  115.        * loadship: executed a planet is selected on dashboard or starmap
  116.        */
  117.       loadship: function() 
  118.       {
  119. 				console.log("LoadShip: plugin called.");
  120.       },
  121. 			
  122.       /***************************************************************************************
  123.        * Custom plugin variables
  124.        ***************************************************************************************/
  125.       missionEnum: {
  126.         EXPLORATION: 0,
  127.         HISS: 8,
  128.         CLOAK: 9,
  129.   			BEAMFUEL: 10,
  130.     	  BEAMDUR: 11,
  131.      	  BEAMTRIT: 12,
  132.      	  BEAMMOLY: 13,
  133.      		BEAMSUP: 14
  134. 			},
  135.      
  136.      /*****************************
  137.      * Unload freighters
  138.      ******************************/     
  139.      unloadToPlanet: function(ship, planet)
  140.      {
  141.      		vgap.plugins["vgaBotCore"].transferClans(ship, planet, ship.clans);
  142.         vgap.plugins["vgaBotCore"].transferSupplies(ship, planet, ship.supplies);
  143.         vgap.plugins["vgaBotCore"].transferDur(ship, planet, ship.duranium);
  144.         vgap.plugins["vgaBotCore"].transferTrit(ship, planet, ship.tritanium);
  145.         vgap.plugins["vgaBotCore"].transferMoly(ship, planet, ship.molybdenum);
  146.         vgap.plugins["vgaBotCore"].transferCredits(ship, planet, ship.megacredits);
  147.      },
  148.      
  149.      transferClans: function(src, dest, nClans)
  150.      {
  151.        if (src.clans >= nClans)
  152.        {
  153.           if (dest.ownerid == src.ownerid)
  154.           {
  155.             dest.clans += nClans;
  156.             dest.changed = 1;
  157.           }
  158.           else
  159.           {
  160.             src.transferclans += nClans;
  161.             vgap.plugins["vgaBotCore"].setTransferTarget(src, dest);
  162.           }
  163.           src.clans -= nClans;
  164.           src.changed = 1;
  165.        }
  166.      },
  167.           
  168.      transferSupplies: function(src, dest, nSupplies)
  169.      {
  170.        if (src.supplies >= nSupplies)
  171.        {
  172.           if (dest.ownerid == src.ownerid)
  173.           {
  174.             dest.supplies += nSupplies;
  175.             dest.changed = 1;
  176.           }
  177.           else
  178.           {
  179.             src.transfersupplies += nSupplies;         
  180.             vgap.plugins["vgaBotCore"].setTransferTarget(src, dest);
  181.           }
  182.           src.supplies -= nSupplies;
  183.           src.changed = 1;
  184.        }
  185.      },
  186.           
  187.      transferDur: function(src, dest, nDur)
  188.      {
  189.        if (src.duranium >= nDur)
  190.        {
  191.           if (dest.ownerid == src.ownerid)
  192.           {
  193.             dest.duranium += nDur;
  194.             dest.changed = 1;
  195.           }
  196.           else
  197.           {
  198.             src.transferduranium += nDur;
  199. 					  vgap.plugins["vgaBotCore"].setTransferTarget(src, dest);
  200.           }
  201.          
  202.           src.duranium -= nDur;
  203.           src.changed = 1;
  204.        }
  205.      },
  206.      
  207.      transferTrit: function(src, dest, nTrit)
  208.      {
  209.        if (src.tritanium >= nTrit)
  210.        {
  211.           if (dest.ownerid == src.ownerid)
  212.           {
  213.             dest.tritanium += nTrit;
  214.             dest.changed = 1;
  215.           }
  216.           else
  217.           {
  218.             src.transfertritanium += nTrit;
  219.             vgap.plugins["vgaBotCore"].setTransferTarget(src, dest);
  220.           }        
  221.             
  222.           src.tritanium -= nTrit;
  223.           src.changed = 1;
  224.        }
  225.      },
  226.      
  227.      transferMoly: function(src, dest, nMoly)
  228.      {
  229.        if (src.molybdenum >= nMoly)
  230.        {         
  231.           if (dest.ownerid == src.ownerid)
  232.           {
  233.             dest.molybdenum += nMoly;
  234.             dest.changed = 1;
  235.           }
  236.           else
  237.           {
  238.             src.transfermolybdenum += nMoly;          
  239.             vgap.plugins["vgaBotCore"].setTransferTarget(src, dest);
  240.           }
  241.          
  242.           src.molybdenum -= nMoly;
  243.           src.changed = 1;
  244.        }
  245.      },
  246.      
  247.      transferCredits: function(src, dest, nCredits)
  248.      {
  249.        if (src.megacredits >= nCredits && dest.ownerid == src.ownerid)
  250.        {
  251.           dest.megacredits += nCredits;         
  252.           src.megacredits -= nCredits;
  253.           src.changed = 1;
  254.           dest.changed = 1;
  255.        }
  256.      },
  257.      
  258.      setTransferTarget: function(src, dest)
  259.      {  
  260.         src.transfertargetid = dest.id;
  261.         if (dest.isPlanet)
  262.         	src.transfertargettype = 1;
  263.         else if (dest.isShip)
  264.           src.transfertargettype = 0;
  265.      },
  266.      
  267.      
  268.      /*****************************
  269.      * Move Ships
  270.      ******************************/    
  271.      findNearestStarbase: function(target)
  272.      {
  273.        var min = 100000;
  274.        var ret = null;
  275.        for (var i=0; i<vgap.planets.length; i++)
  276.        {
  277.          var planet = vgap.planets[i];
  278.          if ( planet.ownerid == vgap.player.id && planet.isbase)
  279.          {
  280.             var distance = vgap.plugins["vgaBotCore"].calcDistance(planet, target);
  281.            	if (distance < min)
  282.             {
  283.               min = distance;
  284.               ret = planet;
  285.             }
  286.          }
  287.        }
  288.        
  289.        return ret;
  290.      },
  291.      
  292.      orbittingPlanet: function(ship)
  293.      {
  294.        for (var i=0; i<vgap.planets.length; i++)
  295.        {
  296.          var planet = vgap.planets[i];
  297.          if ( (ship.x == planet.x && ship.y == planet.y) )
  298.          		return planet;
  299.        }
  300.        
  301.        return null;
  302.      },
  303.      
  304. 		 /**
  305.       * TODO: Need to make sure ships don't go to the same planet.
  306.       */
  307.      findNearestUnownedPlanet: function(thing)
  308.      {
  309.        var min = 100000;
  310.        var ret = null;
  311.        for (var i=0; i<vgap.planets.length; i++)
  312.        {
  313.          var planet = vgap.planets[i];
  314.          if ( (thing.x != planet.x || thing.y != planet.y) && planet.ownerid == 0)
  315.          {
  316.             var distance = vgap.plugins["vgaBotCore"].calcDistance(planet, thing);
  317.            	if (distance < min)
  318.             {
  319.               min = distance;
  320.               ret = planet;
  321.             }
  322.          }
  323.        }
  324.        
  325.        return ret;
  326.      },
  327.      
  328.      findNearestEnemyPlanet: function(thing)
  329.      {
  330.        var min = 100000;
  331.        var ret = null;
  332.        for (var i=0; i<vgap.planets.length; i++)
  333.        {
  334.          var planet = vgap.planets[i];
  335.          if ( (thing.x != planet.x || thing.y != planet.y) && planet.ownerid != 0 && planet.ownerid != vgap.player.id)
  336.          {
  337.             var distance = vgap.plugins["vgaBotCore"].calcDistance(planet, thing);
  338.            	if (distance < min)
  339.             {
  340.               min = distance;
  341.               ret = planet;
  342.             }
  343.          }
  344.        }
  345.        
  346.        return ret;
  347.      },
  348.  
  349.      calcDistance: function(a, b)
  350.      {
  351.        return Math.sqrt(Math.pow(a.x-b.x,2) + Math.pow(a.y-b.y,2));
  352.      },
  353.      
  354.      createWaypoint: function(ship, dest)
  355.      {
  356.        var waypoint = {id:ship.id, x1:ship.x, y1:ship.y, x2:dest.x, y2:dest.y, color:"#009900", dasharray:null};
  357.        ship.lastwaypoint=waypoint;
  358.        //vgap.waypoints.push(waypoint);
  359.        ship.targetx = dest.x;
  360.        ship.targety = dest.y;
  361.        ship.target = dest;
  362.        ship.warp = ship.engineid;
  363.        ship.changed = 1;
  364.      },
  365.      
  366.      clearWaypoint: function(ship)
  367.      {
  368.        ship.lastwaypoint=null;
  369.        ship.targetx = ship.x;
  370.        ship.targety = ship.y;
  371.        ship.target = null;
  372.        ship.changed = 1;
  373.      },
  374.      
  375.      loadFuel: function(ship)
  376.      {
  377.        	var fuelAvailable = vgap.plugins["vgaBotCore"].getFuelAvailable(ship);
  378.        	var planet = vgap.plugins["vgaBotCore"].orbittingPlanet(ship);
  379.         var sbPlanet = vgap.plugins["vgaBotCore"].findNearestStarbase(ship.target);
  380.         var returnFuel = vgap.plugins["vgaBotCore"].calcFuelConsumption(ship, ship.target, sbPlanet, false);
  381.         var needed = vgap.plugins["vgaBotCore"].calcFuelConsumption(ship, ship, ship.target, true) + returnFuel;
  382.         
  383.         var added = 0;
  384.         console.log("Ship " + ship.id + ": Needed: " + needed + " Ship: " + ship.neutronium + " Available: " + fuelAvailable + " Return: " + returnFuel);
  385.         while (needed > ship.neutronium && needed < fuelAvailable)
  386.         {
  387.           if (needed > ship.neutronium)
  388.           {
  389.             if (planet != null && planet.ownerid == vgap.player.id)
  390.             {
  391.               var adding = needed - ship.neutronium;
  392.               added += adding;
  393.               planet.neutronium -= adding;
  394.               ship.neutronium += adding;
  395.             }
  396.           }
  397.           needed = vgap.plugins["vgaBotCore"].calcFuelConsumption(ship, ship, ship.target, true) + returnFuel;
  398.         }
  399.        
  400.         if (ship.neutronium < needed && added > 0)
  401.         {
  402.           ship.neutronium -= added;
  403.           planet.neutronium += added;
  404.         }
  405.         else if (planet != null && planet.neutronium > 0 && planet.ownerid == vgap.player.id)
  406.         {
  407.           planet.neutronium -= 1;
  408.           ship.neutronium += 1;
  409.         }
  410.          
  411.         console.log("Added fuel: " + added);
  412.         return ship.neutronium >= needed;
  413.      },
  414.      
  415.      calcFuelConsumption: function(ship, start, dest, includeCargo)
  416.      {
  417.        var fuelFactor = vgap.plugins["vgaBotCore"].getFuelFactor(ship);
  418.        var mass = vgap.plugins["vgaBotCore"].getMass(ship, includeCargo);
  419.        var distance = vgap.plugins["vgaBotCore"].calcDistance(start, dest);
  420.        
  421.        var cloakFuel = 0;
  422.        if (ship.mission == vgap.plugins["vgaBotCore"].missionEnum.CLOAK)
  423.        {
  424.        		var turns = Math.ceil(distance / Math.pow(ship.engineid,2));
  425.        		var hull = vgap.getHull(ship.hullid);
  426.           cloakFuel = Math.ceil(hull.mass / 20) * turns;
  427.        }
  428.        
  429.        console.log("mass: " + mass + " cloakFuel: " + cloakFuel + " distance: " + distance + " factor: " + fuelFactor);
  430.        return Math.truncate(fuelFactor * Math.truncate(mass / 10) * Math.truncate(distance / Math.pow(ship.engineid,2)) / 10000) + cloakFuel;
  431.      },
  432.           
  433.      getFuelFactor: function(ship)
  434.      {
  435.        var engine = vgap.getEngine(ship.engineid);
  436.        
  437.        return engine.warps[ship.engineid-1];
  438.      },
  439.  
  440.      getMass: function(ship, includeCargo)
  441.      {
  442.        var mass = 0;
  443.        
  444.        var hull = vgap.getHull(ship.hullid);
  445.        mass += hull.mass;
  446.        
  447.        if (ship.torpedoid != 0)
  448.        {
  449.          var torps = vgap.getTorpedo(ship.torpedoid);
  450.        	 mass += torps.mass * ship.torps;
  451.        }
  452.        if (ship.beamid != 0)
  453.        {
  454.          var beam = vgap.getBeam(ship.beamid);
  455.        	 mass += beam.mass * ship.beams;
  456.        }
  457.        
  458.        //Will still have ammo
  459.        mass += ship.ammo;
  460.        
  461.        if (includeCargo)
  462.        {
  463.          mass += ship.duranium + ship.tritanium + ship.molybdenum + ship.supplies + ship.clans +
  464.            ship.neutronium;
  465.        }
  466.        
  467.        return mass;       
  468.      },
  469.        
  470.      getFuelAvailable: function(ship)
  471.      {
  472.        var planet = vgap.plugins["vgaBotCore"].orbittingPlanet(ship);
  473.        var fuel = ship.neutronium;
  474.        
  475.        if (planet != null && planet.ownerid == ship.ownerid)
  476.          fuel += planet.neutronium;
  477.        
  478.        return fuel;
  479.      },
  480.  
  481.     /****************************
  482.      * Intel
  483.      *****************************/
  484.      hasOrbitingShip: function(planet)
  485.      {
  486.        var ret = false;
  487.        
  488.        for (var i=0; i<vgap.myships.length; i++)
  489.        {
  490.          var ship = vgap.myships[i];
  491.          if (ship.x == planet.x && ship.y == planet.y)
  492.            ret = true;
  493.        }  
  494.        
  495.        return ret;
  496.      },
  497.      
  498.      shouldCloak: function(ship)
  499.      {
  500.        var cloak = true;
  501.        var hull = vgap.getHull(ship.hullid);
  502.        
  503.        //Can it cloak?
  504.        if (!hull.cancloak)
  505.        		cloak = false;
  506.        
  507.        //Is it moving (currently only cloaking when moving ...)?
  508.        //TODO: Put in tactical decision to cloak on friendly planets or in space.
  509.        if (cloak)
  510.        {
  511.           if (ship.target == null)
  512. 						cloak = false;
  513.        }
  514.        
  515.        //Target a friendly planet?
  516.        if (cloak)
  517.        {
  518.          if (ship.target.isPlanet && ship.target.ownerid == ship.ownerid)
  519.            cloak = false;
  520.        }
  521.        
  522.        return cloak;
  523.      },
  524.  
  525.      /****************************
  526.      * Build Ships
  527.      *****************************/       
  528.      calcShipCredits: function(shipAssembly, base)
  529.      {
  530.        console.log("Ship hull name: " + shipAssembly.hull.name);
  531.        
  532.        var credits = shipAssembly.hull.cost +
  533.            shipAssembly.hull.engines * shipAssembly.engine.cost;
  534.        if (shipAssembly.hull.launchers != 0 && shipAssembly.torp != null)
  535.          credits += shipAssembly.hull.launchers * shipAssembly.torp.launchercost;
  536.        if (shipAssembly.hull.beams != 0 && shipAssembly.beam != null)
  537.          credits += shipAssembly.hull.beams * shipAssembly.beam.cost;
  538.        
  539.        credits += vgap.plugins["vgaBotCore"].calcTechCost(base.hulltechlevel, shipAssembly.hull.techlevel);
  540.        credits += vgap.plugins["vgaBotCore"].calcTechCost(base.enginetechlevel, shipAssembly.engine.techlevel);
  541.        credits += vgap.plugins["vgaBotCore"].calcTechCost(base.torptechlevel, shipAssembly.torp.techlevel);
  542.        credits += vgap.plugins["vgaBotCore"].calcTechCost(base.beamtechlevel, shipAssembly.beam.techlevel);
  543.        
  544.        return credits;
  545.      },
  546.      
  547.      calcTechCost: function(baseTech, shipTech)
  548.      {
  549.        var cost = 0;
  550.        if (baseTech < shipTech)
  551.        {
  552.          for (i=baseTech; i<shipTech; i++)
  553.            cost += i*100;
  554.        }
  555.        
  556.        //Have we upgraded to level 9 (i.e. 10)
  557.        if (shipTech == 9 && cost > 0)
  558.          cost += 900;
  559.        
  560.        if (cost > 0)
  561.        {
  562.        		console.log("Tech Cost: " + cost);        
  563.        		console.log("Upgrade from " + baseTech + " to " + shipTech);
  564.        }
  565.        
  566.        return cost;
  567.      },
  568.      
  569.      calcShipDur: function(shipAssembly)
  570.      {
  571.        var dur = shipAssembly.hull.duranium +
  572.            shipAssembly.hull.engines * shipAssembly.engine.duranium;
  573.        if (shipAssembly.hull.launchers != 0 && shipAssembly.torp != null)
  574.          dur += shipAssembly.hull.launchers * shipAssembly.torp.duranium;
  575.        if (shipAssembly.hull.beams != 0 && shipAssembly.beam != null)
  576.          dur += shipAssembly.hull.beams * shipAssembly.beam.duranium;
  577.        
  578.        return dur;
  579.      },
  580.      
  581.      calcShipTrit: function(shipAssembly)
  582.      {
  583.        var trit = shipAssembly.hull.tritanium +
  584.            shipAssembly.hull.engines * shipAssembly.engine.tritanium;
  585.        if (shipAssembly.hull.launchers != 0 && shipAssembly.torp != null)
  586.          trit += shipAssembly.hull.launchers * shipAssembly.torp.tritanium;
  587.        if (shipAssembly.hull.beams != 0 && shipAssembly.beam != null)
  588.          trit += shipAssembly.hull.beams * shipAssembly.beam.tritanium;
  589.        
  590.        return trit;
  591.      },
  592.      
  593.      calcShipMoly: function(shipAssembly)
  594.      {
  595.        var moly = shipAssembly.hull.molybdenum +
  596.            shipAssembly.hull.engines * shipAssembly.engine.molybdenum;
  597.        if (shipAssembly.hull.launchers != 0 && shipAssembly.torp != null)
  598.          moly += shipAssembly.hull.launchers * shipAssembly.torp.molybdenum;
  599.        if (shipAssembly.hull.beams != 0 && shipAssembly.beam != null)
  600.          moly += shipAssembly.hull.beams * shipAssembly.beam.molybdenum;
  601.        
  602.        return moly;
  603.      },
  604.            
  605.      findHullNamed: function(hullName)
  606.      {
  607.        var ret = null;
  608.        for (var i=0; i<vgap.hulls.length; i++)
  609.        {
  610.          if (vgap.hulls[i].name == hullName)
  611.            ret = vgap.hulls[i];
  612.        }
  613.        return ret;
  614.      },
  615.      
  616.      assembleShip: function(base, shipAssembly)
  617.      {
  618.        var planet = vgap.getPlanet(base.planetid);
  619.                
  620.        //Pay for the ship       
  621.        var credits = vgap.plugins["vgaBotCore"].calcShipCredits(shipAssembly, base);
  622.        var dur = vgap.plugins["vgaBotCore"].calcShipDur(shipAssembly);
  623.        var trit = vgap.plugins["vgaBotCore"].calcShipTrit(shipAssembly);
  624.        var moly = vgap.plugins["vgaBotCore"].calcShipMoly(shipAssembly);
  625.        
  626.        planet.duranium -= dur;
  627.        planet.tritanium -= trit;
  628.        planet.molybdenum -= moly;              
  629.        vgap.plugins["vgaBotCore"].payForStructure(planet, 0, credits);     
  630.        
  631.        //Upgrade all tech needed
  632.        if (base.beamtechlevel < shipAssembly.beam.techlevel)
  633.        {
  634.          base.beamtechup = shipAssembly.beam.techlevel - base.beamtechlevel;
  635.          base.beamtechlevel = shipAssembly.beam.techlevel;
  636.        }       
  637.        if (base.hulltechlevel < shipAssembly.hull.techlevel)
  638.        {
  639.          base.hulltechup = shipAssembly.hull.techlevel - base.hulltechlevel;
  640.          base.hulltechlevel = shipAssembly.hull.techlevel;
  641.        }
  642.        if (base.enginetechlevel < shipAssembly.engine.techlevel)
  643.        {
  644.          base.enginetechup = shipAssembly.engine.techlevel - base.enginetechlevel;
  645.          base.enginetechlevel = shipAssembly.engine.techlevel;
  646.        }       
  647.        if (base.torptechlevel < shipAssembly.torp.techlevel)
  648.        {
  649.          base.torptechup = shipAssembly.torp.techlevel - base.torptechlevel;
  650.          base.torptechlevel = shipAssembly.torp.techlevel;
  651.        }
  652.        
  653.        //Assemble the ship
  654.        base.buildbeamcount = shipAssembly.hull.beams;
  655.        base.buildbeamid = shipAssembly.beam.id;
  656.        var stockitem = vgap.getStock(base.id, 3, shipAssembly.beam.id);
  657.        stockitem.builtamount += shipAssembly.hull.beams;
  658.        stockitem.amount += shipAssembly.hull.beams;
  659.        stockitem.changed = 1;
  660.        
  661.        base.buildengineid = shipAssembly.engine.id;
  662.        stockitem = vgap.getStock(base.id, 2, shipAssembly.engine.id);
  663.        stockitem.builtamount += shipAssembly.hull.engines;
  664.        stockitem.amount += shipAssembly.hull.engines;
  665.        stockitem.changed = 1;
  666.        
  667. 			 base.buildhullid = shipAssembly.hull.id;
  668.        stockitem = vgap.getStock(base.id, 1, shipAssembly.hull.id);
  669.        stockitem.builtamount += 1;
  670.        stockitem.amount += 1;
  671.        stockitem.changed = 1;
  672.        
  673.    		 base.buildtorpcount = shipAssembly.hull.launchers;
  674. 			 base.buildtorpedoid = shipAssembly.torp.id;
  675.        stockitem = vgap.getStock(base.id, 4, shipAssembly.torp.id);
  676.        stockitem.builtamount += shipAssembly.hull.launchers;
  677.        stockitem.amount += shipAssembly.hull.launchers;
  678.        stockitem.changed = 1;
  679.        
  680.        base.isbuilding = true;
  681.        base.changed = 1;
  682.        planet.changed = 1;
  683.      },
  684.      
  685.      /*****************************
  686.      * Build Structures
  687.      ******************************/
  688.      calcMaxFactories: function(planet)
  689.      {
  690.        var nFactories;
  691.        if (planet.clans <= 100)
  692.          nFactories = planet.clans;
  693.        else
  694.          nFactories = Math.truncate(100 + Math.sqrt( planet.clans - 100));
  695.        
  696.        return nFactories;
  697.      },
  698.      
  699.      calcMaxMines: function(planet)
  700.      {
  701.      	 var nMines;
  702.        if (planet.clans <= 200)
  703.          nMines = planet.clans;
  704.        else
  705.          nMines = Math.truncate(200 + Math.sqrt( planet.clans - 200));
  706.        
  707.        return nMines;
  708.      },
  709.      
  710.      calcMaxDefense: function(planet)
  711.      {
  712.        var nDefense;
  713.        if (planet.clans <= 50)
  714.          nDefense = planet.clans;
  715.        else
  716.          nDefense = Math.truncate(50 + Math.sqrt( planet.clans - 50));
  717.        
  718.        return nDefense;
  719.      },
  720.      
  721.      calcDesiredDefense: function(planet)
  722.      {
  723.        return Math.min(20, vgap.plugins["vgaBotCore"].calcMaxDefense(planet));
  724.      },
  725.      
  726.      buildFactories: function(planet, max)
  727.      {       
  728.        while(planet.factories < max && vgap.plugins["vgaBotCore"].payForStructure(planet, 1, 3))
  729.        {
  730.          planet.factories += 1;
  731.          planet.builtfactories += 1;
  732.        }
  733.        return planet.factories >= max;
  734.      },
  735.      
  736.      buildMines: function(planet, max)
  737.      {
  738.        while(planet.mines < max && vgap.plugins["vgaBotCore"].payForStructure(planet, 1, 4))
  739.        {
  740.          planet.mines += 1;         
  741.          planet.builtmines += 1;
  742.        }
  743.        return planet.mines >= max;
  744.      },
  745.      
  746.      buildDefense: function(planet, max)
  747.      {
  748.        while(planet.defense < max && vgap.plugins["vgaBotCore"].payForStructure(planet, 1, 10))
  749.        {
  750.          planet.defense += 1;  
  751.          planet.builtdefense += 1;
  752.        }
  753.        return planet.defense >= max;
  754.      },
  755.      
  756.      payForStructure: function(planet, nSupplies, nCredits)
  757.      {
  758.        var bought = false;
  759.        
  760.        //Check if we can afford this
  761.        if (planet.supplies >= nSupplies && ((planet.supplies + planet.megacredits) > (nSupplies + nCredits)) )
  762.        {
  763.          bought = true;
  764.          planet.supplies -= nSupplies;
  765.          var nCreditsSpend = Math.min(planet.megacredits, nCredits);
  766.          planet.megacredits -= nCreditsSpend;
  767.          nCredits -= nCreditsSpend;
  768.          
  769.          if (nCredits > 0)
  770.          {
  771.            vgap.plugins["vgaBotCore"].sellSupplies(planet, nCredits);
  772.            planet.megacredits -= nCredits;
  773.          }
  774.        }
  775.               
  776.        return bought;
  777.      },
  778.        
  779.      sellSupplies: function(planet, nSupplies)
  780.      {
  781.      		planet.suppliessold += nSupplies;
  782.         planet.supplies -= nSupplies;
  783.         planet.megacredits += nSupplies;
  784.      },
  785.      
  786.      
  787.      /*****************************
  788.      * Tax
  789.      ******************************/
  790.      
  791.    }; //End plugin
  792. 	
  793.    // register your plugin with NU
  794.    vgap.registerPlugin(vgaBot, "vgaBotCore");
  795. 	 
  796. } //wrapper for injection
  797.  
  798. var script = document.createElement("script");
  799. script.type = "application/javascript";
  800. script.textContent = "(" + wrapper + ")();";
  801.  
  802. document.body.appendChild(script);
  803. document.body.removeChild(script);