Ejemplo n.º 1
0
def test_reactor():
    reactor = Reactor()

    step = 0
    while 0 < reactor.status_percentage() < 1:
        print(f"step {step:04d}")
        print("\n".join(reactor.get_statuses()))
        reactor.auto_changes()
        step += 1

    print("Final")
    print("\n".join(reactor.get_statuses()))
Ejemplo n.º 2
0
class Game:
    rooms: List[Room]
    active_room: Room
    map: Union[None, MapWidget]

    def __init__(self):
        # state of various entities/room thingies
        self.inv = []
        self.rooms = make_rooms()
        self.player_coords = [1, 1]
        self.active_room = self.rooms[0]
        self.hp = HP()
        self.damage_rate = 0.2
        self.time = 0
        self.rads = 0
        self.td = TimeDisplay()

        self.map = None
        self.time_txt = None
        self.room_txt = None
        self.health_txt = None
        self.inventory_txt = None
        self.radiation_exposure_txt = None
        self.current_form = None
        self.air_temp = None
        self.set_map_pos = True
        self.get_map_pos = False
        self.last_time = 0
        self.rad_mult = 1
        self.equipment_txt = None
        self.equipment = []
        self.hinted = False

        self.reactor = Reactor()

        # Variable for end-state
        self.good_end = None

    def change_damage_rate(self, dr):
        pass

    def popup_menu(self, menu):
        self.current_form.popup_menu(menu)

    def show_status(self):
        npyscreen.notify_confirm(self.reactor.get_statuses(), editw=1)

    def setup_form(self, form):
        self.current_form = form
        self.map = form.add(MapWidget, max_height=10)
        self.map.game = self
        self.time_txt = form.add(npyscreen.TitleFixedText,
                                 name="Time:",
                                 editable=False)
        self.room_txt = form.add(npyscreen.TitleFixedText,
                                 name="Room:",
                                 value="set this to roomLoc",
                                 editable=False)
        self.inventory_txt = form.add(npyscreen.TitleFixedText,
                                      name="Inventory:",
                                      editable=False)
        self.equipment_txt = form.add(npyscreen.TitleFixedText,
                                      name="Equipment:",
                                      value="",
                                      editable=False)
        self.air_temp = form.add(npyscreen.TitleFixedText,
                                 name="Air temp:",
                                 editable=False)
        self.radiation_exposure_txt = form.add(npyscreen.TitleFixedText,
                                               name="Rad exposure:",
                                               editable=False)
        self.health_txt = form.add(npyscreen.TitleFixedText,
                                   name="Health:",
                                   editable=False)
        form.before_display = lambda: self.update()
        forms.add_handlers(form, {
            "f": self.handle_interact,
            "e": self.handle_interact
        })

    def handle_interact(self, _arg):
        x, y = self.map.get_player_coords()
        item: Entity = self.active_room.get([x, y])
        if item:
            item.interact(game, [x, y], self.active_room)

    def set_room(self, room, coords):
        self.active_room = room
        self.player_coords = coords
        self.set_map_pos = True
        self.map.set_room(room)

    def update(self):
        self.update_reactor()

        if self.reactor.temp > 150 and not self.hinted:
            self.hinted = True
            npyscreen.notify_confirm(
                "It's getting hot. Maybe I should check PROTOCOLS in the Datapad",
                editw=1)
        if self.rads > 1000 and len(self.hp.consequences) == 0:
            self.hp.consequences.append("Rad poisoning")
        if self.rads > 5000 and len(self.hp.consequences) == 1:
            self.hp.consequences.append("Severe rad poisoning")

        self.damage_rate = 0.2 + len(self.hp.consequences) * 0.2

        self.air_temp.value = f"~{int(self.reactor.air_temp / 5) * 5}°C"
        self.map.set_room(self.active_room)

        if self.get_map_pos:
            self.get_map_pos = False
            self.player_coords = self.map.get_player_coords()

        self.time_txt.set_value(f"{self.td.text()}")
        self.inventory_txt.set_value(f"{len(self.inv)} item(s)")
        self.equipment_txt.set_value(
            f"{', '.join([x.name for x in self.equipment])}")
        self.radiation_exposure_txt.value = f"{self.rads:05d} rad"
        self.health_txt.set_value(f"{', '.join(self.hp.consequences)}")

        new_cursor_position = (self.player_coords[1] *
                               (len(self.active_room.contents[0]) * 2 + 1) +
                               self.player_coords[0] * 2)
        if new_cursor_position != self.map.cursor_position - 1:
            self.map.cursor_position = new_cursor_position
        self.room_txt.set_value(
            f"{self.active_room.name} ({self.player_coords})")

    def update_reactor(self):
        time = floor(self.time)
        for i in range(0, time - self.last_time):
            self.reactor.auto_changes(0.5)
            self.rads += int(self.active_room.rads_per_sec * self.rad_mult)
        self.last_time = time

        if time > 70:
            npyscreen.notify_confirm("Assistance has arrived. You win!",
                                     title="Rescue",
                                     editw=1,
                                     form_color='GOOD')
            exit(0)

        if game.reactor.status_percentage() >= 1:
            # TODO flavor text
            npyscreen.notify_confirm("The reactor explodes violently.",
                                     title="Meltdown",
                                     editw=1)
            exit(0)

    def travel_time(self):
        # Adjust this as necessary for travel time between rooms?
        self.time += 1 * game.damage_rate
        self.get_map_pos = True
        self.update()
        self.current_form.display()

    def tiny_action_time(self):
        self.time += 0.1 * game.damage_rate

    def minor_action_time(self):
        # Examine, take something from inventory, small interactions
        self.time += 1 * game.damage_rate

    def major_action_time(self):
        # Solve a puzzle?
        self.time += 5 * game.damage_rate