Correct spelling

[planeteer] / planeteer.go

diff --git a/planeteer.go b/planeteer.go
index eb78bce1ebb966b35f0720da2ccf59672327fb8a..42a7236811bda3d598b9c864b040489f10f06058 100644 (file)
--- a/planeteer.go
+++ b/planeteer.go
@@ -133,13 +133,21 @@ type planet_data struct {
        i2p, i2c    []string       // Generated; not read from file
 }
 
        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 {
        if err != nil {

-               panic(err)
+               return err

        }
        defer f.Close()
        }
        defer f.Close()

-       err = json.NewDecoder(f).Decode(&data)
+       err = json.NewDecoder(f).Decode(receptacle)
+       if err != nil {
+               return err
+       }
+       return nil
+}
+
+func ReadData() (data planet_data) {
+       err := json_slurp(*planet_data_file, &data)

        if err != nil {
                panic(err)
        }
        if err != nil {
                panic(err)
        }


@@ -289,6 +297,22 @@ func DecodeIndex(dims LogicalIndex, index PhysicalIndex) LogicalIndex {
        return addr
 }
 
        return addr
 }
 

+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 {
 func CreateStateTable(data planet_data, dims LogicalIndex) []State {
        table := make([]State, StateTableSize(dims))
        for i := range table {


@@ -299,9 +323,9 @@ func CreateStateTable(data planet_data, dims LogicalIndex) []State {
        addr := make(LogicalIndex, NumDimensions)
        addr[Fuel] = *fuel
        addr[Edens] = *start_edens
        addr := make(LogicalIndex, NumDimensions)
        addr[Fuel] = *fuel
        addr[Edens] = *start_edens

-       addr[Location] = data.p2i[*start]
+       addr[Location] = PlanetIndex(data, *start)

        if *start_hold != "" {
        if *start_hold != "" {

-               addr[Hold] = data.c2i[*start_hold]
+               addr[Hold] = CommodityIndex(data,*start_hold)

        }
        start_index := EncodeIndex(dims, addr)
        table[start_index].value = Value(*funds)
        }
        start_index := EncodeIndex(dims, addr)
        table[start_index].value = Value(*funds)


@@ -352,7 +376,7 @@ func CellValue(data planet_data, dims LogicalIndex, table []State, addr LogicalI
                if addr[Fuel]+2 < dims[Fuel] {
                        other[Fuel] = addr[Fuel] + 2
                        hole_index := (dims[Fuel] - 1) - (addr[Fuel] + 2)
                if 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)
                                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)


@@ -366,7 +390,7 @@ func CellValue(data planet_data, dims LogicalIndex, table []State, addr LogicalI
                /* 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)
                /* 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)
                                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)


@@ -609,14 +633,14 @@ func FighterAndShieldCost(data planet_data, dims LogicalIndex, table []State, be
                final_state[BuyFighters] = 0
                alt_best := FindBestState(data, dims, table, final_state)
                cost := table[alt_best].value - table[best].value
                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
        }
        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))

        }
 }
 
        }
 }
 


@@ -783,7 +807,7 @@ func main() {
        best := FindBestState(data, dims, table, final_state)
        print("\n")
        if best == -1 {
        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)
                return
        }
        description := DescribePath(data, dims, table, best)