def __init__(self, redis, features={}):
NPC.__init__(self, redis, features, 'npc')
self.logger = logging.getLogger(__name__)
self.generate_features('leader')
#generates self.scope = "country"
self.generate_features('leader' + self.scope)
# generate self.kind from scope; scope.kind = absolutemonarchy
self.generate_features('leader' + self.kind)
# generate self.leader from leaderabsolutemonarchy_leader
# generate leader.description from leaderabsolutemonarchy_leader_description
if self.scope == 'country':
self.location = country.Country(self.redis, {'leader': self})
elif self.scope == 'city':
self.location = city.City(self.redis, {'leader': self})
elif self.scope == 'organization':
self.location = organization.Organization(self.redis,
{'leader': self})
else:
self.location = organization.Organization(self.redis,
{'leader': self})
self.scope = 'organization'
self.name.title = self.leader_description[self.sex['name']]
#re-render the name with the title.
self.name.render()
def start_game(self):
# Create players
self.players[0] = Player(name=input('Input your name: '))
self.players[1] = NPC()
# place ships for both players
if input("[p]lace ships or [r]andomize positions?: ").lower() == 'p':
self.place_ships(self.players[0])
else:
temp = NPC()
self.place_ships(temp)
self.players[0].board = temp.board
self.players[0].ships = temp.ships
# place NPCs ships
self.place_ships(self.players[1])
# determine who goes first
turn = random.randint(0, 1)
while True:
if self.do_turn(self.players[turn], self.players[1 - turn]):
turn = 1 - turn
else:
break
print("{} is the winner!".format(self.players[turn].name))
def __setupNPC(self):
# This is to support the collisions for each node. See the paragraph comment
# above where we modify the npc's collision node
# playerCollisionNP = self.__mainTarget.find("* collision node")
modelStanding = "models/ralph"
modelRunning = "models/ralph-run"
modelWalking = "models/ralph-walk"
self.__NPC = NPC(modelStanding, {
"run": modelRunning,
"walk": modelWalking
},
turnRate=150,
speed=15,
agentList=self.__globalAgentList,
name="Ralph",
collisionMask=BitMask32.bit(3),
rangeFinderCount=13,
adjacencySensorThreshold=5,
radarSlices=5,
radarLength=0,
scale=1.0,
massKg=35.0,
collisionHandler=self.physicsCollisionHandler,
collisionTraverser=self.cTrav,
waypoints=self.roomWaypoints)
self.__NPC.setFluidPos(render, 20, 10, 0) #-190
self.__NPC.setScale(render, 1)
self.__NPC.setTarget(self.__mainTarget)
self.__NPC.reparentTo(render)
self.__NPC.start()
def __init__(self, redis, features={}):
NPC.__init__(self, redis, features, 'npc')
self.logger = logging.getLogger(__name__)
self.generate_features('leader')
#generates self.scope = "country"
self.generate_features('leader' + self.scope)
# generate self.kind from scope; scope.kind = absolutemonarchy
self.generate_features('leader' + self.kind)
# generate self.leader from leaderabsolutemonarchy_leader
# generate leader.description from leaderabsolutemonarchy_leader_description
if self.scope == 'country':
self.location = country.Country(self.redis, {'leader': self})
elif self.scope == 'city':
self.location = city.City(self.redis, {'leader': self})
elif self.scope == 'organization':
self.location = organization.Organization(self.redis, {'leader': self})
else:
self.location = organization.Organization(self.redis, {'leader': self})
self.scope='organization'
self.name.title = self.leader_description[self.sex['name']]
#re-render the name with the title.
self.name.render()
def __init__(self, redis, features={}):
NPC.__init__(self, redis, features, 'npc')
self.logger = logging.getLogger(__name__)
self.generate_features('deity')
self.select_portfolio()
def chat():
npc = NPC()
sentence = input('Say something to ' + npc.name + ': ')
while sentence != 'quit':
eliza_speech = npc.process_input(sentence)
if eliza_speech:
print(npc.name.upper() + ': ', end='')
print_speech(eliza_speech)
sentence = input('YOU: ')
def input_initiative():
initiative = Initiative()
print("Enter initiative in form \"[Count] Name [Initiative]\".")
while True:
# Get input
text = input("> ").strip()
if text == "":
break
words = text.split()
if words[0].isdigit():
count_specified = True
entity_count = int(words[0])
name = words[1].lower()
else:
count_specified = False
name = words[0].lower()
entity_count = 1
# If creature name is found in JSON, use it; otherwise, make an Entity object
try:
new_entity = NPC(loader.get_npc(name))
print("Got " + new_entity.name + " stats from JSON.")
except:
new_entity = Entity(name.capitalize())
# Get the initiative roll
try:
if count_specified:
initiative_result = int(words[2])
else:
initiative_result = int(words[1])
except:
initiative_result = dice.random_int(20)
try:
initiative_result += new_entity.ability_modifiers["DEX"]
except:
pass
print("Rolled " + str(initiative_result) + " for initiative.")
# If count is nonzero
if words[0].isdigit():
for i in range(entity_count):
try:
new_entity_instance = NPC(loader.get_npc(name))
for c in range(len(new_entity_instance.commands)):
new_entity_instance.commands[c] += str(i + 1)
except:
new_entity_instance = Entity(name.capitalize())
new_entity_instance.name += str(i + 1)
initiative.add_entity(new_entity_instance, initiative_result)
# Otherwise, just add it to the order
else:
initiative.add_entity(new_entity, initiative_result)
return initiative
def create_home(self):
person = NPC("Person", 100, -1)
zombie = NPC("Zombie", random.randint(50, 100), random.randint(0, 10))
vampire = NPC("Vampire", random.randint(100, 200),
random.randint(10, 20))
ghoul = NPC("Ghoul", random.randint(40, 80), random.randint(15, 30))
werewolf = NPC("Werewolf", 200, random.randint(0, 40))
npc_index = [person, zombie, vampire, ghoul, werewolf]
num_npcs = random.randint(0, 10)
for i in range(num_npcs):
#print(num_npcs)
self.monsters.append(npc_index[random.randint(1, 4)])
def __init__(self, redis, features={}):
Generator.__init__(self, redis, features)
self.logger = logging.getLogger(__name__)
for field in ['contact', 'npc']:
if not hasattr(self, field):
setattr(self, field, NPC(self.redis))
if not hasattr(self, 'business'):
setattr(self, 'business', Business(self.redis))
if not hasattr(self, 'text'):
for field in ['hook', 'request']:
if hasattr(self, field):
self.template = getattr(self, field) + ' ' + self.template
for field in ['requirement', 'disclaimer', 'payment']:
if hasattr(self, field):
self.template = self.template + ' ' + getattr(self, field)
self.template = self.template + ' Contact ' + self.contact.name.fullname
self.template = self.template + ' at the ' + self.business.name.fullname
if hasattr(self, 'detail'):
self.template = self.template + ' ' + self.detail
self.template += '.'
self.text = self.render_template(self.template)
self.text = self.render_template(self.text)
self.text = self.text[0].capitalize() + self.text[1:]
def init_npc(self, map):
all_npc_names = self.db.get_all_npc()
for data in all_npc_names:
npc = NPC(self.window, data)
self.all_npc.append(npc)
def __setupNPC(self):
# This is to support the collisions for each node. See the paragraph comment
# above where we modify the npc's collision node
# playerCollisionNP = self.__mainTarget.find("* collision node")
modelStanding = "models/ralph"
modelRunning = "models/ralph-run"
modelWalking = "models/ralph-walk"
self.__NPC = NPC(modelStanding,
{"run":modelRunning, "walk":modelWalking},
turnRate = 150,
speed = 15,
agentList = self.__globalAgentList,
name = "Ralph",
collisionMask = BitMask32.bit(3),
rangeFinderCount = 13,
adjacencySensorThreshold = 5,
radarSlices = 5,
radarLength = 0,
scale = 1.0,
massKg = 35.0,
collisionHandler = self.physicsCollisionHandler,
collisionTraverser = self.cTrav,
waypoints = self.roomWaypoints)
self.__NPC.setFluidPos(render, 20, 10, 0)#-190
self.__NPC.setScale(render, 1)
self.__NPC.setTarget(self.__mainTarget)
self.__NPC.reparentTo(render)
self.__NPC.start()
def move_to(self, i, j):
move = self.game_map[i][j]
if move == '#':
print "You run into a wall and take 1 damage."
self.hero.take_damage(1, False)
else:
self.i = i
self.j = j
self.encounter_odd += 0.05
if move == 'E':
print "Congratulations! You've reached the end of this floor!"
exit(0)
elif move == 'T':
self.find_treasure()
self.game_map[i][j] = ' ' #Removes the treasure chest from the game
elif move == "S":
print "Back to start! What now?"
else:
#Move into corridor, generate random fight here.
dice_roll = random.random()
if dice_roll < self.encounter_odd:
#BATTLE!
Combat(self.hero, [NPC("Goblin", 1, 10, 1, 2, 0, 20)])
self.encounter_odd = 0.0
elif dice_roll > 0.95:
print "Surprise! You found something."
else:
#Move normally
print "All is good, keep going!"
pass
"""
def add(self, entitytype, x, y, **parameters):
if entitytype == "knight":
self.entities.append(NPC(x, y, self))
self.npc = self.entities[-1]
elif entitytype == "fireball" or entitytype == "fireball_2":
ang = math.atan2(y - self.npc.y, x - self.npc.x)
spd = 70.0
if 'ang' in parameters:
ang = parameters['ang']
if 'spd' in parameters:
spd = parameters['spd']
if entitytype == "fireball":
self.entities.append(
Entity(self, "projectile", x, y, angle=ang, speed=spd))
if entitytype == "fireball_2":
self.entities.append(
Entity(self, "eprojectile", x, y, angle=ang, speed=spd))
elif entitytype == "geometry":
self.entities.append(
Entity(self,
"geometry",
x,
y,
dimensions=(parameters["w"], parameters["h"])))
elif entitytype == "player":
self.entities.append(Player(self, x, y, "spaceship"))
self.player = self.entities[-1]
elif entitytype == "potato":
self.entities.append(Potato(self))
elif entitytype == "smallexplosion":
self.entities.append(Entity(self, "smallexplosion", x, y))
def __init__(self, NPCNumber):
super().__init__()
self.NPCNumber = NPCNumber
self.NPCArray = []
#### Adds the NPC's to each House ####
for i in range(0, NPCNumber):
self.NPCArray.append(NPC(randint(0, 4)))
self.NPCArray[i].add_observer(self)
def __init__(self, name, ship, printer, game):
"""Stores the information regarding the fire planet."""
super(Fireplanet, self).__init__(name, "Bracing yourself against the heat, you squint out at the blackened landscape, dotted with pools of lava.", ship, game)
self.crater = Location("10", "there is a path that leads back to where you left your spaceship. You hope it's still there and the crater hasn't eaten it.", "Your spaceship sits behind you, hanging on the edge of a large crater, which glows mysteriously due to the magma inside.", printer, [Event(EventName.on_arrival, 'self.game.printer.pprint("You had to be careful as you landed on Paxak, as the surface is mostly covered in seething lava. Even the ground you can walk on is inhospitible and dangerous. You are glad that you weren\'t born here.")', "10"), Event(EventName.on_sign_read, 'self.game.printer.pprint("The words on the sign are written in a language that speaks of crackling embers and barely controlled aggression. Though the language is not your own, you can read it, albeit with some difficutly. You wish you understood why.")', "1-")])
ship_item = Item(False, True, False, ["ship", "spaceship", "craft"], "Your spaceship is still there, thank goodness.", "The plating on the bottom looks a little blackened after the descent through the hot atmosphere.", printer)
crater = Item(False, True, False, ["crater"], "The crater behind the spaceship glows ominously.", "It looks pretty deep. The bottom, far below you, has what looks like a lava spring filling it. You wish you'd spotted a better patch of ground to land on, but this was the closest place to the signs of life you spotted from the air. It'll do for now.", printer)
sign1 = Sign(self.get_sign_list()[1]["first_sign"], "A metal board attached to a section of small girder protrudes from the ground. You guess that this is the Paxak version of signs.", printer)
npc1 = NPC(["man1"], "Man1 stands before you.", "As you look at man1, you see man1.", False, False, self.get_npc_speeches(1,0), printer, [], game)
self.crater.objects = [ship_item, crater, sign1, npc1]
self.base_of_volcano = Location("11", "you see a constant stream of smoke and a hazy glow from the top of a large mountain.", "You look up at the peak of the smoking volcano. You decide not to risk your life venturing up.", printer, [])
volcano = Item(False, True, False, ["mountain", "volcano"], "The volcano stands in front of you like a lightly sleeping giant.", "You reason that going to the top would be a pretty quick way to end your life.", printer)
sign2 = Sign(self.get_sign_list()[1]["second_sign"], "Facing away from the volcano is a second sign, almost red hot from the heated ground.", printer)
self.npc2 = NPC(["man2"], "Man2 stands before you.", "Perhaps she could get into the volcano?", True, False, self.get_npc_speeches(1,1), printer, [Event(EventName.on_talking, 'self.game.fireplanet.npc2.state = NPCState.task_complete', "11", NPCState.during_task), Event(EventName.on_talking, 'self.game.fireplanet.npc5.state = NPCState.task_complete; self.game.player.get("The deepest heat", "the volcano"); self.game.printer.pprint("You got the deepest heat from the volcano!")', "11", NPCState.after_task)], game)
self.base_of_volcano.objects = [volcano, sign2, self.npc2]
self.village = Location("12", "you can just see what could be the remains of a settlement.", "You are surrounded by tumbledown houses, broken and split. Debris is strewn from the doorways, as if they were hurriedly deserted.", printer, [Event(EventName.on_arrival, 'self.game.fireplanet.set_path(self.game.fireplanet.village, ("forwards", "forward"), self.game.fireplanet.crater)', "12")])
buildings = Item(False, True, False, ["buildings", "houses"], "You realise the houses are glittering slightly in the light of the everpresent lava.", "The houses appear to have been made from a glass like substance, now shattered. It's terrible, but it's also beautiful.", printer)
sign3 = Sign(self.get_sign_list()[1]["third_sign"], "Just outside the village is another sign, telling more of the story.", printer)
npc3 = NPC(["man3"], "Man3 stands before you.", "Man3 is a house husband.", False, False, self.get_npc_speeches(1,2), printer, [], game)
self.village.objects = [buildings, sign3, npc3]
self.lava_pool_edge = Location("13", "you can see a large expanse of lava.", "You go as close to the lava pool as you dare. It is hot.", printer, [])
pool = Item(False, True, False, ["pool", "lava"], "The pool of lava is constantly in motion, as if being stirred from within.", "The heat of the molten rock is making bubbles in the liquid, and whenever they burst you have to be careful not to get burned.", printer)
sign4 = Sign(self.get_sign_list()[1]["fourth_sign"], "In danger of being consumed by the spitting lava is a sign.", printer)
npc4 = NPC(["man4"], "Man4 stands before you.", "Man4 will in fact be a child.", False, False, self.get_npc_speeches(1,3), printer, [], game)
self.lava_pool_edge.objects = [pool, sign4, npc4]
self.workshop = Location("14", "you spot a small building all on its own.", "The building is the least damaged of all the ones you have seen here, but then it's not made of the same material as the others.", printer, [Event(EventName.on_arrival, 'self.game.fireplanet.set_path(self.game.fireplanet.workshop, ("left",), self.game.fireplanet.crater)', "14"), Event(EventName.on_arrival, 'EventName.planets_visited_before_npcs += "A"', "14")])
building = Item(False, True, False, ["building", "workshop"], "The small building looks solid and heavily fireproofed, and as if it has had to be rebuilt multiple times.", "The substance the building is made of reminds you of the hardened black rocks you have seen floating within the lava. Inside the building you see a furnace, an anvil, and an iron bucket filled with tools of a blacksmith. This must be the workshop of Paxak.", printer)
sign5 = Sign(self.get_sign_list()[1]["fifth_sign"], "Stuck on the door is the sign that completes the story.", printer)
self.npc5 = NPC(["man5"], "Man5 stands before you.", "Man5 owns the forge.", True, True, self.get_npc_speeches(1,4), printer, [Event(EventName.on_talking, 'self.game.fireplanet.npc2.state = NPCState.during_task; self.game.player.karma += 1', "14", NPCState.during_task), Event(EventName.on_talking, 'self.game.player.get("Explosive power", "Paxak"); self.game.player.gun_pieces += 1; self.game.printer.pprint("You got the Explosive Power part of the Ultimate Weapon!"); del(self.game.player.inventory["The deepest heat"]); self.game.printer.pprint("The deepest heat of the volcano was taken away.")', "14", NPCState.after_task)], game)
self.workshop.objects = [building, sign5, self.npc5]
self.landing_location = self.crater
self.current_location = self.ship
for loc in [self.crater, self.base_of_volcano, self.village, self.lava_pool_edge, self.workshop, self.ship]:
self.add_location(loc)
self.set_path(self.crater, ("left",), self.base_of_volcano)
self.set_path(self.base_of_volcano, ("left",), self.village)
self.set_path(self.village, ("left",), self.lava_pool_edge)
self.set_path(self.lava_pool_edge, ("left",), self.workshop)
def npcGenerator(aliveNPCDict, maxPopulation, location, race = "human"):
# Create seed population with 18 year old couples
for pop in range(int(maxPopulation / 2)):
if race == "human":
coupleRace = MiscTables["BasicRaces"].rollTable()[0].lower()
else:
pass #TODO
# Create male and add him to the alive population dictionary
maleNPC = NPC(race=coupleRace, gender="male", isAlive=True, bornIn=location,
age=randrange(conf.ageGroupLimits[coupleRace][1], conf.ageGroupLimits[coupleRace][2]))
aliveNPCDict[maleNPC.firstName + " " + maleNPC.lastName] = maleNPC
# Create female and add her to the alive population dictionary
femaleNPC = NPC(race=coupleRace, gender="female", isAlive=True, bornIn=location, lastName=maleNPC.lastName,
age = randrange(conf.ageGroupLimits[coupleRace][1], conf.ageGroupLimits[coupleRace][2]))
aliveNPCDict[femaleNPC.firstName + " " + femaleNPC.lastName] = femaleNPC
# Marry the NPCs
marryNPCs(maleNPC, femaleNPC)
def update(self, npc):
tempNum = self.NPCArray.index(npc)
print(self.NPCArray[tempNum].get_name(), "has been slain!")
self.NPCArray.remove(npc)
self.NPCArray.insert(tempNum, NPC(0))
self.NPCArray[tempNum].add_observer(self)
if all(x.get_npcT() is 0 for x in self.NPCArray):
print("THE MONSTERS ARE DEAD!!!")
print("Leave and head to another house!")
super().update(self)
def init_npc(self, map_name):
map_data = self.db.get_map_npc(map_name)
map_npc = []
for data in map_data:
map_npc.append(data["npc"])
for npc in map_npc:
self.all_npc.append(NPC(self.renderer, self.factory, npc))
def __init__(self, redis, features={}):
Generator.__init__(self, redis, features)
self.logger = logging.getLogger(__name__)
for person in ['npc', 'victim']:
if not hasattr(self, person):
setattr(self, person, NPC(self.redis))
self.headline = self.render_template(self.headline)
self.lastseen = self.render_template(self.lastseen)
def start_game(self):
self.players[0] = NPC()
self.players[1] = NPC()
self.place_ships()
tempPlaya = Player(name="Me")
tempPlaya.board = self.players[0].board
tempPlaya.ships = self.players[0].ships
self.players[0] = tempPlaya
turn = random.randint(0, 1)
while True:
if self.do_turn(self.players[turn], self.players[1 - turn]):
turn = 1 - turn
else:
break
print("{} is the winner!".format(self.players[turn].name))
def __init__(self, frontend, template, title):
self.frontend = frontend
self.title = title
self.template = load_yaml('rules', template)
self.dirname = None
if self.title == 'Item Editor':
self.dirname = 'items'
elif self.title == 'NPC Editor':
self.dirname = 'characters'
self.rect = self.frontend.bigwindowrect
FloatDialog.__init__(self, self.rect, frontend)
Tempsprites.__init__(self)
if self.title == 'Item Editor':
self.item = Item({})
elif self.title == 'NPC Editor':
self.item = NPC({},1)
debug (self.item.animations)
self.conditional_sprites = []
self.currentanimation = None
self.baselayout()
self.editorlayout()
def create_npc(self):
self.maxCharacterId += 1
pos_x = random.randint(100, 1024)
arg = {
'health': 100,
'speed': 0.9,
'position': Coordinate(pos_x, 450),
'facingDirection': Direction.RIGHT
}
npc = NPC(self.maxCharacterId, arg)
self.actors[self.maxCharacterId] = npc
def __setupTarget(self):
modelStanding = "models/ralph"
modelRunning = "models/ralph-run"
modelWalking = "models/ralph-walk"
self.__mainTarget = NPC(modelStanding, {
"run": modelRunning,
"walk": modelWalking
},
turnRate=150,
speed=0,
agentList=self.__globalAgentList,
collisionMask=BitMask32.bit(1),
name="target",
massKg=35.0,
collisionHandler=self.physicsCollisionHandler,
collisionTraverser=self.cTrav)
# Make it visible
self.__mainTarget.reparentTo(render)
self.__mainTarget.setPos(-20, -10, 0) #-210
self.gate.find("**/Cube;+h").setCollideMask(
~self.__mainTarget.collisionMask)
def __init__(self, redis, features={}):
Generator.__init__(self, redis, features)
self.logger = logging.getLogger(__name__)
for person in ['npc', 'villain']:
if not hasattr(self, person):
setattr(self, person, NPC(self.redis))
if not hasattr(self, 'text'):
self.text = self.render_template(self.template)
self.text = self.render_template(self.text)
self.text = self.text[0].capitalize() + self.text[1:]
def __init__(self, redis, features={}):
Generator.__init__(self, redis, features)
self.logger = logging.getLogger(__name__)
for person in ['victim', 'culprit', 'source', 'believer']:
if not hasattr(self, person):
setattr(self, person, NPC(self.redis).name.fullname)
if not hasattr(self, 'text'):
self.text = self.render_template(self.template)
self.text = self.render_template(self.text)
self.text = self.text[0].capitalize() + self.text[1:]
def selectMode(self):
value = input("Please enter 1 for vs npc, or 2 for player vs player\n")
while value != "1" and value != "2":
os.system('cls')
value = input(
"Invalid input. Please enter 1 for vs npc, or 2 for player vs player\n"
)
self.vsNPC = value == "1"
self.player1 = HumanPlayer(1)
if self.vsNPC:
self.player2 = NPC(2)
else:
self.player2 = HumanPlayer(2)
def __init__(self):
self.gui = None # set at Logic.start()
self.game_over = False
self.i_say_queue = []
self.last_npc_tick = None
self.tick = 0
# create rooms
self.rooms = {}
self.rooms['execs'] = Room(self, 'execs')
# create NPCs
self.npcs = {} # indexed by title
for title, name in NAMES.items():
is_human = title == MY_TITLE
self.npcs[title] = NPC(self, title, name, is_human)
def testNpc(self):
B = Board(7, 7)
B.Set(1, 1, 1)
C = NPC(B)
for i in range(1, 500):
C.FirstMove()
x, y, v = B.Moves[1][0], B.Moves[1][1], B.Moves[1][2]
self.assertTrue([x, y] != [1, 1])
self.assertTrue(x >= 0)
self.assertTrue(x < 7)
self.assertTrue(y >= 0)
self.assertTrue(y < 7)
B.Set(x, y, 0, True)
self.assertEqual(C.hScore(1, 1, 1), 1)
B.Set(1, 2, 1)
self.assertEqual(C.hScore(1, 1, 1), 2)
B.Set(1, 3, 1)
self.assertEqual(C.hScore(1, 1, 1), 3)
B.Set(1, 4, 1)
self.assertEqual(C.hScore(1, 1, 1), 4)
B.Set(1, 5, 1)
self.assertEqual(C.hScore(1, 1, 1), 5)
# Same idea applies for vScore, d1Score, d2Score, therefore we assume that if this works then those work as well
# Checking the defense
B.Set(1, 5, 0, True)
B.Set(1, 4, 0, True)
x, y = C.FindBlockMove()
self.assertEqual(x, 1)
self.assertEqual(y, 0)
# Checking the offensive
B.Set(2, 1, -1)
B.Set(2, 2, -1)
B.Set(2, 3, -1)
x, y, v = C.FindBestMove()
self.assertEqual(x, 2)
self.assertEqual(y, 0)
self.assertEqual(v, 4)
def __setupTarget(self):
modelStanding = "models/ralph"
modelRunning = "models/ralph-run"
modelWalking = "models/ralph-walk"
self.__mainTarget = NPC(modelStanding,
{"run":modelRunning, "walk":modelWalking},
turnRate = 150,
speed = 0,
agentList = self.__globalAgentList,
collisionMask = BitMask32.bit(1),
name="target",
massKg = 35.0,
collisionHandler = self.physicsCollisionHandler,
collisionTraverser = self.cTrav)
# Make it visible
self.__mainTarget.reparentTo(render)
self.__mainTarget.setPos(-20, -10, 0)#-210
self.gate.find("**/Cube;+h").setCollideMask(~self.__mainTarget.collisionMask)
def __init__(self, redis, features={}):
Generator.__init__(self, redis, features)
self.logger = logging.getLogger(__name__)
self.generate_features(self.kind)
self.npc = NPC(redis)
self.curse_chance_roll = random.randint(1, 100);
if self.curse_chance_roll < self.curse_chance :
self.curse = Curse(redis)
else:
del self.curse
self.build_creator()
text = self.render_template(self.name_template)
self.name = self.render_template(text)
def __init__(self, redis, features={}):
Generator.__init__(self, redis, features)
self.logger = logging.getLogger(__name__)
self.generate_features(self.kind)
self.senses = []
# originally I was going to move these to a for loop, but the verb
# doesn't match the variable name, so it would require refactoring
# of the dataset and every other damn thing. Meh.
if hasattr(self, 'smell'):
self.smell = 'you smell ' + self.smell
self.senses.append(self.smell)
if hasattr(self, 'sound'):
self.sound = 'you hear ' + self.sound
self.senses.append(self.sound)
if hasattr(self, 'sight'):
self.sight = 'you see ' + self.sight
self.senses.append(self.sight)
if not hasattr(self, 'owner'):
self.owner = NPC(redis)
# TODO patrons should be better calculated
if not hasattr(self, 'patroncount'):
self.patroncount = random.randint(1, 10)
# Business is one of the few classes where trailer doesn't start as part of the name
# So we have to add it here.
self.name = Name(self.redis, 'business', {'trailer': self.trailer})
# If maxfloors isn'd designated, set it to 1
if not hasattr(self, 'maxfloors'):
self.maxfloors = 1
# don't set floors if it already exists
if not hasattr(self, 'floor'):
self.floor = random.randint(1, int(self.maxfloors))
def __init__(self, redis, features={}):
Generator.__init__(self, redis, features)
self.logger = logging.getLogger(__name__)
if not hasattr(self, 'region'):
print "noregion!!!"
self.region = region.Region(self.redis)
self.gatheringplace = Business(self.redis,
{'kind': 'bus_' + self.gatheringplace})
if not hasattr(self, 'leader'):
self.leader = leader.Leader(self.redis, {"location": self})
#self.leader = Leader(self.redis)
if not hasattr(self, 'name'):
self.name = Name(self.redis, 'city')
self.citizen = NPC(self.redis)
self.calculate_population()
self.calculate_racial_breakdown()
self.select_subraces()
def update(self, dt):
if self.musicplayer.source == self.musicres[
self.level][1] and not self.musicplayer.eos_action == 'loop':
self.musicplayer.eos_action = 'loop'
for e in self.entities:
if self.controllable:
e.update(dt)
else:
if not e.entitytype == "NPC":
e.update(dt)
for e in [todel for todel in self.entities if todel.active == False]:
self.entities.remove(e)
if self.npc.dead:
# explosions
self.entities.remove(self.npc)
self.entities.append(NPC(random.randint(0, 600), -10, self))
self.npc = self.entities[-1]
def __init__(self, redis, features={}):
Generator.__init__(self, redis, features)
self.logger = logging.getLogger(__name__)
if not hasattr(self, 'npc'):
setattr(self, 'npc', NPC(self.redis))
if not hasattr(self, 'npcname'):
setattr(self, 'npcname', self.npc.name.shortname)
if not hasattr(self, 'npcprofession'):
setattr(self, 'npcprofession', self.npc.profession)
if not hasattr(self, 'text'):
if hasattr(self, 'signature'):
self.template = self.template + ' The message is signed ' + getattr(
self, 'signature')
if hasattr(self, 'age'):
self.template = self.template + " You'd guess the message is " + getattr(
self, 'age')
self.text = self.render_template(self.template)
self.text = self.render_template(self.text)
self.text = self.text[0].capitalize() + self.text[1:]
def load(self,objtype):
if objtype == 'npc':
data = self.get('npc', False)
if not data:
return None
npc = NPC(load_yaml('characters',data))
if not resaved('characters', data):
npc.set_hash()
npc.savetoslot('characters')
self.add('npc', npc.get_hash())
return npc
current = self.get('items', [])
result = []
itemlist = []
for item in current:
i = Item(load_yaml('items',item))
if not resaved('items', item):
i.set_hash()
i.savetoslot('items')
result.append(i)
itemlist.append(i.get_hash())
self.put('items', itemlist)
return result
class World(DirectObject):
def __init__(self):
DirectObject.__init__(self)
self.pathSmoothening = False
self.showWaypoints = True
self.showCollisions = False
self.accept("escape", sys.exit)
self.__setupEnvironment()
self.__setupCollisions()
self.__setupGravity()
self.__setupLevel()
self.__setupTarget()
self.__setupNPC()
self.__setupCamera()
self.__setupTasks()
self.setKeymap()
self.__NPC.pathSmoothening = self.pathSmoothening
if(self.showWaypoints):
print("Showing waypoints")
for w in self.roomWaypoints:
w.draw()
def __setupCollisions(self):
self.cTrav = CollisionTraverser("traverser")
base.cTrav = self.cTrav
self.physicsCollisionHandler = PhysicsCollisionHandler()
self.physicsCollisionHandler.setDynamicFrictionCoef(0.5)
self.physicsCollisionHandler.setStaticFrictionCoef(0.7)
def __setupGravity(self):
base.particlesEnabled = True
base.enableParticles()
gravityFN=ForceNode('world-forces')
gravityFNP=render.attachNewNode(gravityFN)
gravityForce=LinearVectorForce(0,0,-6) #gravity acceleration ft/s^2
gravityFN.addForce(gravityForce)
base.physicsMgr.addLinearForce(gravityForce)
def __setupEnvironment(self):
cm = CardMaker("ground")
size = 100
cm.setFrame(-size, size, -size, size)
environment = render.attachNewNode(cm.generate())
environment.lookAt(0, 0, -1)
environment.setPos(0, 0, 0)
environment.setCollideMask(BitMask32.allOn())
environment.reparentTo(render)
texture = loader.loadTexture("textures/ground.png")
# This is so the textures can look better from a distance
texture.setMinfilter(Texture.FTLinearMipmapLinear)
environment.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldPosition)
environment.setTexScale(TextureStage.getDefault(), 0.02, 0.02)
environment.setTexture(texture, 1)
def __setupLevel(self):
"""
Originally planned to have multiple levels, that never happened.
"""
level1 = render.attachNewNode("level 1 node path")
execfile("rooms/room.py")
self.room = loader.loadModel("rooms/room")
self.room.findTexture("*").setMinfilter(Texture.FTLinearMipmapLinear)
self.room.setScale(10,10,5)
self.room.setTexScale(TextureStage.getDefault(), 10)
self.room.reparentTo(render)
self.room.find("**/Cube;+h").setTag("Room", "1")
gate = loader.loadModel("models/box")
gateTo2 = self.room.attachNewNode("gateTo2")
gate.instanceTo(gateTo2)
gateTo2.setPos(8, -10, 0)
gateTo2.hide()
self.physicsCollisionHandler.addInPattern("%fn-into-%in")
self.physicsCollisionHandler.addOutPattern("%fn-out-%in")
#messenger.toggleVerbose()
self.gate = gate
__globalAgentList = []
__mainTarget = None
def __setupTarget(self):
modelStanding = "models/ralph"
modelRunning = "models/ralph-run"
modelWalking = "models/ralph-walk"
self.__mainTarget = NPC(modelStanding,
{"run":modelRunning, "walk":modelWalking},
turnRate = 150,
speed = 0,
agentList = self.__globalAgentList,
collisionMask = BitMask32.bit(1),
name="target",
massKg = 35.0,
collisionHandler = self.physicsCollisionHandler,
collisionTraverser = self.cTrav)
# Make it visible
self.__mainTarget.reparentTo(render)
self.__mainTarget.setPos(-20, -10, 0)#-210
self.gate.find("**/Cube;+h").setCollideMask(~self.__mainTarget.collisionMask)
__targetCount = 0
__targets = []
__agentToTargetMap = {}
def __setupNPC(self):
# This is to support the collisions for each node. See the paragraph comment
# above where we modify the npc's collision node
# playerCollisionNP = self.__mainTarget.find("* collision node")
modelStanding = "models/ralph"
modelRunning = "models/ralph-run"
modelWalking = "models/ralph-walk"
self.__NPC = NPC(modelStanding,
{"run":modelRunning, "walk":modelWalking},
turnRate = 150,
speed = 15,
agentList = self.__globalAgentList,
name = "Ralph",
collisionMask = BitMask32.bit(3),
rangeFinderCount = 13,
adjacencySensorThreshold = 5,
radarSlices = 5,
radarLength = 0,
scale = 1.0,
massKg = 35.0,
collisionHandler = self.physicsCollisionHandler,
collisionTraverser = self.cTrav,
waypoints = self.roomWaypoints)
self.__NPC.setFluidPos(render, 20, 10, 0)#-190
self.__NPC.setScale(render, 1)
self.__NPC.setTarget(self.__mainTarget)
self.__NPC.reparentTo(render)
self.__NPC.start()
def __setupTasks(self):
"""
This function sets up all the tasks used in the world
"""
taskMgr.add(taskTimer, "taskTimer")
taskMgr.add(self.__NPC.act, "actTask")
def __setupCamera(self):
#This camera position shows the whole level
base.camera.setPos(100,-100, 795) #This is debug camera position.
base.camera.lookAt(100,-100,0)
base.disableMouse()
base.camera.reparentTo(self.__NPC.actor)
base.camera.setPos(0, 60, 200)
base.camera.lookAt(self.__NPC)
base.camera.setP(base.camera.getP() + 10)
def cameraViewRoomPos(self):
base.camera.reparentTo(render)
#This camera position shows entire room at once
base.camera.setPos(0,0, 300) #This is debug camera position.
base.camera.lookAt(0,0,0)
def cameraRegularPos(self):
base.camera.reparentTo(self.__NPC.actor)
base.camera.setPos(0, 60, 200)
base.camera.lookAt(self.__NPC)
base.camera.setP(base.camera.getP() + 10)
positionHeadingText = OnscreenText(text="", style=1, fg=(1,1,1,1),
pos=(-1.3,-0.95), align=TextNode.ALeft, scale = .05, mayChange = True)
__keyMap = {"enablePathSmoothening":False,
"showWaypoints":False}
def setKeymap(self):
def toggleWaypoints(key):
self.showWaypoints = not self.showWaypoints
if(self.showWaypoints):
print("Showing waypoints")
for w in self.roomWaypoints:
w.draw()
else:
print("Hiding waypoints")
for w in self.roomWaypoints:
w.erase()
def togglePathSmoothening(key):
self.__NPC.togglePathSmoothening()
def toggleCollisions(key):
if(self.showCollisions):
base.cTrav.showCollisions(render)
else:
base.cTrav.hideCollisions()
self.showCollisions = not self.showCollisions
print("showCollisions = " + str(self.showCollisions))
self.accept("p", togglePathSmoothening, ["togglePathSmoothening"])
self.accept("w", toggleWaypoints, ["toggleWaypoints"])
self.accept("c", toggleCollisions, ["toggleCollisions"])
self.accept("1", self.cameraRegularPos)
self.accept("2", self.cameraViewRoomPos)
import sys
import numpy as np
import random
from stats import Stats
from npc import NPC
a = NPC("Peter")
b = NPC("Paul")
a.level_to(99)
a.show_stats()
b.level_to(99)
print b.cure(9999)
b.show_stats()
class YAMLEditor(FloatDialog, Tempsprites):
def __init__(self, frontend, template, title):
self.frontend = frontend
self.title = title
self.template = load_yaml('rules', template)
self.dirname = None
if self.title == 'Item Editor':
self.dirname = 'items'
elif self.title == 'NPC Editor':
self.dirname = 'characters'
self.rect = self.frontend.bigwindowrect
FloatDialog.__init__(self, self.rect, frontend)
Tempsprites.__init__(self)
if self.title == 'Item Editor':
self.item = Item({})
elif self.title == 'NPC Editor':
self.item = NPC({},1)
debug (self.item.animations)
self.conditional_sprites = []
self.currentanimation = None
self.baselayout()
self.editorlayout()
def baselayout(self):
self.lastlayer = 18
self.image.blit(render_text (self.title, size=32, color=(255,0,0)),(self.rect.w/2 - 20,10))
split = self.frontend.imagecache['seperator']
split = pygame.transform.smoothscale(split,(self.frontend.screensize.w -20, 10))
self.image.blit(split,(10,60))
save_btn = Button('Save Item', self.save, [], self.frontend.eventstack,self.frontend.imagecache, pos=(self.rect.x + self.rect.w - 150,self.rect.y + self.rect.h - 50), layer=6)
load_btn = Button('Load Item', self.load, [], self.frontend.eventstack,self.frontend.imagecache, pos=(self.rect.x + 10,self.rect.y + self.rect.h - 50), layer=6)
self._addtemp('saveitem', save_btn)
self._addtemp('loaditem', load_btn)
def make_event(self, sender, key):
self.update_yaml()
if key.startswith('event'):
default = default_text
else:
default = ['']
data = self.item.get(key, default)
if not key in data[0]:
data.insert(0,'#%s' % key)
data = editsnippet('\n'.join(data))
self.item.put(key,data.split('\n'))
self.update_yaml()
def editorlayout(self):
debug('Building editor layout')
self._rmtemp()
self.baselayout()
col, row = 0, 0
for key in [i for i in self.template if '__Y' in i]:
value = self.item.get(realkey(key),False)
if value is False:
self.item.put(realkey(key), self.template[key])
list1 = sorted([i for i in self.template if not i.startswith('conditional/') and not i.startswith('events/') and not '__Y' in i and not 'animations' in i and i != 'personal/portrait'])
list3 = sorted([i for i in self.template if i.startswith('events/')])
list2 = sorted([i for i in self.conditional_sprites if not 'animations' in i])
if [i for i in self.template if 'equiped' in i]:
list4=['inventory']
else:
list4 = []
allkeys = list1 + list2 + list3 + list4
for key in allkeys:
x = col * 450 + self.rect.x + 15
y = row * 35 + self.rect.y + 75
if key == 'inventory':
b = Button('Iventory',
self.showinventory,
[],
self.frontend.eventstack,
self.frontend.imagecache,
pos=(x ,y),
layer=6,
fontsize=14)
self._addtemp('%s_button' % key, b)
row += 1
continue
if key.startswith('events/') or key.startswith('__T'):
b = Button(realkey(key),
self.make_event,
[realkey(key)],
self.frontend.eventstack,
self.frontend.imagecache,
pos=(x ,y),
layer=6,
sendself=True,
fontsize=14)
self._addtemp('%s_button' % key, b)
else:
sprites = self.handlekey(key, x,y)
for sprite in sprites:
self._addtemp('%s_%s' % (key,sprites.index(sprite)), sprite)
row += 1
if row * 35 + self.rect.y + 75 + 128> self.rect.y + self.rect.h -75:
row = 0
col += 1
for key in sorted([i for i in self.conditional_sprites if 'animations' in i])+sorted(i for i in self.template if 'animations' in i and not 'conditional' in i and i != 'personal/portrait'):
keyname = realkey(key)
value = self.item.get(keyname,[])
if not value:
value = self.template[key]
self.item.put(keyname, value)
if self.item.animations:
x = col * 450 + self.rect.x + 15
y = row * 35 + self.rect.y + 75
self.animation_editor(x,y)
y = y + 75
for sprite in self.handlekey('personal/portrait', x,y):
self._addtemp(make_hash(), sprite)
def animation_editor(self, x, y):
l = Label('Animations', (x,y))
y += l.rect.h
self._addtemp('animations_label', l)
scale = self.frontend.mapscale
self.previewsprite = AnimatedSprite(self.frontend.tilemaps, pygame.Rect(x, y, scale, scale), self.item.animations, 8, 5)
if self.currentanimation is None:
self.currentanimation = self.previewsprite.animation
self.previewsprite.pause = True
else:
self.previewsprite.setanimation(self.currentanimation)
self.previewsprite.pause = self.paused.checked
self._addtemp('previewsprite', self.previewsprite)
self.animation = Dropdown(self.frontend.eventstack,
self.frontend.imagecache,
18,
pygame.Rect(x + scale + 2, y, 200, 20),
self.previewsprite.animations.keys(),
choice=self.currentanimation,
onselect=self.changeanimation,
layer = self.lastlayer)
self.lastlayer -= 1
self._addtemp('selectanimation', self.animation)
self.paused = checkboxbtn('Paused',
self.togglepause,
[],
self.frontend.eventstack,
self.frontend.imagecache,
pos=(x + 150,y+22), fontsize=16,
layer=6, sendself=True)
self.paused.checked = self.previewsprite.pause
self._addtemp('AnimationPauseButton', self.paused)
if self.paused.checked:
nextframebtn = ButtonArrow(self.previewsprite.nextframe,
[],
self.frontend.eventstack,
self.frontend.imagecache,
'right',
pos=(x + scale,y+22),
layer=6)
self._addtemp('nextframebtn', nextframebtn)
delframebtn = BlitButton(self.delframe,
[],
self.frontend.eventstack,
self.frontend.imagecache,
'minusarrow',
pos=(nextframebtn.rect.x + nextframebtn.rect.w,y+22),
layer=6)
self._addtemp('delete frame button',delframebtn)
addframebtn = BlitButton(self.addframe,[],
self.frontend.eventstack,
self.frontend.imagecache,
'plusarrow',
pos=(delframebtn.rect.x + delframebtn.rect.w,y+22),
layer=6)
self._addtemp('add frame button',addframebtn)
def togglepause(self,pausbtn, *args):
self.previewsprite.pause = pausbtn.checked
self.editorlayout()
def changeanimation(self,animation):
self.previewsprite.setanimation(animation)
self.currentanimation = animation
def delframe(self):
key = 'animations/%s' % self.currentanimation
idx = self.previewsprite.frame
messages.warning('Deleted frame %s' % (idx))
try:
del self.item()[key][idx]
except IndexError:
debug('Tried to delete from an already empty list.')
def addframe(self):
self.updateconditionals()
self._rmtemp()
self.tileselector = TileSelector(self.rect, self.frontend, self.newframe,[])
self._addtemp('ye_tileselector', self.tileselector)
def newframe(self, framepath):
self._rmtemp()
key = 'animations/%s' % self.currentanimation
idx = self.previewsprite.frame
animations = self.item.get(key)
animations.insert(idx, '%s:0' %framepath)
self.item.put(key, animations)
self.editorlayout()
def listmanager(self,keyname, items):
self._rmtemp()
itemlist = []
for itemfile in file_list('items'):
itemfile = os.path.basename(itemfile)
itemlist.append(Item(load_yaml('items',itemfile)))
c = ContainerDialog(self.rect,
self.frontend,
keyname,
7,
items=[Item(i) for i in items],
onclose=self.updatelist,
onclose_parms=[keyname],
animation='view',
can_add=True,
can_remove=True,
addfrom=itemlist)
self._addtemp('%s_listmanager' %keyname, c)
def showinventory(self, *args):
#rect, frontend, char, layer=5
self.update_yaml()
self._rmtemp()
inventory = Inventory(
self.rect,
self.frontend,
self.item,
7,
self.editorlayout
)
self._addtemp('editor_inventory', inventory)
def updatelist(self, items, keyname):
if keyname == 'inventory/pack':
pack = self.item.get(keyname,[])
for I in pack:
self.item.drop_item(Item(I))
for I in items:
self.item.acquire_item(I)
else:
items = [i() for i in items]
self.item.put(keyname, items)
self.editorlayout()
def handlekey(self,key, x,y):
keyname = realkey(key)
has_label = True
l = Label(keyname,(x,y))
lsize = l.rect.w +10
irect = pygame.Rect(x + lsize, y, 250, 20)
value = self.item.get(keyname,'')
if not value:
if key in self.template:
value = self.template[key]
else:
return ()
if str(value).startswith('__'):
value = ''
if keyname == 'personal/portrait':
self.item.put('personal/portrait', value)
self.portrait = value
d = BlitButton(
self.nextportrait,
[],
self.frontend.eventstack,
self.frontend.imagecache,
self.portrait,
pos=(irect.x,y),
scale=128,
layer=7
)
elif isinstance(value, list):
d = Button('Manage list',
self.listmanager,
[keyname, value],
self.frontend.eventstack,
self.frontend.imagecache,
pos=(irect.x, irect.y),
layer=self._layer +1)
elif (key.startswith('conditional') or keyname == key) and not '__[' in str(self.template[key]):
d = TextInput(
irect,18, self.frontend.eventstack, prompt=str(value), clearprompt=False, layer=6, name=keyname)
elif (key.startswith('conditional') or keyname == key) and '__[' in str(self.template[key]):
liststr = self.template[key]
items = liststr[3:-1].split(',')
if sorted([i.upper() for i in items]) == ['FALSE','TRUE']:
has_label = False
d = checkboxbtn(keyname,
self.valuechange,
[],
self.frontend.eventstack,
self.frontend.imagecache,
pos=(x,y), fontsize=16,
layer=6, name=key, sendself=True)
if d.name in self.item():
d.checked = self.item.get(d.name)
else:
d.checked = items[0].upper() == 'TRUE'
else:
if not value and len(items) == 1:
value = items[0]
d = Dropdown(
self.frontend.eventstack,
self.frontend.imagecache,
16,
irect, items,layer=self.lastlayer,
choice=value,
onselect=self.valuechange,
name=keyname,
sendself=True)
self.lastlayer -= 1
if has_label:
return [l, d]
else:
return [d]
def nextportrait(self):
portraitlist = [i for i in self.frontend.imagecache.keys() if i.startswith('portrait_')]
idx = portraitlist.index(self.portrait)
idx += 1
if idx >= len(portraitlist) -1:
idx = 0
self.portrait = portraitlist[idx]
self.item.put('personal/portrait', self.portrait)
self.editorlayout()
def updateconditionals(self):
self.conditional_sprites = []
conditional_keys = FlattenedDict(self.template).readsubtree('conditional')
for key in conditional_keys:
conditions = [k.replace('.','/') for k in key.split('/') if '=' in k]
for condition in conditions:
ckey, cval = condition.split('=')
if self.item.get(ckey,False) == cval:
self.conditional_sprites.append('conditional/%s' % key)
self.editorlayout()
def valuechange(self, *args):
k, v = args[0].name, args[1]
self.item.put(k, v)
self.update_yaml()
self.updateconditionals()
def changepreview(self,choice):
self.previewsprite.setanimation(choice)
def update_yaml(self):
for item in self.temp:
sprite = item[0]
try:
k = realkey(sprite.name)
v = sprite.value
if k and v:
self.item.put(k, v)
except:
continue
def save(self):
self.update_yaml()
if self.dirname:
filename = self.item.save_to_file(self.dirname)
messages.error('Saved to %s' % os.path.basename(filename))
def load(self):
self._rmtemp()
itemlist = []
for itemfile in file_list(self.dirname):
itemfile = os.path.basename(itemfile)
if self.dirname == 'items':
itemlist.append(Item(load_yaml(self.dirname,itemfile)))
else:
itemlist.append(NPC(load_yaml(self.dirname,itemfile)))
c = ContainerDialog(self.rect,
self.frontend,
'Load %s' %self.dirname,
7,
items=itemlist,
onselect=self.loaditem,
onselect_parms=[],
animation='view',
can_add=False,
can_remove=False
)
self._addtemp(make_hash(), c)
def loaditem(self, item):
debug('Loading item', item.displayname())
self.item = item
self.updateconditionals()
def delete(self):
self._rmtemp()
self.kill()
self.restorebg()
def __setupNPCs(self):
# This is to support the collisions for each node. See the paragraph comment
# above where we modify the npc's collision node
playerCollisionNP = self.__mainAgent.find("* collision node")
modelStanding = "models/eve"
modelRunning = "models/eve-run"
modelWalking = "models/eve-walk"
self.__room1NPC = NPC(modelStanding,
{"run":modelRunning, "walk":modelWalking},
turnRate = 150,
speed = 15,
agentList = self.__globalAgentList,
name = "Eve 1",
collisionMask = BitMask32.bit(3),
rangeFinderCount = 13,
adjacencySensorThreshold = 5,
radarSlices = 5,
radarLength = 40,
scale = 1.0,
massKg = 35.0,
collisionHandler = self.physicsCollisionHandler,
collisionTraverser = self.cTrav,
waypoints = self.room1waypoints)
self.__room1NPC.setFluidPos(render, 0, 0, 10)
self.__room1NPC.setScale(render, 1)
self.__room1NPC.setPlayer(self.__mainAgent)
self.__room1NPC.reparentTo(render)
# So here's what I'm thinking. Currently, two collisions are happening when
# we collide with an NPC. Those are Player-->NPC and NPC-->Player. This is
# causing some jumpiness, which in tern causes some collisions to fail (e.g.,
# falling through the floor). In order to fix this, we need to ignore one of
# these collisions. Since the NPC should react to the Player, and not vice-versa,
# I'll ignore the Player-->NPC collision. To do this, we need to set Player's into
# collide mask to exclude NPC's from collide mask. Let's hope this doesn't break
# anything.
npcCollisionNP = self.__room1NPC.find("* collision node")
npcCollisionNP.node().setIntoCollideMask(npcCollisionNP.node().getIntoCollideMask() &
~playerCollisionNP.node().getIntoCollideMask())
## modelStanding = "models/bunny/bunny"
## modelRunning = "models/bunny/bunny"
## modelWalking = "models/bunny/bunny"
self.__room2NPC = NPC(modelStanding,
{"run":modelRunning, "walk":modelWalking},
turnRate = 150,
speed = 15,
agentList = self.__globalAgentList,
name = "Eve 2",#"das Osterhase",
collisionMask = BitMask32.bit(4),
rangeFinderCount = 13,
adjacencySensorThreshold = 5,
radarSlices = 5,
radarLength = 40,
scale = 1.0,
massKg = 35.0,
collisionHandler = self.physicsCollisionHandler,
collisionTraverser = self.cTrav,
waypoints = self.room2waypoints)
self.__room2NPC.setPos(-20, -210, 10)
self.__room2NPC.setPlayer(self.__mainAgent)
self.__room2NPC.reparentTo(render)
npcCollisionNP = self.__room2NPC.find("* collision node")
npcCollisionNP.node().setIntoCollideMask(npcCollisionNP.node().getIntoCollideMask() &
~playerCollisionNP.node().getIntoCollideMask())
self.__room3NPC = NPC(modelStanding,
{"run":modelRunning, "walk":modelWalking},
turnRate = 150,
speed = 15,
agentList = self.__globalAgentList,
name = "Eve 3",#"der Hoppelhaschen",
collisionMask = BitMask32.bit(5),
rangeFinderCount = 13,
adjacencySensorThreshold = 5,
radarSlices = 5,
radarLength = 40,
scale = 1.0,
massKg = 35.0,
collisionHandler = self.physicsCollisionHandler,
collisionTraverser = self.cTrav,
waypoints = self.room3waypoints)
self.__room3NPC.setPos(210, 0, 10)
self.__room3NPC.setPlayer(self.__mainAgent)
self.__room3NPC.reparentTo(render)
npcCollisionNP = self.__room3NPC.find("* collision node")
npcCollisionNP.node().setIntoCollideMask(npcCollisionNP.node().getIntoCollideMask() &
~playerCollisionNP.node().getIntoCollideMask())
class World(DirectObject):
def __init__(self):
DirectObject.__init__(self)
self.pathSmoothening = True
self.showWaypoints = False
self.showCollisions = False
self.accept("escape", sys.exit)
self.__setupEnvironment()
self.__setupCollisions()
self.__setupGravity()
self.__setupLevel()
self.__setupMainAgent()
# self.__setupOtherAgents()
self.__setupNPCs()
self.__setupCamera()
self.__setupRandomClutter()
#Many things within the NPC are dependant on the level it is in.
self.__room1NPC.setKeyAndNestReference(self.keyNest1, self.room1Key)
self.__room2NPC.setKeyAndNestReference(self.keyNest2, self.room2Key)
#self.__room2NPC.handleTransition("playerLeftRoom")
self.__room3NPC.setKeyAndNestReference(self.keyNest3, self.room3Key)
#self.__room3NPC.handleTransition("playerLeftRoom")
self.__setupTasks()
self.setKeymap()
# This is for the HUD
self.keyImages = {
self.room1Key:"models/redKeyHUD.png",
self.room2Key:"models/blueKeyHUD.png",
self.room3Key:"models/greenKeyHUD.png" }
self.room1KeyInHUD = False
self.room2KeyInHUD = False
self.room3KeyInHUD = False
self.redKeyImage = OnscreenImage(image = self.keyImages[self.room1Key], pos = (0.9, 0, 0.9), scale = (0.0451, 0, 0.1))
self.redKeyImage.setTransparency(TransparencyAttrib.MAlpha)
self.redKeyImage.hide()
self.blueKeyImage = OnscreenImage(image = self.keyImages[self.room2Key], pos = (0.7, 0, 0.9), scale = (0.0451, 0, 0.1))
self.blueKeyImage.setTransparency(TransparencyAttrib.MAlpha)
self.blueKeyImage.hide()
self.greenKeyImage = OnscreenImage(image = self.keyImages[self.room3Key], pos = (0.5, 0, 0.9), scale = (0.0451, 0, 0.1))
self.greenKeyImage.setTransparency(TransparencyAttrib.MAlpha)
self.greenKeyImage.hide()
def reComputeHUD(self, room):
"""
reComputeHUD is called when the player leaves a room and enters another room.
The HUD shows the images of the keys that the player has in his backpack,
but not the key to the current room.
"""
## assert False, "add the hack to make sure she doesn't fall through the ground"
if self.__mainAgent.hasKey(self.room1Key) and room is not self.room1:
#self.redKeyImage.show()
self.room1Key.reparentTo(base.cam)
self.room1Key.setScale(render, 1.25)
self.room1Key.setP(base.cam, 0)
self.room1Key.setPos(base.cam.getX(base.cam) + 2.1, base.cam.getY(base.cam) + 10, base.cam.getZ(base.cam) + 2.1)
self.room1KeyInHUD = True
elif self.__mainAgent.hasKey(self.room1Key) and room is self.room1:
rightHand = self.__mainAgent.actor.exposeJoint(None, 'modelRoot', 'RightHand')
self.room1Key.reparentTo(rightHand)
self.room1Key.setPosHpr(.11,-1.99,.06, 0,-90,0)
self.room1Key.setScale(render, 10)
self.room1Key.setTexScale(TextureStage.getDefault(), 1)
self.room1KeyInHUD = False
self.redKeyImage.hide()
else:
self.redKeyImage.hide()
self.room1KeyInHUD = False
if self.__mainAgent.hasKey(self.room2Key) and room is not self.room2:
#self.blueKeyImage.show()
self.room2Key.reparentTo(base.cam)
self.room2Key.setScale(render, 1.25)
self.room2Key.setP(base.cam, 0)
self.room2Key.setPos(base.cam.getX(base.cam) + 2.5, base.cam.getY(base.cam) + 10, base.cam.getZ(base.cam) + 2.1)
self.room2KeyInHUD = True
elif self.__mainAgent.hasKey(self.room2Key) and room is self.room2:
rightHand = self.__mainAgent.actor.exposeJoint(None, 'modelRoot', 'RightHand')
self.room2Key.reparentTo(rightHand)
self.room2Key.setPosHpr(.11,-1.99,.06, 0,-90,0)
self.room2Key.setScale(render, 10)
self.room2Key.setTexScale(TextureStage.getDefault(), 1)
self.room2KeyInHUD = False
self.blueKeyImage.hide()
elif (self.blueKeyImage != None):
self.blueKeyImage.hide()
self.room2KeyInHUD = False
if self.__mainAgent.hasKey(self.room3Key) and room is not self.room3:
#self.greenKeyImage.show()
self.room3Key.reparentTo(base.cam)
self.room3Key.setScale(render, 1.25)
self.room3Key.setP(base.cam, 0)
self.room3Key.setPos(base.cam.getX(base.cam) + 3.0, base.cam.getY(base.cam) + 10, base.cam.getZ(base.cam) + 2.1)
self.room3KeyInHUD = True
elif self.__mainAgent.hasKey(self.room3Key) and room is self.room3:
rightHand = self.__mainAgent.actor.exposeJoint(None, 'modelRoot', 'RightHand')
self.room3Key.reparentTo(rightHand)
self.room3Key.setPosHpr(.11,-1.99,.06, 0,-90,0)
self.room3Key.setScale(render, 10)
self.room3Key.setTexScale(TextureStage.getDefault(), 1)
self.room3KeyInHUD = False
self.greenKeyImage.hide()
elif (self.greenKeyImage != None):
self.greenKeyImage.hide()
def __setupCollisions(self):
self.cTrav = CollisionTraverser("traverser")
base.cTrav = self.cTrav
self.physicsCollisionHandler = PhysicsCollisionHandler()
self.physicsCollisionHandler.setDynamicFrictionCoef(0.5)
self.physicsCollisionHandler.setStaticFrictionCoef(0.7)
def __setupGravity(self):
base.particlesEnabled = True
base.enableParticles()
gravityFN=ForceNode('world-forces')
gravityFNP=render.attachNewNode(gravityFN)
gravityForce=LinearVectorForce(0,0,-6) #gravity acceleration ft/s^2
gravityFN.addForce(gravityForce)
base.physicsMgr.addLinearForce(gravityForce)
def __setupEnvironment(self):
cm = CardMaker("ground")
size = 200
cm.setFrame(-size, size, -size, size)
environment = render.attachNewNode(cm.generate())
environment.lookAt(0, 0, -1)
environment.setPos(100, -100, 0)
environment.setCollideMask(BitMask32.allOn())
environment.reparentTo(render)
texture = loader.loadTexture("textures/ground.png")
# This is so the textures can look better from a distance
texture.setMinfilter(Texture.FTLinearMipmapLinear)
environment.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldPosition)
environment.setTexScale(TextureStage.getDefault(), 0.02, 0.02)
environment.setTexture(texture, 1)
# skyBox = loader.loadModel("models/SunnySky/sunny")
# skyBox.setScale(10)
# skyBox.reparentTo(render)
def animateItems(self, task):
if(not (self.__mainAgent.hasKey(self.room1Key) or self.__room1NPC.hasKey()) or self.room1KeyInHUD):
self.rotate(self.room1Key)
if(not self.__mainAgent.hasKey(self.room2Key) and not self.__room2NPC.hasKey() or self.room2KeyInHUD):
self.rotate(self.room2Key)
if(not self.__mainAgent.hasKey(self.room3Key) and not self.__room3NPC.hasKey() or self.room3KeyInHUD):
self.rotate(self.room3Key)
return Task.cont
hasAllKeys = False
playerWasKilledByNPC1 = False
playerWasKilledByNPC2 = False
playerWasKilledByNPC3 = False
#gameOver = False
fadeCounter = 200
def checkGameState(self, task, message = None):
goodEndingText = OnscreenText(text="", style=1, fg=(0,0,1,0.01),
pos=(0,.4), align=TextNode.ACenter, scale = .25, mayChange = True)
BaadEndingText = OnscreenText(text="", style=1, fg=(1,0,0,0.01),
pos=(0,.4), align=TextNode.ACenter, scale = .25, mayChange = True)
if(self.fadeCounter > 0):
if(self.__mainAgent.hasKey(self.room1Key) and self.__mainAgent.hasKey(self.room2Key) and self.__mainAgent.hasKey(self.room3Key)):
self.hasAllKeys = True
#goodEndingText.setText("You have all 3 keys!")
if(self.hasAllKeys):
goodEndingText.setText("You have all 3 keys!")
if(PathFinder.distance(self.__mainAgent, self.__room1NPC) < 5 and self.__room1NPC.getState() != "returnKey"):
if(not self.__mainAgent.hasKey(self.room1Key)):
self.playerWasKilledByNPC1 = True
if(self.playerWasKilledByNPC1):
self.fadeCounter = self.fadeCounter - 1
BaadEndingText.setText("Killed by Eve clone Alpha")
if(PathFinder.distance(self.__mainAgent, self.__room2NPC) < 5 and self.__room2NPC.getState() != "returnKey"):
if(not self.__mainAgent.hasKey(self.room2Key)):
self.playerWasKilledByNPC2 = True
if(self.playerWasKilledByNPC2):
self.fadeCounter = self.fadeCounter - 1
BaadEndingText.setText("Killed by Eve clone Beta")
if(PathFinder.distance(self.__mainAgent, self.__room3NPC) < 5 and self.__room3NPC.getState() != "returnKey"):
if(not self.__mainAgent.hasKey(self.room3Key)):
self.playerWasKilledByNPC3 = True
if(self.playerWasKilledByNPC3):
self.fadeCounter = self.fadeCounter - 1
BaadEndingText.setText("Killed by Eve clone Gamma")
return Task.cont
currentAngle = 0
def rotate(self, someItem):
if someItem != None:
self.currentAngle = self.currentAngle + 250 * taskTimer.elapsedTime
self.currentAngle %= 360
someItem.setH(self.currentAngle)
def __setupLevel(self):
"""
Some notes and caveats: Each time you add a room, make sure that you tag it with key "Room" and value "<room number>".
This is so our A* algorithm can do clear path detection on only the rooms, not anything else.
"""
level1 = render.attachNewNode("level 1 node path")
execfile("rooms/room1.py")
self.room1 = loader.loadModel("rooms/room1")
self.room1.findTexture("*").setMinfilter(Texture.FTLinearMipmapLinear)
self.room1.setScale(10)
self.room1.setTexScale(TextureStage.getDefault(), 10)
self.room1.reparentTo(render)
self.room1.find("**/Cube*;+h").setTag("Room", "1")
keyNest = loader.loadModel("models/nest")
keyNest.findTexture("*").setMinfilter(Texture.FTLinearMipmapLinear)
keyNest.setScale(0.5)
keyNest.setTexScale(TextureStage.getDefault(), 0.1)
#place keyNest (Like a birds nest, but for keys!)
self.keyNest1 = self.room1.attachNewNode("key nest 1")
keyNest.instanceTo(self.keyNest1)
self.keyNest1.setPos(0, 0, 0.05)
self.room1Key = loader.loadModel("models/redKey")
self.room1Key.findTexture("*").setMinfilter(Texture.FTLinearMipmapLinear)
self.room1Key.reparentTo(self.keyNest1)
self.room1Key.setScale(render, 10)
self.room1Key.setTexScale(TextureStage.getDefault(), 0.1)
#self.setWaypoints("room2")
self.room2waypoints = None
execfile("rooms/room2.py")
self.room2 = loader.loadModel("rooms/room2")
self.room2.findTexture("*").setMinfilter(Texture.FTLinearMipmapLinear)
self.room2.setScale(10)
self.room2.setTexScale(TextureStage.getDefault(), 10)
self.room2.reparentTo(level1)
self.room2.setY(self.room1, -20)
self.room2.find("**/Cube*;+h").setTag("Room", "2")
self.keyNest2 = self.room2.attachNewNode("key nest 2")
keyNest.instanceTo(self.keyNest2)
self.keyNest2.setPos(-2.5, -2.5, 0.05)
self.room2Key = loader.loadModel("models/blueKey")
self.room2Key.findTexture("*").setMinfilter(Texture.FTLinearMipmapLinear)
self.room2Key.reparentTo(self.keyNest2)
self.room2Key.setScale(render, 10)
self.room2Key.setTexScale(TextureStage.getDefault(), 0.1)
# Jim thinks there should be a comment here
# he also thinks that the above comment is very useful
# TODO: fix this hack by re-creating room3 in blender
execfile("rooms/room3.py")
room3Model = loader.loadModel("rooms/room3")
room3Model.findTexture("*").setMinfilter(Texture.FTLinearMipmapLinear)
room3Model.setH(90)
room3Model.setP(180)
room3Model.setZ(2)
self.room3 = level1.attachNewNode("room 3")
room3Model.reparentTo(self.room3)
self.room3.setScale(10)
self.room3.setTexScale(TextureStage.getDefault(), 10)
self.room3.reparentTo(level1)
self.room3.setX(self.room1, 20)
self.room3.find("**/Cube*;+h").setTag("Room", "3")
self.keyNest3 = self.room3.attachNewNode("room 3 keynest")
keyNest.instanceTo(self.keyNest3)
self.keyNest3.setPos(0, 0, 0.05)
self.room3Key = loader.loadModel("models/greenKey")
self.room3Key.findTexture("*").setMinfilter(Texture.FTLinearMipmapLinear)
self.room3Key.reparentTo(self.keyNest3)
self.room3Key.setScale(render, 10)
self.room3Key.setTexScale(TextureStage.getDefault(), 0.1)
room3SphereOfDoom = self.room3.attachNewNode(CollisionNode("Jim's Hair"))
room3SphereOfDoom.node().addSolid(CollisionSphere(3, -9, 0.5, 1.0))
room1Floor = self.room1.attachNewNode(CollisionNode("room1Floor"))
room1Floor.node().addSolid(CollisionPolygon(Point3(9,-9,0), Point3(9,9,0),
Point3(-9,9,0), Point3(-9,-9,0)))
room2Floor = self.room2.attachNewNode(CollisionNode("room2Floor"))
room2Floor.node().addSolid(CollisionPolygon(Point3(9,-9,0), Point3(9,9,0),
Point3(-9,9,0), Point3(-9,-9,0)))
room3Floor = self.room3.attachNewNode(CollisionNode("room3Floor"))
room3Floor.node().addSolid(CollisionPolygon(Point3(9,-9,0), Point3(9,9,0),
Point3(-9,9,0), Point3(-9,-9,0)))
gate = loader.loadModel("models/box")
gateTo2 = self.room1.attachNewNode("gateTo2")
gate.instanceTo(gateTo2)
gateTo2.setPos(8, -10, 0)
gateTo2.hide()
gateTo3 = self.room1.attachNewNode("gateTo3")
gate.instanceTo(gateTo3)
gateTo3.setPos(10, 8, 0)
gateTo3.hide()
self.physicsCollisionHandler.addInPattern("%fn-into-%in")
self.physicsCollisionHandler.addOutPattern("%fn-out-%in")
def orderNPC(parameters, entry):
if(parameters == "ralph has entered room 1"):
self.__room1NPC.handleTransition("playerEnteredRoom")
self.reComputeHUD(self.room1)
if self.__mainAgent.hasKey(self.room1Key):
self.__mainAgent.setCurrentKey(self.room1Key)
elif(parameters == "ralph has left room 1"):
self.__room1NPC.handleTransition("playerLeftRoom")
if self.__mainAgent.hasKey(self.room1Key):
self.__mainAgent.setCurrentKey(None)
elif(parameters == "ralph has entered room 2"):
self.__room2NPC.handleTransition("playerEnteredRoom")
self.reComputeHUD(self.room2)
if self.__mainAgent.hasKey(self.room2Key):
self.__mainAgent.setCurrentKey(self.room2Key)
elif(parameters == "ralph has left room 2"):
self.__room2NPC.handleTransition("playerLeftRoom")
if self.__mainAgent.hasKey(self.room2Key):
self.__mainAgent.setCurrentKey(None)
elif(parameters == "ralph has entered room 3"):
self.__room3NPC.handleTransition("playerEnteredRoom")
if self.__mainAgent.hasKey(self.room3Key):
self.__mainAgent.setCurrentKey(self.room3Key)
self.reComputeHUD(self.room3)
elif(parameters == "ralph has left room 3"):
self.__room3NPC.handleTransition("playerLeftRoom")
if self.__mainAgent.hasKey(self.room3Key):
self.__mainAgent.setCurrentKey(None)
elif(parameters == "NPC1 bumped into wall"):
self.__room1NPC.handleTransition("bumpedIntoWall")
elif(parameters == "NPC2 bumped into wall"):
self.__room2NPC.handleTransition("bumpedIntoWall")
elif(parameters == "NPC3 bumped into wall"):
self.__room3NPC.handleTransition("bumpedIntoWall")
self.accept("ralph collision node-into-room1Floor", orderNPC, ["ralph has entered room 1"])
self.accept("ralph collision node-out-room1Floor", orderNPC, ["ralph has left room 1"])
self.accept("ralph collision node-into-room2Floor", orderNPC, ["ralph has entered room 2"])
self.accept("ralph collision node-out-room2Floor", orderNPC, ["ralph has left room 2"])
self.accept("ralph collision node-into-room3Floor", orderNPC, ["ralph has entered room 3"])
self.accept("ralph collision node-out-room3Floor", orderNPC, ["ralph has left room 3"])
self.accept("Eve 1 collision node-into-Cube1", orderNPC, ["NPC1 bumped into wall"])
self.accept("Eve 2 collision node-into-Cube2", orderNPC, ["NPC2 bumped into wall"])
self.accept("Eve 3 collision node-into-Cube3", orderNPC, ["NPC3 bumped into wall"])
#messenger.toggleVerbose()
self.gate = gate
__globalAgentList = []
__mainAgent = None
def __setupMainAgent(self):
modelStanding = "models/ralph"
modelRunning = "models/ralph-run"
modelWalking = "models/ralph-walk"
self.__mainAgent = Player(modelStanding,
{"run":modelRunning, "walk":modelWalking},
turnRate = 150,
speed = 25,
agentList = self.__globalAgentList,
collisionMask = BitMask32.bit(1),
name="ralph",
massKg = 35.0,
collisionHandler = self.physicsCollisionHandler,
collisionTraverser = self.cTrav)
# Make it visible
self.__mainAgent.reparentTo(render)
self.__mainAgent.setPos(31, 35, 50)
self.gate.find("**/Cube;+h").setCollideMask(~self.__mainAgent.collisionMask)
__targetCount = 0
__targets = []
__agentToTargetMap = {}
def __setupNPCs(self):
# This is to support the collisions for each node. See the paragraph comment
# above where we modify the npc's collision node
playerCollisionNP = self.__mainAgent.find("* collision node")
modelStanding = "models/eve"
modelRunning = "models/eve-run"
modelWalking = "models/eve-walk"
self.__room1NPC = NPC(modelStanding,
{"run":modelRunning, "walk":modelWalking},
turnRate = 150,
speed = 15,
agentList = self.__globalAgentList,
name = "Eve 1",
collisionMask = BitMask32.bit(3),
rangeFinderCount = 13,
adjacencySensorThreshold = 5,
radarSlices = 5,
radarLength = 40,
scale = 1.0,
massKg = 35.0,
collisionHandler = self.physicsCollisionHandler,
collisionTraverser = self.cTrav,
waypoints = self.room1waypoints)
self.__room1NPC.setFluidPos(render, 0, 0, 10)
self.__room1NPC.setScale(render, 1)
self.__room1NPC.setPlayer(self.__mainAgent)
self.__room1NPC.reparentTo(render)
# So here's what I'm thinking. Currently, two collisions are happening when
# we collide with an NPC. Those are Player-->NPC and NPC-->Player. This is
# causing some jumpiness, which in tern causes some collisions to fail (e.g.,
# falling through the floor). In order to fix this, we need to ignore one of
# these collisions. Since the NPC should react to the Player, and not vice-versa,
# I'll ignore the Player-->NPC collision. To do this, we need to set Player's into
# collide mask to exclude NPC's from collide mask. Let's hope this doesn't break
# anything.
npcCollisionNP = self.__room1NPC.find("* collision node")
npcCollisionNP.node().setIntoCollideMask(npcCollisionNP.node().getIntoCollideMask() &
~playerCollisionNP.node().getIntoCollideMask())
## modelStanding = "models/bunny/bunny"
## modelRunning = "models/bunny/bunny"
## modelWalking = "models/bunny/bunny"
self.__room2NPC = NPC(modelStanding,
{"run":modelRunning, "walk":modelWalking},
turnRate = 150,
speed = 15,
agentList = self.__globalAgentList,
name = "Eve 2",#"das Osterhase",
collisionMask = BitMask32.bit(4),
rangeFinderCount = 13,
adjacencySensorThreshold = 5,
radarSlices = 5,
radarLength = 40,
scale = 1.0,
massKg = 35.0,
collisionHandler = self.physicsCollisionHandler,
collisionTraverser = self.cTrav,
waypoints = self.room2waypoints)
self.__room2NPC.setPos(-20, -210, 10)
self.__room2NPC.setPlayer(self.__mainAgent)
self.__room2NPC.reparentTo(render)
npcCollisionNP = self.__room2NPC.find("* collision node")
npcCollisionNP.node().setIntoCollideMask(npcCollisionNP.node().getIntoCollideMask() &
~playerCollisionNP.node().getIntoCollideMask())
self.__room3NPC = NPC(modelStanding,
{"run":modelRunning, "walk":modelWalking},
turnRate = 150,
speed = 15,
agentList = self.__globalAgentList,
name = "Eve 3",#"der Hoppelhaschen",
collisionMask = BitMask32.bit(5),
rangeFinderCount = 13,
adjacencySensorThreshold = 5,
radarSlices = 5,
radarLength = 40,
scale = 1.0,
massKg = 35.0,
collisionHandler = self.physicsCollisionHandler,
collisionTraverser = self.cTrav,
waypoints = self.room3waypoints)
self.__room3NPC.setPos(210, 0, 10)
self.__room3NPC.setPlayer(self.__mainAgent)
self.__room3NPC.reparentTo(render)
npcCollisionNP = self.__room3NPC.find("* collision node")
npcCollisionNP.node().setIntoCollideMask(npcCollisionNP.node().getIntoCollideMask() &
~playerCollisionNP.node().getIntoCollideMask())
def __setupRandomClutter(self):
## self.ball1 = loader.loadModel("models/ball")
## #self.ball1.findTexture("*").setMinfilter(Texture.FTLinearMipmapLinear)
## self.ball1.findTexture("hedge.jpg")
## self.ball1.setTexScale(TextureStage.getDefault(), 0.1)
## self.ball1.setPos(0,0,0)
## self.ball1.reparentTo(render)
pass
def __setupTasks(self):
"""
This function sets up all the tasks used in the world
"""
taskMgr.add(taskTimer, "taskTimer")
#for index, ralph in enumerate(self.__otherRalphs):
## taskMgr.add(ralph.sense, "sense" + str(index))
## taskMgr.add(ralph.think, "think" + str(index))
## taskMgr.add(ralph.act, "act" + str(index))
#taskMgr.add(ralph.wanderTask, "wander" + str(index))
## taskMgr.add(ralph.seekTask, "seekTask" + str(index), extraArgs = [self.__agentToTargetMap[ralph]], appendTask = True)
taskMgr.add(self.__printPositionAndHeading, "__printPositionAndHeading")
## listOfTargets = [(target.getX(), target.getY()) for target in self.__targets]
## agentList = [(ralph.getX(), ralph.getY()) for ralph in self.__otherRalphs]
## taskMgr.add(self.neatEvaluateTask, "self.neatEvaluateTask", extraArgs = [listOfTargets, self.__otherRalphs], appendTask = True)
self.__mainAgent.setKeymap()
taskMgr.add(self.__mainAgent.processKey, "processKeyTask")
# taskMgr.add(self.__mainAgent.handleCollisionTask, "handleCollisionTask")
## taskMgr.add(self.ralph.wanderTask, "wander")
taskMgr.add(self.__room1NPC.sense, "senseTask")
taskMgr.add(self.__room2NPC.sense, "senseTask")
taskMgr.add(self.__room3NPC.sense, "senseTask")
## taskMgr.add(self.ralph.think, "thinkTask")
taskMgr.add(self.__room1NPC.act, "actTask")
taskMgr.add(self.__room2NPC.act, "actTask")
taskMgr.add(self.__room3NPC.act, "actTask")
taskMgr.add(self.checkGameState, "gameStateTask")
taskMgr.add(self.animateItems, "animateItemsTask")
#taskMgr.add(self.processKey, "processKeyTask")
# This is for path finding
#taskMgr.add(self.__room1NPC.followPath, "followPathTask", extraArgs = [self.bestPath], appendTask = True)
def __setupCamera(self):
#This camera position shows the whole level
base.camera.setPos(100,-100, 795) #This is debug camera position.
base.camera.lookAt(100,-100,0)
#This camera position shows room1
#base.camera.setPos(0,0, 375) #This is debug camera position.
#base.camera.lookAt(0,0,0)
#This camera position shows room2
#base.camera.setPos(0,-200, 375) #This is debug camera position.
#base.camera.lookAt(0,-200,0)
#This camera position shows room3
#base.camera.setPos(200,0, 375) #This is debug camera position.
#base.camera.lookAt(200,0,0)
#base.oobeCull()
#base.oobe()
base.disableMouse()
base.camera.reparentTo(self.__mainAgent.actor)
base.camera.setPos(0, 60, 60)
base.camera.lookAt(self.__mainAgent)
base.camera.setP(base.camera.getP() + 10)
def cameraRoom1Pos(self):
base.camera.reparentTo(render)
#This camera position shows room1
base.camera.setPos(0,0, 375) #This is debug camera position.
base.camera.lookAt(0,0,0)
def cameraRoom2Pos(self):
base.camera.reparentTo(render)
#This camera position shows room2
base.camera.setPos(0,-200, 375) #This is debug camera position.
base.camera.lookAt(0,-200,0)
def cameraRoom3Pos(self):
base.camera.reparentTo(render)
#This camera position shows room3
base.camera.setPos(200,0, 375) #This is debug camera position.
base.camera.lookAt(200,0,0)
def cameraRegularPos(self):
base.camera.reparentTo(self.__mainAgent.actor)
base.camera.setPos(0, 60, 60)
base.camera.lookAt(self.__mainAgent)
base.camera.setP(base.camera.getP() + 10)
positionHeadingText = OnscreenText(text="", style=1, fg=(1,1,1,1),
pos=(-1.3,-0.95), align=TextNode.ALeft, scale = .05, mayChange = True)
def __printPositionAndHeading(self, task):
heading = self.__mainAgent.getH()
heading %= 360.0
## self.positionHeadingText.setText("Position: (" +
## str(self.__mainAgent.getX()) + ", " +
## str(self.__mainAgent.getY()) + ", " +
## str(self.__mainAgent.getZ()) + ") at heading " +
## str(heading))
## return Task.cont
# Every generation, throw out the old brains and put in the new ones. At
# this point we can start all over with new nodes.
generationCount = 0
generationLifetimeTicks = 500
neatEvaluateTaskCallCount = 0
## neuralNetwork = NeuralNetwork()
def neatEvaluateTask(self, listOfTargets, agentList, task):
self.neatEvaluateTaskCallCount += 1
if self.generationLifetimeTicks == self.neatEvaluateTaskCallCount:
self.neatEvaluateTaskCallCount = 0
oldBrains = [agent.brain for agent in agentList]
self.generationCount += 1
listOfPositions = [(agent.getX(), agent.getY()) for agent in agentList]
newBrains = self.neuralNetwork.nextGeneration(oldBrains, listOfTargets, listOfPositions)
for agent, brain in zip(agentList, newBrains):
agent.brain = brain
agent.setPos(self.startingPositions[agent])
return Task.cont
__keyMap = {"enablePathSmoothening":False,
"showWaypoints":False}
def setKeymap(self):
def toggleWaypoints(key):
self.showWaypoints = not self.showWaypoints
if(self.showWaypoints):
print("Showing waypoints")
for w in self.room1waypoints:
w.draw()
for w in self.room2waypoints:
w.draw()
for w in self.room3waypoints:
w.draw()
else:
print("Hiding waypoints")
for w in self.room1waypoints:
w.erase()
for w in self.room2waypoints:
w.erase()
for w in self.room3waypoints:
w.erase()
def togglePathSmoothening(key):
self.__room1NPC.togglePathSmoothening()
self.__room2NPC.togglePathSmoothening()
self.__room3NPC.togglePathSmoothening()
def toggleCollisions(key):
if(self.showCollisions):
base.cTrav.showCollisions(render)
else:
base.cTrav.hideCollisions()
self.showCollisions = not self.showCollisions
print("showCollisions = " + str(self.showCollisions))
self.accept("p", togglePathSmoothening, ["togglePathSmoothening"])
self.accept("w", toggleWaypoints, ["toggleWaypoints"])
self.accept("c", toggleCollisions, ["toggleCollisions"])
self.accept("1", self.cameraRoom1Pos)
self.accept("2", self.cameraRoom2Pos)
self.accept("3", self.cameraRoom3Pos)
self.accept("4", self.cameraRegularPos)
