]> git.scottworley.com Git - planeteer/blame_incremental - planeteer.go
Tweak flags
[planeteer] / planeteer.go
... / ...
CommitLineData
1/* Planeteer: Give trade route advice for Planets: The Exploration of Space
2 * Copyright (C) 2011 Scott Worley <sworley@chkno.net>
3 *
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU Affero General Public License as
6 * published by the Free Software Foundation, either version 3 of the
7 * License, or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU Affero General Public License for more details.
13 *
14 * You should have received a copy of the GNU Affero General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
16 */
17
18package main
19
20import "flag"
21import "fmt"
22import "json"
23import "os"
24import "strings"
25
26var start = flag.String("start", "",
27 "The planet to start at")
28
29var end = flag.String("end", "",
30 "A comma-separated list of acceptable ending planets.")
31
32var planet_data_file = flag.String("planet_data_file", "planet-data",
33 "The file to read planet data from")
34
35var fuel = flag.Int("fuel", 16, "Reactor units")
36
37var hold = flag.Int("hold", 300, "Size of your cargo hold")
38
39var start_edens = flag.Int("start_edens", 0,
40 "How many Eden Warp Units are you starting with?")
41
42var end_edens = flag.Int("end_edens", 0,
43 "How many Eden Warp Units would you like to keep (not use)?")
44
45var cloak = flag.Bool("cloak", false,
46 "Make sure to end with a Device of Cloaking")
47
48var drones = flag.Int("drones", 0, "Buy this many Fighter Drones")
49
50var batteries = flag.Int("batteries", 0, "Buy this many Shield Batterys")
51
52var visit_string = flag.String("visit", "",
53 "A comma-separated list of planets to make sure to visit")
54
55func visit() []string {
56 return strings.Split(*visit_string, ",")
57}
58
59type Commodity struct {
60 BasePrice int
61 CanSell bool
62 Limit int
63}
64type Planet struct {
65 BeaconOn bool
66 /* Use relative prices rather than absolute prices because you
67 can get relative prices without traveling to each planet. */
68 RelativePrices map[string]int
69}
70type planet_data struct {
71 Commodities map[string]Commodity
72 Planets map[string]Planet
73 pi, ci map[string]int // Generated; not read from file
74}
75
76func ReadData() (data planet_data) {
77 f, err := os.Open(*planet_data_file)
78 if err != nil {
79 panic(err)
80 }
81 defer f.Close()
82 err = json.NewDecoder(f).Decode(&data)
83 if err != nil {
84 panic(err)
85 }
86 return
87}
88
89/* This program operates by filling in a state table representing the best
90 * possible trips you could make; the ones that makes you the most money.
91 * This is feasible because we don't look at all the possible trips.
92 * We define a list of things that are germane to this game and then only
93 * consider the best outcome in each possible game state.
94 *
95 * Each cell in the table represents a state in the game. In each cell,
96 * we track two things: 1. the most money you could possibly have while in
97 * that state and 2. one possible way to get into that state with that
98 * amount of money.
99 *
100 * A basic analysis can be done with a two-dimensional table: location and
101 * fuel. planeteer-1.0 used this two-dimensional table. This version
102 * adds features mostly by adding dimensions to this table.
103 *
104 * Note that the sizes of each dimension are data driven. Many dimensions
105 * collapse to one possible value (ie, disappear) if the corresponding
106 * feature is not enabled.
107 */
108
109// The official list of dimensions:
110const (
111 // Name Num Size Description
112 Edens = iota // 1 3 # of Eden warp units (0 - 2 typically)
113 Cloaks // 2 2 # of Devices of Cloaking (0 or 1)
114 UnusedCargo // 3 4 # of unused cargo spaces (0 - 3 typically)
115 Fuel // 4 17 Reactor power left (0 - 16)
116 Location // 5 26 Location (which planet)
117 Hold // 6 15 Cargo bay contents (a *Commodity or nil)
118 NeedFighters // 7 2 Errand: Buy fighter drones (needed or not)
119 NeedShields // 8 2 Errand: Buy shield batteries (needed or not)
120 Visit // 9 2**N Visit: Stop by these N planets in the route
121
122 NumDimensions
123)
124
125func bint(b bool) int {
126 if b {
127 return 1
128 }
129 return 0
130}
131
132func DimensionSizes(data planet_data) []int {
133 eden_capacity := data.Commodities["Eden Warp Units"].Limit
134 cloak_capacity := bint(*cloak)
135 dims := []int{
136 eden_capacity + 1,
137 cloak_capacity + 1,
138 eden_capacity + cloak_capacity + 1,
139 *fuel + 1,
140 len(data.Planets),
141 len(data.Commodities),
142 bint(*drones > 0) + 1,
143 bint(*batteries > 0) + 1,
144 1 << uint(len(visit())),
145 }
146 if len(dims) != NumDimensions {
147 panic("Dimensionality mismatch")
148 }
149 return dims
150}
151
152func StateTableSize(dims []int) int {
153 sum := 0
154 for _, size := range dims {
155 sum += size
156 }
157 return sum
158}
159
160type State struct {
161 funds, from int
162}
163
164func NewStateTable(dims []int) []State {
165 return make([]State, StateTableSize(dims))
166}
167
168func EncodeIndex(dims, addr []int) int {
169 index := addr[0]
170 for i := 1; i < len(dims); i++ {
171 index = index*dims[i] + addr[i]
172 }
173 return index
174}
175
176func DecodeIndex(dims []int, index int) []int {
177 addr := make([]int, len(dims))
178 for i := len(dims) - 1; i > 0; i-- {
179 addr[i] = index % dims[i]
180 index /= dims[i]
181 }
182 addr[0] = index
183 return addr
184}
185
186/* What is the value of hauling 'commodity' from 'from' to 'to'?
187 * Take into account the available funds and the available cargo space. */
188func TradeValue(data planet_data,
189from, to Planet,
190commodity string,
191initial_funds, max_quantity int) int {
192 if !data.Commodities[commodity].CanSell {
193 return 0
194 }
195 from_relative_price, from_available := from.RelativePrices[commodity]
196 if !from_available {
197 return 0
198 }
199 to_relative_price, to_available := to.RelativePrices[commodity]
200 if !to_available {
201 return 0
202 }
203
204 base_price := data.Commodities[commodity].BasePrice
205 from_absolute_price := from_relative_price * base_price
206 to_absolute_price := to_relative_price * base_price
207 buy_price := from_absolute_price
208 sell_price := int(float64(to_absolute_price) * 0.9)
209 var can_afford int = initial_funds / buy_price
210 quantity := can_afford
211 if quantity > max_quantity {
212 quantity = max_quantity
213 }
214 return (sell_price - buy_price) * max_quantity
215}
216
217func FindBestTrades(data planet_data) [][]string {
218 // TODO: We can't cache this because this can change based on available funds.
219 best := make([][]string, len(data.Planets))
220 for from := range data.Planets {
221 best[data.pi[from]] = make([]string, len(data.Planets))
222 for to := range data.Planets {
223 best_gain := 0
224 price_list := data.Planets[from].RelativePrices
225 if len(data.Planets[to].RelativePrices) < len(data.Planets[from].RelativePrices) {
226 price_list = data.Planets[to].RelativePrices
227 }
228 for commodity := range price_list {
229 gain := TradeValue(data,
230 data.Planets[from],
231 data.Planets[to],
232 commodity,
233 10000000,
234 1)
235 if gain > best_gain {
236 best[data.pi[from]][data.pi[to]] = commodity
237 gain = best_gain
238 }
239 }
240 }
241 }
242 return best
243}
244
245// (Example of a use case for generics in Go)
246func IndexPlanets(m *map[string]Planet) map[string]int {
247 index := make(map[string]int, len(*m))
248 i := 0
249 for e := range *m {
250 index[e] = i
251 i++
252 }
253 return index
254}
255func IndexCommodities(m *map[string]Commodity) map[string]int {
256 index := make(map[string]int, len(*m))
257 i := 0
258 for e := range *m {
259 index[e] = i
260 i++
261 }
262 return index
263}
264
265func main() {
266 flag.Parse()
267 data := ReadData()
268 data.pi = IndexPlanets(&data.Planets)
269 data.ci = IndexCommodities(&data.Commodities)
270 dims := DimensionSizes(data)
271 table := NewStateTable(dims)
272 table[0] = State{1, 1}
273 best_trades := FindBestTrades(data)
274
275 for from := range data.Planets {
276 for to := range data.Planets {
277 best_trade := "(nothing)"
278 if best_trades[data.pi[from]][data.pi[to]] != "" {
279 best_trade = best_trades[data.pi[from]][data.pi[to]]
280 }
281 fmt.Printf("%s to %s: %s\n", from, to, best_trade)
282 }
283 }
284}