if (from == "") {

return (

df.getAllVoyages()

.filter(

(v) =>

v.toPlanet == planetId &&

v.arrivalTime > new Date().getTime() / 1000

).length +

df.getUnconfirmedMoves().filter((m) => m.to == planetId).length

);

} else {

return (

df

.getAllVoyages()

.filter((v) => v.toPlanet == planetId)

.filter((v) => v.fromPlanet == from).length +

df.getUnconfirmedMoves().filter((m) => m.to == planetId && m.from == from)

.length

);

}

const unconfirmedDepartures = planet.unconfirmedDepartures.reduce(

(acc, dep) => {

return acc + dep.forces;

},

0

);

const FUZZY_ENERGY = Math.floor(planet.energy - unconfirmedDepartures);

return (FUZZY_ENERGY * percentCap) / 100;

const unconfirmedDepartures = planet.unconfirmedDepartures.reduce(

(acc, dep) => {

return acc + dep.forces;

},

0

);

const FUZZY_ENERGY = Math.floor(planet.energy - unconfirmedDepartures);

return Math.floor((FUZZY_ENERGY / planet.energyCap) * 100);

const { energyCap } = df.getPlanetWithId(srcId);

const payload = (energyCap * percentageSend) / 100;

const sync = df.getPlanetWithId(syncId);

return (

df.getEnergyArrivingForMove(srcId, syncId, payload) / (sync.defense / 100)

);

planetLocationId,

maxDistance = 5000,

levelLimit = 3,

numOfPlanets = 5

) {

const owned = df.getMyPlanets();

const ownedFiltered = owned

.filter((p) => p.locationId !== planetLocationId)

.filter((p) => p.planetLevel <= levelLimit)

.filter((p) => df.getDist(planetLocationId, p.locationId) < maxDistance);

ownedFiltered.sort(

(a, b) =>

df.getDist(planetLocationId, a.locationId) -

df.getDist(planetLocationId, b.locationId)

);

return ownedFiltered.slice(0, numOfPlanets).map((p) => {

const landingForces = getEnergyArrival(p.locationId, planetLocationId);

return {

landingForces,

planet: p,

};

});

planetLocationId,

levelLimit = 7,

numOfPlanets = 5,

maxTime = 30 * 60,

excludeList = []

) {

const warmWeapons = df

.getMyPlanets()

.filter((p) => p.locationId !== planetLocationId)

.filter((p) => p.planetLevel <= levelLimit)

.filter((p) => !excludeList.includes(p.locationId))

.filter((p) => df.getTimeForMove(p.locationId, planetLocationId) < maxTime);

const mapped = warmWeapons.map((p) => {

const landingForces = getEnergyArrival(

p.locationId,

planetLocationId,

planetCurrentPercentEnergy(p)

);

return {

landingForces,

planet: p,

};

});

mapped.sort((a, b) => {

return b.landingForces - a.landingForces;

});

return mapped.map((p) => p.planet).slice(0, numOfPlanets);

const arrivals = await df.contractsAPI.getArrivalsForPlanet(locationId);

return (

arrivals

.filter((a) => a.player == df.account)

.filter((a) => a.arrivalTime * 1000 > new Date().getTime()) //If not arrived

.filter((a) => passengersArray.includes(a.fromPlanet)).length > 0

);

const src = df.getPlanetWithId(srcId);

const sync = df.getPlanetWithId(srcId);

const dist = df.getDist(srcId, syncId);

const power_needed_on_arrival = ((sync.energy * sync.defense) / 100) * 1.2; //Want a little buffer

const scale = (1 / 2) ** (dist / src.range);

const power_needed_to_send =

power_needed_on_arrival / scale + 0.05 * src.energyCap;

return power_needed_to_send;

yourPlanetLocationId,

opponentsPlanetLocationsId,

percentageTrigger = 65,

percentageSend = 20

) {

const source = df.getPlanetWithId(yourPlanetLocationId);

if (!source) {

console.error(`[pester] Unable to get planet: ${yourPlanetLocationId}`);

return;

}

if (source.owner !== df.account) {

console.error(`[pester] You don't own planet: ${yourPlanetLocationId}`);

return;

}

const unconfirmedDepartures = source.unconfirmedDepartures.reduce(

(acc, dep) => {

return acc + dep.forces;

},

0

);

if (checkNumInboundVoyages(opponentsPlanetLocationsId) >= 6) {

//Too many inbound

return;

}

const TRIGGER_AMOUNT = Math.floor(

(source.energyCap * percentageTrigger) / 100

);

const FUZZY_ENERGY = Math.floor(source.energy - unconfirmedDepartures);

if (FUZZY_ENERGY > TRIGGER_AMOUNT) {

//If significantly over the trigger amount just batch include excess energy in the attack

// If current energy is 90% instead of sending 20% and landing at 70%, send 45% then recover;

const overflow_send =

planetCurrentPercentEnergy(source) - (percentageTrigger - percentageSend);

const FORCES = Math.floor((source.energyCap * overflow_send) / 100);

console.log(`[pester]: launching attack from ${source.locationId}`);

df.terminal.current.println(

`[pester]: launching attack from ${source.locationId}`,

4

);

//send attack

df.terminal.current.printShellLn(

`df.move('${

);

df.move(yourPlanetLocationId, opponentsPlanetLocationsId, FORCES, 0);

}

srcId,

syncId,

percentageTrigger = 75,

percentageSend = 45,

meta = {}

) {

return {

id: `[PESTER]-${srcId}-${syncId}-${percentageTrigger}-${percentageSend}`,

type: c.PESTER,

payload: {

srcId,

syncId,

percentageTrigger,

percentageSend,

},

meta,

};

srcId,

percentageRange = 75,

percentageSend = 25,

minLevel = 3

) {

const explorer = df.getPlanetWithId(srcId);

const takeable = df

.getPlanetsInRange(srcId, percentageRange)

.filter((p) => p.planetLevel >= minLevel)

.filter((p) => p.owner == pirates)

.filter((p) => planetIsRevealed(p.locationId))

.filter((p) => checkNumInboundVoyages(p.planetId, explorer.owner) < 1)

//Energy Needed to Take

.filter(

(p) =>

df.getEnergyNeededForMove(srcId, p.locationId, planetPower(p)) <

planetPercentEnergy(explorer, percentageSend)

);

takeable.sort((a, b) => b.planetLevel - a.planetLevel);

if (takeable.length > 0) {

df.terminal.current.println("[explore]: launching exploration", 4);

const target = takeable[0];

const FORCES = Math.floor(

df.getEnergyNeededForMove(

srcId,

target.locationId,

planetPower(target) + 200

)

);

//send attack

df.terminal.current.printShellLn(

`df.move('${explorer.locationId}', '${

);

df.move(explorer.locationId, target.locationId, FORCES, 0);

} else if (planetCurrentPercentEnergy(explorer) > 75) {

console.error(

`[explore]: ${explorer.id} has not valid targets consider increasing percentageSend`

);

df.terminal.current.println(

`[explore]: ${explorer.id} has not valid targets consider increasing percentageSend`,

3

);

}

srcId,

percentageRange = 75,

percentageSend = 25,

minLevel = 3

) {

return {

id: `[EXPLORE]-${srcId}-${percentageRange}-${percentageSend}-${minLevel}`,

type: c.EXPLORE,

payload: {

srcId,

percentageRange,

percentageSend,

minLevel,

},

};

const { srcId, syncId, sendAt, percentageSend } = action.payload;

const match = df.getMyPlanets().filter((t) => t.locationId == srcId);

if (match.length == 0) {

//Should delete self on this case

return;

}

const source = match[0];

if (checkNumInboundVoyages(syncId) >= 7) {

//Too many inbound

return;

}

const FORCES = Math.floor((source.energy * percentageSend) / 100);

console.log(sendAt);

if (sendAt < new Date().getTime()) {

console.log(`[delay]: ${source.locationId} attack launch`);

df.terminal.current.println(

`[delay]: ${source.locationId} attack launch`,

4

);

//send attack

df.terminal.current.printShellLn(

`df.move('${srcId}', '${syncId}', ${FORCES}, ${0})`

);

df.move(srcId, syncId, FORCES, 0);

return true;

} else {

console.log(

`[delay]: ${source.locationId} launch in ${msToSeconds(

);

}

return false;

srcId,

syncId,

sendAt,

percentageSend = 80,

meta = {

sent: false,

}

) {

return {

type: c.DELAYED_MOVE,

id: `${c.DELAYED_MOVE}-${srcId}-${syncId}`,

payload: {

srcId,

syncId,

sendAt,

percentageSend,

},

meta: meta,

};

const { srcId, syncId, passengers, departure, percentageSend, createdAt } =

action.payload;

const match = df.getMyPlanets().filter((t) => t.locationId == srcId);

if (match.length == 0) {

//Should delete self on this case

return false;

}

const source = match[0];

if (checkNumInboundVoyages(syncId) >= 7) {

//Too many inbound

return false;

}

const send = () => {

console.log("[chained]: launching attack");

df.terminal.current.println("[chained]: launching attack", 4);

//send attack

df.terminal.current.printShellLn(

`df.move('${srcId}', '${syncId}', ${FORCES}, ${0})`

);

df.move(srcId, syncId, FORCES, 0);

return true;

};

const FORCES = Math.floor((source.energy * percentageSend) / 100);

if (within5Minutes(createdAt, new Date().getTime())) {

console.log("too soon, waiting for passengers to depart");

return false;

} else if (await waitingForPassengers(srcId, passengers)) {

console.log("Waiting for passengers to arrive'");

return false;

} else {

return send();

}

srcId,

syncId,

passengers,

departure,

percentageSend = 90

) {

return {

type: c.CHAINED_MOVE,

id: `${c.CHAINED_MOVE}-${srcId}-${syncId}`,

payload: {

srcId,

syncId,

passengers,

departure,

percentageSend,

createdAt: new Date().getTime(),

},

meta: {

sent: false,

},

};

planetId,

maxDistance = 5000,

levelLimit = 1,

numOfPlanets = 5

) {

const nearby = findNearBy(planetId, maxDistance, levelLimit, numOfPlanets);

return nearby.map((p) => {

return createPester(p.planet.locationId, planetId, 75, 40, {

tag: "SWARM",

});

});

locationId,

levelLimit = 7,

numOfPlanets = 5,

searchRangeSec = 60 * 60,

test = true

) {

const weapons = findWeapons(

locationId,

levelLimit,

numOfPlanets,

searchRangeSec

);

//Sort by who will take longest to land

weapons.sort(

(a, b) =>

df.getTimeForMove(b.locationId, locationId) -

df.getTimeForMove(a.locationId, locationId)

);

const ETA_MS =

new Date().getTime() +

secondsToMs(df.getTimeForMove(weapons[0].locationId, locationId)) +

secondsToMs(10);

//Add 10 seconds for processing

if (test == true) {

const totalLandingEnergy = weapons.reduce(

(acc, w) => acc + getEnergyArrival(w.locationId, locationId, 80),

0

);

console.log(

`all energy will land with ${totalLandingEnergy} at ${locationId}`

);

}

return weapons.map((p) => {

return createDelayedMove(

p.locationId,

locationId,

Math.floor(

ETA_MS - secondsToMs(df.getTimeForMove(p.locationId, locationId))

),

{

ROUTINE: c.FLOOD,

sent: false,

arriveAt: ETA_MS,

}

);

});

srcId,

targetId,

searchRangeSec = 30 * 60,

levelLimit = 7,

numOfPlanets = 5,

test = false

) {

//Change Find Weapons to go off of travel time instead of distance

const weapons = findWeapons(srcId, levelLimit, numOfPlanets, searchRangeSec);

if (weapons.length == 0) {

//No valid weapons

return false;

}

//Sort by who will take longest to land

weapons.sort(

(a, b) =>

df.getTimeForMove(b.locationId, srcId) -

df.getTimeForMove(a.locationId, srcId)

);

const now = new Date().getTime();

const ETA_MS =

now +

secondsToMs(df.getTimeForMove(weapons[0].locationId, srcId)) +

secondsToMs(10);

const juice = weapons.map((p) => {

console.log(

`[overload]: incoming charge from ${

);

return createDelayedMove(

p.locationId,

srcId,

Math.floor(ETA_MS - secondsToMs(df.getTimeForMove(p.locationId, srcId)))

);

});

console.log(

`[overload]: discharge scheduled in ${new Date(

);

if (test) {

const addedEnergy = juice.reduce(

(acc, a) => acc + getEnergyArrival(a.payload.srcId, srcId, 75),

0

);

console.log(

`OVERLOAD TEST: Expect at Minimum ${getEnergyArrivalAbs(

);

}

const launch = createChainedMove(

srcId,

targetId,

juice.map((a) => a.payload.srcId),

ETA_MS + secondsToMs(3 * 60)

);

return [launch, ...juice];

return Math.sqrt(

(fromLoc.coords.x - toLoc.coords.x) ** 2 +

(fromLoc.coords.y - toLoc.coords.y) ** 2

);

fromId,

minCaptureLevel,

maxDistributeEnergyPercent,

capturedMemo = []

) {

//Ripped from Sophon

const planet = df.getPlanetWithId(fromId);

const candidates_ = df

.getPlanetsInRange(fromId, maxDistributeEnergyPercent)

.filter((p) => p.owner === "0x0000000000000000000000000000000000000000")

.filter((p) => p.planetLevel >= minCaptureLevel)

.map((to) => {

const fromLoc = df.getLocationOfPlanet(fromId);

const toLoc = df.getLocationOfPlanet(to.locationId);

return [to, distance(fromLoc, toLoc)];

})

.sort(distanceSort);

let i = 0;

const energyBudget = Math.floor(

(maxDistributeEnergyPercent / 100) * planet.energy

);

console.log("energyBudget ", energyBudget);

let energySpent = 0;

try {

while (energyBudget - energySpent > 0 && i < candidates_.length) {

const energyLeft = energyBudget - energySpent;

// Remember its a tuple of candidates and their distance

const candidate = candidates_[i++][0];

// Check if has incoming moves from another planet to safe

const arrivals = await df.contractsAPI.getArrivalsForPlanet(

candidate.locationId

);

if (arrivals.length !== 0) {

continue;

}

const energyArriving = candidate.energyCap * 0.25;

const energyNeeded = Math.ceil(

df.getEnergyNeededForMove(fromId, candidate.locationId, energyArriving)

);

if (energyLeft - energyNeeded < 0) {

continue;

}

if (capturedMemo.includes(candidate.locationId)) {

continue;

}

console.log(

`df.move("${fromId}","${candidate.locationId}",${energyNeeded},0)`

);

await df.move(fromId, candidate.locationId, energyNeeded, 0);

capturedMemo.push(candidate.locationId);

energySpent += energyNeeded;

}

} catch (err) {

console.error(err);

}

return capturedMemo;

return Math.sqrt(

(fromLoc.coords.x - toLoc.coords.x) ** 2 +

(fromLoc.coords.y - toLoc.coords.y) ** 2

);

fromId,

maxDistributeEnergyPercent,

minPlanetLevel = 4

) {

const planet = df.getPlanetWithId(fromId);

const candidates_ = df

.getPlanetsInRange(fromId, maxDistributeEnergyPercent)

.filter((p) => p.owner === df.getAccount())

.filter((p) => p.planetLevel >= minPlanetLevel)

.filter((p) => !isAsteroid(p))

.map((to) => {

const fromLoc = df.getLocationOfPlanet(fromId);

const toLoc = df.getLocationOfPlanet(to.locationId);

return [to, distance$1(fromLoc, toLoc)];

})

.sort(distanceSort$1);

let i = 0;

const energyBudget = Math.floor(

(maxDistributeEnergyPercent / 100) * planet.energy

);

const silverBudget = Math.floor(planet.silver);

let energySpent = 0;

let silverSpent = 0;

while (energyBudget - energySpent > 0 && i < candidates_.length) {

const silverLeft = silverBudget - silverSpent;

const energyLeft = energyBudget - energySpent;

// Remember its a tuple of candidates and their distance

const candidate = candidates_[i++][0];

// Check if has incoming moves from a previous asteroid to be safe

const arrivals = await df.contractsAPI.getArrivalsForPlanet(

candidate.locationId

);

if (arrivals.length !== 0) {

continue;

}

const silverRequested = Math.ceil(candidate.silverCap - candidate.silver);

const silverNeeded =

silverRequested > silverLeft ? silverLeft : silverRequested;

// Setting a 100 silver guard here, but we could set this to 0

if (silverNeeded < 100) {

continue;

}

const energyNeeded = Math.ceil(

df.getEnergyNeededForMove(fromId, candidate.locationId, 1)

);

if (energyLeft - energyNeeded < 0) {

continue;

}

console.log(

'df.move("' +

fromId +

'","' +

candidate.locationId +

'",' +

energyNeeded +

"," +

silverNeeded +

")"

);

await df.move(fromId, candidate.locationId, energyNeeded, silverNeeded);

energySpent += energyNeeded;

silverSpent += silverNeeded;

}

if (!oldVersion) {

return false;

}

const newV = parseVersionString(newVersion);

const oldV = parseVersionString(oldVersion);

if (newV.major !== oldV.major) {

//Raise Error

return false;

} else if (newV.minor !== oldV.minor) {

//Should have a migration available

return false;

} else if (newV.patch !== oldV.patch) {

//Should not effect actions schema

return true;

} else {

return true;

}

for (let index = 0; index < array.length; index++) {

await callback(array[index], index, array);

}

actions = [];

intervalId = "";

version = "0.0.1";

dead = false;

utils = utils;

constructor(blob = []) {