X-Git-Url: http://git.scottworley.com/planeteer/blobdiff_plain/e346cb3782a1bfd09dd52b8ad65a96ea96105aa4..809e65f43c41047a34e0731e11e2f3639e7e0b8a:/planeteer.go

diff --git a/planeteer.go b/planeteer.go
index 3783a8c..d17c5a5 100644
--- a/planeteer.go
+++ b/planeteer.go
@@ -23,13 +23,16 @@ import "json"
 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 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",
@@ -57,18 +60,29 @@ var visit_string = flag.String("visit", "",
 
 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
@@ -165,6 +179,9 @@ func bint(b bool) int {
 
 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
@@ -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[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()))
@@ -203,7 +220,7 @@ func EncodeIndex(dims, addr []int) int {
 	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)
 		}
@@ -213,8 +230,8 @@ func EncodeIndex(dims, addr []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]
 	}
@@ -222,34 +239,47 @@ func DecodeIndex(dims []int, index int) []int {
 	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 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 */
-	if addr[Fuel] + 2 < dims[Fuel] {
+	if addr[Fuel]+2 < dims[Fuel] {
 		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]++ {
+			if data.Planets[data.i2p[addr[Location]]].BeaconOn {
+				UpdateCell(table, my_index, EncodeIndex(dims, other), 0)
 			}
 		}
 		other[Location] = addr[Location]
@@ -257,70 +287,151 @@ func FillStateTableCell(data planet_data, dims []int, table []State, addr []int)
 	}
 
 	/* 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)
-		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]]
-			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 */
-	/* Silly: Dump Eden warp units */
+	if addr[Edens]+1 < dims[Edens] {
+		_, available := data.Planets[data.i2p[addr[Location]]].RelativePrices["Eden Warp Units"]
+		if !available {
+			other[Edens] = addr[Edens] + 1
+			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 */
+	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 */
-	if addr[Hold] == 0 {
-		/* Sell or dump things */
-		// for commodity := range data.Commodities { }
-	} else {
-		/* Buy this thing */
-	}
 	/* 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]++ {
-				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
 }
 
@@ -356,69 +467,81 @@ func FillStateTable1(data planet_data, dims []int, table []State) {
 				<-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")
 }
 
-/* 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]++ {
+		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
+}
 
-	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)
@@ -451,20 +574,15 @@ func main() {
 	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)
-	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])
 		}
 	}
 }