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",
func visit() []string {
if *visit_string == "" {
- return []string{}
+ return nil
}
return strings.Split(*visit_string, ",")
}
func flight_plan() []string {
if *flight_plan_string == "" {
- return []string{}
+ return nil
}
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(*end_string, ",") {
+ m[p] = true
+ }
+ return m
+}
+
type Commodity struct {
BasePrice int
CanSell bool
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()))
panic(0)
}
for i := 1; i < NumDimensions; i++ {
- if addr[i] > dims[i] {
+ if addr[i] < 0 || addr[i] > dims[i] {
panic(i)
}
index = index*dims[i] + addr[i]
if addr[Fuel]+2 < dims[Fuel] {
other[Fuel] = addr[Fuel] + 2
for other[Location] = 0; other[Location] < dims[Location]; other[Location]++ {
- UpdateCell(table, my_index, EncodeIndex(dims, other), 0)
+ if data.Planets[data.i2p[addr[Location]]].BeaconOn {
+ UpdateCell(table, my_index, EncodeIndex(dims, other), 0)
+ }
}
other[Location] = addr[Location]
other[Fuel] = addr[Fuel]
/* Travel here via a hidey hole */
if addr[Fuel]+1 < dims[Fuel] {
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[Location] = data.p2i[flight_plan()[hole_index]]
- UpdateCell(table, my_index, EncodeIndex(dims, other), 0)
+ 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 */
- 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)
+ if addr[Edens]+1 < dims[Edens] && addr[UnusedCargo] > 1 {
+ _, available := data.Planets[data.i2p[addr[Location]]].RelativePrices["Eden Warp Units"]
+ if !available {
+ other[Edens] = addr[Edens] + 1
+ other[UnusedCargo] = addr[UnusedCargo] - 1
+ for other[Location] = 0; other[Location] < dims[Location]; other[Location]++ {
+ UpdateCell(table, my_index, EncodeIndex(dims, other), 0)
+ }
+ other[Location] = addr[Location]
+ other[UnusedCargo] = addr[UnusedCargo]
+ other[Edens] = addr[Edens]
}
}
- other[Location] = addr[Location]
- other[Edens] = addr[Edens]
}
func FillCellBySelling(data planet_data, dims []int, table []State, addr []int) {
continue
}
base_price := data.Commodities[commodity].BasePrice
- absolute_price := relative_price * base_price
- sell_price := int(float64(absolute_price) * 0.9)
+ 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] // TODO: Partial sales
+ quantity := *hold - (other[UnusedCargo] + other[Cloaks] + other[Edens])
sale_value := quantity * sell_price
UpdateCell(table, my_index, EncodeIndex(dims, other), sale_value)
}
return
}
base_price := data.Commodities[commodity].BasePrice
- absolute_price := relative_price * base_price
- quantity := *hold - addr[UnusedCargo]
+ 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) {
- /* Buy Eden warp units */
+ my_index := EncodeIndex(dims, addr)
+ other := make([]int, NumDimensions)
+ copy(other, addr)
+
/* 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 */
/* Visit this planet */
}
+func FillCellByBuyingEdens(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 */
+ eden_limit := data.Commodities["Eden Warp Units"].Limit
+ if addr[Edens] > 0 && addr[Edens] <= eden_limit {
+ relative_price, available := data.Planets[data.i2p[addr[Location]]].RelativePrices["Eden Warp Units"]
+ if available {
+ absolute_price := int(float64(data.Commodities["Eden Warp Units"].BasePrice) * float64(relative_price) / 100.0)
+ for quantity := addr[Edens]; quantity > 0; quantity-- {
+ other[Edens] = addr[Edens] - quantity
+ if addr[Hold] != 0 {
+ other[UnusedCargo] = addr[UnusedCargo] + quantity
+ }
+ if other[UnusedCargo] < dims[UnusedCargo] {
+ UpdateCell(table, my_index, EncodeIndex(dims, other), -absolute_price * quantity)
+ }
+ }
+ other[Edens] = addr[Edens]
+ other[UnusedCargo] = addr[UnusedCargo]
+ }
+ }
+}
+
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
}
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]
+addr []int, barrier chan<- bool) {
FillStateTable2Iteration(data, dims, table, addr, FillCellByArriving)
FillStateTable2Iteration(data, dims, table, addr, FillCellBySelling)
FillStateTable2Iteration(data, dims, table, addr, FillCellByBuying)
work_done := 0.0
for fuel_remaining := *fuel; fuel_remaining >= 0; fuel_remaining-- {
for edens_remaining := eden_capacity; edens_remaining >= 0; edens_remaining-- {
+ /* Do the brunt of the work */
for planet := range data.Planets {
- go FillStateTable2(data, dims, table, fuel_remaining,
- edens_remaining, planet, barrier)
+ addr := make([]int, len(dims))
+ addr[Edens] = edens_remaining
+ addr[Fuel] = fuel_remaining
+ addr[Location] = data.p2i[planet]
+ go FillStateTable2(data, dims, table, addr, barrier)
}
for _ = range data.Planets {
<-barrier
}
work_done++
- fmt.Printf("\r%3.0f%%", 100*work_done/work_units)
+ print(fmt.Sprintf("\r%3.0f%%", 100*work_done/work_units))
+ }
+ /* Make an Eden-buying pass (uphill) */
+ addr := make([]int, len(dims))
+ addr[Fuel] = fuel_remaining
+ for addr[Edens] = 0; addr[Edens] <= eden_capacity; addr[Edens]++ {
+ for planet := range data.Planets {
+ addr[Location] = data.p2i[planet]
+ FillStateTable2Iteration(data, dims, table, addr, FillCellByBuyingEdens)
+ }
}
}
print("\n")
}
+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]++ {
+ if len(end()) == 0 || end()[data.i2p[addr[Location]]] {
+ index := EncodeIndex(dims, addr)
+ if table[index].value > max_value {
+ max_value = table[index].value
+ max_index = index
+ }
+ }
+ }
+ return max_index
+}
+
+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 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 {
+ var line string
+ addr := DecodeIndex(dims, index)
+ prev := DecodeIndex(dims, table[index].from)
+ if addr[Fuel] != prev[Fuel] {
+ from := data.i2p[prev[Location]]
+ to := data.i2p[addr[Location]]
+ line += fmt.Sprintf("Jump from %v to %v (%v reactor units)", from, to, prev[Fuel]-addr[Fuel])
+ }
+ if addr[Edens] == prev[Edens] - 1 {
+ from := data.i2p[prev[Location]]
+ to := data.i2p[addr[Location]]
+ line += fmt.Sprintf("Eden warp from %v to %v", from, to)
+ }
+ 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"
+ }
+ if addr[Edens] > prev[Edens] {
+ line += fmt.Sprint("Buy ", addr[Edens] - prev[Edens], " Eden Warp Units")
+ }
+ if line == "" {
+ line = fmt.Sprint(prev, " -> ", addr)
+ }
+ description = append(description, fmt.Sprintf("%13v ", Commas(table[index].value)) + line)
+ }
+ return
+}
+
// (Example of a use case for generics in Go)
func IndexPlanets(m *map[string]Planet, start_at int) (map[string]int, []string) {
e2i := make(map[string]int, len(*m)+start_at)
dims := DimensionSizes(data)
table := InitializeStateTable(data, dims)
FillStateTable1(data, dims, table)
- print("Going to print state table...")
- fmt.Printf("%v", table)
+ 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])
+ }
+ }
}
projects / planeteer / blobdiff