swamp_monster.py

#!/usr/bin/python

import os
import random
import sys
import time

import termios
import tty


# --------------------------------------------------------
#   static
# --------------------------------------------------------
KEY_ESC = 27
KEY_ENTER = 13
KEY_SPACE = 32

SPACE_BUFFER = ' '*5
NSPACE_BUFFER = '\n%s'%SPACE_BUFFER

COUNT_STATUS_LINES_RESERVED = 5

# try to maintain 360
ROWSIZE = 16
COLSIZE = 22

COLOURS = { 'blue': '\033[94m'
          , 'green': '\033[92m'
          , 'yellow': '\033[93m'
          , 'red': '\033[91m'
          }
ENDC = '\033[0m'

TURN_DUSK = 2
TURN_NIGHT = 20
TURN_TIDE = 70
TURN_DAWN = 100
TURN_LIGHT = 110


# --------------------------------------------------------
#   entity statics
# --------------------------------------------------------
ENTITY_SIZE_MULTIPLE = 5

ES_PILL = 1
ES_RING = ES_PILL * ENTITY_SIZE_MULTIPLE
ES_VIAL = ES_RING * ENTITY_SIZE_MULTIPLE
ES_TOOL = ES_VIAL * ENTITY_SIZE_MULTIPLE
ES_TOME = ES_TOOL * ENTITY_SIZE_MULTIPLE
ES_STOOL = ES_TOME * ENTITY_SIZE_MULTIPLE
ES_PLINTH = ES_STOOL * ENTITY_SIZE_MULTIPLE
ES_WALL = ES_PLINTH * ENTITY_SIZE_MULTIPLE


# --------------------------------------------------------
#   space statics
# --------------------------------------------------------
SPACE_CAPACITY = ES_WALL


# --------------------------------------------------------
#   context struct
# --------------------------------------------------------
#
# This gives us a namespace that we can pass around the
# program. It's a centralised place for storing game
# state, and a the place to start when you want to reach
# an object known to the game.
#
class Context(object):

    def __init__(self):
        self.keep_running = True
        self.exit_message = None
        self.turn_counter = 0

        self.io = None

        self.status = []

        self.monster_spawn_randomiser = 4
        self.first_shambler = True

        # int v object
        self.planes = {}
        self.unique_plane_idx = -1
        #
        # fairies
        self.fairies = []
        self.player = None
        self.lady_of_the_lake = None
        #
        # feature planes
        self.island_plane = None
        self.water_spots = []

    def player_plane(self):
        return self.player.ent.owner.plane

    def retain_plane(self, plane):
        self.unique_plane_idx += 1
        plane.unique_id = self.unique_plane_idx
        self.planes[self.unique_plane_idx] = plane

    def release_plane(self, plane_id):
        del self.planes[plane_id]


# --------------------------------------------------------
#   io
# --------------------------------------------------------
class UnixIo(object):

    def __init__(self, context):
        self.context = context

    def clear_screen(self):
        os.system('clear')
        #print('\033[H')

    def getchar(self):
        fd = sys.stdin.fileno()
        old_settings = termios.tcgetattr(fd)
        try:
            tty.setraw(sys.stdin.fileno())
            ch = sys.stdin.read(1)
        finally:
            termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
        return ch

    def ask_yn(self, msg, default, clear=True):
        def say_no():
            print('No')
            time.sleep(0.1)
        def say_yes():
            print('Yes')
            time.sleep(0.1)

        if clear:
            self.clear_screen()

        sys.stdout.write('\n%s'%msg)

        if None != default:
            if default:
                print("[y]")
            else:
                print("[n]")
        else:
            print
        r = self.getchar()
        if r in ['y', 'Y']:
            say_yes()
            return True
        if r in ['n', 'N']:
            say_no()
            return False

        if default:
            say_yes()
            return True
        else:
            say_no()
            return False

    def get_wordy_input(self):
        sys.stdout.write(':')
        input = raw_input()
        return input

    def redraw(self, lines, with_status=False):
        status_buffer = COUNT_STATUS_LINES_RESERVED - len(self.context.status)

        sb = []
        #
        # status messages, or gaps in their stead
        for i in range(status_buffer):
            sb.append('')
        if with_status:
            sb.extend(self.context.status)
        #
        # render the supplied lines
        sb.extend(lines)

        out = "%s%s"%(SPACE_BUFFER, NSPACE_BUFFER.join(sb))

        self.clear_screen()
        print(out)


# --------------------------------------------------------
#   container
# --------------------------------------------------------
#
# A container holds entities. e.g. a player's inventory. The
# base case looks very much like a list, but containers need
# logic for things like capacity checking and placement.
#
# Entities always reside in something that quacks like a
# container.
#
class Container(object):

    def __init__(self):
        self.within = []

    def contained(self):
        return self.within[:]

    def add(self, ent):
        """Don't call this directly. Use move_ent, because
        this takes responsibility for reassigning the
        owner."""
        self.within.append(ent)

    def remove(self, ent):
        self.within.remove(ent)

    def get_position(self):
        """Returns a three-item tuple representing the
        global coordinate position of this container,
        (level, row, column)"""
        raise Exception("Needs to be implemented.")


# --------------------------------------------------------
#   mapping
# --------------------------------------------------------
#
# Planes are composed of Space.
#
class Plane(object):
    def __init__(self, context, rowsize, colsize):
        self.unique_id = None

        self.context = context
        self.rowsize = rowsize
        self.colsize = colsize

        self.d_space = {}

    def retain_entity(self, row, col, placement):
        coords = (row, col)
        self.placements[coords] = placement

    def release_entity(self, entity):
        ridx, cidx = [(r, c) for (r, c), p in self.placements.items() if p == entity][0]
        coords = (ridx, cidx)
        del self.placements[coords]

    def render(self):
        rows = []
        for ridx in range(self.rowsize):
            sb = []
            for cidx in range(self.colsize):
                sb.append(self.d_space[ (ridx, cidx) ].symbol())
            rows.append(sb)
        return [''.join(colchars) for colchars in rows]

    def move(self, ent, keypad_cardinal):
        #
        # Work out the desired coordinate
        plane_id, old_ridx, old_cidx = ent.owner.get_position()
        plane = self.context.planes[plane_id]
        nrow, ncol = old_ridx, old_cidx
        if keypad_cardinal in (1,2,3):
            nrow += 1
        if keypad_cardinal in (1,4,7):
            ncol -= 1
        if keypad_cardinal in (3,6,9):
            ncol += 1
        if keypad_cardinal in (7,8,9):
            nrow -= 1
        #
        # Validate it's within map bounds
        val_msg = "You escaped! Well done."
        if nrow < 0 or nrow > self.rowsize-1:
            if ent.name == ENT_PLAYER:
                self.context.exit_message = val_msg
                self.context.keep_running = False
            return
        elif ncol < 0 or ncol > self.colsize-1:
            if ent.name == ENT_PLAYER:
                self.context.exit_message = val_msg
                self.context.keep_running = False
            return
        new_space = self.d_space[(nrow, ncol)]
        #
        # If the user has motioned towards claimed space, that's
        # an interaction rather than movement.
        lst_cl = new_space.claimants()
        if lst_cl:
            for cl in lst_cl:
                if ent.sentient and cl.sentient:
                    ent.sentient_interaction(cl)
                    return
            if ent.name == ENT_PLAYER:
                status(self.context, "You bump into a %s"%lst_cl[-1].name)
            return
        #
        # Player can't move into water.
        if new_space.surface.within[-1].name == ENT_WATER:
            if ent.name == ENT_PLAYER:
                m = random.choice( [ "But it's much warmer out here."
                                   , "You can't swim."
                                   , "The water looks dirty."
                                   , "You can't walk on that!"
                                   , "You splash your toes in the water"
                                   , "You might sink"
                                   , "Your wouldn't want your crowbar to get rusty."
                                   , "You're scared of water"
                                   , "No way - there might be sharks!"
                                   ] )
                self.context.status.append(m)
                return
        #
        # Do the move
        move_ent(ent, new_space)
        #
        # If the user isn't the player, we allow them to
        # mess up any well-cultivated sand
        if ent.name != ENT_PLAYER:
            surface = new_space.surface.within[-1]

def create_plane(context, rowsize, colsize):
    plane = Plane(context, rowsize, colsize)
    context.retain_plane(plane)
    #
    # Prepare the space containers in the plane
    for ridx in range(plane.rowsize):
        for cidx in range(plane.colsize):
            space = create_space(plane.context, plane, ridx, cidx)
            plane.d_space[ (ridx, cidx) ] = space

    return plane

def merge_plane_onto_plane(context, source_plane, target_plane, t_ridx_offset, t_cidx_offset):
    """Merges all of source onto target, using (t_ridx_offset, t_cidx_offset)
    as the top-left point at which to start merging."""
    for ridx in range(source_plane.rowsize):
        for cidx in range(source_plane.colsize):
            space = source_plane.d_space[ (ridx, cidx) ]
            space.plane = target_plane
            space.ridx = ridx + t_ridx_offset
            space.cidx = cidx + t_cidx_offset
            t_coords = ( space.ridx
                       , space.cidx
                       )
            target_plane.d_space[t_coords] = space

class SpaceContainer(object):

    def __init__(self, context, plane, ridx, cidx):
        self.context = context
        self.capacity = SPACE_CAPACITY
        self.surface = Container()
        self.within = []
        self.plane = plane
        self.ridx = ridx
        self.cidx = cidx

    def contained(self):
        return self.within[:]

    def claimants(self):
        return [e for e in self.within if e.claims_space]

    def add(self, ent):
        self.within.append(ent)

    def remove(self, ent):
        self.within.remove(ent)

    def symbol(self):
        ent = self.top_ent()
        if ent:
            return str(ent)
        else:
            return str(self.surface.within[-1])

    def top_ent(self):
        if not self.within:
            return None
        for ent in self.within:
            if ent.claims_space:
                return ent
        return self.within[-1]

    def get_position(self):
        """Returns a three-item tuple representing the
        global coordinate position of this container,
        (level, row, column)"""
        return (self.plane.unique_id, self.ridx, self.cidx)

def create_space(context, plane, ridx, cidx):
    space = SpaceContainer(context, plane, ridx, cidx)
    declare_water(context, space.surface)
    return space


# --------------------------------------------------------
#   feature planes
# --------------------------------------------------------
#
# You create structures on a plane of their own, and then
# copy them onto the player's current plane. You should
# either create the plane once and store it in context so
# you can reuse it, or else be vigilant to deallocate the
# plane once you're done with it! :)
#
def declare_island_plane(context):
    plane = create_plane( context
                        , rowsize=8
                        , colsize=10
                        )
    sketch = [ 'xxxxxxxxxx'
             , 'xxx....xxx'
             , 'xx......xx'
             , 'x.......xx'
             , 'x........x'
             , 'x........x'
             , 'xx......xx'
             , 'xxxxxxxxxx'
             ]
    def replace_water_with_dirt(context, space):
        space.surface.within.pop()
        declare_dirt(context, space.surface)
    legend = { 'x': None
             , '.': lambda context, container: replace_water_with_dirt(context, container)
             }
    for ridx, row in enumerate(sketch):
        for cidx, cell in enumerate(row):
            setup_fn = legend[cell]
            if setup_fn:
                container = plane.d_space[ (ridx, cidx) ]
                setup_fn(context, container)
    randomish_mangroves_and_stuff(context, plane)

    context.island_plane = plane


# --------------------------------------------------------
#   entity foundations
# --------------------------------------------------------
#
# An entity is anything that can have a sprite in the world.
# So a table, a c
#
class Entity(object):

    def __init__(self):
        self.c = None
        self.name = None
        self.size = None
        self.mass = None
        self.inv = None
        self.colour = None
        # sentience indicates that moving into it should check
        # for a custom interaction.
        self.sentient = False
        self.sentient_fn = None
        # container this sits in
        self.owner = None
        # a piece of space can't be claimed by more than
        # one entity.
        self.claims_space = False
        # can it be picked up?
        self.mobile = True
        #
        # item-specific properties and functions
        self.d = {}
        #
        # plugin functions
        self.desc_fn = None
        self.apply_fn = None
        self.wet_fn = None

    def __repr__(self):
        if None == self.colour:
            return self.c
        return ''.join( [ COLOURS[self.colour]
                        , self.c
                        , ENDC
                        ] )

    def apply(self, context):
        if not self.apply_fn:
            # shouldn't get here
            context.status.append("Your developer is a muppet. (apply)")
            return
        self.apply_fn(self, context)

    def desc(self):
        """This is default, but you can override it by setting
        desc_fn."""
        if self.desc_fn:
            return self.desc_fn(self)
        else:
            return self.name

    def sentient_interaction(self, acc):
        """Pass in the entity with which you're interacting as the
        accusative."""
        if self.sentient_fn == None:
            # shouldn't get here
            self.context.status.append("Your developer is a muppet. (sent.i)")
            return
        self.sentient_fn( nom=self
                        , acc=acc
                        )

    def wet(self):
        if self.wet_fn:
            self.wet_fn()

class InventoryContainer(object):

    def __init__(self, entity):
        self.entity = entity
        self.within = []

    def contained(self):
        return self.within

    def add(self, ent):
        self.within.append(ent)

    def remove(self, ent):
        self.within.remove(ent)

    def get_position(self):
        return self.entity.owner.get_position()

def create_entity(container, c, name, size, colour=None, claims_space=False, mobile=True):
    ent = Entity()
    ent.c = c
    ent.name = name
    ent.size = size
    ent.inv = InventoryContainer(ent)
    ent.owner = container
    ent.colour = colour
    ent.claims_space = claims_space
    ent.mobile = mobile

    container.add(ent)

    return ent

def move_ent(ent, new_container):
    """Can be used for dropping, pickup and just rearrangement."""
    ent.owner.remove(ent)
    new_container.add(ent)
    ent.owner = new_container


# --------------------------------------------------------
#   entities
# --------------------------------------------------------
ENT_CROWBAR = 'crowbar'
def declare_crowbar(context, container):
    e = create_entity(container, ')', ENT_CROWBAR, ES_STOOL)

ENT_DIRT = 'dirt'
ENT_DIRT_Q_KEY = 'quality'
ENT_DIRT_Q_ROUGH = 'rough'
ENT_DIRT_Q_TILLED = 'tilled'
def declare_dirt(context, container):
    e = create_entity(container, '.', ENT_DIRT, ES_STOOL)
    e.d[ENT_DIRT_Q_KEY] = ENT_DIRT_Q_ROUGH
    def desc(ent):
        return '%s %s'%(e.d[ENT_DIRT_Q_KEY], e.name)
    e.desc_fn = desc

ENT_MANGROVE = 'mangrove'
def declare_mangrove(context, container):
    e = create_entity(container, "%", ENT_MANGROVE, ES_WALL, colour='green')
    e.claims_space = True

ENT_SHAMBLER = 'shambler'
ENT_SHAMBLER_K_FIRST_TURN = 'is_first_turn'
ENT_SHAMBLER_K_DEAD = 'is_dead'
def declare_shambler(context, container):
    ent = create_entity(container, 'Y', ENT_SHAMBLER, ES_PLINTH*3, colour="red")
    ent.claims_space = True
    ent.sentient = True
    def sentient_fn(nom, acc):
        if acc.name == ENT_SHAMBLER:
            pass
        if acc.name == ENT_PLAYER:
            context.exit_message = "A shambler crushes you."
            context.keep_running = False
            context.player.ent.c = '&'
    ent.sentient_fn = sentient_fn
    ent.d[ENT_SHAMBLER_K_DEAD] = False
    ent.d[ENT_SHAMBLER_K_FIRST_TURN] = True
    return ent

ENT_WATER = 'water'
def declare_water(context, container):
    ent = create_entity(container, '~', ENT_WATER, ES_WALL, colour="blue")
    ent.claims_space = True



# --------------------------------------------------------
#   inventory
# --------------------------------------------------------
INVENTORY_SELECTION_KEYS = []
INVENTORY_SELECTION_KEYS.extend( [chr(c) for c in range(ord('a'), ord('z')+1)] )
INVENTORY_SELECTION_KEYS.extend( [chr(c) for c in range(ord('A'), ord('Z')+1)] )

def inspect_mobile_items_in_container(context, container, heading, use_selection):
    """Looks at a container. If selection is True, then you can select
    something from the container."""
    mobile_items = [tpl[1] for tpl in sorted([(e.desc(), e) for e
                                                            in container.contained()
                                                            if e.mobile
                                                            ])
                    ]

    choice_d = {}
    for idx, ent in enumerate(mobile_items):
        idesc = ent.desc()
        choice_d[INVENTORY_SELECTION_KEYS[idx]] = (idesc, ent)

    selection = None
    status = None

    while selection == None:
        lines = []
        lines.append(heading)
        lines.append('')
        for key in sorted(choice_d.keys()):
            name = choice_d[key][0]
            if use_selection:
                lines.append("  %s) %s"%(key, name))
            else:
                lines.append("  %s"%name)
        if len(choice_d) == 0:
            lines.append('  [Nothing]')
        lines.append('')
        if status:
            lines.append(status)

        context.io.redraw(lines)
        result = context.io.getchar()
        if not use_selection:
            break
        if ord(result) in (KEY_ESC, KEY_SPACE, KEY_ENTER):
            return None
        elif result in choice_d:
            selection = choice_d[result][1]
        else:
            status = "* escape to return"
    return selection


# --------------------------------------------------------
#   actions
# --------------------------------------------------------
KEYPRESS_ACTIONS = {}

def handle_keypress(*keys):
    def decorator(func):
        def wrapper(context):
            func(context)
        for key in keys:
            if key in KEYPRESS_ACTIONS:
                raise Exception("Duplicate keybind definition. %s"%key)
            KEYPRESS_ACTIONS[key] = wrapper
        if func.__doc__:
            wrapper.__doc__ = func.__doc__
        else:
            wrapper.__doc__ = func.__name__
        if wrapper.__doc__.startswith('action_'):
            wrapper.__doc__ = ' '.join(wrapper.__doc__.split('_')[1:])
        return wrapper
    return decorator

@handle_keypress('w', ' ')
def action_wait(context):
    pass

@handle_keypress('q')
def action_quit(context):
    # xxx polish
    context.keep_running = False

@handle_keypress('?')
def action_help(context):
    "Help: shows this menu"
    context.io.clear_screen()
    sb = []
    for i in range(COUNT_STATUS_LINES_RESERVED):
        sb.append('')
    sb.append('%sKeys:'%SPACE_BUFFER)
    sb.append('')
    for k, fn in sorted(KEYPRESS_ACTIONS.items()):
        text = fn.__doc__
        sb.append('%s  %s  %s'%(SPACE_BUFFER, k, text))
    sb.append('')
    sb.append('  [paused]')
    print('\n'.join(sb))
    context.io.getchar()

@handle_keypress('i')
def action_inventory(context):
    "Inventory: Show what you're holding"
    # xxx change this so that once you've selected an item, you get a
    # choice of how you'd like to interact with it.
    ent = inspect_mobile_items_in_container( context
                                           , context.player.ent.inv
                                           , 'Inventory:'
                                           , use_selection=False
                                           )
    if None == ent:
        return

    context.status.append("Selected a %s"%ent.desc())

@handle_keypress('1', 'b')
def action_go_sw(context):
    context.player_plane().move(context.player.ent, 1)

@handle_keypress('2', 'j')
def action_go_s(context):
    context.player_plane().move(context.player.ent, 2)

@handle_keypress('3', 'n')
def action_go_se(context):
    context.player_plane().move(context.player.ent, 3)

@handle_keypress('4', 'h')
def action_go_w(context):
    context.player_plane().move(context.player.ent, 4)

@handle_keypress('6', 'l')
def action_go_e(context):
    context.player_plane().move(context.player.ent, 6)

@handle_keypress('7', 'y')
def action_go_e(context):
    context.player_plane().move(context.player.ent, 7)

@handle_keypress('8', 'k')
def action_go_n(context):
    context.player_plane().move(context.player.ent, 8)

@handle_keypress('9', 'u')
def action_go_n(context):
    context.player_plane().move(context.player.ent, 9)


# --------------------------------------------------------
#   fairies
# --------------------------------------------------------
#
# The program runs on fairies. A game 'turn' is comprised
# of all fairies working out what they want to do.
#
class PlayerFairy(object):
    def __init__(self, context, ent):
        self.context = context
        self.ent = ent
        self.health = 0
    def turn(self):
        "Have a turn"
        self.context.io.clear_screen()

        player_plane = self.context.player_plane()
        self.context.status.append(str(self.context.turn_counter))
        self.context.io.redraw( player_plane.render()
                              , True
                              )
        self.context.status = []
        key = self.context.io.getchar()
        if key in KEYPRESS_ACTIONS:
            fn = KEYPRESS_ACTIONS[key]
            fn(self.context)
        else:
            self.context.status.append("Unknown command, %s"%key)

ENT_PLAYER = 'player'
def declare_player_actor(context):
    middle = (ROWSIZE/2, COLSIZE/2)
    starting_space = context.starting_plane.d_space[middle]
    starting_space.within = []
    ent = create_entity( starting_space
                       , '@'
                       , ENT_PLAYER
                       , ES_PLINTH * 2
                       , colour='yellow'
                       , claims_space=True
                       , mobile=False
                       )
    ent.sentient = True
    def sentient_fn(nom, acc):
        if acc.name == ENT_SHAMBLER:
            status(context, 'Klunk!')
            acc.d[ENT_SHAMBLER_K_DEAD] = True
    ent.sentient_fn = sentient_fn

    context.player = PlayerFairy(context, ent)
    context.fairies.append(context.player)

    declare_crowbar(context, context.player.ent.inv)

class LadyOfTheLakeFairy(object):
    "She sends swamp monsters after you."
    def __init__(self, context):
        self.context = context
        # list of entity
        self.monsters = []
    def turn(self):
        #
        # clean up the dead shambers
        dead = [m for m
                  in self.monsters
                  if m.d[ENT_SHAMBLER_K_DEAD] == True
                  ]
        for d in dead:
            d.owner.within.remove(d)
        self.monsters = [m for m
                           in self.monsters
                           if m.d[ENT_SHAMBLER_K_DEAD] == False
                           ]
        #
        # move the shamblers
        player_space = self.context.player.ent.owner
        p_ridx, p_cidx = player_space.ridx, player_space.cidx
        for m in self.monsters:
            # Otherwise they appear and kill the player before
            # the player can see them. "Unfair"
            if m.d[ENT_SHAMBLER_K_FIRST_TURN]:
                m.d[ENT_SHAMBLER_K_FIRST_TURN] = False
            else:
                m_space = m.owner
                m_ridx, m_cidx = m_space.ridx, m_space.cidx
                cardinal = None
                if m_ridx > p_ridx and m_cidx > p_cidx:
                    cardinal = random.choice( [7,7,7,7,4,8] )
                elif m_ridx > p_ridx and m_cidx < p_cidx:
                    cardinal = random.choice( [9,9,9,9,8,6] )
                elif m_ridx < p_ridx and m_cidx > p_cidx:
                    cardinal = random.choice( [1,1,1,1,2,4] )
                elif m_ridx < p_ridx and m_cidx < p_cidx:
                    cardinal = random.choice( [3,3,3,3,2,6] )
                elif m_ridx < p_ridx:
                    cardinal = random.choice( [2,2,2,2,1,3] )
                elif m_ridx > p_ridx:
                    cardinal = random.choice( [8,8,8,8,9,7] )
                elif m_cidx < p_cidx:
                    cardinal = random.choice( [6,6,6,6,9,3] )
                elif m_cidx > p_cidx:
                    cardinal = random.choice( [4,4,4,4,1,7] )
                m.owner.plane.move(m, cardinal)

        # randomly create monsters
        val = random.choice(range(self.context.monster_spawn_randomiser))
        if val == 0 and TURN_DUSK < self.context.turn_counter < TURN_LIGHT:
            empty_water_spots = [ws for ws
                                    in self.context.water_spots
                                    if len(ws.within) == 0
                                    ]
            if empty_water_spots:
                if self.context.first_shambler:
                    status( self.context
                          , "A creature rises from the waters, and moans at you menacingly."
                          )
                    status(self.context, "")
                    status( self.context
                          , '[To attack, walk into the enemy, avoid letting them do the same]'
                          )
                    self.context.first_shambler = False
                elif random.choice(range(50)) == 0:
                    status(self.context, "A distant sheep bleets. Baaaa!")
                else:
                    m = random.choice( [ "You hear a rustle."
                                       , "You hear a sudden bubbling."
                                       , "A creature splashes violently."
                                       , "A shambler rises from the froth."
                                       , "You hear disturbed birds take flight."
                                       , "Red eyes flicker through the darkness."
                                       , "A creature shambles towards you."
                                       ] )
                    status(self.context, m)
                starting_space = random.choice(self.context.water_spots)
                ent = declare_shambler(self.context, starting_space)
                self.monsters.append(ent)

def declare_lady_of_the_lake(context):
    context.lady_of_the_lake = LadyOfTheLakeFairy(context)
    context.fairies.append(context.lady_of_the_lake )

def create_initial_fairies(context):
    declare_player_actor(context)
    declare_lady_of_the_lake(context)


# --------------------------------------------------------
#   complex actions
# --------------------------------------------------------
def talk_to_shed_door(context, player_ent, shed_door_ent):
    ent = inspect_mobile_items_in_container( context=context
                                           , container=shed_door_ent.inv
                                           , heading="Contents of the shed:"
                                           , use_selection=False
                                           )
    if context.io.ask_yn("Pack something in the shed?", default=False, clear=False):
        ent = inspect_mobile_items_in_container( context=context
                                               , container=player_ent.inv
                                               , heading="Select item to deposit:"
                                               , use_selection=True
                                               )
        if ent:
            move_ent(ent, shed_door_ent.inv)
            status(context, 'Done')
    if context.io.ask_yn("Retrieve from shed?", default=False, clear=False):
        ent = inspect_mobile_items_in_container( context=context
                                               , container=shed_door_ent.inv
                                               , heading="Select item to get"
                                               , use_selection=True
                                               )
        if ent:
            move_ent(ent, player_ent.inv)
            status(context, 'Taken')


# --------------------------------------------------------
#   alg
# --------------------------------------------------------
def setup_and_populate_the_map(context):
    """Create rooms, and then spaces for walls and
    the enclosed areas of this plane."""
    context.starting_plane = create_plane(context, ROWSIZE, COLSIZE)

    randomish_mangroves_and_stuff(context, context.starting_plane)

    #
    # put land randomly on the map

    #
    # create the island
    declare_island_plane(context)
    merge_plane_onto_plane( context=context
                          , source_plane=context.island_plane
                          , target_plane=context.starting_plane
                          , t_ridx_offset=(ROWSIZE / 2) - (context.island_plane.rowsize/2)
                          , t_cidx_offset=(COLSIZE / 2) - (context.island_plane.colsize/2)
                          )

    context.water_spots = [ent for ent
                               in context.starting_plane.d_space.values()
                               if ent.surface.within[-1].name == ENT_WATER
                               ]

def randomish_mangroves_and_stuff(context, plane):
    #
    # randomly allocate mangroves and land
    for ridx in range(plane.rowsize):
        for cidx in range(plane.colsize):
            choice = random.choice( [1,2,3,4,5,6,7,8,9] )
            if choice == 1:
                space = plane.d_space[ (ridx, cidx) ]
                space.surface.within.pop() # eliminate water
                declare_dirt(context, space.surface)
            elif choice == 2:
                space = plane.d_space[ (ridx, cidx) ]
                space.surface.within.pop() # eliminate water
                declare_dirt(context, space.surface)
                declare_mangrove(context, space)

def main():
    context = Context()
    context.io = UnixIo(context)

    status(context, "The tide has trappd you in the swamp.")
    status(context, "Fortunately, you brought your crowbar.")
    status(context, 'Survive until the tide drops.')
    status(context, "[Numlock+keypad or vi keys. ? for help]")

    setup_and_populate_the_map(context)

    create_initial_fairies(context)

    key = None
    while context.keep_running:
        context.turn_counter += 1
        if context.turn_counter == TURN_DUSK:
            status(context, 'It is getting dark.')
            context.monster_spawn_randomiser = 3
        if context.turn_counter == TURN_NIGHT:
            status(context, 'It is dark.')
            context.monster_spawn_randomiser = 2
        if context.turn_counter == (TURN_NIGHT - TURN_DUSK) / 2:
            status(context, 'You hear an ethereal singing.')
        if context.turn_counter == TURN_DAWN:
            status(context, 'You see light on the horizon.')
            context.monster_spawn_randomiser = 4
        if context.turn_counter == TURN_LIGHT:
            context.exit_message = 'You survived the night'
            context.keep_running = False
        if context.turn_counter == TURN_TIDE:
            status(context, 'The tide is going out. Escape.')
        if context.turn_counter > TURN_TIDE and 0 == context.turn_counter % 6:
            if len(context.water_spots) > 40:
                sample = random.sample(context.water_spots, 16)
                for space in sample:
                    space.surface.within.pop()
                    declare_dirt(context, space.surface)
                status(context, 'The water level drops.')
                status(context, 'Escape.')
                context.water_spots = [ent for ent
                                           in context.starting_plane.d_space.values()
                                           if ent.surface.within[-1].name == ENT_WATER
                                           ]
        for actor in context.fairies:
            actor.turn()

    context.io.clear_screen()
    player_plane = context.player_plane()
    context.io.redraw( player_plane.render()
                     , True
                     )

    if context.exit_message:
        print(context.exit_message)


# --------------------------------------------------------
#   stencil
# --------------------------------------------------------
def status(context, msg):
    context.status.append(msg)


# --------------------------------------------------------
#   util
# --------------------------------------------------------
class Timer(object):
    def __init__(self, context, turns, fn_action):
        self.context = context
        self.turns = turns
        self.fn_action = fn_action
    def tick(self):
        self.turns -= 1
        if self.turns == 0:
            fn_action()
            context.timers.remove(t)
def create_timer(context, turns, fn_action):
    t = Timer(context, 5, fn_action)
    context.timers.append(t)


# --------------------------------------------------------
#   loader
# --------------------------------------------------------
if __name__ == '__main__':
    main()