redirarcs

#!/usr/bin/env python
# vim: set ts=2 sw=2 expandtab:

import game
from optparse import OptionParser
import sys
import shape
import random

def main():
  parser = OptionParser()
  parser.add_option("-U", "--username", dest="username",
                    help="username of login")
  parser.add_option("-P", "--password", dest="password",
                    help="password for login")
  parser.add_option("-n", "--noupgrade", dest="doupgrade",
                    action="store_false", default=True, help="dry run")
  parser.add_option("-s", "--source_route", dest="source",
                    type="string", help="source route area")
  parser.add_option("-d", "--dest_route", dest="dest",
                    type="string", help="destination route area")
  parser.add_option("-r", "--random", dest="random",
                    action="store_true", default=False, help="pick a random planet in the target area")

  (options, args) = parser.parse_args()

  print "options " + str(options)

  g=game.Galaxy()
  if options.username and options.password:
    # explicit login
    g.login(options.username, options.password, force=True)
  else:
    # try to pick up stored credentials
    g.login()

  try:
    dest_route = g.find_route(options.dest)
    dest_shape = shape.Polygon(*(dest_route.points))
  except:
    print "could't find dest route"
    sys.exit(1)

  source_shape = None
  try:
    source_route = g.find_route(options.source)
    source_shape = shape.Polygon(*(source_route.points))
  except:
    pass

  g.load_fleet_cache()

  if source_shape == None:
    print "could't find source route"
    sys.exit(1)

  RedirArcsFromOwned(g, options.doupgrade, source_shape, dest_shape)
  RedirReturningArcs(g, options.doupgrade, source_shape, dest_shape)

#  RedirArcsFromSource(g, options.doupgrade, source_shape, dest_shape, options.random)

  g.write_fleet_cache()

# redirect all arcs with targets in source shape into dest shape
def RedirArcsFromSource(g, doupgrade, source_shape, dest_shape, random, overlap=True, rearrange=False):

  print "finding planets in source sector..."
  source_targets = game.FindAllPlanetsInShape(g, source_shape)
  print "%d planets in source sector" % len(source_targets)

  print "finding planets in target sector..."
  targets = game.FindUnownedPlanetsInShape(g, dest_shape)
  print "%d unowned planets in target sector" % len(targets)

  # only handle planets that aren't in source
  if overlap:
    print "removing overlap planets from source..."
    for p in targets:
      for s in source_targets:
        if p.planetid == s.planetid:
          targets.remove(p)
          break

  print "%d unowned planets in target sector" % len(targets)
  
  # if we're rearranging things, then consider targets that are already targetted
  if not rearrange:
    print "removing already targetted planets in target sector..."
    targets = game.TrimColonyTargettedPlanets(g, targets)
    print "%d unowned planets in target sector" % len(targets)

  if len(targets) == 0:
    print "all planets in destination already claimed"
    return False

  redir_arcs = []
  for f in g.fleets:
    f.load()
    try:
      if f.ships['arcs'] >= 1:
        #print "found potential arc fleet %s, destination %s" % (f, f.destination)

        dest_planet_id = game.FleetDestToPlanetID(f.destination)
        if dest_planet_id != None:
          for p in source_targets:
            if int(p.planetid) == int(dest_planet_id):
              print "found arc %s heading into source space" % f

              redir_arcs.append(f)
        else:
          #print "not going to planet"
          #print f.destination
          if source_shape.inside(f.destination):
            print "found arc %s heading into source space" % f

            redir_arcs.append(f)
    except:
      pass


  print "%d arcs to redirect from source" % len(redir_arcs)

  RedirArcs(g, doupgrade, redir_arcs, targets, random)

# redirect arcs with their home as their target
def RedirReturningArcs(g, doupgrade, source_shape, dest_shape):

  targets = game.FindUnownedPlanetsInShape(g, dest_shape)
  owned_planets = game.FindOwnedPlanetsInShape(g, dest_shape)

  print "%d unowned planets in sector" % len(targets)

  targets = game.TrimColonyTargettedPlanets(g, targets)
  print "%d unowned planets in sector after trimming colony targets" % len(targets)

#  if len(targets) == 0:
#    print "all planets in destination already claimed"
#    return False

  redir_arcs = []
  for f in g.fleets:
    f.load()
    if f.ships.get('arcs', 0) > 0:
      #print "found potential arc fleet %s, destination %s" % (f, f.destination)

      dest_planet_id = game.FleetDestToPlanetID(f.destination)

      #print "fleet %s dest %s home %s" % (f, str(dest_planet_id), str(f.home.planetid))

      if source_shape == None or source_shape.inside(f.coords):
        if f.home != None:
          if dest_planet_id == f.home.planetid:
            print "found returning arc %s" % f

            redir_arcs.append(f)

  RedirArcs(g, doupgrade, redir_arcs, targets)

# redirect arcs away from owned planets
def RedirArcsFromOwned(g, doupgrade, source_shape, dest_shape):

  targets = game.FindUnownedPlanetsInShape(g, dest_shape)
  print "%d unowned planets in sector" % len(targets)

  targets = game.TrimColonyTargettedPlanets(g, targets)
  print "%d unowned planets in sector after trimming colony targets" % len(targets)

  owned_planets = game.FindOwnedPlanetsInShape(g, source_shape)
  print "%d owned planets in source sector" % len(owned_planets)

#  if len(targets) == 0:
#    print "all planets in destination already claimed"
#    return False

  redir_arcs = []
  for f in g.fleets:
    f.load()
    try:
      if f.ships['arcs'] >= 1:
        #print "found potential arc fleet %s, destination %s" % (f, f.destination)

        dest_planet_id = game.FleetDestToPlanetID(f.destination)

        for p in owned_planets:
          if int(p.planetid) == int(dest_planet_id):
            print "found newly owned planet %s with arc %s heading for it" % (p, f)

            redir_arcs.append(f)
            break
    except:
      pass

  RedirArcs(g, doupgrade, redir_arcs, targets)

def RedirArcs(g, doupgrade, arc_fleets, targets, rand=False):
  print "redirecting %d arcs to %d targets" % (len(arc_fleets), len(targets))

  #print arc_fleets
  #print targets
  #sys.exit(1)

  if rand:
    for f in arc_fleets:
      index = random.randrange(0, len(targets)-1)
      t = targets[index]
      print "moving fleet %s to planet %s, distance %f" % (f, t, game.distance_between(f.coords, t.location))

      if doupgrade:
        f.move_to_planet(t)

      # try not to pick this one again
      targets.remove(t)
      
      if len(targets) == 0:
        print "ran out of targets"
        break
  else: # not random
    # sort the shortest distances for each fleet
    for f in arc_fleets:
      f.targets = sorted(targets, key=lambda planet: game.distance_between(f.coords, planet.location))

    # iterate over all the fleets, building the shortest route of all of them
    while len(arc_fleets) > 0 and len(targets) > 0:
      # sort all of the remaining arcs by their shortest route
      arc_fleets = sorted(arc_fleets, key=lambda fleet: game.distance_between(fleet.coords, fleet.targets[0].location))

      arc = arc_fleets[0]
      target = arc.targets[0]
      print "moving fleet %s to planet %s, distance %f" % (arc, target, game.distance_between(arc.coords, target.location))
      if doupgrade:
        arc.move_to_planet(target)

      # remove this fleet and this target out of all of the lists
      arc_fleets.remove(arc)
      for f in arc_fleets:
        f.targets.remove(target)

      # trim the master target list
      targets.remove(target)

    for f in arc_fleets:
      del f.targets

if __name__ == "__main__":
    main()