Calculate visit costs

[planeteer] / planeteer.go

diff --git a/planeteer.go b/planeteer.go
index a707d589d11778890efc81cb73b5f2a31346278a..82650b9ffe88e72179ef149d87bf350bd4cdeee6 100644 (file)
--- a/planeteer.go
+++ b/planeteer.go
@@ -19,7 +19,7 @@ package main
 
 import "flag"
 import "fmt"
 
 import "flag"
 import "fmt"

-import "json"
+import "encoding/json"

 import "os"
 import "runtime/pprof"
 import "strings"
 import "os"
 import "runtime/pprof"
 import "strings"


@@ -65,6 +65,9 @@ var battery_price = flag.Int("battery_price", 0, "Today's Shield Battery price")
 var visit_string = flag.String("visit", "",
        "A comma-separated list of planets to make sure to visit")
 
 var visit_string = flag.String("visit", "",
        "A comma-separated list of planets to make sure to visit")
 

+var tomorrow_weight = flag.Float64("tomorrow_weight", 1.0,
+       "Weight for the expected value of tomorrow's trading.  0.0 - 1.0")
+

 var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
 
 var visit_cache []string
 var cpuprofile = flag.String("cpuprofile", "", "write cpu profile to file")
 
 var visit_cache []string


@@ -113,8 +116,9 @@ type Commodity struct {
        Limit     int
 }
 type Planet struct {
        Limit     int
 }
 type Planet struct {

-       BeaconOn bool
-       Private  bool
+       BeaconOn      bool
+       Private       bool
+       TomorrowValue int

        /* Use relative prices rather than absolute prices because you
           can get relative prices without traveling to each planet. */
        RelativePrices map[string]int
        /* Use relative prices rather than absolute prices because you
           can get relative prices without traveling to each planet. */
        RelativePrices map[string]int


@@ -476,8 +480,7 @@ func CellValue(data planet_data, dims []int, table []State, addr []int) int32 {
        }
 
        /* Visit this planet */
        }
 
        /* Visit this planet */

-       var i uint
-       for i = 0; i < uint(len(visit())); i++ {
+       for i := uint(0); i < uint(len(visit())); i++ {

                if addr[Visit]&(1<<i) != 0 && visit()[i] == data.i2p[addr[Location]] {
                        other[Visit] = addr[Visit] & ^(1 << i)
                        Consider(data, dims, table, other, 0, &best_value, best_source)
                if addr[Visit]&(1<<i) != 0 && visit()[i] == data.i2p[addr[Location]] {
                        other[Visit] = addr[Visit] & ^(1 << i)
                        Consider(data, dims, table, other, 0, &best_value, best_source)


@@ -531,7 +534,7 @@ func CellValue(data planet_data, dims []int, table []State, addr []int) int32 {
        return table[my_index].value
 }
 
        return table[my_index].value
 }
 

-func FindBestState(data planet_data, dims []int, table []State) int32 {
+func FinalState(dims []int) []int {

        addr := make([]int, NumDimensions)
        addr[Edens] = *end_edens
        addr[Cloaks] = dims[Cloaks] - 1
        addr := make([]int, NumDimensions)
        addr[Edens] = *end_edens
        addr[Cloaks] = dims[Cloaks] - 1


@@ -541,17 +544,25 @@ func FindBestState(data planet_data, dims []int, table []State) int32 {
        addr[Traded] = 1
        addr[Hold] = 0
        addr[UnusedCargo] = 0
        addr[Traded] = 1
        addr[Hold] = 0
        addr[UnusedCargo] = 0

+       // Fuel and Location are determined by FindBestState
+       return addr
+}
+
+func FindBestState(data planet_data, dims []int, table []State, addr []int) int32 {

        max_index := int32(-1)
        max_index := int32(-1)

-       max_value := int32(0)
+       max_value := 0.0

        max_fuel := 1
        if *fuel == 0 {
                max_fuel = 0
        }
        for addr[Fuel] = 0; addr[Fuel] <= max_fuel; addr[Fuel]++ {
                for addr[Location] = 0; addr[Location] < dims[Location]; addr[Location]++ {
        max_fuel := 1
        if *fuel == 0 {
                max_fuel = 0
        }
        for addr[Fuel] = 0; addr[Fuel] <= max_fuel; addr[Fuel]++ {
                for addr[Location] = 0; addr[Location] < dims[Location]; addr[Location]++ {

-                       if len(end()) == 0 || end()[data.i2p[addr[Location]]] {
+                       planet := data.i2p[addr[Location]]
+                       if len(end()) == 0 || end()[planet] {

                                index := EncodeIndex(dims, addr)
                                index := EncodeIndex(dims, addr)

-                               value := CellValue(data, dims, table, addr)
+                               today_value := CellValue(data, dims, table, addr)
+                               tomorrow_value := *tomorrow_weight * float64(*hold+data.Planets[planet].TomorrowValue)
+                               value := float64(today_value) + tomorrow_value

                                if value > max_value {
                                        max_value = value
                                        max_index = index
                                if value > max_value {
                                        max_value = value
                                        max_index = index


@@ -563,6 +574,9 @@ func FindBestState(data planet_data, dims []int, table []State) int32 {
 }
 
 func Commas(n int32) (s string) {
 }
 
 func Commas(n int32) (s string) {

+       if n < 0 {
+               panic(n)
+       }

        r := n % 1000
        n /= 1000
        for n > 0 {
        r := n % 1000
        n /= 1000
        for n > 0 {


@@ -687,14 +701,64 @@ func main() {
        data.c2i, data.i2c = IndexCommodities(&data.Commodities, 1)
        dims := DimensionSizes(data)
        table := CreateStateTable(data, dims)
        data.c2i, data.i2c = IndexCommodities(&data.Commodities, 1)
        dims := DimensionSizes(data)
        table := CreateStateTable(data, dims)

-       best := FindBestState(data, dims, table)
+       final_state := FinalState(dims)
+       best := FindBestState(data, dims, table, final_state)

        print("\n")
        if best == -1 {
                print("Cannot acheive success criteria\n")
        print("\n")
        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])
-               }
+               return
+       }
+       description := DescribePath(data, dims, table, best)
+       for i := len(description) - 1; i >= 0; i-- {
+               fmt.Println(description[i])
+       }
+
+       // Ok, that was the important stuff.  Now some fun stuff.
+
+       // Calculate total cost of fighters and shields
+       if *drones > 0 || *batteries > 0 {
+               fmt.Println()
+       }
+       if *drones > 0 {
+               final_state[BuyFighters] = 0
+               alt_best := FindBestState(data, dims, table, final_state)
+               cost := table[alt_best].value - table[best].value
+               fmt.Println("\rDrones were", float64(cost)/float64(*drones), "each")
+               final_state[BuyFighters] = 1
+       }
+       if *batteries > 0 {
+               final_state[BuyShields] = 0
+               alt_best := FindBestState(data, dims, table, final_state)
+               cost := table[alt_best].value - table[best].value
+               fmt.Println("\rBatteries were", float64(cost)/float64(*batteries), "each")
+               final_state[BuyShields] = 1
+       }
+
+       // Use extra eden warps
+       if *end_edens > 0 {
+               fmt.Println()

        }
        }

+       for extra_edens := 1; extra_edens <= *end_edens; extra_edens++ {
+               final_state[Edens] = *end_edens - extra_edens
+               alt_best := FindBestState(data, dims, table, final_state)
+               extra_funds := table[alt_best].value - table[best].value
+               fmt.Println("\rUse", extra_edens, "extra edens, make an extra",
+                       Commas(extra_funds), "(",
+                       Commas(extra_funds/int32(extra_edens)), "per eden)")
+       }
+       final_state[Edens] = *end_edens
+
+       // Cost of visiting places
+       if dims[Visit] > 1 {
+               fmt.Println()
+       }
+       for i := uint(0); i < uint(len(visit())); i++ {
+               all_bits := dims[Visit] - 1
+               final_state[Visit] = all_bits & ^(1 << i)
+               alt_best := FindBestState(data, dims, table, final_state)
+               cost := table[alt_best].value - table[best].value
+               fmt.Println("\r", Commas(cost), "Cost to visit", visit()[i])
+       }
+       final_state[Visit] = dims[Visit] - 1
+

 }
 }