def _apply_message(self, obj, status):
if self._should_write_message(obj):
rog.msg("{t}{n} {v1} {v2}!".format(
t=obj.title,n=obj.name,
v1=self._get_verb1(status),
v2=self._get_verb2(status))
)
def pocketThing(obj, item):
## if not item: return False
rog.drain(obj, 'nrg', NRG_POCKET)
rog.give(obj, item)
rog.release_inanimate(item)
rog.msg("{t}{n} pockets {i}.".format(
t=obj.title,n=obj.name,i=item.name))
def run(self):
super(Manager_SoundsHeard, self).run()
pc = rog.pc()
atLeastOneMsg = False
text = "You hear "
skills = rog.world().component_for_entity(pc, cmp.Skills)
for k, v in self.sounds.items():
vol, lis = v
if not vol: continue
if vol > VOLUME_DEAFEN:
rog.set_status(pc, DEAF)
#super hearing
## if SKL_SUPERHEARING in skills.skills:
## volTxt=self.get_volume_name(vol)
## dirStr=DIRECTIONS_TERSE[k]
## if not dirStr == "self":
## text += "<{d}>".format(d=dirStr)
## text += "({v}) ".format(v=volTxt)
#combine strings with commas
for strng in lis:
text += "{s}, ".format(s=strng)
#terminate with a period
text = text[:-2] + "."
atLeastOneMsg = True
if atLeastOneMsg:
rog.msg(text)
self.init_sounds()
def run(self):
super(Manager_SoundsHeard,self).run()
atLeastOneMsg=False
text="You hear "
for k,v in self.sounds.items():
vol,lis=v
if not vol: continue
if vol > VOLUME_DEAFEN:
rog.set_status(rog.pc(), DEAF)
#super hearing
if rog.pc().stats.get("hearing") >= SUPER_HEARING:
volTxt=self.get_volume_name(vol)
dirStr=DIRECTIONS_TERSE[k]
if not dirStr == "self":
text += "<{d}>".format(d=dirStr)
text += "({v}) ".format(v=volTxt)
#combine strings with commas
for strng in lis:
text += "{s}, ".format(s=strng)
#terminate with a period
text=text[:-2] + "."
atLeastOneMsg=True
if atLeastOneMsg:
rog.msg(text)
self.init_sounds()
def drop(obj, item):
if not rog.wallat(pc.x+dx,pc.y+dy):
rog.drain(obj, 'nrg', NRG_RUMMAGE)
rog.drop(obj,item, dx,dy)
rog.msg("{t}{n} dropped {i}.".format(t=obj.title,n=obj.name,i=item.name))
return True
else:
return False
def funcUsePC(self, ent):
pos=world.component_for_entity(ent, cmp.Position)
reading = rog.radsat(pos.x,pos.y)
rog.msg("The geiger counter reads '{} RADS'".format(reading))
#could do, instead:
# use turns it on, activates an observer.
# updates when rad damage received by player. Adds rad value to dosimeter
# when you use again, you can either read it or turn it off.
rog.spendAP(ent, NRG_USE)
def pocketThing(ent, item):
## if not item: return False
world = rog.world()
rog.drain(ent, 'nrg', NRG_POCKET)
rog.give(ent, item)
rog.release_inanimate(item)
entn = world.component_for_entity(ent, cmp.Name)
itemn = world.component_for_entity(item, cmp.Name)
rog.msg("{t}{n} packs {ti}{ni}.".format(
t=entn.title,n=entn.name,ti=itemn.title,ni=itemn.name))
def funcPlayer(self, obj):
xx = obj.x
yy = obj.y
reading = rog.radsat(xx, yy)
rog.msg("The geiger counter reads '{} RADS'".format(reading))
#could do, instead:
# use turns it on, activates an observer.
# updates when rad damage received by player. Adds rad value to dosimeter
# when you use again, you can either read it or turn it off.
rog.drain(obj, 'nrg', NRG_USE)
def drop(ent, item):
world = rog.world()
pos = world.component_for_entity(ent, cmp.Position)
dx=0; dy=0; # TODO: code AI to find a place to drop item
if not rog.wallat(pos.x+dx,pos.y+dy):
rog.drain(ent, 'nrg', NRG_RUMMAGE)
rog.drop(ent,item, dx,dy)
entn = world.component_for_entity(ent, cmp.Name)
itemn = world.component_for_entity(item, cmp.Name)
rog.msg("{t}{n} drops {ti}{ni}.".format(
t=entn.title,n=entn.name,ti=itemn.title,ni=itemn.name))
return True
else:
return False
def openClose(obj, xto, yto):
#open containers
#close containers
#open doors
if rog.tile_get(xto,yto) == DOORCLOSED:
rog.drain(obj, 'nrg', NRG_OPEN)
rog.tile_change(xto,yto, DOOROPEN)
rog.msg("{n} opened a door.".format(n=obj.name))
return True
#close doors
if rog.tile_get(xto,yto) == DOOROPEN:
rog.drain(obj, 'nrg', NRG_OPEN)
rog.tile_change(xto,yto, DOORCLOSED)
rog.msg("{n} closed a door.".format(n=obj.name))
return True
return False
def say(ent:int, string:str, ttype=-1, success=False, ):
''' converse with an entity and msg out that entity's response '''
# TODO: elapse time while talking as interruptable delayed action
# temporary: just do a one-time AP cost for each thing said
rog.spendAP(rog.pc(), NRG_TALK)
rog.spendAP(ent, NRG_TALK)
if ttype==-1:
message = "{}: {}".format(rog.getname(ent), string)
else:
talk_string = PERSUASION[ttype][1]
success_string = "success" if success else "failure"
disposition = get_effective_disposition(
ent, rog.get_disposition(ent))
message = "<{} {}> {}: {} Disposition: {} / {}".format(
talk_string, success_string, rog.getname(ent), string,
disposition//10, MAX_DISPOSITION//10
)
rog.alert(message) # just in case it doesn't get displayed right away.
rog.msg(message)
def openClose(ent, xto, yto):
world = rog.world()
actor = world.component_for_entity(ent, cmp.Actor)
entn = world.component_for_entity(ent, cmp.Name)
#open containers
#close containers
#open doors
if rog.tile_get(xto,yto) == DOORCLOSED:
actor.ap -= NRG_OPEN
rog.tile_change(xto,yto, DOOROPEN)
rog.msg("{t}{n} opened a door.".format(t=entn.title,n=entn.name))
return True
#close doors
if rog.tile_get(xto,yto) == DOOROPEN:
actor.ap -= NRG_OPEN
rog.tile_change(xto,yto, DOORCLOSED)
rog.msg("{t}{n} closed a door.".format(t=entn.title,n=entn.name))
return True
return False
def run(self):
super(Manager_SightsSeen, self).run()
pc = rog.pc()
atLeastOneMsg = False
text = ""
for k, v in self.sights.items():
if not v: continue
atLeastOneMsg = True
lis = v
dirStr = DIRECTIONS_TERSE[k]
if not dirStr == "self":
text += "<{d}> ".format(d=dirStr)
for strng in lis:
text += "{}{} ".format(strng[0].upper(), strng[1:])
if atLeastOneMsg:
rog.msg(text)
self.init_sights()
def explosion(bomb):
con=libtcod.console_new(ROOMW, ROOMH)
rog.msg("{t}{n} explodes!".format(t=bomb.title, n=bomb.name))
fov=rog.fov_init()
libtcod.map_compute_fov(
fov, bomb.x,bomb.y, bomb.r,
light_walls = True, algo=libtcod.FOV_RESTRICTIVE)
for x in range(bomb.r*2 + 1):
for y in range(bomb.r*2 + 1):
xx=x + bomb.x - bomb.r
yy=y + bomb.y - bomb.r
if not libtcod.map_is_in_fov(fov, xx,yy):
continue
if not rog.is_in_grid(xx,yy): continue
dist=maths.dist(bomb.x,bomb.y, xx,yy)
if dist > bomb.r: continue
thing=rog.thingat(xx, yy)
if thing:
if rog.on(thing,DEAD): continue
if thing.isCreature:
decay=bomb.dmg/bomb.r
dmg= bomb.dmg - round(dist*decay) - thing.stats.get('arm')
rog.hurt(thing, dmg)
if dmg==0: hitName="not damaged"
elif rog.on(thing,DEAD): hitName="killed"
else: hitName="hit"
rog.msg("{t}{n} is {h} by the blast.".format(
t=thing.title,n=thing.name,h=hitName) )
else:
# explode any bombs caught in the blast
if (thing is not bomb
and hasattr(thing,'explode')
and dist <= bomb.r/2 ):
thing.timer=0
def quaff(ent, drink):
world = rog.world()
pos = world.component_for_entity(ent, cmp.Position)
quaffable=world.component_for_entity(drink, cmp.Quaffable)
entn = world.component_for_entity(ent, cmp.Name)
drinkn = world.component_for_entity(drink, cmp.Name)
#quaff function
quaffable.func(ent)
# TODO: do delayed action instead of immediate action.
rog.drain(ent, 'nrg', quaffable.timeToConsume)
rog.givemp(ent, quaffable.hydration)
#events - sight
if ent == rog.pc():
rog.msg("It tastes {t}".format(t=quaffable.taste))
else:
rog.event_sight(pos.x,pos.y, "{t}{n} quaffs a {p}.".format(
t=entn.title, n=entn.name, p=drinkn.name))
#events - sound
rog.event_sound(pos.x,pos.y, SND_QUAFF)
# TODO: make sure this works...
world.delete_entity(drink)
def main():
#------------------------------------------------#
# INIT
#------------------------------------------------#
rog.Rogue.create_settings() # later controllers may depend on settings
rog.Rogue.create_window()
rog.Rogue.create_consoles()
rog.Rogue.create_world()
rog.Rogue.create_controller()
rog.Rogue.create_data()
rog.Rogue.create_map(ROOMW, ROOMH)
## rog.Rogue.create_fov_maps()
rog.Rogue.create_clock()
rog.Rogue.create_updater()
rog.Rogue.create_view()
rog.Rogue.create_log()
rog.Rogue.create_savedGame() # TODO: learn/use Pickle.
rog.Rogue.create_processors()
rog.Rogue.create_perturn_managers()
rog.Rogue.create_const_managers()
rog.Rogue.create_const_entities()
rog.init_keyBindings()
#map generation
rog.getmap(rog.dlvl()).init_specialGrids(
) # inits fov_map; do this before you init terrain
rog.getmap(rog.dlvl()).init_terrain(WALL) # clear the map to all walls
rog.getmap(rog.dlvl()).generate_dlvl(rog.dlvl())
# init player
# TESTING THIS IS ALL TEMPORARY!!!
# temporary: find a position to place the player
xpos = 15
ypos = 15
_borders = 10
while rog.getmap(rog.dlvl()).tileat(xpos, ypos) == WALL:
xpos += 1
if xpos >= ROOMW - _borders:
xpos = _borders
ypos += 1
if ypos >= ROOMH:
print("~~ ! FATAL ERROR ! Failed to place player in the map!")
break
rog.Rogue.create_player(xpos, ypos) # create player
pc = rog.pc()
# TESTING
# HELP THE PLAYER TO SEE
rog.create_envlight(16)
## rog.make(rog.pc(), NVISION)
#
w = rog.create_monster('W', xpos, ypos - 1)
## rog.world().add_component(w, cmp.AttractedToMen())
## rog.world().add_component(w, cmp.AttractedToWomen())
##
## #testing speech
## rog.init_person(w)
#
## w2=rog.create_monster('W',xpos,ypos+1)
## w3=rog.create_monster('W',xpos,ypos+2)
## rog.setskill(pc, SKL_BOXING, 100)
## rog.setskill(pc, SKL_PERSUASION, 0)
## rog.setskill(pc, SKL_ARMOR, 100)
## rog.sets(pc, 'dex', 12*MULT_STATS)
## rog.sets(pc, 'int', 4*MULT_STATS)
## rog.setskill(pc, SKL_UNARMORED, 40)
## for x in range(20):
## rog.create_monster("L", 1+x*5,1)
## rog.alts(pc, 'sight', 50)
weap = rog.create_weapon("sword", xpos, ypos, mat=MAT_METAL)
weap = rog.create_weapon("buckler", xpos, ypos, mat=MAT_METAL)
##
## rog.wound(pc, WOUND_BURN, 2)
## rog.damage(weap, 200)
## rog.fitgear(weap, pc)
## print(rog.equip(
## pc,weap,EQ_MAINHANDW
## ))
## rog.create_weapon("wooden club", xpos,ypos)
## rog.create_weapon("estoc", xpos-1,ypos)
## shield=rog.create_weapon("metal shield", 0,0)
## rog.equip(
## pc,shield,EQ_OFFHAND
## )
## rog.fitgear(shield, pc)
## armor=rog.create_armor("metal gear", 0,0)
## rog.equip(
## pc,armor,EQ_FRONT
## )
## rog.fitgear(armor, pc)
## helm=rog.create_headwear("metal helm", 0,0)
## rog.equip(
## pc,helm,EQ_MAINHEAD
## )
## rog.fitgear(helm, pc)
## leg1=rog.create_legwear("metal mail legging", 0,0)
## rog.equip(
## pc,leg1,EQ_MAINLEG
## )
## rog.fitgear(leg1, pc)
## leg2=rog.create_legwear("metal mail legging", 0,0)
## rog.equip(
## pc,leg2,EQ_OFFLEG
## )
## rog.fitgear(leg2, pc)
## arm1=rog.create_armwear("metal vambrace", 0,0)
## rog.equip(
## pc,arm1,EQ_MAINARM
## )
## rog.fitgear(arm1, pc)
## arm2=rog.create_armwear("metal vambrace", 0,0)
## rog.equip(
## pc,arm2,EQ_OFFARM
## )
## rog.fitgear(arm2, pc)
## foot1=rog.create_footwear("metal boot", 0,0)
## rog.equip(
## pc,foot1,EQ_MAINFOOT
## )
## rog.fitgear(foot1, pc)
## foot2=rog.create_footwear("metal boot", 0,0)
## rog.equip(
## pc,foot2,EQ_OFFFOOT
## )
## rog.fitgear(foot2, pc)
#
# create light so player can see
## log=rog.create_rawmat("log", 18,18)
## rog.burn(log,500)
#
# /TESTING /TEMPORARY
#
# TODO?: observer for player
## obs=observer.Observer_playerChange()
## pc.observer_add(obs)
#-----------------------------------------------#
# # MAIN GAME LOOP # #
#-----------------------------------------------#
rog.game_set_state("normal")
while rog.game_is_running():
# manually close game #
if libtcod.console_is_window_closed():
rog.end()
# defeat conditions #
if rog.on(rog.pc(), DEAD):
rog.game_set_state("game over")
# get input #
pcInput = IO.get_raw_input()
pcAct = IO.handle_mousekeys(pcInput).items()
# commands that are available from anywhere #
player.commands_const(rog.pc(), pcAct)
# Finally record game state after any/all changes #
gameState = rog.game_state()
#----------#
# PLAY #
#----------#
#
# normal game play
#
if gameState == "normal":
game.play(pc, pcAct)
#
# manager game states #
#
elif gameState == "manager":
manager = rog.get_active_manager()
manager.run(pcAct)
if manager.result:
rog.close_active_manager()
#
elif gameState == "game over":
rog.msg("You died...")
def _remove_message(self, obj, status):
if self._should_write_message(obj):
rog.msg("{t}{n} is no longer {v2}.".format(
t=obj.title,n=obj.name,
v2=self._get_verb2(status))
)
def add(self, ent, component, t=-1, q=None, firstVar=None):
'''
add a status if entity doesn't already have that status
**MUST NOT set the DIRTY_STATS flag.
'''
if rog.world().has_component(ent, component): return False
status_str = ""
# message, attribute modifiers, aux. effects (based on status type)
if component is cmp.StatusHot:
status_str = " becomes hyperthermic"
elif component is cmp.StatusBurn:
status_str = " begins smoldering"
elif component is cmp.StatusChilly:
status_str = " becomes cold"
elif component is cmp.StatusCold:
status_str = " becomes hypothermic"
elif component is cmp.StatusFrozen:
status_str = " becomes frozen"
rog.damage(ent, rog.getms(ent, 'hpmax') * FREEZE_DMG_PC)
rog.makenot(ent, DIRTY_STATS)
elif component is cmp.StatusAcid:
status_str = " begins corroding"
elif component is cmp.StatusBlinded:
status_str = " becomes blinded"
elif component is cmp.StatusDeafened:
status_str = " becomes deafened"
elif component is cmp.StatusIrritated:
status_str = " becomes irritated"
elif component is cmp.StatusBleed:
status_str = " begins bleeding"
elif component is cmp.StatusParalyzed:
status_str = "'s muscles stiffen"
elif component is cmp.StatusSick:
status_str = " comes down with the sickness"
elif component is cmp.StatusVomit:
status_str = " becomes nauseous"
elif component is cmp.StatusCough:
status_str = " enters into a coughing fit"
elif component is cmp.StatusSprint:
status_str = " starts sprinting"
elif component is cmp.StatusTired:
status_str = " starts to yawn"
elif component is cmp.StatusFrightening:
status_str = " puts on a frightening display"
elif component is cmp.StatusFrightened:
status_str = " becomes frightened"
elif component is cmp.StatusHaste:
status_str = "'s movements speed up"
elif component is cmp.StatusSlow:
status_str = "'s movements slow"
elif component is cmp.StatusDrunk:
status_str = " becomes inebriated"
elif component is cmp.StatusHazy:
pronoun = rog.get_pronoun_possessive(ent)
status_str = " begins slurring {} speech".format(pronoun)
elif component is cmp.StatusRage:
status_str = " enters into a fit of rage"
elif component is cmp.StatusAngry:
status_str = " becomes angry"
elif component is cmp.StatusAnnoyed:
status_str = " becomes annoyed"
elif component is cmp.StatusCreepedOut:
status_str = " becomes creeped out"
elif component is cmp.StatusCharmed:
status_str = " becomes charmed"
elif component is cmp.StatusDiabetes:
status_str = " gets Diabetes"
# TODO: events to display the messages
name = rog.world().component_for_entity(ent, cmp.Name)
if status_str:
string = "{}{}{}".format(TITLES[name.title], name.name, status_str)
rog.msg(string) # TEMPORARY
# figure out what parameters the status needs
if t == -1: # use the default time value for the component
if firstVar: # " target var
if q: # status components with quality variable
rog.world().add_component(ent, component(firstVar, q=q))
else:
rog.world().add_component(ent, component(firstVar))
elif q: # status components with quality variable
rog.world().add_component(ent, component(q=q))
else: # default
rog.world().add_component(ent, component())
else: # pass in the time value
if firstVar: # " target var
if q: # status components with quality variable
rog.world().add_component(ent, component(firstVar,
t=t,
q=q))
else:
rog.world().add_component(ent, component(firstVar, t=t))
elif q: # status components with quality variable
rog.world().add_component(ent, component(t=t, q=q))
else: # default
rog.world().add_component(ent, component(t=t))
return True
def sprint(obj):
#if sprint cooldown elapsed
rog.set_status(obj, SPRINT)
rog.msg("{n} begins sprinting.".format(n=obj.name))
def main():
#------------------------------------------------#
# INIT
#------------------------------------------------#
# init settings
settings = rog.init_settings()
rog.init_keyBindings()
# init global controllers
rog.create_window(settings.window_width, settings.window_height)
rog.create_consoles()
rog.create_map()
rog.create_data()
rog.create_view()
rog.create_clock()
rog.create_log()
rog.create_update()
rog.create_environment()
rog.create_controller()
rog.create_savedGame()
# init managers
rog.create_const_managers()
rog.create_perturn_managers()
#map generation
rog.map_generate(rog.map(), rog.dlvl())
# init player object
pc = rog.create_player(15, 15)
obs = observer.Observer_playerChange()
pc.observer_add(obs)
rog.view_center(pc)
##TESTING
rog.gain(pc, "hpmax", 100)
log = rog.create_stuff(THG.LOG, 18, 18)
rog.burn(log, 200)
box = rog.create_stuff(THG.BOX, 20, 18)
#fluids.smoke(16,16)
'''pc.stats.hpmax = 20
pc.stats.mpmax = 20
pc.stats.sight = 20
pc.stats.spd = 100
pc.stats.nvision = False'''
#LIGHT
pc.light = rog.create_light(pc.x, pc.y, 5, owner=pc)
#HEAL
rog.givehp(pc)
rog.givemp(pc)
#EQUIP
#print(pc.stats.get('atk'))
#item=gear.create_weapon("sword",pc.x,pc.y)
#rog.equip(pc, item, EQ_MAINHAND)
#print(pc.stats.get('atk'))
#rog.deequip(pc,EQ_MAINHAND)
#print(pc.stats.get('atk'))
#BUFF
#rog.effect_add(pc,{'atk':5})
#rog.effect_add(pc,{'dmg':5})
#rog.effect_add(pc,{'arm':0})
#rog.effect_add(pc,{'msp':15})
#rog.effect_add(pc,{'msp':-50})'''
'''
z = rog.create_monster('Z',15,16)
rog.effect_add(z,{'arm':1})
rog.effect_add(z,{'dfn':4})
rog.effect_add(z,{'atk':3})
rog.effect_add(z,{'dmg':3})
rog.givehp(z)'''
z = rog.create_monster('z', 13, 19, COL['ltblue'])
a = rog.create_monster('a', 12, 13, COL['scarlet'])
o = rog.create_monster('U', 19, 18, COL['red'])
a = rog.create_monster('a', 15, 17, COL['scarlet'])
W = rog.create_monster('W', 20, 15, COL['purple'])
'''import dice
for x in range(ROOMW):
for y in range(ROOMH):
if dice.roll(100) > 98:
if not (rog.wallat(x,y)
or rog.monat(x,y) ):
r=rog.create_monster('r',x,y)
r.color=COL['ltgray']
print("num monsters: ", len(rog.list_creatures()))
'''
#create a create_thing function for specific items.
#make list of items, etc.
yyy = Thing()
yyy.x = 16
yyy.y = 13
yyy.mask = '4'
yyy.name = 'the four of destiny'
yyy.color = COL['gold']
rog.register_inanimate(yyy)
##
yyy = Thing()
yyy.x = 17
yyy.y = 13
yyy.mask = '*'
yyy.name = 'blood clot'
yyy.color = COL['dkmagenta']
rog.register_inanimate(yyy)
##
'''
yyy=Thing()
yyy.name="wood"
yyy.mask=chr(15)
yyy.material=MAT_WOOD
yyy.x=20
yyy.y=12
yyy.mass=20
yyy.stats.hp=1250
yyy.color=COL['brown']
rog.register_inanimate(yyy)
rog.set_status(yyy, FIRE)
yyy=Thing()
yyy.name="wood"
yyy.mask=chr(15)
yyy.material=MAT_WOOD
yyy.x=10
yyy.y=19
yyy.mass=12
yyy.stats.hp=400
yyy.color=COL['brown']
rog.register_inanimate(yyy)
rog.set_status(yyy, FIRE)'''
'''
yyy=rog.create_light(25,25, 15)
yyy=rog.create_light(14,11, 7)'''
#-----------------------------------------------#
# # MAIN GAME LOOP # #
#-----------------------------------------------#
rog.game_set_state("normal")
# initialize fov for creatures with sight
for creat in rog.list_creatures():
if creat.stats.sight > 0:
rog.fov_compute(creat)
while rog.game_is_running():
# manually close game #
if libtcod.console_is_window_closed():
rog.end()
# defeat conditions #
if rog.on(pc, DEAD):
rog.game_set_state("game over")
# get input #
pcInput = IO.get_raw_input()
pcAct = IO.handle_mousekeys(pcInput).items()
# commands that are available from anywhere #
player.commands_const(pc, pcAct)
# Finally record game state after any/all changes #
gameState = rog.game_state()
#----------#
# PLAY #
#----------#
#
# normal game play
#
if gameState == "normal":
game.play(pc, pcAct)
#
# other game states #
#
elif (gameState == "move view" or gameState == "look"
or gameState == "busy" or gameState == "message history"):
manager = rog.get_active_manager()
manager.run(pcAct)
if manager.result:
rog.close_active_manager()
#
elif gameState == "game over":
rog.msg("You died...")
def sprint(ent):
entn = rog.world().component_for_entity(ent, cmp.Name)
#if sprint cooldown elapsed
rog.set_status(ent, SPRINT)
rog.msg("{n} begins sprinting.".format(n=entn.name))
def main():
#------------------------------------------------#
# INIT
#------------------------------------------------#
# new way to init
rog.Rogue.create_settings() # later controllers might depend on settings
rog.Rogue.create_window()
rog.Rogue.create_consoles()
rog.Rogue.create_world()
rog.Rogue.create_controller()
rog.Rogue.create_data()
rog.Rogue.create_map()
rog.Rogue.create_clock()
rog.Rogue.create_updater()
rog.Rogue.create_view()
rog.Rogue.create_log()
rog.Rogue.create_savedGame()
rog.Rogue.create_processors()
rog.Rogue.create_perturn_managers()
rog.Rogue.create_const_managers()
rog.Rogue.create_player(0,0) # what position should be given?
rog.init_keyBindings()
## #map generation
## rog.map_generate(rog.map(),rog.dlvl())
##
## # init player object
## pc=rog.create_player(15,15)
## # TODO: observer for player
#### obs=observer.Observer_playerChange()
#### pc.observer_add(obs)
## rog.view_center(pc)
##
##
## ##TESTING
## rog.gain(pc,"hpmax",100)
## log=rog.create_stuff(THG.LOG, 18,18)
## rog.burn(log,200)
## box=rog.create_stuff(THG.BOX,20,18)
## #fluids.smoke(16,16)
## '''pc.stats.hpmax = 20
## pc.stats.mpmax = 20
## pc.stats.sight = 20
## pc.stats.spd = 100
## pc.stats.nvision = False'''
## #LIGHT
## pc.light=rog.create_light(pc.x,pc.y, 5, owner=pc)
## #HEAL
## rog.givehp(pc)
## rog.givemp(pc)
## #EQUIP
## #print(pc.stats.get('atk'))
## item=gear.create_weapon("sword",pc.x,pc.y)
## rog.equip(pc, item, EQ_MAINHAND)
## #print(pc.stats.get('atk'))
## #rog.deequip(pc,EQ_MAINHAND)
## #print(pc.stats.get('atk'))
## #BUFF
## #rog.effect_add(pc,{'atk':5})
## #rog.effect_add(pc,{'dmg':5})
## #rog.effect_add(pc,{'arm':0})
## #rog.effect_add(pc,{'msp':15})
## #rog.effect_add(pc,{'msp':-50})'''
## '''
## z = rog.create_monster('Z',15,16)
## rog.effect_add(z,{'arm':1})
## rog.effect_add(z,{'dfn':4})
## rog.effect_add(z,{'atk':3})
## rog.effect_add(z,{'dmg':3})
## rog.givehp(z)'''
## z=rog.create_monster('z',13,19,COL['ltblue'])
## a=rog.create_monster('a',12,13,COL['scarlet'])
## o=rog.create_monster('U',19,18,COL['red'])
## a=rog.create_monster('a',15,17,COL['scarlet'])
## W=rog.create_monster('W',20,15,COL['purple'])
## '''import dice
## for x in range(ROOMW):
## for y in range(ROOMH):
## if dice.roll(100) > 98:
## if not (rog.wallat(x,y)
## or rog.monat(x,y) ):
## r=rog.create_monster('r',x,y)
## r.color=COL['ltgray']
## print("num monsters: ", len(rog.list_creatures()))
## '''
#-----------------------------------------------#
# # MAIN GAME LOOP # #
#-----------------------------------------------#
rog.game_set_state("normal")
## # initialize fov for creatures with sight
## # IS THIS NOT WORKING???? WHAT'S GOING ON?
## for creat in rog.list_creatures():
## if creat.stats.sight > 0:
## rog.fov_compute(creat)
while rog.game_is_running():
# manually close game #
if libtcod.console_is_window_closed():
rog.end()
# defeat conditions #
if rog.on(pc, DEAD):
rog.game_set_state("game over")
# get input #
pcInput=IO.get_raw_input()
pcAct=IO.handle_mousekeys(pcInput).items()
# commands that are available from anywhere #
player.commands_const(pc, pcAct)
# Finally record game state after any/all changes #
gameState=rog.game_state()
#----------#
# PLAY #
#----------#
#
# normal game play
#
if gameState == "normal":
game.play(pc, pcAct)
#
# other game states #
#
elif (gameState == "move view"
or gameState == "look"
or gameState == "busy"
or gameState == "message history"
):
manager=rog.get_active_manager()
manager.run(pcAct)
if manager.result:
rog.close_active_manager()
#
elif gameState == "game over":
rog.msg("You died...")
def commands(pc, pcAct):
world = rog.world()
directional_command = 'move'
for act,arg in pcAct:
## print(act)
## print(arg)
rog.update_base()
#----------------#
# convert action #
#----------------#
if act =='context-dir':
act=directional_command
## if act =='context':
## pass
# moving using the menu move keys
if (act =='menu-nav' and rog.game_state()=="normal"):
act=directional_command
#----------------#
# perform action #
#----------------#
#-----------MOUSE ACTION----------------------------#
if act == 'lclick':
mousex,mousey,z=arg
if rog.wallat(mousex,mousey):
return
pos = world.component_for_entity(pc, cmp.Position)
print("Left click unimplemented")
## rog.path_compute(pc.path, pos.x,pos.y, rog.mapx(mousex), rog.mapy(mousey))
#rog.occupation_set(pc,'path')
if act == 'rclick':
pass
#------------OTHER ACTION--------------------------#
if act == 'help':
rog.help()
# "move-prompt" : True
# prompt for a direction
# and then perform the move action in that direction
if act == 'move-prompt':
pass
# "attack-prompt" : True
# prompt for a direction
# and then perform the attack action in that direction
if act == 'attack-prompt':
pass
# "move" : (x_change, y_change, z_change,)
if act == 'move':
_Update()
dx,dy,dz=arg
pos = world.component_for_entity(pc, cmp.Position)
actor = world.component_for_entity(pc, cmp.Actor)
xto=pos.x + dx
yto=pos.y + dy
# wait
if (xto==pos.x and yto==pos.y):
actor.ap = 0
return
# out of bounds
if ( not rog.is_in_grid_x(xto) or not rog.is_in_grid_y(yto) ):
return
# warning for slow move speed
if rog.allow_warning_msp():
msp=rog.getms(pc, 'msp')
if msp <= 10:
inp=rog.prompt(
0,0,rog.window_w(), 6, mode='wait',
q='''Warning: your movement speed is critically slow
(MSP: {}). Are you sure you want to move? y/n'''.format(msp)
)
if inp!='y':
return
else:
rog.expire_warning_msp() #TODO: when is best time to reset this warning?
# end if
# choose context-sensitive action #
# fight if there is a monster present
mon = rog.monat(xto,yto)
if mon: # and mon != pc):
action.fight(pc,mon)
# or move
elif not rog.solidat(xto,yto):
# space is free, so we can move
if action.move(pc, dx,dy):
rog.view_center_player()
else:
rog.alert("That space is occupied.")
# end conditional
# "attack" : (x, y, z,)
if act == 'attack':
_Update()
xto,yto,zto=arg
pos = world.component_for_entity(pc, cmp.Position)
actor = world.component_for_entity(pc, cmp.Actor)
# out of bounds
if ( not rog.is_in_grid_x(xto) or not rog.is_in_grid_y(yto) ):
return
# fight if there is a monster present
mon = rog.monat(xto,yto)
# ... but don't attack yourself!
if mon == pc:
rog.alert("You can't fight yourself!")
return
if mon:
action.fight(pc,mon)
else:
ent = rog.thingat(xto,yto)
if ent:
action.fight(pc,ent)
else:
rog.msg("You strike out at thin air, losing your balance.")
actor.ap = 0
rog.set_status(
pc, cmp.StatusOffBalance,
t=2, q=-MISS_BAL_PENALTY
)
# end conditional
# chat with closest speaking entity;
# if multiple good options, prompt for which one.
if act == "chat-context":
action.chat_context(pc)
_Update()
return
if act == "change-pos": # change body position
action.change_bodypos_pc(pc)
_Update()
return
if act == "change-msp": # change speed of movement (walking, running, jogging, etc.)
action.change_speed_pc(pc)
_Update()
return
if act == "msp-up": # change from walk to powerwalk, to trot, jog, etc.
action.speed_up_pc(pc)
_Update()
return
if act == "msp-down": # change from sprint to run, to jog, to trot, etc.
action.slow_down_pc(pc)
_Update()
return
if act == "target-prompt": #target entity + fire / throw / attack
action.target_pc_generic(pc)
_Update()
return
if act == "get-prompt":
action.pickup_pc(pc)
_Update()
return
if act == "openclose-prompt": #open or close
action.open_pc(pc)
_Update()
return
if act == "open-prompt": #open or close
action.open_pc(pc)
_Update()
return
if act == "close-prompt": #open or close
action.open_pc(pc)
_Update()
return
if act == "jog": #begin jogging
action.jog_pc(pc)
_Update()
return
if act == "run": #begin running
action.run_pc(pc)
_Update()
return
if act == "sprint": #begin sprinting
action.sprint_pc(pc)
_Update()
return
#unused actions
'''if act == "bomb":
action.bomb_pc(pc)
return'''
#
#
# special actions #
#
if act == 'find player': #useful to immediately show where the player is
pos = world.component_for_entity(pc, cmp.Position)
rog.view_center_player()
rog.update_game()
rog.update_final()
rog.game_update() #call all the updates
rog.alert('press any key to continue...')
rog.Input(rog.getx(pos.x), rog.gety(pos.y), mode='wait')
rog.update_base()
rog.alert('')
return
if act == "look":
pos = world.component_for_entity(pc, cmp.Position)
rog.routine_look(pos.x,pos.y)
return
if act == "move view":
rog.routine_move_view()
return
if act == "fixed view":
rog.fixedViewMode_toggle()
return
if act == 'select':
# TESTING
print(rog.Input(0,0,20))
return
if act == 'exit':
return
