+/* This program operates by filling in a state table representing the best
+ * possible trips you could make; the ones that makes you the most money.
+ * This is feasible because we don't look at all the possible trips.
+ * We define a list of things that are germane to this game and then only
+ * consider the best outcome in each possible game state.
+ *
+ * Each cell in the table represents a state in the game. In each cell,
+ * we track two things: 1. the most money you could possibly have while in
+ * that state and 2. one possible way to get into that state with that
+ * amount of money.
+ *
+ * A basic analysis can be done with a two-dimensional table: location and
+ * fuel. planeteer-1.0 used this two-dimensional table. This version
+ * adds features mostly by adding dimensions to this table.
+ *
+ * Note that the sizes of each dimension are data driven. Many dimensions
+ * collapse to one possible value (ie, disappear) if the corresponding
+ * feature is not enabled.
+ */
+
+// The official list of dimensions:
+const (
+ // Name Num Size Description
+ Edens = iota // 1 3 # of Eden warp units (0 - 2 typically)
+ Cloaks // 2 2 # of Devices of Cloaking (0 or 1)
+ UnusedCargo // 3 4 # of unused cargo spaces (0 - 3 typically)
+ Fuel // 4 17 Reactor power left (0 - 16)
+ Location // 5 26 Location (which planet)
+ Hold // 6 15 Cargo bay contents (a *Commodity or nil)
+ NeedFighters // 7 2 Errand: Buy fighter drones (needed or not)
+ NeedShields // 8 2 Errand: Buy shield batteries (needed or not)
+ Visit // 9 2**N Visit: Stop by these N planets in the route
+
+ NumDimensions
+)
+
+func bint(b bool) int {
+ if b {
+ return 1
+ }
+ return 0
+}
+
+func DimensionSizes(data planet_data) []int {
+ eden_capacity := data.Commodities["Eden Warp Units"].Limit
+ cloak_capacity := bint(*cloak)
+ dims := []int{
+ eden_capacity + 1,
+ cloak_capacity + 1,
+ eden_capacity + cloak_capacity + 1,
+ *fuel + 1,
+ len(data.Planets),
+ len(data.Commodities),
+ bint(*drones > 0) + 1,
+ bint(*batteries > 0) + 1,
+ 1 << uint(len(visit())),
+ }
+ if len(dims) != NumDimensions {
+ panic("Dimensionality mismatch")
+ }
+ return dims
+}
+
+func StateTableSize(dims []int) int {
+ sum := 0
+ for _, size := range dims {
+ sum += size
+ }
+ return sum
+}
+
+type State struct {
+ funds, from int
+}
+
+func NewStateTable(dims []int) []State {
+ return make([]State, StateTableSize(dims))
+}
+
+func EncodeIndex(dims, addr []int) int {
+ index := addr[0]
+ for i := 1; i < len(dims); i++ {
+ index = index*dims[i] + addr[i]
+ }
+ return index
+}
+
+func DecodeIndex(dims []int, index int) []int {
+ addr := make([]int, len(dims))
+ for i := len(dims) - 1; i > 0; i-- {
+ addr[i] = index % dims[i]
+ index /= dims[i]
+ }
+ addr[0] = index
+ return addr
+}
+
+/* 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 {
projects / planeteer / blobdiff