Oolite Bulletins

Code: Select all

this.name           = "PAGroove_superhubPopulator";
this.author         = "Thargoid";
this.copyright      = "This script is hereby placed in the public domain.";
this.version        = "1.1";
this.description    = "Script to add a single superhub near the system main station";


this.shipWillLaunchFromStation = function(station)
   {
   if(station.isMainStation)
      {
      this.spawnHub();
      }
   }

this.shipWillExitWitchspace = function()
   {
   this.spawnHub();
   }

this.spawnHub = function()
   {
   if(Math.random() < 0.5 || system.techLevel < 11 || system.government < 4 || system.countShipsWithRole("pagroove_superhub") > 0 || this.superHubBlock)   
      {
      this.superHubBlock = true;
      return;
      }
   else
      {
      this.xOffset = (Math.random() * 10000) + 10000; // x offset between 10 and 20km
      this.yOffset = (Math.random() * 10000) + 10000; // y offset between 10 and 20km

      if(Math.random() > 0.5) // 50:50 chance of offsetting in the other direction
         {
         this.xOffset = -this.xOffset;
         }
      if(Math.random() > 0.5) // 50:50 chance of offsetting in the other direction
         {
         this.yOffset = -this.yOffset;
         }

      system.legacy_addShipsAtPrecisely("pagroove_superhub", 1, "abs", system.mainStation.position.add([this.xOffset, this.yOffset, 0]));
      }
   }

this.shipWillEnterWitchspace = function()
   {
   this.superHubBlock = null;
   }

Code: Select all

   if(Math.random() < 0.5 || system.techLevel < 11 || system.government < 4 || system.countShipsWithRole("pagroove_superhub") > 0 || this.superHubBlock)

Code: Select all

   if(system.pseudoRandomNumber < 0.5 || ...

Code: Select all

// mix up pseudo random number up
if((system.pseudoRandomNumber * 27 * 463) % 53 == 0  || .

Code: Select all

worldScripts["Cheyd_JS_Common_Functions_1"].generateUniquePseudoRandomArray({LowerLimit: <Integer Inclusive>, UpperLimit: <Integer Inclusive>, HowMany: <Integer>, Seed_1: <Prime Number>, Seed_2: <Prime Number>, Seed_3: <Prime Number>, MaxSeed:<Prime Number>});

Code: Select all

this.name = "Cheyd_JS_Common_Functions_1";
this.author	= "Blake Deakins - a.k.a. Cmd. Cheyd";
this.description = "Provide a set of commonly used JS functions for all OXPs.";
this.version = "0.0.2";
this.copyright = "© Creative Commons Attribution-Noncommercial-No Derivative Works 3.0 United States";

// These variables are used in various functions within the system.
// ********************* DO NOT ALTER THESE  *********************
this.oxpArraySeeds = new Array();
this.oxpArrayArguments = new Array();
this.totalArrays = 0;
var arraysNeeded = 0;

// ***************************************************************

// ********************* this.dbg_Cmn_JS_Func_ScriptGING VARIABLES  *********************
// These variables are for this.dbg_Cmn_JS_Func_Scriptging purposes only.  Some of them
// can cause significant decrease in system speed while enabled.  
// Enabling of these options is not recommended unless you are
// familiar with scripting.
this.dbg_Cmn_JS_Func_Script = false;
this.dbg_oxpRegistration = false;
this.dbg_oxpArraySeeds = false;
this.dbg_events = false;
this.dbg_stringsearch = true;
// ***************************************************************

/*    ********  Internal Functions for this OXP  ********    */

this.setUpArrays = function()
{
	for (var i=this.oxpArraySeeds.length; i < this.oxpArrayArguments.length; i++) {
		this.oxpArraySeeds[i] = this.generateUniquePseudoRandomArray({LowerLimit: 1, UpperLimit: 1048575, HowMany: 2048, Seed_1: this.oxpArrayArguments[i][0], Seed_2: this.oxpArrayArguments[i][1], Seed_3: this.oxpArrayArguments[i][2], MaxSeed: 16777215});
	}
	if(this.dbg_Cmn_JS_Func_Script == true && this.dbg_oxpArraySeeds == true) {
		for (var i=0; i < this.oxpArraySeeds.length; i++) {
			for (var j=0; j < this.oxpArraySeeds[i].length; j++) {
				log (this.name,"this.oxpArraySeeds["+i+"]["+j+"] = " + this.oxpArraySeeds[i][j]);
			}
		}
	}

}

this.registerOXPArrayRequirements = function (Seed, Prime1, Prime2) {
	if (this.dbg_Cmn_JS_Func_Script == true && this.dbg_oxpRegistration == true) {
		log (this.name, "this.registerOXPArrayRequirements called by: " + this.registerOXPArrayRequirements.caller.toString());
		log (this.name, "Arguments passed were Seed: " + Seed + ".  Prime1: " + Prime1 + ".  Prime2: " + Prime2 + ".");
	}
	return this.oxpArrayArguments.push([Seed, Prime1, Prime2]) - 1;
}

this.fetchOXPArraySeeds = function (SeedSet, element){
	if (this.dbg_Cmn_JS_Func_Script == true && this.dbg_oxpRegistration == true) {
		log (this.name, "this.fetchOXPArraySeeds called by: " + this.fetchOXPArraySeeds.caller.toString());
		log (this.name, "Arguments passed were: SeedSet = " + SeedSet + ".  Element requested was: " + element + ".");
		log (this.name, "this.fetchOXPArraySeeds.length = " + this.fetchOXPArraySeeds.length);
	}
	return this.oxpArraySeeds[SeedSet][element];
}

/*    ********  String Manipulation Functions  ********    */
this.Left = function(str, n) {
	if (n <= 0)
	    return "";
	else if (n > String(str).length)
	    return str;
	else
	    return String(str).substring(0,n);
}
this.Right = function (str, n) {
    if (n <= 0)
       return "";
    else if (n > String(str).length)
       return str;
    else {
       var iLen = String(str).length;
       return String(str).substring(iLen, iLen - n);
    }
}

this.searchStringAForStringB = function (stringA,stringB) {
	if (this.dbg_Cmn_JS_Func_Script == true && this.dbg_stringsearch == true) log(this.name, "String A = " + stringA + ".  String B = " + stringB + ".");
	if(stringA.indexOf(stringB) != -1 ) return true;
	return false;
}


/*    ********  Orientation / Vector Functions  ********    */
this.turnEntityToPlanet = function(entity) {
	var targetVector = system.mainPlanet.position.subtract(entity.position).direction();
	var angle = entity.heading.angleTo(targetVector);
	var cross = entity.heading.cross(targetVector).direction();
	entity.orientation = entity.orientation.rotate(cross, -angle);
	return;		
}

this.turnEntity1ToEntity2 = function(entity1,entity2) {
	var targetVector = entity2.position.subtract(entity1.position).direction();
	var angle = entity1.heading.angleTo(targetVector);
	var cross = entity1.heading.cross(targetVector).direction();
	entity1.orientation = entity1.orientation.rotate(cross, -angle);
	return;		
}


/*    ********  Numerical Manipulation Functions  ********    */
this.generateUniquePseudoRandomArray = function(parameters) {
	/*
	This function was provided by PhantorGorth (Paul Cooper) and is
	licensed under Creative Commons Attribution-Non-Commercial 2.5 UK: Scotland Licence.
	Full license and acknowledgement details are available in the ReadMe.
	*/
	
	
	// Break out passed parameters into individual components
	var intLower = parameters.LowerLimit;	// Minimum Value for the random numbers selected
	var intUpper = parameters.UpperLimit;	// Maximum Value for the random numbers selected
	var intSize = parameters.HowMany;		// How many results do you want returned?
	var intSeed = parameters.Seed_1;			// Seed value from Global array
	var intMaxInternalSeed = parameters.MaxSeed
	var SeedVal1 = parameters.Seed_2;	// Prime Number
	var SeedVal2 = parameters.Seed_3;	// Second Prime Number

	
	//Initialise List
	var List = new Array();
	var Tree = new Array();
	if (SeedVal1 == undefined) SeedVal1 = 3631;
	if (SeedVal2 == undefined) SeedVal2 = 761;

	Tree[0] = {"Value" : undefined, "Lower" : -1, "Higher": -1, "CountBelow" : 0};

	function AddSeedToTree(inValue, NodeRef)
	{
		if ((NodeRef.Lower == -1) && (NodeRef.Higher == -1) && (NodeRef.Value == undefined))
		{
			NodeRef.Value = inValue;
			return;
		}
		if (inValue < NodeRef.Value)
		{
			NodeRef.CountBelow++;
			if (NodeRef.Lower == -1)
			{
				//Create and Intialise New NodeRef
				var obj = {"Value" : undefined, "Lower" : -1, "Higher": -1, "CountBelow" : 0};
				NodeRef.Lower = Tree.push(obj) - 1;
			}
			AddSeedToTree(inValue, Tree[NodeRef.Lower]);
		}
		else if (inValue > NodeRef.Value)
		{
			if (NodeRef.Higher == -1)
			{
				//Create and Intialise New NodeRef
				var obj = {"Value" : undefined, "Lower" : -1, "Higher": -1, "CountBelow" : 0};
				NodeRef.Higher = Tree.push(obj) - 1;
			}
			AddSeedToTree(inValue, Tree[NodeRef.Higher]);
		}
		else
		{
			return //Shouldn't happen as no two values in tree should be the same
		}
		return; 
	}

	function CountSeedsBelow(inValue, NodeRef)
	{
		if (NodeRef.Value == inValue)
		{
			return NodeRef.CountBelow + 1;
		}
		else if (inValue < NodeRef.Value)
		{
			if (NodeRef.Lower == -1)
			{
				return 0;
			}
			else
			{
				return CountSeedsBelow(inValue, Tree[NodeRef.Lower]);
			}
		}
		if (inValue > NodeRef.Value)
		{
			if (NodeRef.Higher == -1)
			{
				return NodeRef.CountBelow + 1;
			}
			else
			{
				return NodeRef.CountBelow + 1 + CountSeedsBelow(inValue, Tree[NodeRef.Higher]);
			}
		}
		else
		{
			return 0; // shouldn't get here
		}
	} 

	var newSeed = intSeed;
	var count = 0;
	var skipbase = 0;
	var lastvalue = 0;
	
	while (count < intSize)
	{	
		var c2 = 1;
		skipbase = lastvalue;
		newSeed = ((SeedVal1 * newSeed + SeedVal2) % (intMaxInternalSeed + 1));
		var trynewvalue = lastvalue + newSeed;
		if (trynewvalue > intUpper)
		{
			trynewvalue = (trynewvalue - intUpper) % (intUpper-intLower+1-count) + intUpper + 1;
		}
		if (count > 0)
		{
			var tryoldvalue = trynewvalue +1; // Just to make it different for the while test.
			while (trynewvalue != tryoldvalue)
			{
				if (tryoldvalue < trynewvalue) skipbase = tryoldvalue;
				var tryoldvalue = trynewvalue;
				var trynewvalue = trynewvalue + CountSeedsBelow(trynewvalue, Tree[0]) - CountSeedsBelow(skipbase, Tree[0]);
				if (trynewvalue > intUpper)  // To deal with wrapping
				{
					trynewvalue = (trynewvalue - (intUpper-intLower+1));
					skipbase = intLower - 1;
				}
				c2++;
			}
		}
		else
		{
			trynewvalue = ((newSeed) % (intUpper-intLower+1)) + intLower;
		}
		//Add newSeed to List
		List.push(trynewvalue);
		lastvalue = trynewvalue
		AddSeedToTree(trynewvalue, Tree[0]);
		count++;
	} 
	return List;
}

/*    ********  Miscellaneous Functions  ********    */