X-Git-Url: http://git.scottworley.com/planeteer/blobdiff_plain/bc4a3744c612277ded9e74e3463934f127b46041..HEAD:/planeteer.go diff --git a/planeteer.go b/planeteer.go index d81713e..cf00d56 100644 --- a/planeteer.go +++ b/planeteer.go @@ -3,8 +3,7 @@ * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU Affero General Public License as - * published by the Free Software Foundation, either version 3 of the - * License, or (at your option) any later version. + * published by the Free Software Foundation, version 3. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -133,17 +132,26 @@ type planet_data struct { i2p, i2c []string // Generated; not read from file } -func ReadData() (data planet_data) { - f, err := os.Open(*planet_data_file) +func json_slurp(filename string, receptacle interface{}) error { + f, err := os.Open(filename) if err != nil { - panic(err) + return err } defer f.Close() - err = json.NewDecoder(f).Decode(&data) + err = json.NewDecoder(f).Decode(receptacle) + if err != nil { + return err + } + return nil +} + +func ReadData() planet_data { + var data planet_data + err := json_slurp(*planet_data_file, &data) if err != nil { panic(err) } - return + return data } /* This program operates by filling in a state table representing the best @@ -170,20 +178,22 @@ func ReadData() (data planet_data) { * independent -- some combinations are illegal and not used. They are * handled as three dimensions rather than one for simplicity. Placing * these dimensions first causes the unused cells in the table to be - * grouped together in large blocks. This keeps them from polluting - * cache lines, and if they are large enough, allows the memory manager - * to swap out entire pages. + * grouped together in large blocks. This keeps the unused cells from + * polluting cache lines, and if the spans of unused cells are large + * enough, allows the memory manager to swap out entire pages. * * If the table gets too big to fit in RAM: * * Combine the Edens, Cloaks, and UnusedCargo dimensions. Of the * 24 combinations, only 15 are legal: a 38% savings. - * * Reduce the size of the Fuel dimension to 3. We only ever look - * backwards 2 units, so just rotate the logical values through - * the same 3 physical addresses. This is good for an 82% savings. + * * Reduce the size of the Fuel dimension to 3. Explicit iteration + * only ever needs to look backwards 2 units, so the logical values + * can rotate through the same 3 physical addresses. This would be + * good for an 82% savings. Note that explicit iteration went away + * in 0372f045. * * Reduce the size of the Edens dimension from 3 to 2, for the * same reasons as Fuel above. 33% savings. * * Buy more ram. (Just sayin'. It's cheaper than you think.) - * + * */ // The official list of dimensions: @@ -210,13 +220,13 @@ func bint(b bool) int { return 0 } -func DimensionSizes(data planet_data) []int { +func DimensionSizes(data planet_data) LogicalIndex { 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 := make(LogicalIndex, NumDimensions) dims[Edens] = eden_capacity + 1 dims[Cloaks] = cloak_capacity + 1 dims[UnusedCargo] = eden_capacity + cloak_capacity + 1 @@ -237,7 +247,11 @@ func DimensionSizes(data planet_data) []int { return dims } -func StateTableSize(dims []int) int { +type Value int32 +type PhysicalIndex int32 +type LogicalIndex []int + +func StateTableSize(dims LogicalIndex) int { product := 1 for _, size := range dims { product *= size @@ -246,7 +260,8 @@ func StateTableSize(dims []int) int { } type State struct { - value, from int32 + value Value + from PhysicalIndex } const ( @@ -257,7 +272,7 @@ const ( VALUE_RUBISH ) -func EncodeIndex(dims, addr []int) int32 { +func EncodeIndex(dims, addr LogicalIndex) PhysicalIndex { index := addr[0] if addr[0] > dims[0] { panic(0) @@ -268,35 +283,52 @@ func EncodeIndex(dims, addr []int) int32 { } index = index*dims[i] + addr[i] } - return int32(index) + return PhysicalIndex(index) } -func DecodeIndex(dims []int, index int32) []int { - addr := make([]int, NumDimensions) +func DecodeIndex(dims LogicalIndex, index PhysicalIndex) LogicalIndex { + scratch := int(index) + addr := make(LogicalIndex, NumDimensions) for i := NumDimensions - 1; i > 0; i-- { - addr[i] = int(index) % dims[i] - index /= int32(dims[i]) + addr[i] = scratch % dims[i] + scratch /= dims[i] } - addr[0] = int(index) + addr[0] = scratch return addr } -func CreateStateTable(data planet_data, dims []int) []State { +func PlanetIndex(data planet_data, name string) int { + index, ok := data.p2i[name] + if !ok { + panic("Unknown planet " + name) + } + return index +} + +func CommodityIndex(data planet_data, name string) int { + index, ok := data.c2i[name] + if !ok { + panic("Unknown commodity " + name) + } + return index +} + +func CreateStateTable(data planet_data, dims LogicalIndex) []State { table := make([]State, StateTableSize(dims)) for i := range table { table[i].value = VALUE_UNINITIALIZED table[i].from = FROM_UNINITIALIZED } - addr := make([]int, NumDimensions) + addr := make(LogicalIndex, NumDimensions) addr[Fuel] = *fuel addr[Edens] = *start_edens - addr[Location] = data.p2i[*start] + addr[Location] = PlanetIndex(data, *start) if *start_hold != "" { - addr[Hold] = data.c2i[*start_hold] + addr[Hold] = CommodityIndex(data, *start_hold) } start_index := EncodeIndex(dims, addr) - table[start_index].value = int32(*funds) + table[start_index].value = Value(*funds) table[start_index].from = FROM_ROOT return table @@ -305,13 +337,13 @@ func CreateStateTable(data planet_data, dims []int) []State { /* CellValue fills in the one cell at address addr by looking at all * the possible ways to reach this cell and selecting the best one. */ -func Consider(data planet_data, dims []int, table []State, there []int, value_difference int, best_value *int32, best_source []int) { +func Consider(data planet_data, dims LogicalIndex, table []State, there LogicalIndex, value_difference int, best_value *Value, best_source LogicalIndex) { there_value := CellValue(data, dims, table, there) - if value_difference < 0 && int32(-value_difference) > there_value { + if value_difference < 0 && Value(-value_difference) > there_value { /* Can't afford this transition */ return } - possible_value := there_value + int32(value_difference) + possible_value := there_value + Value(value_difference) if possible_value > *best_value { *best_value = possible_value copy(best_source, there) @@ -320,7 +352,7 @@ func Consider(data planet_data, dims []int, table []State, there []int, value_di var cell_filled_count int -func CellValue(data planet_data, dims []int, table []State, addr []int) int32 { +func CellValue(data planet_data, dims LogicalIndex, table []State, addr LogicalIndex) Value { my_index := EncodeIndex(dims, addr) if table[my_index].value == VALUE_BEING_EVALUATED { panic("Circular dependency") @@ -330,9 +362,9 @@ func CellValue(data planet_data, dims []int, table []State, addr []int) int32 { } table[my_index].value = VALUE_BEING_EVALUATED - best_value := int32(VALUE_RUBISH) - best_source := make([]int, NumDimensions) - other := make([]int, NumDimensions) + best_value := Value(VALUE_RUBISH) + best_source := make(LogicalIndex, NumDimensions) + other := make(LogicalIndex, NumDimensions) copy(other, addr) planet := data.i2p[addr[Location]] @@ -341,14 +373,12 @@ func CellValue(data planet_data, dims []int, table []State, addr []int) int32 { other[Traded] = 1 /* Travel from states that have done trading. */ /* Travel here via a 2-fuel unit jump */ - if addr[Fuel]+2 < dims[Fuel] { + if data.Planets[data.i2p[addr[Location]]].BeaconOn && addr[Fuel]+2 < dims[Fuel] { other[Fuel] = addr[Fuel] + 2 hole_index := (dims[Fuel] - 1) - (addr[Fuel] + 2) - if hole_index >= len(flight_plan()) || addr[Location] != data.p2i[flight_plan()[hole_index]] { + if hole_index >= len(flight_plan()) || addr[Location] != PlanetIndex(data, flight_plan()[hole_index]) { for other[Location] = 0; other[Location] < dims[Location]; other[Location]++ { - if data.Planets[data.i2p[addr[Location]]].BeaconOn { - Consider(data, dims, table, other, 0, &best_value, best_source) - } + Consider(data, dims, table, other, 0, &best_value, best_source) } } other[Location] = addr[Location] @@ -358,7 +388,7 @@ func CellValue(data planet_data, dims []int, table []State, addr []int) int32 { /* Travel here via a 1-fuel unit jump (a hyper hole) */ if addr[Fuel]+1 < dims[Fuel] { hole_index := (dims[Fuel] - 1) - (addr[Fuel] + 1) - if hole_index < len(flight_plan()) && addr[Location] == data.p2i[flight_plan()[hole_index]] { + if hole_index < len(flight_plan()) && addr[Location] == PlanetIndex(data, flight_plan()[hole_index]) { other[Fuel] = addr[Fuel] + 1 for other[Location] = 0; other[Location] < dims[Location]; other[Location]++ { Consider(data, dims, table, other, 0, &best_value, best_source) @@ -369,7 +399,7 @@ func CellValue(data planet_data, dims []int, table []State, addr []int) int32 { } /* Travel here via Eden Warp Unit */ - if addr[Edens]+1 < dims[Edens] && addr[UnusedCargo] > 0 { + if addr[Edens]+1 < dims[Edens] && (addr[Hold] == 0 || addr[UnusedCargo] > 0) { _, available := data.Planets[data.i2p[addr[Location]]].RelativePrices["Eden Warp Units"] if !available { other[Edens] = addr[Edens] + 1 @@ -537,8 +567,8 @@ func CellValue(data planet_data, dims []int, table []State, addr []int) int32 { return table[my_index].value } -func FinalState(dims []int) []int { - addr := make([]int, NumDimensions) +func FinalState(dims LogicalIndex) LogicalIndex { + addr := make(LogicalIndex, NumDimensions) addr[Edens] = *end_edens addr[Cloaks] = dims[Cloaks] - 1 addr[BuyFighters] = dims[BuyFighters] - 1 @@ -551,8 +581,8 @@ func FinalState(dims []int) []int { return addr } -func FindBestState(data planet_data, dims []int, table []State, addr []int) int32 { - max_index := int32(-1) +func FindBestState(data planet_data, dims LogicalIndex, table []State, addr LogicalIndex) PhysicalIndex { + max_index := PhysicalIndex(-1) max_value := 0.0 max_fuel := 1 if *fuel == 0 { @@ -576,7 +606,8 @@ func FindBestState(data planet_data, dims []int, table []State, addr []int) int3 return max_index } -func Commas(n int32) (s string) { +func Commas(n Value) string { + var s string if n < 0 { panic(n) } @@ -588,10 +619,10 @@ func Commas(n int32) (s string) { n /= 1000 } s = fmt.Sprint(r) + s - return + return s } -func FighterAndShieldCost(data planet_data, dims []int, table []State, best int32) { +func FighterAndShieldCost(data planet_data, dims LogicalIndex, table []State, best PhysicalIndex) { if *drones == 0 && *batteries == 0 { return } @@ -601,18 +632,18 @@ func FighterAndShieldCost(data planet_data, dims []int, table []State, best int3 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") + fmt.Printf("\rDrones were %.2f each\n", float64(cost)/float64(*drones)) } if *batteries > 0 { final_state := FinalState(dims) 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") + fmt.Printf("\rBatteries were %.2f each\n", float64(cost)/float64(*batteries)) } } -func EndEdensCost(data planet_data, dims []int, table []State, best int32) { +func EndEdensCost(data planet_data, dims LogicalIndex, table []State, best PhysicalIndex) { if *end_edens == 0 { return } @@ -624,11 +655,11 @@ func EndEdensCost(data planet_data, dims []int, table []State, best int32) { 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)") + Commas(extra_funds/Value(extra_edens)), "per eden)") } } -func VisitCost(data planet_data, dims []int, table []State, best int32) { +func VisitCost(data planet_data, dims LogicalIndex, table []State, best PhysicalIndex) { if dims[Visit] == 1 { return } @@ -643,7 +674,7 @@ func VisitCost(data planet_data, dims []int, table []State, best int32) { } } -func EndLocationCost(data planet_data, dims []int, table []State, best int32) { +func EndLocationCost(data planet_data, dims LogicalIndex, table []State, best PhysicalIndex) { if len(end()) == 0 { return } @@ -658,7 +689,8 @@ func EndLocationCost(data planet_data, dims []int, table []State, best int32) { *end_string = save_end_string } -func DescribePath(data planet_data, dims []int, table []State, start int32) (description []string) { +func DescribePath(data planet_data, dims LogicalIndex, table []State, start PhysicalIndex) []string { + var description []string for index := start; table[index].from > FROM_ROOT; index = table[index].from { if table[index].from == FROM_UNINITIALIZED { panic(index) @@ -715,7 +747,7 @@ func DescribePath(data planet_data, dims []int, table []State, start int32) (des } description = append(description, fmt.Sprintf("%13v ", Commas(table[index].value))+line) } - return + return description } // (Example of a use case for generics in Go) @@ -775,7 +807,7 @@ func main() { best := FindBestState(data, dims, table, final_state) print("\n") if best == -1 { - print("Cannot acheive success criteria\n") + print("Cannot achieve success criteria\n") return } description := DescribePath(data, dims, table, best)