34 | 34 |
# - a belief that an object is somewhere
|
35 | 35 |
# - because they saw it there (memory)
|
36 | 36 |
# - because some other character told them it was there
|
37 | |
# - a belief that they should do something (a goal)
|
|
37 |
# - a belief that they should do something (a goal), which has subtypes:
|
|
38 |
# - a belief that an object is desirable & they should try to acquire it
|
|
39 |
# - a belief that something should be done about something (bland, general)
|
38 | 40 |
# - a belief that another Animate believes something
|
39 | 41 |
#
|
40 | 42 |
# of course, any particular belief may turn out not to be true
|
|
42 | 44 |
|
43 | 45 |
# abstract base class
|
44 | 46 |
class Belief(object):
|
45 | |
def __init__(self, subject): # kind of silly for an ABC to have a constructor, but ok
|
|
47 |
def __init__(self, subject): # kind of silly for an ABC to have a
|
|
48 |
# constructor, but it is to emphasize that
|
|
49 |
# all beliefs have a subject, which is
|
46 | 50 |
self.subject = subject # the thing we believe something about
|
47 | 51 |
|
48 | 52 |
def __str__(self):
|
|
57 | 61 |
self.concealer = concealer # the actor who we think hid it ther
|
58 | 62 |
|
59 | 63 |
def __str__(self):
|
60 | |
return "%s is in %s" % (
|
|
64 |
s = "%s is in %s" % (
|
61 | 65 |
self.subject.render([]),
|
62 | 66 |
self.location.render([])
|
63 | 67 |
)
|
64 | |
#if .
|
65 | |
# print ".oO{ I hid it there }"
|
|
68 |
if self.concealer:
|
|
69 |
s += " (hidden there by %s)" % self.concealer.render([])
|
|
70 |
if self.informant:
|
|
71 |
s += " (%s told me so)" % self.informant.render([])
|
|
72 |
return s
|
66 | 73 |
|
67 | 74 |
|
68 | 75 |
# this could itself have several subclasses
|
69 | |
class GoalBelief(Belief):
|
|
76 |
class Goal(Belief):
|
70 | 77 |
def __init__(self, subject, phrase):
|
71 | 78 |
self.subject = subject # the thing we would like to do something about
|
72 | 79 |
self.phrase = phrase # human-readable description
|
|
80 |
|
|
81 |
def __str__(self):
|
|
82 |
return "I should %s %s" % (
|
|
83 |
self.phrase,
|
|
84 |
self.subject.render([])
|
|
85 |
)
|
|
86 |
|
|
87 |
|
|
88 |
class Desire(Belief):
|
|
89 |
def __init__(self, subject):
|
|
90 |
self.subject = subject # the thing we would like to acquire
|
|
91 |
|
|
92 |
def __str__(self):
|
|
93 |
return "I want %s" % (
|
|
94 |
self.subject.render([])
|
|
95 |
)
|
73 | 96 |
|
74 | 97 |
|
75 | 98 |
# oh dear
|
|
79 | 102 |
assert isinstance(belief, Belief)
|
80 | 103 |
self.subject = subject # the animate we think holds the belief
|
81 | 104 |
self.belief = belief # the belief we think they hold
|
|
105 |
|
|
106 |
def __str__(self):
|
|
107 |
return "%s believes %s" % (
|
|
108 |
self.subject.render([]),
|
|
109 |
self.belief
|
|
110 |
)
|
82 | 111 |
|
83 | 112 |
|
84 | 113 |
### ACTORS (objects in the world) ###
|
|
218 | 247 |
self.topic = None
|
219 | 248 |
# map of actors to sets of Beliefs about them
|
220 | 249 |
self.beliefs = {}
|
221 | |
self.desired_items = set()
|
222 | 250 |
# this should really be *derived* from having a recent memory
|
223 | 251 |
# of seeing a dead body in the bathroom. but for now,
|
224 | 252 |
self.nerves = 'calm'
|
|
235 | 263 |
# for debugging
|
236 | 264 |
def dump_beliefs(self):
|
237 | 265 |
for subject in self.beliefs:
|
238 | |
print ".oO{ %s }" % self.beliefs[subject]
|
239 | |
print "desired items:", repr(self.desired_items)
|
|
266 |
for belief in self.beliefs[subject]:
|
|
267 |
print ".oO{ %s }" % belief
|
240 | 268 |
print "decisions:", repr(self.what_to_do_about)
|
241 | 269 |
print "knowledge of others' decisions:", repr(self.other_decision_about)
|
|
270 |
|
|
271 |
###--- belief accessors/manipulators ---###
|
242 | 272 |
|
243 | 273 |
def remember_location(self, thing, location, concealer=None):
|
244 | 274 |
"""Update this Animate's beliefs to include a belief that the
|
|
281 | 311 |
return None
|
282 | 312 |
|
283 | 313 |
def forget_location(self, thing):
|
|
314 |
# this code is unusually roundabout because Python does
|
|
315 |
# not like you to modify a set while iterating it and because
|
|
316 |
# how I've chosen to implement these sets of beliefs
|
284 | 317 |
assert isinstance(thing, Actor)
|
285 | 318 |
belief_set = self.beliefs.get(thing, set())
|
286 | 319 |
target_beliefs = set()
|
287 | 320 |
for belief in belief_set:
|
288 | 321 |
if isinstance(belief, ItemLocationBelief):
|
289 | 322 |
target_beliefs.add(belief)
|
290 | |
assert len(target_beliefs) in (0, 1)
|
|
323 |
assert len(target_beliefs) in (0, 1), len(target_beliefs)
|
291 | 324 |
for belief in target_beliefs:
|
292 | 325 |
belief_set.remove(belief)
|
|
326 |
|
|
327 |
def desire(self, thing):
|
|
328 |
assert isinstance(thing, Actor)
|
|
329 |
belief_set = self.beliefs.get(thing, set())
|
|
330 |
for belief in belief_set:
|
|
331 |
if isinstance(belief, Desire):
|
|
332 |
return
|
|
333 |
belief_set.add(Desire(thing))
|
|
334 |
self.beliefs[thing] = belief_set
|
|
335 |
|
|
336 |
def quench_desire(self, thing):
|
|
337 |
# usually called when it has been acquired
|
|
338 |
assert isinstance(thing, Actor)
|
|
339 |
belief_set = self.beliefs.get(thing, set())
|
|
340 |
target_beliefs = set()
|
|
341 |
for belief in belief_set:
|
|
342 |
if isinstance(belief, Desire):
|
|
343 |
target_beliefs.add(belief)
|
|
344 |
assert len(target_beliefs) in (0, 1), len(target_beliefs)
|
|
345 |
for belief in target_beliefs:
|
|
346 |
belief_set.remove(belief)
|
|
347 |
|
|
348 |
def does_desire(self, thing):
|
|
349 |
assert isinstance(thing, Actor)
|
|
350 |
if thing.treasure():
|
|
351 |
return True # omg YES
|
|
352 |
if thing.weapon():
|
|
353 |
return True # well it could come in useful. (this may change)
|
|
354 |
belief_set = self.beliefs.get(thing, set())
|
|
355 |
for belief in belief_set:
|
|
356 |
if isinstance(belief, Desire):
|
|
357 |
return True
|
293 | 358 |
|
294 | 359 |
def address(self, other, topic, phrase, participants=None):
|
295 | 360 |
if participants is None:
|