game.map_size = size
cmd_MAP_SIZE.argtypes = 'yx_tuple:pos'
-def cmd_MAP(game, map_pos):
- """Ensure (possibly empty/'?'-filled) map at position map_pos."""
- game.get_map(map_pos)
-cmd_MAP.argtypes = 'yx_tuple'
+def cmd_MAP(game, map_pos, awakeness):
+ """Ensure (possibly empty/'?'-filled) map at position map_pos.
+
+ Awakeness > 0 puts the map into the player's reality bubble.
+
+ """
+ m = game.get_map(map_pos)
+ m.awake = awakeness
+cmd_MAP.argtypes = 'yx_tuple int:nonneg'
+
+def cmd_MAP_STATS(game, map_pos, type_, population, health):
+ m = game.get_map(map_pos)
+ m.stats[type_] = {'population': population, 'health': health}
+cmd_MAP_STATS = 'yx_tuple string:thingtype int:nonneg int:nonneg'
def cmd_THING_TYPE(game, i, type_):
t_old = game.get_thing(i)
write(f, 'SEED %s' % game.rand.prngod_seed)
write(f, 'MAP_SIZE %s' % (game.map_size,))
for map_pos in game.maps:
- write(f, 'MAP %s' % (map_pos,))
+ m = game.maps[map_pos]
+ write(f, 'MAP %s %s' % (map_pos, m.awake))
+ for t_type in m.stats:
+ write(f, 'MAP_STATS %s %s %s %s' %
+ (map_pos, t_type, m.stats[t_type]['population'],
+ m.stats[t_type]['health']))
for map_pos in game.maps:
for y, line in game.maps[map_pos].lines():
write(f, 'TERRAIN_LINE %s %5s %s' % (map_pos, y, quote(line)))
from plomrogue.parser import Parser
from plomrogue.io import GameIO
from plomrogue.misc import quote
-from plomrogue.things import Thing, ThingMonster, ThingHuman, ThingFood
+from plomrogue.things import (Thing, ThingMonster, ThingHuman, ThingFood,
+ ThingAnimate)
import random
self.io.send('THING_TYPE %s %s' % (thing.id_, thing.type_))
self.io.send('THING_POS %s %s' % (thing.id_, view_pos))
+ self.io.send('PLAYER_ID ' + str(self.player_id))
self.io.send('TURN ' + str(self.turn))
visible_map = self.player.get_visible_map()
self.io.send('VISIBLE_MAP %s %s' % (visible_map.size,
return 0
return self.things[-1].id_ + 1
- def get_map(self, map_pos, create_unfound=True):
+ def get_map(self, map_pos):
if not (map_pos in self.maps and
self.maps[map_pos].size == self.map_size):
- if create_unfound:
- self.maps[map_pos] = Map(self.map_size)
- for pos in self.maps[map_pos]:
- self.maps[map_pos][pos] = '.'
- else:
- return None
+ self.maps[map_pos] = Map(self.map_size)
+ for pos in self.maps[map_pos]:
+ self.maps[map_pos][pos] = '.'
return self.maps[map_pos]
def proceed_to_next_player_turn(self):
"""Run game world turns until player can decide their next step.
- Iterates through all non-player things, on each step
- furthering them in their tasks (and letting them decide new
- ones if they finish). The iteration order is: first all things
- that come after the player in the world things list, then
- (after incrementing the world turn) all that come before the
- player; then the player's .proceed() is run, and if it does
- not finish his task, the loop starts at the beginning. Once
- the player's task is finished, or the player is dead, the loop
- breaks.
+ All things and processes inside the player's reality bubble
+ are worked through. Things are furthered in their tasks and,
+ if finished, decide new ones. The iteration order is: first
+ all things that come after the player in the world things
+ list, then (after incrementing the world turn) all that come
+ before the player; then the player's .proceed() is run.
+
+ Next, parts of the game world are put to sleep or woken up
+ based on how close they are to the player's position, or how
+ short ago the player visited them.
+
+ If the player's last task is finished at the end of the loop,
+ it breaks; otherwise it starts again.
"""
- while True:
- player_i = self.things.index(self.player)
+
+ def proceed_world():
for thing in self.things[player_i+1:]:
thing.proceed()
self.turn += 1
- for pos in self.maps[YX(0,0)]:
- if self.maps[YX(0,0)][pos] == '.' and \
- len(self.things_at_pos((YX(0,0), pos))) == 0 and \
- self.rand.random() > 0.999:
- self.add_thing_at('food', (YX(0,0), pos))
+ for map_pos in self.maps:
+ if self.maps[map_pos].awake:
+ for pos in self.maps[map_pos]:
+ if self.rand.random() > 0.999 and \
+ self.maps[map_pos][pos] == '.' and \
+ len(self.things_at_pos((map_pos, pos))) == 0:
+ self.add_thing_at('food', (map_pos, pos))
for thing in self.things[:player_i]:
thing.proceed()
self.player.proceed(is_AI=False)
+
+ def reality_bubble():
+ import math
+ for map_pos in self.maps:
+ m = self.maps[map_pos]
+ if map_pos in self.player.close_maps:
+
+ # Newly inside chunks are regenerated from .stats.
+ if not m.awake:
+ for t_type in m.stats:
+ stat = m.stats[t_type]
+ to_create = stat['population'] // 100
+ to_create = stat['population'] // 100 +\
+ int(self.rand.randint(0, 99) < (stat['population'] % 100))
+ if to_create == 0:
+ continue
+ average_health = None
+ if stat['health'] > 0:
+ average_health = math.ceil(stat['health'] /
+ stat['population'])
+ for i in range(to_create):
+ t = self.add_thing_at_random(map_pos, t_type)
+ if average_health:
+ t.health = average_health
+
+ # Inside chunks are set to max .awake and don't collect
+ # stats.
+ m.awake = 100
+ m.stats = {}
+
+ # Outside chunks grow distant through .awake decremention.
+ # They collect .stats until they fall asleep – then any things
+ # inside are disappeared.
+ elif m.awake > 0:
+ m.awake -= 1
+ for t in self.things:
+ if t.position[0] == map_pos:
+ if not t.type_ in m.stats:
+ m.stats[t.type_] = {'population': 0,
+ 'health': 0}
+ m.stats[t.type_]['population'] += 1
+ if isinstance(t, ThingAnimate):
+ m.stats[t.type_]['health'] += t.health
+ if not m.awake:
+ if not m.awake:
+ del self.things[self.things.index(t)]
+
+ while True:
+ player_i = self.things.index(self.player)
+ proceed_world()
+ reality_bubble()
if self.player.task is None or not self.player_is_alive:
break
self.things += [t]
return t
- def make_new_world(self, yx, seed):
-
- def add_thing_at_random(type_):
- while True:
- new_pos = (YX(0,0),
- YX(self.rand.randint(0, yx.y - 1),
- self.rand.randint(0, yx.x - 1)))
- if self.maps[new_pos[0]][new_pos[1]] != '.':
- continue
- if len(self.things_at_pos(new_pos)) > 0:
- continue
- return self.add_thing_at(type_, new_pos)
-
+ def add_thing_at_random(self, big_yx, type_):
+ while True:
+ new_pos = (big_yx,
+ YX(self.rand.randint(0, self.map_size.y - 1),
+ self.rand.randint(0, self.map_size.x - 1)))
+ if self.maps[new_pos[0]][new_pos[1]] != '.':
+ continue
+ if len(self.things_at_pos(new_pos)) > 0:
+ continue
+ return self.add_thing_at(type_, new_pos)
+
+ def make_map_chunk(self, big_yx):
+ map_ = self.get_map(big_yx)
+ for pos in map_:
+ map_[pos] = self.rand.choice(('.', '.', '.', '~', 'x'))
+ self.add_thing_at_random(big_yx, 'monster')
+ self.add_thing_at_random(big_yx, 'monster')
+ self.add_thing_at_random(big_yx, 'monster')
+ self.add_thing_at_random(big_yx, 'monster')
+ self.add_thing_at_random(big_yx, 'monster')
+ self.add_thing_at_random(big_yx, 'monster')
+ self.add_thing_at_random(big_yx, 'monster')
+ self.add_thing_at_random(big_yx, 'monster')
+ self.add_thing_at_random(big_yx, 'food')
+ self.add_thing_at_random(big_yx, 'food')
+ self.add_thing_at_random(big_yx, 'food')
+ self.add_thing_at_random(big_yx, 'food')
+
+ def make_new_world(self, size, seed):
self.things = []
self.rand.seed(seed)
self.turn = 0
self.maps = {}
- self.map_size = yx
- map_ = self.get_map(YX(0,0))
- for pos in map_:
- map_[pos] = self.rand.choice(('.', '.', '.', '~', 'x'))
- player = add_thing_at_random('human')
+ self.map_size = size
+ self.make_map_chunk(YX(0,0))
+ player = self.add_thing_at_random(YX(0,0), 'human')
+ player.surroundings # To help initializing reality bubble, see
+ # comment on ThingAnimate._position_set
self.player_id = player.id_
- add_thing_at_random('monster')
- add_thing_at_random('monster')
- add_thing_at_random('food')
- add_thing_at_random('food')
- add_thing_at_random('food')
- add_thing_at_random('food')
return 'success'
-
projects / plomrogue2-experiments / commitdiff