-
Notifications
You must be signed in to change notification settings - Fork 20
/
util.lua
283 lines (247 loc) · 8.23 KB
/
util.lua
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
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
local util = {}
-- Position adjustments
function util.moveposition(position, offset)
return {x=position.x + offset.x, y=position.y + offset.y}
end
function util.offset(direction, longitudinal, orthogonal)
if direction == defines.direction.north then
return {x=orthogonal, y=-longitudinal}
end
if direction == defines.direction.south then
return {x=-orthogonal, y=longitudinal}
end
if direction == defines.direction.east then
return {x=longitudinal, y=orthogonal}
end
if direction == defines.direction.west then
return {x=-longitudinal, y=-orthogonal}
end
end
-- BoundingBox utilities
--[[
+----------------------+
| |
| |
| |
| O |
| |
+----------------------+
]]
function util.rotate_box(box, direction)
local left = box.left_top.x
local top = box.left_top.y
local right = box.right_bottom.x
local bottom = box.right_bottom.y
if direction == defines.direction.north then
return box
elseif direction == defines.direction.east then
-- 90 degree rotation
return {
left_top = {x=-bottom, y=left},
right_bottom = {x=-top, y=right},
}
elseif direction == defines.direction.south then
-- 180 degree rotation
return {
left_top = {x=-right, y=-bottom},
right_bottom = {x=-left, y=-top},
}
elseif direction == defines.direction.west then
-- 270 degree rotation
return {
left_top = {x=top, y=-right},
right_bottom = {x=bottom, y=-left},
}
else
error('invalid direction passed to rotate_box')
end
end
function util.move_box(box, offset)
return {
left_top = util.moveposition(box.left_top, offset),
right_bottom = util.moveposition(box.right_bottom, offset),
}
end
function util.entity_key(entity)
return entity.surface.name.."@"..entity.position.x..","..entity.position.y
end
-- Direction utilities
function util.is_ns(direction)
return direction == 0 or direction == 4
end
function util.is_ew(direction)
return direction == 2 or direction == 6
end
function util.opposite_direction(direction)
if direction >= 4 then
return direction - 4
end
return direction + 4
end
-- orientation utilities
-- hood_side returns the "back" or hood side of a loader or underground belt
function util.hood_side(entity)
if entity.type == "loader-1x1" and entity.loader_type == "output" then
return util.opposite_direction(entity.direction)
end
if entity.type == "underground-belt" and entity.belt_to_ground_type == "output" then
return util.opposite_direction(entity.direction)
end
return entity.direction
end
-- belt_side returns the "front" side of a loader or underground belt
function util.belt_side(entity)
if entity.type == "loader-1x1" and entity.loader_type == "input" then
return util.opposite_direction(entity.direction)
end
if entity.type == "underground-belt" and entity.belt_to_ground_type == "input" then
return util.opposite_direction(entity.direction)
end
return entity.direction
end
-- miniloader utilities
function util.find_miniloaders(params)
params.type = "loader-1x1"
local entities = params.surface.find_entities_filtered(params)
local out = {}
for i=1,#entities do
local ent = entities[i]
if util.is_miniloader(ent) then
out[#out+1] = ent
end
end
return out
end
function util.is_miniloader(entity)
return string.find(entity.name, "miniloader%-loader$") ~= nil
end
function util.is_miniloader_inserter(entity)
return util.is_miniloader_inserter_name(entity.name)
end
function util.is_miniloader_inserter_name(name)
return name:find("miniloader%-inserter$") ~= nil
end
-- 60 items/second / 60 ticks/second / 8 items/tile = X tiles/tick
local BELT_SPEED_FOR_60_PER_SECOND = 60/60/8
function util.num_inserters(entity)
return math.ceil(entity.prototype.belt_speed / BELT_SPEED_FOR_60_PER_SECOND) * 2
end
function util.pickup_position(entity)
if entity.loader_type == "output" then
return util.moveposition(entity.position, util.offset(entity.direction, -0.8, 0))
end
return util.moveposition(entity.position, util.offset(entity.direction, -0.2, 0))
end
local moveposition = util.moveposition
local offset = util.offset
-- drop positions for input (belt->chest) = { 0.7, +-0.25}, { 0.9, +-0.25}, {1.1, +-0.25}, {1.3, +-0.25}
-- drop positions for output (chest->belt) = {-0.2, +-0.25}, {-0.0, +-0.25}, {0.1, +-0.25}, {0.3, +-0.25}
function util.drop_positions(entity)
local base_offset = 1.2
if entity.loader_type == "output" then
base_offset = base_offset - 1
end
local out = {}
local dir = entity.direction
local p1 = moveposition(entity.position, offset(dir, base_offset, -0.25))
local p2 = moveposition(p1, offset(dir, 0, 0.5))
out[1] = p1
out[2] = p2
for i=1,3 do
local j = i * 2 + 1
out[j ] = moveposition(p1, offset(dir, -0.20*i, 0))
out[j+1] = moveposition(p2, offset(dir, -0.20*i, 0))
end
for i=0,3 do
local j = i * 2 + 9
out[j ] = moveposition(p1, offset(dir, -0.20*i, 0))
out[j+1] = moveposition(p2, offset(dir, -0.20*i, 0))
end
return out
end
function util.get_loader_inserters(entity)
return entity.surface.find_entities_filtered{
position = entity.position,
type = "inserter",
}
end
function util.update_miniloader(entity, direction, type)
if entity.loader_type ~= type then
entity.rotate()
end
entity.direction = direction
util.update_inserters(entity)
end
function util.update_inserters(entity)
local inserters = util.get_loader_inserters(entity)
local pickup = util.pickup_position(entity)
local drop = util.drop_positions(entity)
local direction = entity.direction
if entity.loader_type == "input" then
direction = util.opposite_direction(direction)
end
for i=1,#inserters do
inserters[i].direction = direction
inserters[i].pickup_position = pickup
inserters[i].drop_position = drop[i]
inserters[i].direction = direction
end
end
function util.orientation_from_inserters(entity)
local find_entities_filtered = entity.surface.find_entities_filtered
local inserter =
find_entities_filtered{type = "inserter", position = entity.position}[1] or
find_entities_filtered{ghost_type = "inserter", position = entity.position}[1]
if inserter.drop_position.x > inserter.position.x + 0.5 then
return {direction=defines.direction.east, type="input"}
elseif inserter.drop_position.x < inserter.position.x - 0.5 then
return {direction=defines.direction.west, type="input"}
elseif inserter.drop_position.y > inserter.position.y + 0.5 then
return {direction=defines.direction.south, type="input"}
elseif inserter.drop_position.y < inserter.position.y - 0.5 then
return {direction=defines.direction.north, type="input"}
elseif inserter.pickup_position.x > inserter.position.x + 0.5 then
return {direction=defines.direction.west, type="output"}
elseif inserter.pickup_position.x < inserter.position.x - 0.5 then
return {direction=defines.direction.east, type="output"}
elseif inserter.pickup_position.y > inserter.position.y + 0.5 then
return {direction=defines.direction.north, type="output"}
elseif inserter.pickup_position.y < inserter.position.y - 0.5 then
return {direction=defines.direction.south, type="output"}
end
end
function util.rebuild_belt(entity)
local surface = entity.surface
local name = entity.name
local protos = game.get_filtered_entity_prototypes{{filter="type", type=entity.type}}
local temporary_replacement
for proto_name in pairs(protos) do
if proto_name ~= name and proto_name ~= "__self" then
temporary_replacement = proto_name
break
end
end
if not temporary_replacement then return false end
local last_user = entity.last_user
local params = {
name = temporary_replacement,
position = entity.position,
direction = entity.direction,
force = entity.force,
fast_replace = true,
spill = false,
create_build_effect_smoke = false,
type = entity.type:find("loader") and entity.loader_type
or entity.type == "underground-belt" and entity.belt_to_ground_type,
}
surface.create_entity(params)
params.name = name
local belt = surface.create_entity(params)
if belt then
belt.last_user = last_user
return true
else
return false
end
end
return util