Read --end into a map

[planeteer] / planeteer.go

diff --git a/planeteer.go b/planeteer.go
index 3783a8cb9009c076ce6ec3b014502770370c2b39..c207c13c1fe05719c3e5fcfdc19f677282fcb63c 100644 (file)
--- a/planeteer.go
+++ b/planeteer.go
@@ -23,13 +23,16 @@ import "json"
 import "os"
 import "strings"
 
 import "os"
 import "strings"
 

+var funds = flag.Int("funds", 0,
+       "Starting funds")
+

 var start = flag.String("start", "",
        "The planet to start at")
 
 var flight_plan_string = flag.String("flight_plan", "",
        "Your hidey-holes for the day, comma-separated.")
 
 var start = flag.String("start", "",
        "The planet to start at")
 
 var flight_plan_string = flag.String("flight_plan", "",
        "Your hidey-holes for the day, comma-separated.")
 

-var end = flag.String("end", "",
+var end_string = flag.String("end", "",

        "A comma-separated list of acceptable ending planets.")
 
 var planet_data_file = flag.String("planet_data_file", "planet-data",
        "A comma-separated list of acceptable ending planets.")
 
 var planet_data_file = flag.String("planet_data_file", "planet-data",


@@ -57,18 +60,29 @@ var visit_string = flag.String("visit", "",
 
 func visit() []string {
        if *visit_string == "" {
 
 func visit() []string {
        if *visit_string == "" {

-               return []string{}
+               return nil

        }
        return strings.Split(*visit_string, ",")
 }
 
 func flight_plan() []string {
        if *flight_plan_string == "" {
        }
        return strings.Split(*visit_string, ",")
 }
 
 func flight_plan() []string {
        if *flight_plan_string == "" {

-               return []string{}
+               return nil

        }
        return strings.Split(*flight_plan_string, ",")
 }
 
        }
        return strings.Split(*flight_plan_string, ",")
 }
 

+func end() map[string]bool {
+       if *end_string == "" {
+               return nil
+       }
+       m := make(map[string]bool)
+       for _, p := range strings.Split(*flight_plan_string, ",") {
+               m[p] = true
+       }
+       return m
+}
+

 type Commodity struct {
        BasePrice int
        CanSell   bool
 type Commodity struct {
        BasePrice int
        CanSell   bool


@@ -165,6 +179,9 @@ func bint(b bool) int {
 
 func DimensionSizes(data planet_data) []int {
        eden_capacity := data.Commodities["Eden Warp Units"].Limit
 
 func DimensionSizes(data planet_data) []int {
        eden_capacity := data.Commodities["Eden Warp Units"].Limit

+       if *start_edens > eden_capacity {
+               eden_capacity = *start_edens
+       }

        cloak_capacity := bint(*cloak)
        dims := make([]int, NumDimensions)
        dims[Edens] = eden_capacity + 1
        cloak_capacity := bint(*cloak)
        dims := make([]int, NumDimensions)
        dims[Edens] = eden_capacity + 1


@@ -172,7 +189,7 @@ func DimensionSizes(data planet_data) []int {
        dims[UnusedCargo] = eden_capacity + cloak_capacity + 1
        dims[Fuel] = *fuel + 1
        dims[Location] = len(data.Planets)
        dims[UnusedCargo] = eden_capacity + cloak_capacity + 1
        dims[Fuel] = *fuel + 1
        dims[Location] = len(data.Planets)

-       dims[Hold] = len(data.Commodities)
+       dims[Hold] = len(data.Commodities) + 1

        dims[NeedFighters] = bint(*drones > 0) + 1
        dims[NeedShields] = bint(*batteries > 0) + 1
        dims[Visit] = 1 << uint(len(visit()))
        dims[NeedFighters] = bint(*drones > 0) + 1
        dims[NeedShields] = bint(*batteries > 0) + 1
        dims[Visit] = 1 << uint(len(visit()))


@@ -203,7 +220,7 @@ func EncodeIndex(dims, addr []int) int {
        if addr[0] > dims[0] {
                panic(0)
        }
        if addr[0] > dims[0] {
                panic(0)
        }

-       for i := 1; i < len(dims); i++ {
+       for i := 1; i < NumDimensions; i++ {

                if addr[i] > dims[i] {
                        panic(i)
                }
                if addr[i] > dims[i] {
                        panic(i)
                }


@@ -213,8 +230,8 @@ func EncodeIndex(dims, addr []int) int {
 }
 
 func DecodeIndex(dims []int, index int) []int {
 }
 
 func DecodeIndex(dims []int, index int) []int {

-       addr := make([]int, len(dims))
-       for i := len(dims) - 1; i > 0; i-- {
+       addr := make([]int, NumDimensions)
+       for i := NumDimensions - 1; i > 0; i-- {

                addr[i] = index % dims[i]
                index /= dims[i]
        }
                addr[i] = index % dims[i]
                index /= dims[i]
        }


@@ -222,105 +239,193 @@ func DecodeIndex(dims []int, index int) []int {
        return addr
 }
 
        return addr
 }
 

-func InitializeStateTable(data planet_data, dims []int, table []State) {
+func InitializeStateTable(data planet_data, dims []int) []State {
+       table := make([]State, StateTableSize(dims))
+
+       addr := make([]int, NumDimensions)
+       addr[Fuel] = *fuel
+       addr[Edens] = *start_edens
+       addr[Location] = data.p2i[*start]
+       table[EncodeIndex(dims, addr)].value = *funds
+
+       return table

 }
 
 }
 

-/* Fill in the cell at address addr by looking at all the possible ways
- * to reach this cell and selecting the best one.
+/* These four fill procedures fill in the cell at address addr by
+ * looking at all the possible ways to reach this cell and selecting
+ * the best one.

  *
  * The other obvious implementation choice is to do this the other way
  * around -- for each cell, conditionally overwrite all the other cells
  * that are reachable *from* the considered cell.  We choose gathering
  * reads over scattering writes to avoid having to take a bunch of locks.
  *
  * The other obvious implementation choice is to do this the other way
  * around -- for each cell, conditionally overwrite all the other cells
  * that are reachable *from* the considered cell.  We choose gathering
  * reads over scattering writes to avoid having to take a bunch of locks.

- *
- * The order that we check things here matters only for value ties.  We
- * keep the first best path.  So when action order doesn't matter, the
- * check that is performed first here will appear in the output first.

  */
  */

-func FillStateTableCell(data planet_data, dims []int, table []State, addr []int) {
+
+func UpdateCell(table []State, here, there, value_difference int) {
+       possible_value := table[there].value + value_difference
+       if table[there].value > 0 && possible_value > table[here].value {
+               table[here].value = possible_value
+               table[here].from = there
+       }
+}
+
+func FillCellByArriving(data planet_data, dims []int, table []State, addr []int) {

        my_index := EncodeIndex(dims, addr)
        other := make([]int, NumDimensions)
        copy(other, addr)
 
        /* Travel here via a 2-fuel unit jump */
        my_index := EncodeIndex(dims, addr)
        other := make([]int, NumDimensions)
        copy(other, addr)
 
        /* Travel here via a 2-fuel unit jump */

-       if addr[Fuel] + 2 < dims[Fuel] {
+       if addr[Fuel]+2 < dims[Fuel] {

                other[Fuel] = addr[Fuel] + 2
                other[Fuel] = addr[Fuel] + 2

-               for p := 0; p < dims[Location]; p++ {
-                       other[Location] = p
-                       if table[EncodeIndex(dims, other)].value > table[my_index].value {
-                               table[my_index].value = table[EncodeIndex(dims, other)].value
-                               table[my_index].from = EncodeIndex(dims, other)
-                       }
+               for other[Location] = 0; other[Location] < dims[Location]; other[Location]++ {
+                       UpdateCell(table, my_index, EncodeIndex(dims, other), 0)

                }
                other[Location] = addr[Location]
                other[Fuel] = addr[Fuel]
        }
 
        /* Travel here via a hidey hole */
                }
                other[Location] = addr[Location]
                other[Fuel] = addr[Fuel]
        }
 
        /* Travel here via a hidey hole */

-       if addr[Fuel] + 1 < dims[Fuel] {
+       if addr[Fuel]+1 < dims[Fuel] {

                hole_index := (dims[Fuel] - 1) - (addr[Fuel] + 1)
                hole_index := (dims[Fuel] - 1) - (addr[Fuel] + 1)

-               if hole_index < len(flight_plan()) {
+               if hole_index < len(flight_plan()) && addr[Location] == data.p2i[flight_plan()[hole_index]] {

                        other[Fuel] = addr[Fuel] + 1
                        other[Fuel] = addr[Fuel] + 1

-                       other[Location] = data.p2i[flight_plan()[hole_index]]
-                       if table[EncodeIndex(dims, other)].value > table[my_index].value {
-                               table[my_index].value = table[EncodeIndex(dims, other)].value
-                               table[my_index].from = EncodeIndex(dims, other)
+                       for other[Location] = 0; other[Location] < dims[Location]; other[Location]++ {
+                               UpdateCell(table, my_index, EncodeIndex(dims, other), 0)

                        }
                        }

+                       other[Location] = addr[Location]

                        other[Fuel] = addr[Fuel]
                }
        }
 
        /* Travel here via Eden Warp Unit */
                        other[Fuel] = addr[Fuel]
                }
        }
 
        /* Travel here via Eden Warp Unit */

-       /* Silly: Dump Eden warp units */
+       for other[Edens] = addr[Edens] + 1; other[Edens] < dims[Edens]; other[Edens]++ {
+               for other[Location] = 0; other[Location] < dims[Location]; other[Location]++ {
+                       UpdateCell(table, my_index, EncodeIndex(dims, other), 0)
+               }
+       }
+       other[Location] = addr[Location]
+       other[Edens] = addr[Edens]
+}
+
+func FillCellBySelling(data planet_data, dims []int, table []State, addr []int) {
+       if addr[Hold] > 0 {
+               // Can't sell and still have cargo
+               return
+       }
+       if addr[UnusedCargo] > 0 {
+               // Can't sell everything and still have 'unused' holds
+               return
+       }
+       my_index := EncodeIndex(dims, addr)
+       other := make([]int, NumDimensions)
+       copy(other, addr)
+       planet := data.i2p[addr[Location]]
+       for other[Hold] = 0; other[Hold] < dims[Hold]; other[Hold]++ {
+               commodity := data.i2c[other[Hold]]
+               if !data.Commodities[commodity].CanSell {
+                       // TODO: Dump cargo
+                       continue
+               }
+               relative_price, available := data.Planets[planet].RelativePrices[commodity]
+               if !available {
+                       continue
+               }
+               base_price := data.Commodities[commodity].BasePrice
+               absolute_price := float64(base_price) * float64(relative_price) / 100.0
+               sell_price := int(absolute_price * 0.9)
+
+               for other[UnusedCargo] = 0; other[UnusedCargo] < dims[UnusedCargo]; other[UnusedCargo]++ {
+
+                       quantity := *hold - (other[UnusedCargo] + other[Cloaks] + other[Edens])
+                       sale_value := quantity * sell_price
+                       UpdateCell(table, my_index, EncodeIndex(dims, other), sale_value)
+               }
+       }
+       other[UnusedCargo] = addr[UnusedCargo]
+}
+
+func FillCellByBuying(data planet_data, dims []int, table []State, addr []int) {
+       if addr[Hold] == 0 {
+               // Can't buy and then have nothing
+               return
+       }
+       my_index := EncodeIndex(dims, addr)
+       other := make([]int, NumDimensions)
+       copy(other, addr)
+       planet := data.i2p[addr[Location]]
+       commodity := data.i2c[addr[Hold]]
+       if !data.Commodities[commodity].CanSell {
+               return
+       }
+       relative_price, available := data.Planets[planet].RelativePrices[commodity]
+       if !available {
+               return
+       }
+       base_price := data.Commodities[commodity].BasePrice
+       absolute_price := int(float64(base_price) * float64(relative_price) / 100.0)
+       quantity := *hold - (addr[UnusedCargo] + addr[Cloaks] + addr[Edens])
+       total_price := quantity * absolute_price
+       other[Hold] = 0
+       other[UnusedCargo] = 0
+       UpdateCell(table, my_index, EncodeIndex(dims, other), -total_price)
+       other[UnusedCargo] = addr[UnusedCargo]
+       other[Hold] = addr[Hold]
+}
+
+func FillCellByMisc(data planet_data, dims []int, table []State, addr []int) {
+       my_index := EncodeIndex(dims, addr)
+       other := make([]int, NumDimensions)
+       copy(other, addr)

        /* Buy Eden warp units */
        /* Buy a Device of Cloaking */
        /* Buy Eden warp units */
        /* Buy a Device of Cloaking */

+       if addr[Cloaks] == 1 && addr[UnusedCargo] < dims[UnusedCargo]-1 {
+               relative_price, available := data.Planets[data.i2p[addr[Location]]].RelativePrices["Device Of Cloakings"]
+               if available {
+                       absolute_price := int(float64(data.Commodities["Device Of Cloakings"].BasePrice) * float64(relative_price) / 100.0)
+                       other[Cloaks] = 0
+                       if other[Hold] != 0 {
+                               other[UnusedCargo] = addr[UnusedCargo] + 1
+                       }
+                       UpdateCell(table, my_index, EncodeIndex(dims, other), -absolute_price)
+                       other[UnusedCargo] = addr[UnusedCargo]
+                       other[Cloaks] = addr[Cloaks]
+               }
+       }

        /* Silly: Dump a Device of Cloaking */
        /* Buy Fighter Drones */
        /* Buy Shield Batteries */
        /* Silly: Dump a Device of Cloaking */
        /* Buy Fighter Drones */
        /* Buy Shield Batteries */

-       if addr[Hold] == 0 {
-               /* Sell or dump things */
-               // for commodity := range data.Commodities { }
-       } else {
-               /* Buy this thing */
-       }

        /* Visit this planet */
 }
 
        /* Visit this planet */
 }
 

-func FillStateTable2(data planet_data, dims []int, table []State,
-fuel_remaining, edens_remaining int, planet string, barrier chan<- bool) {
-       /* The dimension nesting order up to this point is important.
-        * Beyond this point, it's not important.
-        *
-        * It is very important when iterating through the Hold dimension
-        * to visit the null commodity (empty hold) first.  Visiting the
-        * null commodity represents selling.  Visiting it first gets the
-        * action order correct: arrive, sell, buy, leave.  Visiting the
-        * null commodity after another commodity would evaluate the action
-        * sequence: arrive, buy, sell, leave.  This is a useless action
-        * sequence.  Because we visit the null commodity first, we do not
-        * consider these action sequences.
-        */
-       eden_capacity := data.Commodities["Eden Warp Units"].Limit
-       addr := make([]int, len(dims))
-       addr[Edens] = edens_remaining
-       addr[Fuel] = fuel_remaining
-       addr[Location] = data.p2i[planet]
+func FillStateTable2Iteration(data planet_data, dims []int, table []State,
+addr []int, f func(planet_data, []int, []State, []int)) {
+       /* TODO: Justify the safety of the combination of this dimension
+        * iteration and the various phases f.  */

        for addr[Hold] = 0; addr[Hold] < dims[Hold]; addr[Hold]++ {
                for addr[Cloaks] = 0; addr[Cloaks] < dims[Cloaks]; addr[Cloaks]++ {
                        for addr[UnusedCargo] = 0; addr[UnusedCargo] < dims[UnusedCargo]; addr[UnusedCargo]++ {
        for addr[Hold] = 0; addr[Hold] < dims[Hold]; addr[Hold]++ {
                for addr[Cloaks] = 0; addr[Cloaks] < dims[Cloaks]; addr[Cloaks]++ {
                        for addr[UnusedCargo] = 0; addr[UnusedCargo] < dims[UnusedCargo]; addr[UnusedCargo]++ {

-                               if addr[Edens]+addr[Cloaks]+addr[UnusedCargo] <=
-                                       eden_capacity+1 {
-                                       for addr[NeedFighters] = 0; addr[NeedFighters] < dims[NeedFighters]; addr[NeedFighters]++ {
-                                               for addr[NeedShields] = 0; addr[NeedShields] < dims[NeedShields]; addr[NeedShields]++ {
-                                                       for addr[Visit] = 0; addr[Visit] < dims[Visit]; addr[Visit]++ {
-                                                               FillStateTableCell(data, dims, table, addr)
-                                                       }
+                               for addr[NeedFighters] = 0; addr[NeedFighters] < dims[NeedFighters]; addr[NeedFighters]++ {
+                                       for addr[NeedShields] = 0; addr[NeedShields] < dims[NeedShields]; addr[NeedShields]++ {
+                                               for addr[Visit] = 0; addr[Visit] < dims[Visit]; addr[Visit]++ {
+                                                       f(data, dims, table, addr)

                                                }
                                        }
                                }
                        }
                }
        }
                                                }
                                        }
                                }
                        }
                }
        }

+}
+
+func FillStateTable2(data planet_data, dims []int, table []State,
+fuel_remaining, edens_remaining int, planet string, barrier chan<- bool) {
+       addr := make([]int, len(dims))
+       addr[Edens] = edens_remaining
+       addr[Fuel] = fuel_remaining
+       addr[Location] = data.p2i[planet]
+       FillStateTable2Iteration(data, dims, table, addr, FillCellByArriving)
+       FillStateTable2Iteration(data, dims, table, addr, FillCellBySelling)
+       FillStateTable2Iteration(data, dims, table, addr, FillCellByBuying)
+       FillStateTable2Iteration(data, dims, table, addr, FillCellByMisc)

        barrier <- true
 }
 
        barrier <- true
 }
 


@@ -356,69 +461,79 @@ func FillStateTable1(data planet_data, dims []int, table []State) {
                                <-barrier
                        }
                        work_done++
                                <-barrier
                        }
                        work_done++

-                       fmt.Printf("\r%3.0f%%", 100*work_done/work_units)
+                       print(fmt.Sprintf("\r%3.0f%%", 100*work_done/work_units))

                }
        }
        print("\n")
 }
 
                }
        }
        print("\n")
 }
 

-/* What is the value of hauling 'commodity' from 'from' to 'to'?
- * Take into account the available funds and the available cargo space. */
-func TradeValue(data planet_data,
-from, to Planet,
-commodity string,
-initial_funds, max_quantity int) int {
-       if !data.Commodities[commodity].CanSell {
-               return 0
-       }
-       from_relative_price, from_available := from.RelativePrices[commodity]
-       if !from_available {
-               return 0
-       }
-       to_relative_price, to_available := to.RelativePrices[commodity]
-       if !to_available {
-               return 0
+func FindBestState(data planet_data, dims []int, table []State) int {
+       addr := make([]int, NumDimensions)
+       addr[Edens] = *end_edens
+       addr[Cloaks] = dims[Cloaks] - 1
+       addr[NeedFighters] = dims[NeedFighters] - 1
+       addr[NeedShields] = dims[NeedShields] - 1
+       addr[Visit] = dims[Visit] - 1
+       // Fuel, Hold, UnusedCargo left at 0
+       max_index := -1
+       max_value := 0
+       for addr[Location] = 0; addr[Location] < dims[Location]; addr[Location]++ {
+               index := EncodeIndex(dims, addr)
+               if table[index].value > max_value {
+                       max_value = table[index].value
+                       max_index = index
+               }

        }
        }

+       return max_index
+}

 
 

-       base_price := data.Commodities[commodity].BasePrice
-       from_absolute_price := from_relative_price * base_price
-       to_absolute_price := to_relative_price * base_price
-       buy_price := from_absolute_price
-       sell_price := int(float64(to_absolute_price) * 0.9)
-       var can_afford int = initial_funds / buy_price
-       quantity := can_afford
-       if quantity > max_quantity {
-               quantity = max_quantity
-       }
-       return (sell_price - buy_price) * max_quantity
+func Commas(n int) (s string) {
+       r := n % 1000
+       n /= 1000
+       for n > 0 {
+               s = fmt.Sprintf(",%03d", r) + s
+               r = n % 1000
+               n /= 1000
+       }
+       s = fmt.Sprint(r) + s
+       return

 }
 
 }
 

-func FindBestTrades(data planet_data) [][]string {
-       // TODO: We can't cache this because this can change based on available funds.
-       best := make([][]string, len(data.Planets))
-       for from := range data.Planets {
-               best[data.p2i[from]] = make([]string, len(data.Planets))
-               for to := range data.Planets {
-                       best_gain := 0
-                       price_list := data.Planets[from].RelativePrices
-                       if len(data.Planets[to].RelativePrices) < len(data.Planets[from].RelativePrices) {
-                               price_list = data.Planets[to].RelativePrices
+func DescribePath(data planet_data, dims []int, table []State, start int) (description []string) {
+       for index := start; index > 0 && table[index].from > 0; index = table[index].from {
+               line := fmt.Sprintf("%13v", Commas(table[index].value))
+               addr := DecodeIndex(dims, index)
+               prev := DecodeIndex(dims, table[index].from)
+               if addr[Location] != prev[Location] {
+                       from := data.i2p[prev[Location]]
+                       to := data.i2p[addr[Location]]
+                       if addr[Fuel] != prev[Fuel] {
+                               line += fmt.Sprintf(" Jump from %v to %v (%v reactor units)", from, to, prev[Fuel]-addr[Fuel])
+                       } else if addr[Edens] != prev[Edens] {
+                               line += fmt.Sprintf(" Eden warp from %v to %v", from, to)
+                       } else {
+                               panic("Traveling without fuel?")

                        }
                        }

-                       for commodity := range price_list {
-                               gain := TradeValue(data,
-                                       data.Planets[from],
-                                       data.Planets[to],
-                                       commodity,
-                                       10000000,
-                                       1)
-                               if gain > best_gain {
-                                       best[data.p2i[from]][data.p2i[to]] = commodity
-                                       gain = best_gain
-                               }
+               }
+               if addr[Hold] != prev[Hold] {
+                       if addr[Hold] == 0 {
+                               quantity := *hold - (prev[UnusedCargo] + prev[Edens] + prev[Cloaks])
+                               line += fmt.Sprintf(" Sell %v %v", quantity, data.i2c[prev[Hold]])
+                       } else if prev[Hold] == 0 {
+                               quantity := *hold - (addr[UnusedCargo] + addr[Edens] + addr[Cloaks])
+                               line += fmt.Sprintf(" Buy %v %v", quantity, data.i2c[addr[Hold]])
+                       } else {
+                               panic("Switched cargo?")

                        }
                        }

+

                }
                }

+               if addr[Cloaks] == 1 && prev[Cloaks] == 0 {
+                       // TODO: Dump cloaks, convert from cargo?
+                       line += " Buy a Cloak"
+               }
+               description = append(description, line)

        }
        }

-       return best
+       return

 }
 
 // (Example of a use case for generics in Go)
 }
 
 // (Example of a use case for generics in Go)


@@ -451,20 +566,15 @@ func main() {
        data.p2i, data.i2p = IndexPlanets(&data.Planets, 0)
        data.c2i, data.i2c = IndexCommodities(&data.Commodities, 1)
        dims := DimensionSizes(data)
        data.p2i, data.i2p = IndexPlanets(&data.Planets, 0)
        data.c2i, data.i2c = IndexCommodities(&data.Commodities, 1)
        dims := DimensionSizes(data)

-       table := make([]State, StateTableSize(dims))
-       InitializeStateTable(data, dims, table)
+       table := InitializeStateTable(data, dims)

        FillStateTable1(data, dims, table)
        FillStateTable1(data, dims, table)

-       print("Going to print state table...")
-       fmt.Printf("%v", table)
-       best_trades := FindBestTrades(data)
-
-       for from := range data.Planets {
-               for to := range data.Planets {
-                       best_trade := "(nothing)"
-                       if best_trades[data.p2i[from]][data.p2i[to]] != "" {
-                               best_trade = best_trades[data.p2i[from]][data.p2i[to]]
-                       }
-                       fmt.Printf("%s to %s: %s\n", from, to, best_trade)
+       best := FindBestState(data, dims, table)
+       if best == -1 {
+               print("Cannot acheive success criteria\n")
+       } else {
+               description := DescribePath(data, dims, table, best)
+               for i := len(description) - 1; i >= 0; i-- {
+                       fmt.Println(description[i])

                }
        }
 }
                }
        }
 }