Safespot Generator Script

G

GliderPro

Active Member
Here is a little script to make generating safe spots easier. It will:

  1. Warp to the farthest moon @ 100km.
  2. Snap a bookmark 30 seconds after initiating warp. The 30 seconds does include align time!
  3. Warp back to the bookmark it just created.
  4. Repeat 1-3 ten times.

If you have a fast warping ship you may want to reduce the 30 second delay.

Be sure that your system is safe before using this script!

Code: 
#define CATEGORYID_CELESTIAL    2
#define GROUPID_MOON            8

#define CATEGORYID_STRUCTURE    23
#define GROUPID_CONTROL_TOWER   365

variable string LogFile

function atexit()
{
    call LogEcho "EVE Safespot Maker Script -- Ended"
    return
}

function LogEcho(string aString)
{
    echo "${aString}"
    redirect -append "${LogFile}" echo "${aString}"
}

function WarpWait()
{
    variable bool Warped = FALSE
    
    variable int Count
    for (Count:Set[0] ; ${Count}<10 ; Count:Inc)
    {
        if ${Me.ToEntity.Mode} == 3
        {
            call LogEcho "Warping..."
            break
        }
        wait 20
    }
    
    while ${Me.ToEntity.Mode} == 3
    {
        Warped:Set[TRUE]
        wait 20
    }
    call LogEcho "Dropped out of warp"
    wait 20
    return ${Warped}
}   

function WarpToFarthestMoonAndMakeBookmark(string bm_name)
{
    if ${EVE.Bookmark[${bm_name}](exists)}
    {
        call LogEcho "Bookmark ${bm_name} already exists!"
        return
    }

    variable index:entity moonIndex
    variable iterator moonIterator
    
    EVE:DoGetEntities[moonIndex,CategoryID,CATEGORYID_CELESTIAL,GroupID,GROUPID_MOON]
    moonIndex:GetIterator[moonIterator]
    
    if !${moonIterator:Last(exists)}
    {
        call LogEcho "moonIterator:Last not found!"
        return
    }
    
    moonIterator.Value:WarpTo[100000]
    
    variable int Count
    for (Count:Set[0] ; ${Count}<10 ; Count:Inc)
    {
        if ${Me.ToEntity.Mode} == 3
        {
            break
        }
        wait 20
    }
    
    for (Count:Set[0] ; ${Me.ToEntity.Mode} == 3 ; Count:Inc)
    {
        if ${Count} == 30
        {
            EVE:CreateBookmark["${bm_name}"]
            call LogEcho "${bm_name} created."
        }
        wait 10
    }    
}

; 'Args' is an array
function main(... Args)
{
    LogFile:Set["${Script.CurrentDirectory}/${Universe[${Me.SolarSystemID}]}-ssmaker.log"]

    call LogEcho "EVE Safespot Maker Script"
    call LogEcho "EVE Safespot Maker will log to ${LogFile}"
    
    variable int BookmarkCount
    variable string bm_name
    for (BookmarkCount:Set[1] ; ${BookmarkCount}<10 ; BookmarkCount:Inc)    
    {
        bm_name:Set["SS ${Universe[${Me.SolarSystemID}]} #${BookmarkCount}"]
        call LogEcho "Making ${bm_name}"
        call WarpToFarthestMoonAndMakeBookmark "${bm_name}"
        if ${EVE.Bookmark[${bm_name}](exists)}
        {
            EVE.Bookmark[${bm_name}]:WarpTo
            call WarpWait
        }
        else
        {
            call LogEcho "${bm_name} not found!"
            break
        }
    }
}
 
T

tsumari

Active Member
another version

Heya, I made a modded copy of this. It warps to the third closest planet, keeping track of which planets it has been to, and excluding them from the list of valid warp-to objects until you've visited every planet in the system.

It does safespots in multiple systems - you have to bookmark an object inside of the systems, and call it as run scriptname bookmark1 bookmark2 bookmark3. If you start it in a station it will return you to that station when it is done. Pulled some code from Ama's salvager. It's useful for everything.


Code: 
#define CATEGORYID_CELESTIAL    2
#define GROUPID_MOON            8
#define GROUPID_PLANET          7

#define CATEGORYID_STRUCTURE    23
#define GROUPID_CONTROL_TOWER   365

;; Declare all script or global variables here
variable(script) int NumSafeSpotLocations
variable(script) index:bookmark MyBookmarks
variable(script) int MyBookmarksCount
variable(script) bool LeftStation
variable(script) bool SafeSpotHomeBaseFound
variable(script) int Counter
variable(script) bool SafeSpotSystemFound
variable(script) bool DoLoot
variable(script) index:string SafeSpotLocationLabels
variable(script) collection:int ProcessedEntities


variable string LogFile

function atexit()
{
    call LogEcho "EVE Safespot Maker Script -- Ended"
    return
}

function LogEcho(string aString)
{
    echo "${aString}"
    redirect -append "${LogFile}" echo "${aString}"
}

function WarpWait()
{
    variable bool Warped = FALSE
    
    variable int Count
    for (Count:Set[0] ; ${Count}<10 ; Count:Inc)
    {
        if ${Me.ToEntity.Mode} == 3
        {
            call LogEcho "Warping..."
            break
        }
        wait 20
    }
    
    while ${Me.ToEntity.Mode} == 3
    {
        Warped:Set[TRUE]
        wait 20
    }
    call LogEcho "Dropped out of warp"
    wait 20
    return ${Warped}
}   

function WarpToFarthestMoonAndMakeBookmark(string bm_name)
{
    if ${EVE.Bookmark[${bm_name}](exists)}
    {
        call LogEcho "Bookmark ${bm_name} already exists!"
        return
    }

    variable index:entity moonIndex
    variable iterator moonIterator
    
    EVE:DoGetEntities[moonIndex,CategoryID,CATEGORYID_CELESTIAL,GroupID,GROUPID_MOON]
    moonIndex:GetIterator[moonIterator]
    
    if !${moonIterator:Last(exists)}
    {
        call LogEcho "moonIterator:Last not found!"
        return
    }
    
    moonIterator.Value:WarpTo[100000]
    
    variable int Count
    for (Count:Set[0] ; ${Count}<10 ; Count:Inc)
    {
        if ${Me.ToEntity.Mode} == 3
        {
            break
        }
        wait 20
    }
    
    for (Count:Set[0] ; ${Me.ToEntity.Mode} == 3 ; Count:Inc)
    {
        if ${Count} == 16
        {
            EVE:CreateBookmark["${bm_name}"]
            call LogEcho "${bm_name} created."
        }
        wait 10
    }    
}

function WarpToFarthestPlanetAndMakeBookmark(string bm_name)
{
    if ${EVE.Bookmark[${bm_name}](exists)}
    {
        call LogEcho "Bookmark ${bm_name} already exists!"
        return
    }

    variable index:entity planetIndex
    variable iterator planetIterator
    
    EVE:DoGetEntities[planetIndex,CategoryID,CATEGORYID_CELESTIAL,GroupID,GROUPID_PLANET]
    planetIndex:GetIterator[planetIterator]
    
    if !${planetIterator:Last(exists)}
    {
        call LogEcho "moonIterator:Last not found!"
        return
    }
    
    planetIterator.Value:WarpTo[100000]
    
    variable int Count
    for (Count:Set[0] ; ${Count}<10 ; Count:Inc)
    {
        if ${Me.ToEntity.Mode} == 3
        {
            break
        }
        wait 20
    }
    
    for (Count:Set[0] ; ${Me.ToEntity.Mode} == 3 ; Count:Inc)
    {
        if ${Count} == 17
        {
            EVE:CreateBookmark["${bm_name}"]
            call LogEcho "${bm_name} created."
        }
        wait 10
    }    
}

function WarpToPlanetAndMakeBookmark(string bm_name)
{
    if ${EVE.Bookmark[${bm_name}](exists)}
    {
        call LogEcho "Bookmark ${bm_name} already exists!"
        return
    }

    variable index:entity planetIndex
    variable iterator planetIterator
    
    EVE:DoGetEntities[planetIndex,CategoryID,CATEGORYID_CELESTIAL,GroupID,GROUPID_PLANET]
    planetIndex:GetIterator[planetIterator]
    
    if !${planetIterator:First(exists)}
    {
        call LogEcho "planetIterator:First not found!"
        return
    }
    
    if ${planetIterator:First(exists)}
    {
    /* Exclude closest planets */
    planetIterator:Next
    planetIterator:Next
    	do
    	{    
    		if (!${ProcessedEntities.Element[${planetIterator.Value.ID}](exists)})
				{
   				planetIterator.Value:WarpTo[100000]
    			ProcessedEntities:Set[${planetIterator.Value.ID},1]
    			break
				}
			}
			while ${planetIterator:Next(exists)}
		}
    

    
    variable int Count
    for (Count:Set[0] ; ${Count}<10 ; Count:Inc)
    {
        if ${Me.ToEntity.Mode} == 3
        {
            break
        }
        wait 20
    }
    
    for (Count:Set[0] ; ${Me.ToEntity.Mode} == 3 ; Count:Inc)
    {
        if ${Count} == 28
        {
            EVE:CreateBookmark["${bm_name}"]
            call LogEcho "${bm_name} created."
        }
        wait 5
    }    
}

; 'Args' is an array
function MakeSafeSpots(... Args)
{
		variable int i = 1
		/* this is just used one time */
		variable index:entity planetarray
		variable int Planets = ${EVE.GetEntities[planetarray,CategoryID,CATEGORYID_CELESTIAL,GroupID,GROUPID_PLANET]} 
    LogFile:Set["${Script.CurrentDirectory}/${Universe[${Me.SolarSystemID}]}-ssmaker.log"]

    call LogEcho "EVE Safespot Maker Script"
    call LogEcho "EVE Safespot Maker will log to ${LogFile}"
    
    variable int BookmarkCount
    variable string bm_name
    for (BookmarkCount:Set[1] ; ${BookmarkCount}<20 ; BookmarkCount:Inc)    
    {
        bm_name:Set["SS ${Universe[${Me.SolarSystemID}]} #${BookmarkCount}"]
        call LogEcho "Making ${bm_name}"
        call WarpToPlanetAndMakeBookmark "${bm_name}"
        if ${EVE.Bookmark[${bm_name}](exists)}
        {
            EVE.Bookmark[${bm_name}]:WarpTo
            call WarpWait
            wait 150
        }
        else
        {
            call LogEcho "${bm_name} not found!"
            break
        }
        echo "recycle check ${i} - number of planets ${Planets}
        if ${i:Inc} > ${Planets}
        {
        	ProcessedEntities:Clear
        	i:Set[1]
        }
    }
    ProcessedEntities:Clear
}

function main(... Args)
{
	variable int i = 1
  variable int j = 1
  variable int k = 1
  variable int WaitCount = 0
  variable int Iterator = 1
  
  SafeSpotSystemFound:Set[FALSE]
  LeftStation:Set[FALSE]
  
  if !${ISXEVE(exists)}
  {
     echo "- ISXEVE must be loaded to use this script."
     return
  }
  do
  {
     waitframe
  }
  while !${ISXEVE.IsReady}
  
  echo " \n \n \n** EVE Safespot creation script ** \n \n"
  
  ; 'Args' is an array ... arrays are static.  Copying to an index just in case we have a desire at some point to add/remove elements.
	if ${Args.Size} > 0
	{
		do
		{
			if ${EVE.Bookmark[${Args[${Iterator}]}](exists)}
				SafeSpotLocationLabels:Insert[${Args[${Iterator}]}]
			else
				echo "- '${Args[${Iterator}]}' is not a valid Bookmark label or command line argument:  Ignoring..."
		}
		while ${Iterator:Inc} <= ${Args.Size}
	}

  if (${SafeSpotLocationLabels.Used} <= 0)
  {
  	echo "- Syntax:  'run makesafespots <bookmarklabel1> <bookmarklabel2> ...'"
  	return
  }  
  
 
	MyBookmarksCount:Set[${EVE.GetBookmarks[MyBookmarks]}]
	if ${MyBookmarksCount} == 0
	{
		echo "- Sorry, you do not appear to have any bookmarks!"
		return
	}  
  

  ;;; Main Loop ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  NumSafeSpotLocations:Set[${SafeSpotLocationLabels.Used}]
  do
  {
  	j:Set[1]
    do
    {
			if (${MyBookmarks.Get[${j}].Label.Find[${SafeSpotLocationLabels[${i}]}]} > 0)
			{  
			  SafeSpotSystemFound:Set[TRUE]
				echo "- Safespot location found in bookmarks: (${SafeSpotLocationLabels[${i}]})..."
    		
    		;;; Leave station 
    		if !${LeftStation}
    		{
	   			if ${Me.InStation}
	   			{
					   ;; First, make sure we have a bookmark labeled "SafeSpot Home Base" -- otherwise, create it ;;;;;;;;;;;;;
					   SafeSpotBaseFound:Set[FALSE]
					   do
					   {
					    	if (${MyBookmarks.Get[${k}].Label.Find["SafeSpot Home Base"]} > 0)
					  		{
					  			SafeSpotHomeBaseFound:Set[TRUE]
					  		}
					   }
					   while ${k:Inc} <= ${MyBookmarksCount}
					
					   if !${SafeSpotHomeBaseFound}
					   {
					   		echo "- Creating 'SafeSpot Home Base' bookmark..."
					  		EVE:CreateBookmark["SafeSpot Home Base"]
					  		wait 10
					 	 } 
					 	   			
	   			   echo "- Undocking from station..."
	   			   EVE:Execute[CmdExitStation]	
	   			   wait 150
	   			   Counter:Set[0]
	   			   if (${Me.InStation})
	   			   {
	   			   		do
	   			   		{
	   			   			wait 20
	   			   			Counter:Inc[20]
					   			if (${Counter} > 300)
					   			{
					   			  echo "- Undocking atttempt failed ... trying again." 
					   				EVE:Execute[CmdExitStation]
					   				Counter:Set[0]
					   			}	   			   			
	   			   		}
	   			   		while (${Me.InStation} || !${EVEWindow[Local](exists)} || !${Me.InStation(exists)})
	   			   }
	   			   wait 5
	   			   LeftStation:Set[TRUE]
	   			}
	   			else
	   			   echo "- WARNING: You must be in a station to properly utilize this script."
	   			wait 1
   			}
   			
   			;;; Set destination and then activate autopilot (if we're not in that system to begin with)    			
   			if (${MyBookmarks[${j}].SolarSystemID} != ${Me.SolarSystemID})
   			{
   			  echo "- Setting Destination and activating auto pilot for safespot operation ${i} (${MyBookmarks.Get[${j}].Label})."
   			  wait 5
   				MyBookmarks[${j}]:SetDestination
   				wait 5
   				EVE:Execute[CmdToggleAutopilot]
					do
					{
					   wait 50
					   if !${Me.AutoPilotOn(exists)}
					   {
					     do
					     {
					        wait 5
					     }
					     while !${Me.AutoPilotOn(exists)}
					   }
					}
   				while ${Me.AutoPilotOn}
   				wait 20
   				do
   				{
   				   wait 10
   				}
   				while !${Me.ToEntity.IsCloaked}
   				wait 5
   			}
   			
				;*******************************
				call MakeSafeSpots
				;********************************
      }
    }
   	while ${j:Inc} <= ${MyBookmarksCount}
  }
  while ${i:Inc} <= ${NumSafeSpotLocations}
  
  
  ; No SafeSpot locations were found..so just end the script
  if !${SafeSpotSystemFound}
  { 
    echo "- Sorry, no bookmarks were found that matched the arguments given."
    return
  }

  
  ;;; Finished...returning home ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  echo "- Safespotting operations completed .. returning to home base"	

  MyBookmarksCount:Set[${EVE.GetBookmarks[MyBookmarks]}]
	j:Set[1]
	do
	{
		if (${MyBookmarks.Get[${j}].Label.Find["SafeSpot Home Base"]} > 0)
		{
			if (${MyBookmarks[${j}].SolarSystemID} != ${Me.SolarSystemID})
			{
				echo "- Setting destination and activating auto pilot for return to home base"
				MyBookmarks[${j}]:SetDestination
				wait 5
				EVE:Execute[CmdToggleAutopilot]
				do
				{
				   wait 50
				   if !${Me.AutoPilotOn(exists)}
				   {
				     do
				     {
				        wait 5
				     }
				     while !${Me.AutoPilotOn(exists)}
				   }
				}
 				while ${Me.AutoPilotOn}
 				wait 20
 				do
 				{
 				   wait 10
 				}
 				while !${Me.ToEntity.IsCloaked}
			}
   			
			;;; Warp to location
			echo "- Warping to home base location"
			MyBookmarks[${j}]:WarpTo
			wait 120
			do
			{
				wait 20
			}
			while (${Me.ToEntity.Mode} == 3)	
			wait 20
			
			;;; Dock, if applicable
			if ${MyBookmarks[${j}].ToEntity(exists)}
			{
				if (${MyBookmarks[${j}].ToEntity.CategoryID} == 3)
				{
					MyBookmarks[${j}].ToEntity:Approach
					do
					{
						wait 20
					}
					while (${MyBookmarks[${j}].ToEntity.Distance} > 50)
					
					MyBookmarks[${j}].ToEntity:Dock
					Counter:Set[0]			
					do
					{
					   wait 20
					   Counter:Inc[20]
					   if (${Counter} > 200)
					   {
					      echo " - Docking atttempt failed ... trying again."
					      ;EVE.Bookmark[${Destination}].ToEntity:Dock	
					      Entity[CategoryID,3]:Dock
					      Counter:Set[0]
					   }
					}
					while (!${Me.InStation})					
				}
			}
		}
	}
	while ${j:Inc} <= ${MyBookmarksCount}
 	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
}
 
S

speedy

Member
just wondering, is it possible to use this code to make a

warp to random moon @ 100

then start making bookmarks for all the stargates
so 100km then 200km then 300km

Basically just so i have 300km off gate bookmark

:)
 
You must log in or register to reply here.
Top Bottom