File size: 6,497 Bytes
0a3edb6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
"""Tasks from lane-labelled save regions: a WIN x WIN window of a human factory,
cleared, with a source wherever a labelled belt enters it and a sink wherever one
leaves. The human's own build (with those markers) is the reference; only windows
it actually produces something in are kept."""
import glob, gzip, json, pickle, random, sys
import numpy as np, torch
import factorion_rs
from compare import frame
from corpus.convert import designs, rasterise, _MASKED, _TERRAIN
from factorion import Channel, Footprint, refresh_power, str2ent, str2item

SIZE, WIN, OFF = 32, 20, 6
BELTISH = {str2ent(n).value for n in ("transport_belt", "underground_belt")}
SPLITTER = str2ent("splitter").value
MACH = {str2ent(n).value for n in ("assembling_machine_1", "stone_furnace", "steel_furnace", "electric_furnace")}
SRC, SNK = str2ent("source").value, str2ent("sink").value
DELTA = {1: (0, -1), 2: (1, 0), 3: (0, 1), 4: (-1, 0)}
C = [Channel.ENTITIES.value, Channel.DIRECTION.value, Channel.ITEMS.value, Channel.MISC.value]


def records(paths):
    for p in paths:
        with gzip.open(p, "rt") as f:
            try:
                for line in f:
                    yield json.loads(line)
            except (EOFError, json.JSONDecodeError, OSError):
                pass  # the pipeline is still appending to this file


def tasks_from(rec, rng, tries=30):
    if not rec.get("lanes"):
        return
    bp = next(designs(rec["string"]))
    bp["unbuildable"] = rec.get("unbuildable") or []
    r = rasterise(bp)
    if r is None:
        return
    mx, my = frame(bp)
    lab = {}
    for x, y, _, its in rec["lanes"]:
        lab.setdefault((x - mx, y - my), set()).update(i.replace("-", "_") for i in its.split(","))
    W, H = r.ent.shape
    if W < WIN + 3 or H < WIN + 3:
        return
    seen = set()
    for _ in range(tries):
        x0, y0 = rng.randrange(1, W - WIN - 1), rng.randrange(1, H - WIN - 1)
        if (x0 // 8, y0 // 8) in seen:
            continue
        seen.add((x0 // 8, y0 // 8))
        win = (slice(x0, x0 + WIN), slice(y0, y0 + WIN))
        inst = r.inst[win]
        inner = np.bincount(inst[inst > 0], minlength=len(r.tiles))
        whole = (inst > 0) & (inner == r.tiles)[np.maximum(inst, 0)]
        if not np.isin(r.ent[win][whole], list(MACH)).any():
            continue
        if ((inst > 0) & ~whole & (r.ent[win] == SPLITTER)).any():
            continue  # a splitter cut in half
        markers = {}
        inside = lambda x, y: x0 <= x < x0 + WIN and y0 <= y < y0 + WIN  # noqa: E731
        for x in range(x0, x0 + WIN):
            for y in range(y0, y0 + WIN):
                if x not in (x0, x0 + WIN - 1) and y not in (y0, y0 + WIN - 1):
                    continue
                if r.ent[x, y] not in BELTISH or r.inst[x, y] <= 0 or int(r.dir[x, y]) not in DELTA:
                    continue
                d = int(r.dir[x, y]); dx, dy = DELTA[d]
                its = lab.get((x, y), set())
                if len(its) != 1 or str2item(next(iter(its))) is None:
                    continue
                item = str2item(next(iter(its))).value
                u, v = (x - dx, y - dy), (x + dx, y + dy)
                if not inside(*u) and 0 <= u[0] < W and 0 <= u[1] < H and r.ent[u] in BELTISH | {SPLITTER}:
                    markers[u] = (SRC, d, item)
                if not inside(*v) and 0 <= v[0] < W and 0 <= v[1] < H and r.ent[v] in BELTISH | {SPLITTER}:
                    markers[v] = (SNK, d, item)
        kinds = {m[0] for m in markers.values()}
        if kinds != {SRC, SNK}:
            continue
        worlds = []
        for context in (False, True):
            w = np.zeros((len(Channel), SIZE, SIZE), np.int64)
            w[Channel.FOOTPRINT.value] = Footprint.UNBUILDABLE.value
            gx0, gy0 = x0 - OFF, y0 - OFF  # raster coord of grid (0, 0)
            for gx in range(SIZE):
                for gy in range(SIZE):
                    x, y = gx + gx0, gy + gy0
                    if not (0 <= x < W and 0 <= y < H):
                        continue
                    if inside(x, y):
                        if r.inst[x, y] in (_MASKED, _TERRAIN) or (r.inst[x, y] > 0 and not whole[x - x0, y - y0]):
                            continue
                        w[Channel.FOOTPRINT.value, gx, gy] = Footprint.BUILDABLE.value
                        if r.inst[x, y] > 0:
                            for c, a in zip(C, (r.ent, r.dir, r.item, r.misc)):
                                w[c, gx, gy] = a[x, y]
                    elif context and r.inst[x, y] > 0 and max(abs(2 * x - 2 * x0 - WIN + 1), abs(2 * y - 2 * y0 - WIN + 1)) > WIN + 1:
                        for c, a in zip(C, (r.ent, r.dir, r.item, r.misc)):
                            w[c, gx, gy] = a[x, y]
            for (x, y), (ent, d, item) in markers.items():
                gx, gy = x - gx0, y - gy0
                w[C[0], gx, gy], w[C[1], gx, gy], w[C[2], gx, gy], w[C[3], gx, gy] = ent, d, item, 0
            refresh_power(torch.from_numpy(w))
            worlds.append(w)
        # A sink still fed with every machine gone is a belt passing through: not a task.
        bare = worlds[0].copy()
        bare[:, np.isin(bare[C[0]], list(MACH))] = 0
        bare[Channel.FOOTPRINT.value] = worlds[0][Channel.FOOTPRINT.value]
        through = {(x, y) for x, y, _, rate in factorion_rs.py_sink_deliveries(np.ascontiguousarray(bare.transpose(1, 2, 0))) if rate > 0}
        for w in worlds:
            for x, y in through:
                w[:4, x, y] = 0
        ref = factorion_rs.simulate_throughput(np.ascontiguousarray(worlds[0].transpose(1, 2, 0)))[0]
        if ref <= 0 or not (worlds[0][C[0]] == SNK).any():
            continue
        yield {"id": f"{rec['id']}@{x0},{y0}", "world": worlds[0], "context": worlds[1], "max_throughput": ref,
               "n_src": sum(m[0] == SRC for m in markers.values()), "n_snk": int((worlds[0][C[0]] == SNK).sum()),
               "n_machines": len(set(inst[whole & np.isin(r.ent[win], list(MACH))].tolist()))}


if __name__ == "__main__":
    out, want = sys.argv[1], int(sys.argv[2])
    rng = random.Random(0)
    tasks, n_rec = [], 0
    for rec in records(sorted(glob.glob(sys.argv[3]))):
        n_rec += 1
        for t in tasks_from(rec, rng):
            tasks.append(t)
            break  # one task per region, for variety
        if len(tasks) >= want:
            break
    pickle.dump(tasks, open(out, "wb"))
    print(f"{len(tasks)} tasks from {n_rec} regions")