def render(self):
self.call_game_instructs_clear(rail_h=self.rail_h)
for spot in self.board.wall_spots:
(drop, rest) = spot
self.call_game_instructs_write(rail_h=self.rail_h,
drop=drop,
rest=rest,
s='.',
cpair=solent_cpair('orange'))
for spot in self.board.egg_spots:
(drop, rest) = spot
self.call_game_instructs_write(rail_h=self.rail_h,
drop=drop,
rest=rest,
s='O',
cpair=solent_cpair('yellow'))
#
if self.board.is_game_over():
cpair = solent_cpair('red')
else:
cpair = solent_cpair('green')
#
for spot in self.board.snake_spots:
(drop, rest) = spot
self.call_game_instructs_write(rail_h=self.rail_h,
drop=drop,
rest=rest,
s='O',
cpair=cpair)
# replace the head with a new character
self.call_game_instructs_write(rail_h=self.rail_h,
drop=drop,
rest=rest,
s='X',
cpair=cpair)
def __init__(self, console, initiative):
self.console = console
self.initiative = initiative
#
self.rogue_plane = create_origin_plane()
self.player_meep = self.rogue_plane.create_meep(
s=0, e=0, c='@', cpair=solent_cpair('red'))
#
self.rogue_interaction = rogue_interaction_new(
console=console,
cursor=cursor_new(fn_s=lambda: self.player_meep.coords.s,
fn_e=lambda: self.player_meep.coords.e,
fn_c=lambda: self.player_meep.c,
fn_cpair=lambda: self.player_meep.cpair))
#
# algobunny
self.algobunny_meep = self.rogue_plane.create_meep(
mind=algobunny_mind_new(),
overhead=3,
s=3,
e=3,
c='"',
cpair=solent_cpair('white'))
self.initiative.add_meep(meep=self.algobunny_meep)
#
# player
self.player_mind = player_mind_new(
console=console, rogue_interaction=self.rogue_interaction)
self.player_meep.mind = self.player_mind
self.initiative.add_meep(meep=self.player_meep)
def orb_turn(self, activity):
self.spin_term.write(
drop=6,
rest=2,
s=self.counter,
cpair=solent_cpair('blue'))
self.counter += 1
def _diff_display_refresh(self):
self.rail_roguebox.get_cgrid(
cgrid=self.cgrid_next,
nail=ROGUEBOX_GAMEBOX_NAIL,
peri=ROGUEBOX_GAMEBOX_PERI)
for idx, message in enumerate(self.rail_message_feed.list_messages()):
self.cgrid_next.put(
drop=idx,
rest=0,
s=message,
cpair=solent_cpair('white'))
#
for drop in range(self.track_prime_console.height):
for rest in range(self.track_prime_console.width):
(old_c, old_cpair) = self.cgrid_last.get(
drop=drop,
rest=rest)
(c, cpair) = self.cgrid_next.get(
drop=drop,
rest=rest)
if c == old_c and cpair == old_cpair:
continue
self.nearcast.term_write(
drop=drop,
rest=rest,
s=c,
cpair=cpair)
#
self.cgrid_last.blit(
src_cgrid=self.cgrid_next)
def _setup_mobs(self):
self.nearcast.mob_o(mob_h=0)
cpair = solent_cpair('green')
self.nearcast.mob_set(mob_h=0,
mtype=MTYPE_PLAYER,
drop=4,
rest=4,
c='@',
cpair=cpair)
#
self.nearcast.mob_o(mob_h=1)
cpair = solent_cpair('red')
self.nearcast.mob_set(mob_h=1,
mtype=MTYPE_AI,
drop=3,
rest=8,
c='h',
cpair=cpair)
def render(self):
self.call_draw_surface_clear(rail_h=self.rail_h)
for spot in self.spots:
(drop, rest) = spot
self.call_draw_surface_write(rail_h=self.rail_h,
drop=drop,
rest=rest,
s='@',
cpair=solent_cpair('yellow'))
def cb_menu_asks_display_to_write(self, cs_menu_asks_display_to_write):
drop = cs_menu_asks_display_to_write.drop
rest = cs_menu_asks_display_to_write.rest
s = cs_menu_asks_display_to_write.s
#
self.nearcast.term_write(drop=drop,
rest=rest,
s=s,
cpair=solent_cpair('blue'))
def on_init(self):
console_height = self.track_prime_console.height
console_width = self.track_prime_console.width
#
if console_height < ROGUEBOX_GAMEBOX_HEIGHT:
raise Exception("console height %s too small for game height %s."%(
console_height, ROGUEBOX_GAMEBOX_HEIGHT))
if console_width < ROGUEBOX_GAMEBOX_WIDTH:
raise Exception("console width %s too small for game width %s."%(
console_width, ROGUEBOX_GAMEBOX_WIDTH))
#
rail_h = '%s/roguebox'%(self.cog_h)
self.rail_roguebox.zero(
rail_h=rail_h,
engine=self.engine,
grid_height=ROGUEBOX_GAMEBOX_HEIGHT,
grid_width=ROGUEBOX_GAMEBOX_WIDTH,
cb_ready_alert=self._rl_ready_alert,
cb_grid_alert=self._rl_grid_alert,
cb_mail_alert=self._rl_mail_alert,
cb_over_alert=self._rl_over_alert)
#
rail_h = '%s/message_feed'%(self.cog_h)
self.rail_message_feed.zero(
rail_h=rail_h,
height=ROGUEBOX_MFEED_HEIGHT,
width=ROGUEBOX_MFEED_WIDTH,
cpair_new=solent_cpair('teal'),
cpair_old=solent_cpair('blue'))
self.cgrid_last = Cgrid(
width=console_width,
height=console_height)
self.cgrid_next = Cgrid(
width=console_width,
height=console_height)
#
# sequence the possible directives in the game to the core. this will
# give this outer core the opportunity to match directives it
# recognises to keycodes. in the future, you could imagine being able
# to configure user keystrokes using this data.
for directive in self.rail_roguebox.get_supported_directives():
self.nearcast.directive(
directive_h=directive.h,
description=directive.description)
def on_net_condrop(self, message):
self.rail_line_finder = None
#
self.spin_term.clear()
self.spin_term.write(drop=0,
rest=0,
s=message,
cpair=solent_cpair('red'))
self.drop = 1
self.rest = 0
self.spin_term.refresh_console()
def _render_cgrid(self):
self.cgrid.clear()
for coord in self.cpool_spare:
(drop, rest) = coord
(c, cpair) = (' ', solent_cpair('teal'))
self.cgrid.put(drop=drop, rest=rest, s=c, cpair=cpair)
for coord in self.cpool_wall:
(drop, rest) = coord
(c, cpair) = PAIR_WALL
self.cgrid.put(drop=drop, rest=rest, s=c, cpair=cpair)
for coord in self.cpool_player:
(drop, rest) = coord
(c, cpair) = PAIR_PLAYER
if not self.b_game_alive:
cpair = solent_cpair('blue')
self.cgrid.put(drop=drop, rest=rest, s=c, cpair=cpair)
for coord in self.cpool_weed:
(drop, rest) = coord
(c, cpair) = PAIR_WEED
self.cgrid.put(drop=drop, rest=rest, s=c, cpair=cpair)
def event_loop(console):
cgrid = Cgrid(
width=console.width,
height=console.height)
cgrid.put(
drop=console.height-3,
rest=1,
s='(Escape to quit)',
cpair=solent_cpair('white'))
for (idx, (cpair, name)) in enumerate(solent_cpair_pairs()):
cgrid.put(
drop=(5+int(idx/4)),
rest=(2+int(18*(idx%4))),
s='%s %s'%(name, cpair),
cpair=cpair)
console.screen_update(
cgrid=cgrid)
#
t = 0
while True:
keycode = console.async_get_keycode()
if keycode != None:
if keycode == solent_keycode('esc'):
raise SolentQuitException()
cgrid.put(
drop=3,
rest=1,
s='key %s (%s) '%(hex(keycode), chr(keycode)),
cpair=solent_cpair('red'))
else:
time.sleep(0.05)
cgrid.put(
drop=1,
rest=1,
s='loop counter: %s'%(t),
cpair=solent_cpair('green'))
console.screen_update(
cgrid=cgrid)
t += 1
def on_net_connect(self):
self.rail_line_finder = RailLineFinder()
self.rail_line_finder.zero(
rail_h='line_finder.only',
cb_line_finder_event=self.cb_line_finder_event)
#
self.spin_term.clear()
self.spin_term.write(drop=0,
rest=0,
s='Connected',
cpair=solent_cpair('red'))
self.drop = 1
self.rest = 0
self.spin_term.refresh_console()
def __init__(self, cog_h, engine, orb):
self.cog_h = cog_h
self.engine = engine
self.orb = orb
#
self.counter = 0
self.spin_term = self.engine.init_spin(
construct=SpinSelectionUi,
console_type='pygame',
cb_selui_keycode=self.cb_selui_keycode,
cb_selui_lselect=self.cb_selui_lselect)
self.spin_term.open_console(
width=CONSOLE_WIDTH,
height=CONSOLE_HEIGHT)
self.spin_term.write(
drop=0,
rest=0,
s='Escape toggles selection mode.',
cpair=solent_cpair('green'))
self.spin_term.write(
drop=1,
rest=0,
s='Press Q to quit (when selection mode is off).',
cpair=solent_cpair('green'))
def refresh_console(self):
if self.mode == MODE_NONE:
pass
elif self.mode == MODE_SELECT:
# cursor flipping
t100 = time.time() * 100
if t100 - self.select_cursor_t100 > 53:
self.select_cursor_t100 = t100
if self.select_cursor_on:
self.select_cursor_on = False
else:
self.select_cursor_on = True
# cursor display
self.select_cgrid.blit(src_cgrid=self.cgrid)
if self.select_cursor_on:
self.select_cgrid.put(drop=self.select_drop,
rest=self.select_rest,
s='@',
cpair=solent_cpair('red'))
self.console.screen_update(cgrid=self.select_cgrid)
elif self.mode == MODE_STANDARD:
self.console.screen_update(cgrid=self.cgrid)
def _received_keycode(self, keycode):
if keycode in QUIT_KEYCODES:
raise SolentQuitException()
#
if None == self.rail_line_finder:
return
#
cpair = solent_cpair('orange')
# This backspace mechanism is far from perfect.
if keycode == solent_keycode('backspace'):
self.rail_line_finder.backspace()
s = self.rail_line_finder.get()
idx = len(s) % CONSOLE_WIDTH
s = s[-1 * idx:]
self.spin_term.write(drop=self.drop,
rest=0,
s='%s ' % s,
cpair=cpair)
self.rest = len(s)
else:
self.rail_line_finder.accept_bytes([keycode])
self._print(keycode=keycode, cpair=cpair)
self.spin_term.refresh_console()
def create_origin_plane():
rogue_plane = rogue_plane_new()
#make_border(rogue_plane)
#
# // terrain: walls
make_box(rogue_plane=rogue_plane,
se_nail=(-11, -11),
width=22,
height=22,
box_type=e_boxtype.stop)
#
# // scrap
rogue_plane.create_meep(s=2, e=-5, c='o', cpair=solent_cpair('green'))
rogue_plane.create_meep(s=3, e=-4, c='o', cpair=solent_cpair('green'))
rogue_plane.create_meep(s=3, e=-5, c='o', cpair=solent_cpair('green'))
rogue_plane.create_meep(s=4, e=-6, c='o', cpair=solent_cpair('green'))
rogue_plane.create_meep(s=4, e=-4, c='o', cpair=solent_cpair('green'))
rogue_plane.create_meep(s=4, e=-5, c='o', cpair=solent_cpair('green'))
return rogue_plane
# Solent is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# Solent. If not, see <http://www.gnu.org/licenses/>.
from solent import solent_cpair
from solent import run_tests
from solent import test
from solent.console import Cgrid
import sys
DEFAULT_CPAIR = solent_cpair('white')
def cgrid_console_print(cgrid):
for h in range(cgrid.height):
nail = (h * cgrid.width)
peri = nail + cgrid.width
spots = cgrid.spots[nail:peri]
line = ''.join([s.c for s in spots])
print('%2s|%s' % (h, line))
def cgrid_populate(cgrid, c):
for drop in range(cgrid.height):
cgrid.put(drop=drop, rest=0, s=c * cgrid.height, cpair=DEFAULT_CPAIR)
# any later version.
#
# Solent is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# Solent. If not, see <http://www.gnu.org/licenses/>.
from solent import solent_cpair
import sys
import types
DEFAULT_CPAIR = solent_cpair('grey')
class Spot(object):
def __init__(self):
self.c = None
self.cpair = None
#
self.zero()
def zero(self):
self.c = ' '
self.cpair = DEFAULT_CPAIR
def compare(self, spot):
if self.c != spot.c:
return False
if self.cpair != spot.cpair:
return False
HELP = '''Hit things with your crowbar. Survive.
Movement:
q w e 7 8 9 y k u
a d 4 6 h l
z x d 1 2 3 b j n
Buttons
a: s 5 space
b: r plus slash
(Tab returns to the main menu.)
'''
PAIR_WALL = ('.', solent_cpair('blue'))
PAIR_PLAYER = ('@', solent_cpair('green'))
PAIR_WEED = ('t', solent_cpair('red'))
class RailRoguebox:
def __init__(self):
pass
def zero(self, rail_h, engine, grid_height, grid_width, cb_ready_alert, cb_grid_alert, cb_mail_alert, cb_over_alert):
self.rail_h = rail_h
self.engine = engine
self.grid_height = grid_height
self.grid_width = grid_width
self.cb_grid_alert = cb_grid_alert
self.cb_mail_alert = cb_mail_alert
self.cb_ready_alert = cb_ready_alert
self.cb_over_alert = cb_over_alert
from collections import deque
import os
import sys
import time
import traceback
ESC_KEY_ORD = 27
C_GAME_WIDTH = 78
C_GAME_HEIGHT = 25
# --------------------------------------------------------
# :game
# --------------------------------------------------------
T_WHITE = solent_cpair('white')
def make_box(rogue_plane,
se_nail,
width,
height,
cpair=T_WHITE,
box_type=e_boxtype.line):
'''
Box type indicates the kind of corners the box should have.
'''
(s_nail, e_nail) = se_nail
hori = width + 2
for i in range(hori):
if (i, box_type) in [(0, e_boxtype.edge), (hori - 1, e_boxtype.void)]:
import os
import sys
import time
import traceback
ESC_KEY_ORD = 27
C_GAME_WIDTH = 78
C_GAME_HEIGHT = 25
TITLE = sys.argv[0].split(os.sep)[-1]
# --------------------------------------------------------
# :game
# --------------------------------------------------------
CPAIR_DEFAULT = solent_cpair('white')
def make_box(rogue_plane,
se_nail,
width,
height,
cpair=CPAIR_DEFAULT,
box_type=e_boxtype.line):
'''
Box type indicates the kind of corners the box should have.
'''
(s_nail, e_nail) = se_nail
hori = width + 2
for i in range(hori):
if (i, box_type) in [(0, e_boxtype.edge), (hori - 1, e_boxtype.void)]:
def on_net_recv(self, bb):
hexdump_bytes(bb)
for keycode in bb:
self._print(keycode=keycode, cpair=solent_cpair('grey'))
self.spin_term.refresh_console()
PROFILE_GREEN = ((0, 255, 0), (0, 0, 0))
PROFILE_TEAL = ((0, 128, 128), (0, 0, 0))
PROFILE_BLUE = ((0, 0, 255), (0, 0, 0))
PROFILE_VIOLET = ((128, 0, 255), (0, 0, 0))
PROFILE_PURPLE = ((255, 0, 255), (0, 0, 0))
PROFILE_MAGENTA = ((255, 127, 255), (0, 0, 0))
PROFILE_BLACK_INFO = ((0, 0, 0), (255, 255, 255))
PROFILE_GREY_INFO = ((0, 0, 0), (127, 127, 127))
PROFILE_GREEN_INFO = ((0, 255, 0), (255, 255, 255))
PROFILE_ALARM = ((255, 64, 0), (0, 255, 255))
MAP_CONST_COLOURS_TO_CPAIR = {
solent_cpair('grey'): PROFILE_GREY,
solent_cpair('white'): PROFILE_WHITE,
solent_cpair('red'): PROFILE_RED,
solent_cpair('vermilion'): PROFILE_VERMILION,
solent_cpair('orange'): PROFILE_ORANGE,
solent_cpair('amber'): PROFILE_AMBER,
solent_cpair('yellow'): PROFILE_YELLOW,
solent_cpair('chartreuse'): PROFILE_CHARTREUSE,
solent_cpair('green'): PROFILE_GREEN,
solent_cpair('teal'): PROFILE_TEAL,
solent_cpair('blue'): PROFILE_BLUE,
solent_cpair('violet'): PROFILE_VIOLET,
solent_cpair('purple'): PROFILE_PURPLE,
solent_cpair('magenta'): PROFILE_MAGENTA,
solent_cpair('black_info'): PROFILE_BLACK_INFO,
solent_cpair('grey_info'): PROFILE_GREY_INFO,
# details.
#
# You should have received a copy of the GNU General Public License along with
# Solent. If not, see <http://www.gnu.org/licenses/>.
from .logbook import logbook_new
from .glyph import glyph_new
from .scope import scope_new
from solent import solent_cpair
from solent import SolentQuitException
from solent.console import Cgrid
from collections import deque
STATUS_NEW_CPAIR = solent_cpair('yellow')
STATUS_OLD_CPAIR = solent_cpair('white')
class StatusEntry(object):
def __init__(self, s):
self.s = s
#
self.turns = 0
class RogueInteraction(object):
def __init__(self, console, cursor, cgrid, logbook):
self.console = console
self.cursor = cursor
self.cgrid = cgrid
#
# Solent is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
# FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
# details.
#
# You should have received a copy of the GNU General Public License along with
# Solent. If not, see <http://www.gnu.org/licenses/>.
from .meep import meep_new
from solent import solent_cpair
import types
TERRAIN_DEFAULT_COL = solent_cpair('purple')
class RoguePlane(object):
def __init__(self):
self._terrain = []
self._scrap = []
self._meeps = []
def get_plane_type(self):
return 'RoguePlane'
#
# terrain: architecture of the plane
def get_terrain(self):
return self._terrain
def create_terrain(self, s, e, c, cpair=TERRAIN_DEFAULT_COL):
t = meep_new(
mind=None,
def create_origin_plane():
rogue_plane = rogue_plane_new()
#
# // terrain: walls
make_box(rogue_plane=rogue_plane,
se_nail=(-5, -8),
width=30,
height=14,
box_type=e_boxtype.stop)
make_box(rogue_plane=rogue_plane, se_nail=(6, 3), width=1, height=1)
make_box(rogue_plane=rogue_plane,
se_nail=(-2, -17),
width=3,
height=3,
cpair=solent_cpair('teal'),
box_type=e_boxtype.edge)
make_box(rogue_plane=rogue_plane,
se_nail=(-2, 10),
width=3,
height=3,
cpair=solent_cpair('teal'),
box_type=e_boxtype.void)
make_box(rogue_plane=rogue_plane,
se_nail=(4, 10),
width=3,
height=3,
cpair=solent_cpair('teal'),
box_type=e_boxtype.stop)
make_box(rogue_plane=rogue_plane,
se_nail=(-4, 28),
width=3,
height=3,
box_type=e_boxtype.hash)
make_box(rogue_plane=rogue_plane,
se_nail=(4, 28),
width=3,
height=3,
box_type=e_boxtype.stop)
#
# // terrain: boulder
rogue_plane.create_terrain(s=-1, e=-3, c='o')
#
# // terrain: standing stones
rogue_plane.create_terrain(s=-2, e=-2, c='i', cpair=solent_cpair('white'))
rogue_plane.create_terrain(s=-3, e=0, c='i', cpair=solent_cpair('white'))
rogue_plane.create_terrain(s=-2, e=2, c='i', cpair=solent_cpair('white'))
rogue_plane.create_terrain(s=0, e=-3, c='i', cpair=solent_cpair('white'))
rogue_plane.create_terrain(s=0, e=3, c='i', cpair=solent_cpair('white'))
rogue_plane.create_terrain(s=2, e=-2, c='i', cpair=solent_cpair('white'))
rogue_plane.create_terrain(s=3, e=0, c='i', cpair=solent_cpair('white'))
rogue_plane.create_terrain(s=2, e=2, c='i', cpair=solent_cpair('white'))
#
# // scrap
rogue_plane.create_meep(s=3, e=-4, c=':', cpair=solent_cpair('yellow'))
return rogue_plane
