class Miner(Machine):
imgs = Img.imgstripxf("Machines/Miner", 16)
mine_prog = 0
mine_speed = 0.25
a = 0
mrects = [
Rect(4, 36, 56, 40),
Rect(4, 4, 44, 72),
Rect(4, 4, 56, 44),
Rect(16, 4, 44, 72)
]
def update(self, pos, area, events):
super().update(pos, area, events)
if "Ore" in area.ldict:
ore = area.get("Ore", pos)
if ore:
self.a += 0.1
self.a %= math.tau
self.mine_prog += self.mine_speed
if self.mine_prog >= ore.hardness and self.add_output(
Items.resources[ore.name]):
if not ore.inf:
ore.q -= 1
if ore.q == 0:
area.dobj(ore, pos)
self.mine_prog = 0
def render(self, layer, surf, tpos, area, scale=3):
if layer == self.renderlayer:
Img.draw_rotor(surf,
V(*tpos) + V(32, 48), 24, 3, self.a, (80, 80, 80))
super().render(layer, surf, tpos, area, scale)
class Splitter(Machine):
imgs=Img.imgstripxf("Transport/Splitter",16)
phase=-1
def input(self,d,i):
for r in (self.phase,-self.phase):
if self.add_output(i,r):
self.phase=-r
return True
class Tree(Object):
hardness = 60
img = Img.imgstripxf("World/Tree")[-1]
layers = ["Conv", "Items", "Objects"]
renderlayer = "Objects"
exoff = Vector.VectorX(0, -16)
updates = False
def mined(self):
return Items.resources["Log"]
class Farmer(OutputMachine):
imgs = Img.imgstripxf("Machines/Farmer")
crops = None
crop = None
def __init__(self, c, r, p):
self.gui = MUI.MUI(
"Select Crop",
[MUI.SelList([c.get_name() for c in Agriculture.crops])])
super().__init__(c, r, p)
def init_crops(self, area, pos):
self.crops = {}
for tpos in V(5, 5).iter_space_2d(pos - V(2, 2)):
pcrop = True
for l in self.crop.layers:
if not area.clear(l, tpos):
pcrop = False
tcrop = area.get(l, tpos)
if isinstance(tcrop, self.crop) and not tcrop.bound:
tcrop.bound = self
area.ups.remove((tpos, tcrop))
self.crops[tpos] = tcrop
break
if area.get("Tiles", tpos).name != self.crop.tile:
pcrop = False
if tpos not in self.crops:
self.crops[tpos] = area.spawn_new(self.crop, tpos,
self) if pcrop else None
def gui_trigger(self, *args):
self.crop = Agriculture.crops[args[0]]
def update(self, pos, area, events):
if self.crops:
if not randint(0, self.crop.gspeed // 25):
tpos, ch = choice(list(self.crops.items()))
if ch:
if not ch.exists:
self.crops[tpos] = None
elif ch.growth < ch.max_g:
ch.growth += 1
elif self.add_output(ch.mined()):
ch.growth = ch.harvest_state
elif self.crop:
self.init_crops(area, pos)
super().update(pos, area, events)
def on_dest(self, area, pos):
if self.crops:
for tpos, crop in self.crops.items():
if crop:
crop.bound = None
area.ups.add((tpos, crop))
class Electrolyser(Furnace):
imgs = Img.imgstripxf("Machines/Electrolyser")
def __init__(self, c, r, p):
SlotMachine.__init__(self, c, r, p)
self.processor = MUI.Processor("Electrolyser", 20)
self.fuel = MUI.ElectroSlot(self)
self.gui = MUI.MUI("Electrolyser", [self.processor, self.fuel])
self.outputslot = self.processor.output
def input(self, d, i):
return self.processor.input.add(i)
class EntangledBox1(Box):
img = Img.imgstripxf("Buildings/EntangledBox")[0]
gen = Generators.EntangledBuilding()
def __init__(self, c):
Object.__init__(self, c)
self.dummy = EntangledDummy(self)
self.area = Area(self.internalsize, self.gen, self.dummy)
def in_warp(self, d):
hb = self.area.bounds // 2
return Coordinate(self.area, hb - d * hb - V(bool(d.y), bool(d.x)))
class Monolith(Owned):
imgs=Img.imgstripxf("Buildings/Monolith",16)
t=0
layers = ["Conv","Items","Objects"]
renderlayer = "Objects"
def update(self, pos, area, events):
self.t+=1
if self.t==240:
from Lib import GUI
raise GUI.GameEnd(self.p.team)
@property
def img(self):
return self.imgs[self.t%20==19]
class Input(Rotatable):
imgs=Img.imgstripxf("Transport/Input")
layers = ["Objects"]
hardness = 10
slayer = "Conv"
def update(self, pos, area, events):
conv=area.get("Conv",pos)
if isinstance(conv,Conveyor):
conv.cm=self
area.de_update(self,pos)
def conv_update(self,pos,area,conv):
item = area.get("Items", pos)
if item and not item.mprog:
area.move(item, pos, Vector.vdirs[self.r], override_speed=conv.cspeed)
def mined(self):
return Placeable(self.__class__)
class Tunnel(Rotatable):
imgs=Img.imgstripxf("Transport/Tunnel")
updates = False
layers = ["Conv","Items","Objects"]
renderlayer = "Objects"
exoff = Vector.VectorX(0,-8)
hardness = 60
def in_warp(self,d):
if d==Vector.vdirs[self.r]:
for x in range(1,6):
tc=self.coords+d*x
o=tc.get("Objects")
if isinstance(o,Tunnel) and o.r==(self.r+2)%4:
tc.pos+=d
return tc
def mined(self):
return Placeable(Tunnel)
class EntangledBox2(Box):
img = Img.imgstripxf("Buildings/EntangledBox")[1]
def __init__(self, c, a, d):
Object.__init__(self, c)
self.area = a
self.dummy = d
self.dummy.es.append(self)
def update(self, pos, area, events):
if not self.dummy.es[0].exists:
super().update(pos, area, events)
else:
self.area.generate(area.get_power)
def in_warp(self, d):
hb = self.area.bounds // 2
return Coordinate(self.area, hb - d * hb + V(bool(d.y), bool(d.x)))
class Buffer(Machine):
imgs=Img.imgstripxf("Transport/Buffer")
def __init__(self,c,r,p):
super().__init__(c,r,p)
self.inv=MultiSlot([Slot() for _ in range(7)])
self.gui=MUI.MUI("Buffer",[MUI.Inventory(self.inv)])
self.v=Vector.vdirs[self.r]
def input(self,d,i):
if d==self.v:
return self.inv.add(i)
def update(self, pos, area, events):
if not self.output[self.v]:
for s in self.inv.slots:
if s.q:
if self.add_output(s.item):
s.remove(1)
break
super().update(pos,area,events)
class Lab(FixedMachine):
imgs = Img.imgstripxf("Machines/Lab")
working = False
def __init__(self, c, p):
super().__init__(c, p)
self.lab = MUI.Lab(100, 10, p.team)
self.gui = MUI.MUI("LAB", [self.lab, MUI.ElectroSlot(self)])
def update(self, pos, area, events):
lp = self.lab.progress
super().update(pos, area, events)
self.working = self.lab.progress != lp
def input(self, d, i):
return self.lab.inputs.add(i)
@property
def img(self):
return self.imgs[self.working]
class Generator(FixedMachine):
imgs = Img.imgstripxf("Machines/Generator")
working = False
def __init__(self, c, p):
super().__init__(c, p)
self.fuel = MUI.FuelSlot(20)
self.gui = MUI.MUI("Generator", [self.fuel])
def update(self, pos, area, events):
lfl = self.fuel.left
area.generate(self.fuel.get_power)
self.working = lfl != self.fuel.left
def input(self, d, i):
if i.name in fuels:
return self.fuel.slot.add(i, 1)
@property
def img(self):
return self.imgs[self.working]
class AutoCrafter(SlotMachine):
imgs = Img.imgstripxf("Machines/AutoCrafter")
processor = None
rtype = "Crafting"
def __init__(self, c, r, p):
super().__init__(c, r, p)
self.electro = MUI.ElectroSlot(self)
self.gui = MUI.MUI("Select Recipe",
[MUI.RSelect(get_recipes(self.p.team, self.rtype))])
def gui_trigger(self, *args):
if args[0] == "Change Recipe" and not (self.processor and any(
self.processor.inputs.slots)):
self.gui.re_init(
"Select Recipe",
[MUI.RSelect(get_recipes(self.p.team, self.rtype))])
self.processor = None
else:
self.processor = MUI.Crafter(args,
sum(q for q in args[0].values()) * 10,
10)
self.outputslot = self.processor.output
self.gui.re_init(
"AutoCrafter",
[self.processor, self.electro,
MUI.Button(self.rtype)])
def input(self, d, i):
return self.processor and self.processor.inputs.add(i, 1)
def re_own(self, p):
self.p = p
self.gui = MUI.MUI("Select Recipe",
[MUI.RSelect(get_recipes(self.p.team, self.rtype))])
@property
def img(self):
return self.imgs[bool(self.processor and self.processor.progress)]
class Furnace(SlotMachine):
imgs = Img.imgstripxf("Machines/Furnace", 16)
working = False
def __init__(self, c, r, p):
super().__init__(c, r, p)
self.processor = MUI.Processor("Smelting", 10)
self.fuel = MUI.FuelSlot()
self.gui = MUI.MUI("Furnace", [self.processor, self.fuel])
self.outputslot = self.processor.output
def input(self, d, i):
if i.name in fuels:
return self.fuel.slot.add(i, 1)
return self.processor.input.add(i, 1)
def update(self, pos, area, events):
lp = self.processor.progress
super().update(pos, area, events)
self.working = self.processor.progress != lp
@property
def img(self):
return self.imgs[self.working]
class Tree(Crop):
imgs=Img.imgstripxf("World/Tree")
item = Items.resources["Log"]
class FireFlower(Crop):
imgs = Img.imgstripxf("Plants/FireFlower")
item=Tools.FireFlower()
