def create_world():
global character, floor, bullets, mushs, semiboses, time, skills, semi_sound, items,background
# 캐릭터
character = Character()
character.life = temp.character_life
character.skill = temp.character_skill
#배경
floor = Floor()
background = Background(1024,600)
#준보스
semiboses.append(Semi())
for semiboss in semiboses:
semiboss.set_floor(floor)
# 스크롤링
floor.set_center_object(character)
character.set_floor(floor)
# 몬스터
mushs = create_mush();
for mush in mushs:
mush.set_floor(floor)
#총알
bullets = list()
#스킬
skills = list()
#시간
time = Time()
#사운드
semi_sound = load_music("Resource/Sound/stage_2.mp3")
semi_sound.set_volume(48)
semi_sound.repeat_play()
# item
items.append(Item())
for item in items:
item.set_floor(floor)
def create_world():
global character, floor, bullets, semiboses, time, skills, semi_sound
# 캐릭터
character = Character()
character.life = temp.character_life
character.skill = temp.character_skill
#배경
floor = Floor()
#준보스
semiboses.append(Final())
for semiboss in semiboses:
semiboss.set_floor(floor)
# 스크롤링
floor.set_center_object(character)
character.set_floor(floor)
#총알
bullets = list()
#스킬
skills = list()
#시간
time = Time()
#사운드
semi_sound = load_music("Resource/Sound/semi_stage.mp3")
semi_sound.set_volume(64)
semi_sound.repeat_play()
def create(self):
name = string.join(self.name, '')
character = Character(None, None)
character.create(self.engine.family.name, name, self.job.name,
self.distAreas, self.distPoints, sprite = self.sprites[self.selectedSprite])
self.engine.family.refresh()
self.engine.viewport.changeScene("Maplist")
def update(self, camera, delta, platforms):
attackRand = R.randint(0,100)
if (attackRand > 92 and self.attackReady==1 and self.grounded==1):
self.isAttacking = 1
if self.health == 0:
self.dead = True
self.deathSound.play(0,0,0)
Character.update(self, camera, delta, platforms)
self.chooseState()
def create_world():
global character, floor, background, bullets , yangs
character = Character(95)
yangs = create_sheep();
floor = Floor()
background = Background(1024,600)
floor.set_center_object(character)
character.set_floor(floor)
for yang in yangs:
yang.set_floor(floor)
bullets = list()
def testCanDecrement(self):
character = Character()
# default of 8 cannot be decremented
self.assertFalse(character.canDecrement(1))
# decrementing gains 2 points for values between 14 and 16 up to a max of 27 points
character.points = 25
for i in range(14, 16):
character.setStat(1, i)
self.assertTrue(character.canDecrement(1))
# decrementing gains 1 point for values between 9 and 13 up to a max of 27 points
character.points = 26
for i in range(9, 13):
character.setStat(1, i)
self.assertTrue(character.canDecrement(1))
def testDecrement(self):
character = Character()
for i in range(0, 5):
for j in range(14, 15):
character.stats[i] = j
character.points = 0
character.Decrement(i)
self.assertEqual(2, character.points)
self.assertEqual((j - 1), character.stats[i])
for j in range(9, 13):
character.stats[i] = j
character.points = 0
character.Decrement(i)
self.assertEqual(1, character.points)
self.assertEqual((j - 1), character.stats[i])
def Populate(self):
with self.conn:
cur = self.conn.cursor()
cur.execute("SELECT * FROM Characters")
rows = cur.fetchall()
i = 1
for row in rows:
self.character = Character(row[0], row[1], row[2], row[3], row[4], row[5], row[6])
self.character.id = i
cur.execute("SELECT * FROM PlayerInventory WHERE PlayerID="+str(self.character.id))
inventory = cur.fetchall()
for item in inventory:
cur.execute("SELECT * FROM Item WHERE ItemID="+str(item[1]))
tempItem = cur.fetchall()
itemName = tempItem[0][0]
self.character.addItem(itemName, item[2])
daemon.register(self.character)
self.Characters.append(self.character)
i = i+1
cur.execute("SELECT * FROM Enemy")
rows = cur.fetchall()
for row in rows:
self.enemy = Character(row[0], row[1], 0, row[2], row[3], row[4], row[5])
daemon.register(self.enemy)
self.Enemies.append(self.enemy)
def __init__(self):
self.window = pyglet.window.Window(640, 320)
self.window.set_caption("Pedometer")
self.window.set_icon(pyglet.image.load("../res/graphics/icons/020-Accessory05.png"))
self.window.on_key_press = self.keyDown
self.window.on_key_release = self.keyUp
self.window.on_draw = self.render
self.fps = pyglet.clock.ClockDisplay()
self.map = Map()
pygame.init()
pygame.mixer.music.load("../res/audio/music/001-Battle01.mid")
pygame.mixer.music.play(-1, 0.0)
self.background = pyglet.image.load("../res/graphics/battlebacks/001-Grassland01.jpg")
self.character = Character(self, 0, 0)
self.steps = 0
self.label = pyglet.text.Label("Steps: 0", font_name = "Helvetica", font_size = 12, x = 10, y = self.window.height - 10, anchor_x = "left", anchor_y = "top", bold = True)
pyglet.gl.glEnable(pyglet.gl.GL_BLEND)
pyglet.gl.glBlendFunc(pyglet.gl.GL_SRC_ALPHA, pyglet.gl.GL_ONE_MINUS_SRC_ALPHA)
pyglet.clock.schedule_interval(self.update, 0.1 / 32)
pyglet.app.run()
def addCharacter(self,characterID,focus=False):
temp = Character.character(self,*self.charList.getList()[characterID])
if focus == True:
self.over.obj = temp
self.charList.setStats(temp,characterID)
self.entities.append(temp)
return temp
def testIncrement(self):
character = Character()
for i in range(0, 5):
for j in range(13, 14):
character.stats[i] = j
character.points = 27
character.Increment(i)
self.assertEqual(25, character.points)
self.assertEqual((j + 1), character.stats[i])
self.assertEqual(((j + 1) - 10)/2, character.modifiers[i])
for j in range(8, 12):
character.stats[i] = j
character.points = 27
character.Increment(i)
self.assertEqual(26, character.points)
self.assertEqual((j + 1), character.stats[i])
self.assertEqual(((j + 1) - 10)/2, character.modifiers[i])
def draw(self, screen, camera, time):
Character.draw(self, screen, camera, time)
if camera.xScrolling == 'right':
temp = (camera.rightBorder - self.image.get_width(), camera.edwardScreen[1])
elif camera.xScrolling == 'left':
temp = (camera.leftBorder, camera.edwardScreen[1])
else:
temp = camera.edwardScreen
if camera.yScrolling == 'down':
temp = (temp[0], camera.bottomBorder - self.image.get_height())
elif camera.yScrolling == 'up':
temp = (temp[0], camera.topBorder)
if self.sparkleCloud > 0:
self.sparkleEnemies(camera)
temp1 = (temp[0] - 80, temp[1] - 50)
Globals.Screen.blit(self.sparkleCloudImage, temp1)
Globals.Screen.blit(self.image, temp)
def update(self, camera, delta, platforms):
jumpRand = R.randint(0,100)
#if jumpRand == 3 and self.grounded == 1:
# self.v = (self.v[0],-370)
#if self.rect.topleft[0] + self.image.get_width() >= camera.p[0]+ Globals.xRes - 1:
# self.leftkey = 1
# self.rightkey = 0
# self.direction = 'left'
#elif self.rect.topleft[0] <= camera.p[0]:
# self.rightkey = 1
# self.leftkey = 0
# self.direction = 'right'
if self.health == 0:
self.dead = True
self.deathSound.play(0,0,0)
self.chooseState()
Character.update(self, camera, delta, platforms)
def create_world():
global character, floor, background, bullets , yangs , items, skills,bgm_sound
character = Character()
yangs = create_sheep();
floor = Floor()
items.append(Item())
for item in items:
item.set_floor(floor)
background = Background(1024,600)
floor.set_center_object(character)
character.set_floor(floor)
for yang in yangs:
yang.set_floor(floor)
bullets = list()
skills = list()
if bgm_sound == None:
bgm_sound = load_music("Resource/Sound/stage_1.mp3")
bgm_sound.set_volume(64)
bgm_sound.repeat_play()
class Game (object):
def __init__ (self):
# Config
self.tps_max = 100.0
# Inicialization
pygame.init()
self.screen = pygame.display.set_mode((1280,720))
self.tps_clock = pygame.time.Clock()
self.tps_delta = 0.0
self.player = Character(self)
while True:
#Handle events
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
sys.exit(0)
# Ticking:
self.tps_delta += self.tps_clock.tick()/1000.0 # w sekundach
while self.tps_delta > 1/self.tps_max: # to w srodku wykonuje sie gdy minie 1/max_tps
self.tps_delta -= 1/self.tps_max
self.tick() #wywolanie tej funkcji nizej
# Drawing:
self.screen.fill((0,0,0))
self.draw()
pygame.display.flip()
def tick(self):
self.player,tick():
# Checking inputs:
keys = pygame.key.get_pressed()
def draw(self):
self.player.draw()
def main():
pygame.init()
screen = pygame.display.set_mode(SIZE)
my_sprite = Character()
my_group = pygame.sprite.Group(my_sprite)
clock = pygame.time.Clock()
done = False
while not done:
# --- Main event loop
for event in pygame.event.get():
if event.type == pygame.QUIT:
done = True
keys = pygame.key.get_pressed()
if keys[pygame.K_RIGHT]:
print("MOVE RIGHT ......", my_sprite.x)
my_sprite.move_right()
if keys[pygame.K_LEFT]:
print("MOVE RIGHT ......", my_sprite.x)
my_sprite.move_left()
if keys[pygame.K_UP]:
print("MOVE UP ......", my_sprite.x)
my_sprite.move_up()
if keys[pygame.K_DOWN]:
print("MOVE DOWN ......", my_sprite.x)
my_sprite.move_down()
# When the keys are released ... my_sprite.stop()
my_group.update()
screen.fill(BACKGROUND_COLOR)
my_group.draw(screen)
pygame.display.update()
# --- Limit to 60 frames per second
clock.tick(60)
# Close the window and quit.
pygame.quit()
def evil_monster_attack_me(player_character: Character, enemy_monster: Monster) -> None:
"""
Monster attack back user
Param:player_character, Character
enemy_monster, Monster
PRECONDITON: User attacked monster and monster is still alive
POST CONDITION: Fight goes until one side die.
RETURN : NONE
"""
mon_attack = roll_a_die(1, 4)
print("EVEIL MONSTER HP:", enemy_monster.get_hp(), "\n", enemy_monster.get_name(),
":HAHA, NICE TRY. It's MY turn hahahahhahahh", "\nEVIL MONSTER: ICE ARROW!!!!!!!!!!")
hp = player_character.get_hp()
new_hp = hp - int(mon_attack)
player_character.set_hp(new_hp)
print(enemy_monster.name, "DAMAGE:", mon_attack)
if player_character.hp > 0:
print("It's MY TURN. ARE YOU READY?")
def loadSprites(self, spritelist):
#print "loading sprites"
if(len(self._sprites) > 0):
tmp = self._sprites[0]
self._sprites = []
self._sprites.append(tmp)
for sprite in spritelist:
img = self.images.get(sprite[2])
image = self.getImage(img)
if sprite[1] == npc:
log.debug(sprite[3])
s = Character(self.evtmngr, "NPC", (sprite[0][0], sprite[0][1]),
img, self, self.gtk, self._encounters[sprite[3]])
elif sprite[1] == door:
s = Door(self.evtmngr, "Door", sprite[0], img, self, self.gtk)
s.setDoorData(sprite[3])
else:
s = TileSprite(self.evtmngr, img, self, sprite[0][0], sprite[0][1], self.gtk)
# if len(sprite) == 4:
# s.setDoorData(sprite[3])
self._sprites.append(s)
def cha_map(player_character: Character) -> None:
"""
Draw a map on a console
PARAM: player_character, Character
PRE CONDITION: None
POST CONDITION: User can view their current location
RETURN: None
"""
x_coord = player_character.get_x()
y_coord = player_character.get_y()
print("\n\n\n\nMAP \nMy Mission: What is ", player_character.get_mission(), "\n\n\n\n")
for row in range(3):
for column in range(3):
if row == x_coord and column == y_coord:
print('[', "#", ']' "\t", end=" ")
else:
print('[ ', ' ]'"\t", end=" ")
print("\n")
print("# --> Your current location")
def CompleteQuest(id, npc, tp=False):
flag = False
if Field.FindNpc(npc).valid and tp:
if Terminal.GetCheckBox("Kami Vac"):
flag = True
CheckBox("Kami Vac", False)
time.sleep(1)
Character.Teleport(npc.x, npc.y - 10)
print("Completing quest " + str(id))
Quest.CompleteQuest(id, npc)
time.sleep(1)
def next_move(player_character: Character) -> int:
"""
Get a next_move possible events for Character
PARAM: player_character, Character
PRECONDITON: User must have type E,W,S,N to move one direction to another direction.
POST CONDITION: Depends on random die roll, user encounters monster, find information of missions
or hp increase by 1
RETURNS: Returns random integer
"""
die_roll = roll_a_die(1, 10)
if die_roll == 1:
monster_appear_user_choice(player_character)
return die_roll
elif die_roll == 2:
if player_character.get_mission_01() == 0:
korean_translator(player_character)
elif player_character.get_mission_01() == 1:
korean_translator_secondword(player_character)
return die_roll
else:
if player_character.get_hp() < 10:
player_character.increment()
print("My new HP:", player_character.get_hp())
def generate_character() -> Character:
"""
Generate new character for new user.
PARAM: None
PRE CONDITION: User must not have a character.
POST CONDITION: Returns well formed character
RETURN: Returns character that contains character information
"""
name = get_user_input("What is your name?")
print("Hello " + name + "!\nLet's start! Hope you are ready!")
player_character = Character.Character(name, 0, 0)
return player_character
def getNewPlayer(x, y, master_name, image = '../characters/sprites/ordan.png'):
if (x > Person.CONST_MAX_WH / 4 or y > Person.CONST_MAX_WH / 4):
return None
p = Character.Player((x, y), master_name, image)
p.setId(len(Person.person_list))
if (Walls.Walls.pushPerson(x, y, p)):
Person.person_list.append(p)
return p
return None
def getNewBot(x, y, image):
if (x > Person.CONST_MAX_WH / 4 or y > Person.CONST_MAX_WH / 4):
return None
p = Character.Bot((x, y), image=image)
p.setId(len(Person.person_list))
if (Walls.Walls.pushPerson(x, y, p)):
Person.person_list.append(p)
return p
return None
def slime_generator():
"""
Generates a random number of slime enemies
Returns:
enemy_list: a list of enemy slimes
"""
enemy_list = []
n_slimes = random.randint(1, 4)
for n in range(n_slimes):
slime = Character.Enemy("Slime {}".format(n + 1), 5, "weak")
enemy_list.append(slime)
return enemy_list
def startNewLevel(num):
'''
Loads level file based on number passed, returns level, player and enemies
returns the new level, player, enemy list, and boss (None if no boss in level)
- num, level number which is passed to the level initialization method
'''
level = Level(num)
x, y = level.playerStartPosit
player = Character.PlayerCharacter(level, x, y)
enemies = []
if level.bossLevel:
x, y = level.bossStartPosit
boss = Character.Boss(level, x, y)
else:
boss = None
for i in range(level.numEnemies):
x, y = level.enemyStartPosit[i]
enemies.append(Character.Enemy(level, x, y))
return (level, player, enemies, boss)
def delete_character(self, character: Character):
# Delete character in player's inventory
if character.side == Character.Side.GOOD:
self.player_fellowship.characters.remove(character)
else:
self.player_sauron.characters.remove(character)
# Delete character in region in map.
character_region = self.map.region_with_character(character)
if character_region:
character_region.characters.remove(character)
# Delete region in character
character.region = None
self.form.msg(character.name + " has been slain. ")
def __init__(self):
SceneBase.__init__(self)
self.characters = []
self.characters.append(Character())
self.characters.append(Character())
self.characters.append(Character())
self.enemies = []
self.enemies.append(Character())
self.enemies.append(Character())
self.enemies.append(Character())
self.enemies.append(Character())
self.menu = BattleMenu(self.characters, self.enemies)
def FindInner(op1, op1scale, op2, op2scale, op3, op3scale):
if (op1 == innerid and op1scale == 40) or \
(op2 == innerid and op2scale == 40) or \
(op3 == innerid and op3scale == 40):
print("Found it")
Terminal.SetProperty(Character.GetName() + str(innerid), True)
return True
elif (op1 == innerid and op1scale == 20) or \
(op2 == innerid and op2scale == 20) or \
(op3 == innerid and op3scale == 20):
print("Found 15% inner ability")
return True
else:
return False
def createSampleTeamOne():
roster = []
centurion_character = Character.Character()
centurion_profession = Centurion.Centurion()
centurion_profession.apply(centurion_character)
centurion_character.equipped_shield = Buckler.Buckler()
centurion_character.equipped_armor = HideArmor.HideArmor()
iron_skinned = IronSkinned.IronSkinned()
centurion_character.addPassive(iron_skinned)
heroic_fortitude = HeroicFortitude.HeroicFortitude()
centurion_character.addPassive(heroic_fortitude)
roster.append(centurion_character)
team = Team(roster)
return team
def setAttack(bool):
if Character.GetJob() == 4212: # kanna settings
Terminal.SetCheckBox("MonkeySpiritsNDcheck", bool)
Terminal.SetCheckBox("bot/kanna_kami", bool)
Terminal.SetCheckBox("Summon Kishin", bool)
Terminal.SetCheckBox("bot/kishin_fma", bool)
Terminal.SetCheckBox("Grenade Kami", bool)
else:
if kami == 1 and Terminal.GetCheckBox("Kami Vac") != bool:
Terminal.SetCheckBox("Kami Vac", bool)
if auto == 1 and Terminal.GetCheckBox("Auto Attack") != bool:
Terminal.SetCheckBox("Auto Attack", bool)
elif auto == 0 and Terminal.GetCheckBox("Skill Injection") != bool:
Terminal.SetCheckBox("Skill Injection", bool)
def combine(a, b):
xMax = max(a.xPos + a.width, b.xPos + b.width)
xMin = min(a.xPos, b.xPos)
yMax = max(a.yPos + a.height, b.yPos + b.height)
yMin = min(a.yPos, b.yPos)
char = np.ones((yMax - yMin, xMax - xMin), dtype=np.uint8) * 255
char[a.yPos - yMin:a.yPos + a.height - yMin,
a.xPos - xMin:a.xPos + a.width - xMin] = a.image
char[b.yPos - yMin:b.yPos + b.height - yMin,
b.xPos - xMin:b.xPos + b.width - xMin] = b.image
return Character.Character(char, xMin, yMin, xMax - xMin, yMax - yMin)
def AssignHyperStats():
hyperStats = [
(80000400, 15), (80000401, 15), (80000402, 15), (80000403, 15),
(80000404, 15), (80000405, 15), (80000406, 10), (80000409, 15),
(80000410, 15), (80000412, 15), (80000413, 15), (80000414, 15),
(80000419, 15), (80000420, 15), (80000421, 15)
]
for hyperStat in hyperStats:
if Character.GetSkillLevel(hyperStat[0]) < hyperStat[1]:
hyperStatPacket = Packet.COutPacket(0x0150)
hyperStatPacket.EncodeBuffer("** ** ** ** {} FFFFFFFA".format(
hex(hyperStat[0])[2:].zfill(8)))
Packet.SendPacket(hyperStatPacket)
print("Assigning a skill point to {}".format(hyperStat[0]))
def playing_group(self, name):
"""
Erstellt aus den ausgewählten Gruppennamen die Charakter-Objekte sowie das Objekt für die Heldengruppe und
speichert diese unter der Klassenvariable für die spielende Gruppe.
:param name: Der Name der ausgewählten Gruppe.
"""
chr_list, exp, lvl = self.find_group_members(name)
hero_group = []
for items in range(0, len(chr_list)): # Wird so oft wiederholt wie es Charaktere in der gewünschten Gruppe gibt. Ermöglicht das Spielen mit weniger als 4 Charakteren.
weapon = self.find_weapon(chr_list[items][6])
character = Character.Character(chr_list[items][0], int(chr_list[items][1]), int(chr_list[items][2]),
int(chr_list[items][3]),int(chr_list[items][4]), int(chr_list[items][5]), weapon)
hero_group.append(character)
self.__current_group = CharacterGroup.CharacterGroup(name, int(exp), int(lvl), hero_group) # Erfahrung und Level werden mit den in der Datei gespeicherten Werten übergeben.
def withdraw_mesos():
if Field.GetID() ==101000000: #wait till character gets to ellinia
#1032006
time.sleep(2)
Packet.BlockRecvHeader(PACKET_HEADERS.block_header)
print("Current Mesos before withdraw = {}".format(Character.GetMeso()))
Character.TalkToNpc(1032006)
time.sleep(3)
oPacket = Packet.COutPacket(PACKET_HEADERS.store_header)
oPacket.EncodeBuffer("07 00000006FC23ABFF")
Packet.SendPacket(oPacket)
oPacket1 = Packet.COutPacket(PACKET_HEADERS.store_header)
oPacket1.Encode2(8)
#oPacket2.EncodeBuffer("08")
Packet.SendPacket(oPacket1)
time.sleep(1)
print("Current Mesos after withdraw = {}".format(Character.GetMeso()))
time.sleep(1)
Packet.UnBlockRecvHeader(PACKET_HEADERS.block_header)
else:
Terminal.Rush(101000000)
time.sleep(3)
def __init__(self):
self.window = pyglet.window.Window(640, 320)
self.window.set_caption("Pedometer")
self.window.set_icon(
pyglet.image.load("../res/graphics/icons/020-Accessory05.png"))
self.window.on_key_press = self.keyDown
self.window.on_key_release = self.keyUp
self.window.on_draw = self.render
self.fps = pyglet.clock.ClockDisplay()
self.map = Map()
pygame.init()
pygame.mixer.music.load("../res/audio/music/001-Battle01.mid")
pygame.mixer.music.play(-1, 0.0)
self.background = pyglet.image.load(
"../res/graphics/battlebacks/001-Grassland01.jpg")
self.character = Character(self, 0, 0)
self.steps = 0
self.label = pyglet.text.Label("Steps: 0",
font_name="Helvetica",
font_size=12,
x=10,
y=self.window.height - 10,
anchor_x="left",
anchor_y="top",
bold=True)
pyglet.gl.glEnable(pyglet.gl.GL_BLEND)
pyglet.gl.glBlendFunc(pyglet.gl.GL_SRC_ALPHA,
pyglet.gl.GL_ONE_MINUS_SRC_ALPHA)
pyglet.clock.schedule_interval(self.update, 0.1 / 32)
pyglet.app.run()
def enter():
global stage, character, background, running, hurdle, hurdle2, jelly, hp, jellysound, hpjellysound, font, score
background = Background2()
stage = Stage2()
character = Character()
hurdle = Hurdle2().create()
hurdle2 = Hurdle22().create()
jelly = Jelly2().create()
hp = Hp2().create()
jellysound = Jelly()
hpjellysound = Hp()
score = Score()
font = load_font('sprite\\ENCR10B.TTF')
running = True
def copyJointPose(rtg_S, rtg_T, s, t, offsets=None):
'''
Inputs: Source Skeleton, Target Skeleton, Source Joint Name, Target Joint Name
Optional Input: current joint channels to pose from
Returns: Updated Joint Channels
We seek a rotation, R, such that G_t R b_t = G_s b_s where G is the global matrix of a joint and b the child bone
As such R is the rotation from b_t to G_t.T G_s b_s. Calculate using the cross product method.
setChannelsFromMatrix starts by doing L.T M where L is the local matrix of the joint and M the given matrix so
we pre-multiply by L_t to offset this.
'''
jS = rtg_S['jointIndex'][s]
jT = rtg_T['jointIndex'][t]
if offsets is None:
offsets = np.zeros(rtg_T['numChans'], dtype=np.float32)
Character.pose_skeleton(rtg_S['Gs'], rtg_S,
np.zeros(rtg_S.numChans, dtype=np.float32))
Character.pose_skeleton(rtg_T['Gs'], rtg_T, offsets)
Gs = rtg_S['Gs'][jS]
Gt = rtg_T['Gs'][jT]
Lt = rtg_T['Ls'][jT]
bS = findChildBone(rtg_S, jS)
bT = findChildBone(rtg_T, jT)
print("Source: {} Target: {}".format(bS, bT))
if bS is None or bT is None: return offsets
bS = np.dot(Gt[:, :3].T, np.dot(Gs[:, :3], bS))
R = np.eye(3, 4, dtype=np.float32)
r = rotateBetweenVectors(bT, bS)
R[:, :3] = np.dot(Lt[:, :3], r)
setChannelsFromMatrix(R, rtg_T, jT)
where = np.where(rtg_T.chanValues != 0)[0]
offsets[where] = rtg_T.chanValues[where]
return offsets
def GotoHorntail():
ToggleKami(False)
ToggleHyperTeleportRock(True)
print("Going to Horntail")
if Field.GetID() != CaveOfLifeEntrance:
if Field.GetID() != PeakOfTheBigNest:
Terminal.Rush(PeakOfTheBigNest)
else:
ToggleHyperTeleportRock(False)
time.sleep(0.5)
Terminal.Rush(CaveOfLifeEntrance)
else:
Party.CreateParty()
Npc.ClearSelection()
Character.TalkToNpc(2083000)
def __init__(self):
ShowBase.__init__(self)
addInstructions(0.95, 'Text ')
self.world = World.World()
self.mainCharakter = Character.Character(self.world.odeWorld,
self.world.space)
self.world.addToObjects(self.mainCharakter)
#self.eventHandler = EventHandler.EventHandler()
self.makeSomeTea()
taskMgr.add(self.worldTasksBeforCharacter, 'worldTask01')
taskMgr.add(self.charakterTasks, 'charakterTask02')
taskMgr.add(self.worldTasktsAfterCharacter, 'worldTask02')
self.accept("escape", sys.exit)
def dungeonSelector():
charLvl = Character.GetLevel()
if charLvl in range(115, 125):
return (leopard_portal, mossy_tree_forest)
elif charLvl in range(125, 135):
return (leopard_portal, secret_pirate)
elif charLvl in range(135, 144):
return (leopard_portal, other_world)
elif charLvl in range(145, 155):
return (leopard_portal, forbidden_time)
elif charLvl in range(155, 160):
return (leopard_portal, clandestine_ruins)
elif charLvl in range(160, 250):
return (tiger_portal, ruined_city)
def store_mesos():
while True:
if Field.GetID() == storage_map_id:
print("Current Mesos before store = {}".format(Character.GetMeso()))
Packet.BlockRecvHeader(PACKET_HEADERS.block_header)
Character.Teleport(2268,17)
time.sleep(1)
Character.TalkToNpc(storage_npc_id)
time.sleep(1)
oPacket = Packet.COutPacket(PACKET_HEADERS.store_header)
oPacket.EncodeBuffer("07 FFFFFFF903DC5401")
Packet.SendPacket(oPacket)
oPacket1 = Packet.COutPacket(PACKET_HEADERS.store_header)
oPacket1.Encode2(8)
Packet.SendPacket(oPacket1)
print("Completed meso storing")
time.sleep(1)
print("Current Mesos after store = {}".format(Character.GetMeso()))
Packet.UnBlockRecvHeader(PACKET_HEADERS.block_header)
break
else:
Terminal.Rush(storage_map_id)
print("Still rushing to storage")
time.sleep(2)
def RushCheck(ID):
if (ID == 450007210 or ID == 450007230) and Field.GetID() < 450007200:
Terminal.Rush(450007030)
while Terminal.IsRushing():
time.sleep(1)
Terminal.Rush(450007040)
while Terminal.IsRushing():
time.sleep(1)
while Field.GetID() != 450007200:
Character.TalkToNpc(3003533)
time.sleep(3)
if Field.GetID() != ID:
Terminal.Rush(ID)
while Terminal.IsRushing():
time.sleep(1)
def health_check(self, player_stat, opponent):
player = player_stat
if player["health"] <= 0:
prompt = "You have died"
temp_list = [True, prompt]
return temp_list
elif opponent["health"] <= 0:
build = Character.Attributes(player_stat["base attributes"])
player["exp"] += opponent["exp"]
prompt1 = "You have killed your opponent\nYou gain " + str(opponent["exp"]) + " experiance."
player_update = build.levelup(player)
temp_list = [False, player_update[0], prompt1, player_update[1]]
return temp_list
else:
return
def loop():
status = draw()
done = False
run_game = False
reset = True
while done == False:
if reset:
comm.sendAnything("AllOff")
clock = pygame.time.Clock()
Player = Character.Character(comm)
reset = False
if run_game:
time = pygame.time.get_ticks()
for event in pygame.event.get(): # User did something.
if event.type == pygame.QUIT: # If user clicked close.
done = True # Flag that we are done so we exit this loop.
elif event.type == pygame.JOYBUTTONDOWN:
print("Joystick button pressed.")
elif event.type == pygame.JOYBUTTONUP:
print("Joystick button released.")
joystick = pygame.joystick.Joystick(0)
joystick.init()
axis0 = joystick.get_axis(0)
axis1 = joystick.get_axis(1)
Player.updatePosition(axis0, axis1)
spawner.randomSpawn(time)
if (Player.HasWon == 1):
print("Won")
comm.sendAnything("Murica")
time.sleep(2)
done = True
if (Player.HasLos == 1):
comm.sendAnything("RED")
time.sleep(2)
done = True
status = draw()
# start
if (status == 1):
run_game = True
elif (status == 2):
reset = True
clock.tick(5)
def __init__(self, screen, inClock):
#Window variables
self.screen = screen
self.resolutionX = screen.get_width()
self.resolutionY = screen.get_height()
self.clock = inClock
self.marginHUD = 100
#Game variables
self.cellSizeX = 16
self.cellSizeY = 16
self.xCells = int(self.resolutionX / self.cellSizeX)
self.yCells = int(self.resolutionY / self.cellSizeY - self.marginHUD / self.cellSizeY)
self.cellSizeDivisor = 2
self.cellUpdate = 4
self.deadCells = 0
self.aliveCells = 0
self.infectedCells = 0
self.cellSet = [[Cell]*self.yCells for x in range(self.xCells)]
self.dirtyCells = []
self.updateTime = 0
self.updateNumber = 0
self.cellDeathLimit = 35
self.gameState = gameState.MENU_STATE
self.player = Character("finalizedmasterchiefsprite.gif", 100, 100, 288, 288, 4, 4, 10, 10)
self.level = 1
self.menuList = []
self.enemyList = []
#bool variables
self.playerAlive = True
self.enemyAlive = True
self.enemyAI = True
self.bMusic = True
self.bTimer = False
self.setUpGame = False
self.crosInput = False
##music variables
pygame.mixer.stop()
pygame.mixer.init(44100, -16, 2, 2048)
self.soundMaster = GameSound()
##keyboard variables
self.keyboard = pygame.key.get_pressed()
self.key1 = pygame.K_1
self.key2 = pygame.K_2
self.makeColorArray()
self.setUpMouse()
self.startMenu()
def load_characters_kaggle_format(file_name, test_train, load_range = 'default'): file_contents = np.genfromtxt(file_name, delimiter = ',') if(load_range == 'default'): load_range = (0, file_contents.shape[0] - 1) if(load_range[0] < 0): load_range[0] = 0 if(load_range[1] > file_contents.shape[0] - 1): load_range[1] = file_contents.shape[0] - 1 character_list = np.zeros((load_range[1] - load_range[0],), dtype = ch.character) for i in range(load_range[0], load_range[1]): char = ch.character(file_contents[i+1,:], test_train) character_list[i-load_range[0]] = char return character_list
def render(self):
self.back.draw()
character = self.character
width = self.back.scale[0]
height = self.back.scale[1]
y = self.position
#name
self.engine.drawText(self.font, character.name, position = (10, y), alignment = "left")
#level
self.engine.drawText(self.font, "Level: %i" % (character.level), position = (self.engine.w/4, y), alignment = "left")
#hp
self.engine.drawText(self.font, "HP: %i" % character.hp, position = (self.engine.w/2, y), alignment = "left")
#exp
for bar in self.bars:
bar.draw()
self.engine.drawText(self.font, "EXP: %i/%i" % (character.exp, Character._expCalc(character.level)),
position = (self.engine.w - 10, y), alignment = "right")
def testtwoguysshooting():
print '------------------ Testing two guys shooting at each other ---------------------'
mngr = EventManager()
#Meet Joe and Bob
bob = Character(mngr, 'Bob', (0,0), None, None, None)
joe = Character(mngr, 'Joe', (0,0), None, None, None)
#joe.adjustSkill('attack', 100) #Joe is now quite dangerous
#Lets give them both guns
bobgun = Gun(mngr)
joegun = Gun(mngr)
bobgun.name = 'Shotgun'
#bobgun.updateData(pistol)
joegun.updateData(ak47)
bob.pickup(bobgun)
joe.pickup(joegun)
bob.equipWeapon(bobgun)
joe.equipWeapon(joegun)
#Let the shooting begin!
joe.attack(bob)
bob.attack(joe)
joe.reload()
joeammo = Ammo(mngr)
joe.pickup(joeammo)
joe.reload()
# joe.reloadWeapon(joeammo)
joe.attack(bob)
class Roster(object):
def __init__(self):
self.contents = []
self.Characters = []
self.Enemies = []
self.isWaiting = True
self.conn = sqlite3.connect('stats.db')
self.Populate()
def Populate(self):
with self.conn:
cur = self.conn.cursor()
cur.execute("SELECT * FROM Characters")
rows = cur.fetchall()
i = 1
for row in rows:
self.character = Character(row[0], row[1], row[2], row[3], row[4], row[5], row[6])
self.character.id = i
cur.execute("SELECT * FROM PlayerInventory WHERE PlayerID="+str(self.character.id))
inventory = cur.fetchall()
for item in inventory:
cur.execute("SELECT * FROM Item WHERE ItemID="+str(item[1]))
tempItem = cur.fetchall()
itemName = tempItem[0][0]
self.character.addItem(itemName, item[2])
daemon.register(self.character)
self.Characters.append(self.character)
i = i+1
cur.execute("SELECT * FROM Enemy")
rows = cur.fetchall()
for row in rows:
self.enemy = Character(row[0], row[1], 0, row[2], row[3], row[4], row[5])
daemon.register(self.enemy)
self.Enemies.append(self.enemy)
def get(self, i):
return self.contents[i]
def getLast(self):
i = len(self.contents)
return self.contents[i-1]
def retList(self):
return self.contents
def add(self, i, isChar):
if isChar == True:
self.contents.append(self.Characters[i])
else:
en = Character(self.Enemies[i].name, self.Enemies[i].HP, 0, self.Enemies[i].attack, self.Enemies[i].defense, self.Enemies[i].acc, self.Enemies[i].eva)
daemon.register(en)
self.contents.append(en)
def getName(self, i):
return self.contents[i].name
def getHasItems(self, i):
return self.contents[i].hasItems
def checkItems(self, i):
return self.contents[i].checkItems()
def getNumChars(self):
return len(self.Characters)
def getCharName(self, i):
return self.Characters[i].name
def getNumEn(self):
return len(self.Enemies)
def getEnName(self, i):
return self.Enemies[i].name
def waiting(self):
return self.isWaiting
def update(self, camera, delta, platforms, enemies):
#print "Player at x: " + str(self.p[0]) + "and y: " + str(self.p[1])
#triggers moved to Game
miss = R.randint(0,30000)
if self.sparkleCloud > 0:
self.sparkleCloud -= 1
else:
self.sparkleCloud = 0
if miss == 765:
self.imissyou.play(0,0,0)
#self.missedyou = True
Player.checkTriggers(self, camera)
#update hp
self.hpsurf = Globals.Font.render("HP: " + str(self.health),True,(255,0,0))
#enemies = Globals.State.enemies
for e in enemies:
if pygame.sprite.collide_rect(self,e) and not self.invincible and e.attackReady:
self.gotHit = True
if isinstance(Globals.State, Game.Game):
gargs = Globals.State.gargs
for g in gargs:
if pygame.sprite.collide_rect(self,g) and not self.invincible and g.attackReady:
self.gotHit = True
if isinstance(Globals.State, Game.Game):
projectiles = Globals.State.projectiles
for p in projectiles:
if pygame.sprite.collide_rect(self,p) and not self.invincible:
self.gotHit = True
powerups = Globals.State.powerups
for pw in powerups:
if pygame.sprite.collide_rect(self,pw) and self.grounded == 1:
self.gotBambi = True
Globals.State.powerups.remove(pw)
if self.gotHit and not self.invincible:
self.damageCounter = 1
self.health -= 40
if(self.hitTimes < 3):
self.shortHitSounds[R.randint(0,2)].play(0,0,0)
self.hitTimes += 1
else:
self.longDamageSounds[R.randint(0,1)].play(0,0,0)
self.hitTimes = 0
self.gotHit = False
if isinstance(Globals.State, Game.Level4) and self.p[1] > 1250:
Globals.State.backgroundTrack.stop()
Globals.State = Game.Level4()
self.chooseState()
Character.update(self, camera, delta, platforms)
# if self.damagetime >= 1:
# self.takingdamage = 0
# if self.takingdamage == 1:
# self.damagetime += delta
# for e in enemies:
# if pygame.sprite.collide_rect(self, e):
# if self.takingdamage == 0:
# self.health -= 40
# self.takingdamage = 1
# self.damageCounter = 1
# break
camera.update(self.p, self.image.get_width(), self.image.get_height())
def jump(self):
Character.jump(self)
class TestCharacterFunctions(unittest.TestCase): def setUp(self): """ Initializes the ninja """ pygame.init() self._screen = pygame.display.set_mode ((900, 600)) self.ninja = Character(x = 0, y = 0) def tearDown(self): """ There is nothing to tear down """ pass def test_init(self): """ Tests that the correct exception is raised when the program cannot load the image file """ self.assertRaises(SystemExit, self.ninja.__init__, \ imageName = 'random.png') def test_getXLocation(self): """ Tests that the function returns the proper value for x """ self.assertTrue(self.ninja.getXLocation() == 0) def test_getYLocation(self): """ Tests that the function returns the proper value for y """ self.assertTrue(self.ninja.getYLocation() == 0) def test_setXLocation(self): """ Tests that the function sets x to the correct value """ self.ninja.setXLocation(33) self.assertTrue(self.ninja.getXLocation() == 33) def test_setYLocation(self): """ Tests that the function sets y to the correct value """ self.ninja.setYLocation(66) self.assertTrue(self.ninja.getYLocation() == 66) def test_setLocationByOffset(self): """ Tests that the function sets x and y to the correct values """ self.ninja.setLocationByOffset(100, 200) self.assertTrue(self.ninja.getXLocation() == 100) self.assertTrue(self.ninja.getYLocation() == 200) self.ninja.setLocationByOffset(10, 20) self.assertTrue(self.ninja.getXLocation() == 110) self.assertTrue(self.ninja.getYLocation() == 220) def test_setRectLocation(self): """ Tests that the function sets x and y of the rect attribute to the correct values """ self.ninja.setRectLocation(100, 300) self.assertEqual(self.ninja.rect.x, 100) self.assertEqual(self.ninja.rect.y, 300) def test_setIsMoving(self): """ Tests that the function sets isMoving to the correct value """ self.ninja.setIsMoving(True) self.assertTrue(self.ninja._isMoving) self.ninja.setIsMoving(False) self.assertFalse(self.ninja._isMoving) def test_getIsMoving(self): """ Tests that the function returns the proper value for isMoving """ self.ninja.setIsMoving(True) self.assertTrue(self.ninja.getIsMoving()) def test_setCharacterImage(self): """ Tests that the correct exception is raised when the program cannot load the image file """ self.assertRaises(SystemExit, self.ninja.setCharacterImage, \ imageName = 'random.png')
def update(self, camera, delta, platforms):
if self.health == 0:
self.dead = True
self.chooseState()
#print "Garg at x: " + str(self.p[0]) + "and y: " + str(self.p[1])
Character.update(self,camera,delta,platforms)
def setUp(self): """ Initializes the ninja """ pygame.init() self._screen = pygame.display.set_mode ((900, 600)) self.ninja = Character(x = 0, y = 0)
def __init__(self, scene, character, position):
self.scene = scene
self.engine = scene.engine
self.character = character
self.position = position
scenepath = os.path.join("scenes", "menusystem")
self.back = WinObj(Texture(os.path.join(scenepath, "window.png")), self.engine.w, self.engine.h*.1)
self.back.setPosition(self.engine.w/2, self.position)
self.font = FontObj("default.ttf", size = 16)
self.bigFont = FontObj("default.ttf", size = 32)
length = 200
self.bars = [BarObj(Texture(os.path.join(scenepath, "bar_bottom.png")), length),
BarObj(Texture(os.path.join(scenepath, "exp_bar.png")), length*(character.exp/float(Character._expCalc(character.level)))),
BarObj(Texture(os.path.join(scenepath, "bar_top.png")), length)]
for bar in self.bars:
bar.setPosition(self.engine.w - 10 - length, self.position-10)
def createPlayers():
mngr = EventManager()
bob = Character(mngr, 'Bob', (0,0), None, None, None)
joe = Character(mngr, 'Joe', (0,0), None, None, None)
gun = Gun(mngr)
ammo = Ammo(mngr)
gun.updateData(ak47)
joe.pickup(gun)
joe.pickup(ammo)
joe.equipWeapon(gun)
joe.reload()
tom = Character(mngr, 'Tom', (0,0), None, None, None)
tom.initative = 12
return [joe, tom, bob]
#Created May 14, 2015
#Character module
import Character
name = input("Enter a name for your Character: ");
age = input("Enter the age of your Character: ");
HEALF = input("What is your Health?")
print("You have ",HEALF," Health.")
strength = 10
constitution = 10
dexterity = 10
wisdom = 10
inteligence = 10
charisma = 10
charName = Character.createCharacter(name, age, 10, 10, 10, 10, 10, 10)
exit = "false"
while (exit == "false"):
printStat = input("What stat would you like to print for ")
if (printStat == "exit"):
exit = "true"
elif (printStat == "str"):
print ("str =", charName.strength)
elif (printStat == "con"):
print ("con =", charName.constitution)
elif (printStat == "dex"):
def setUpPlayer(self):
self.playerAlive = True
self.player = Character("finalizedmasterchiefsprite.gif", 100, 100, 288, 288, 4, 4, 10, 10)
self.player.set_animation_delay(100)
self.player.play(True)
class Game:
def __init__(self, screen, inClock):
#Window variables
self.screen = screen
self.resolutionX = screen.get_width()
self.resolutionY = screen.get_height()
self.clock = inClock
self.marginHUD = 100
#Game variables
self.cellSizeX = 16
self.cellSizeY = 16
self.xCells = int(self.resolutionX / self.cellSizeX)
self.yCells = int(self.resolutionY / self.cellSizeY - self.marginHUD / self.cellSizeY)
self.cellSizeDivisor = 2
self.cellUpdate = 4
self.deadCells = 0
self.aliveCells = 0
self.infectedCells = 0
self.cellSet = [[Cell]*self.yCells for x in range(self.xCells)]
self.dirtyCells = []
self.updateTime = 0
self.updateNumber = 0
self.cellDeathLimit = 35
self.gameState = gameState.MENU_STATE
self.player = Character("finalizedmasterchiefsprite.gif", 100, 100, 288, 288, 4, 4, 10, 10)
self.level = 1
self.menuList = []
self.enemyList = []
#bool variables
self.playerAlive = True
self.enemyAlive = True
self.enemyAI = True
self.bMusic = True
self.bTimer = False
self.setUpGame = False
self.crosInput = False
##music variables
pygame.mixer.stop()
pygame.mixer.init(44100, -16, 2, 2048)
self.soundMaster = GameSound()
##keyboard variables
self.keyboard = pygame.key.get_pressed()
self.key1 = pygame.K_1
self.key2 = pygame.K_2
self.makeColorArray()
self.setUpMouse()
self.startMenu()
def gamePrint(self, screen, text, xx, yy, color, fontSize):
font = pygame.font.SysFont("Courier New",fontSize)
ren = font.render(text,1,color)
screen.blit(ren, (xx,yy))
def makeColorArray(self):
self.colorArray = []
self.colorArray.append(black)
self.colorArray.append(darkBlue)
self.colorArray.append(blue)
self.colorArray.append(green)
self.colorArray.append(yellow)
self.colorArray.append(orange)
self.colorArray.append(red)
self.colorArray.append(pink)
self.colorArray.append(white)
self.colorArray.append(zombie)
self.colorArray.append(dead)
def initializeGame(self, screen):
self.setUpPlayer()
self.setUpEnemy(screen)
self.seedLevel();
self.gameState = gameState.PLAY_STATE
def setUpPlayer(self):
self.playerAlive = True
self.player = Character("finalizedmasterchiefsprite.gif", 100, 100, 288, 288, 4, 4, 10, 10)
self.player.set_animation_delay(100)
self.player.play(True)
def setUpEnemy(self, screen):
self.enemyList = []
enemy = Enemy("Zombie.gif", screen.get_width() - 100, screen.get_height() - 100, 288, 288, 4, 4, self.enemyAI)
self.enemyList.append(enemy)
if self.level > 2:
enemy = Enemy("Zombie.gif", screen.get_width() - 100, screen.get_height() - 700, 288, 288, 4, 4, True)
self.enemyList.append(enemy)
if self.level > 4:
enemy = Enemy("Zombie.gif", screen.get_width() / 2, screen.get_height() / 2, 288, 288, 4, 4, True)
self.enemyList.append(enemy)
for enemy in self.enemyList:
enemy.set_animation_delay(100)
enemy.play(True)
def setUpMouse(self):
pygame.mouse.set_visible(False)
self.crosshair = MouseCrosshair(Point2D(50, 50), Point2D(30, 30), "crosshair.bmp", 60, 30, 2, 1)
self.crosshair.set_image_color_key(255, 255, 255)
self.crosshair.set_animation_delay(200)
self.crosshair.play(True)
def seedLevel(self):
for index1 in range(self.xCells):
for index2 in range(self.yCells):
self.cellSet[index1][index2] = Cell()
for x in range(100):
index1 = random.randint(0, self.xCells - 1)
index2 = random.randint(0, self.yCells - 1)
life = random.randint(1,8)
self.cellSet[index1][index2].makeAlive()
def incrementLevel(self, screen):
self.level += 1
self.initializeGame(screen)
def startMenu(self):
self.gameState = gameState.MENU_STATE
keypress = pygame.key.get_pressed()
screen = pygame.display.set_mode((self.resolutionX, self.resolutionY))
self.menuList.append(MenuObject(Point2D(350, 380), 60, 35, "start"))
self.menuList.append(MenuObject(Point2D(500, 700), 60, 35, "quit"))
self.menuList.append(MenuObject(Point2D(60, 750), 60, 35, "music", True))
self.menuList.append(MenuObject(Point2D(115, 750), 70, 35, "music", False))
def updateMenu(self, screen):
self.gamePrint(self.screen, "Start!", 350, 380, white, 30)
self.gamePrint(self.screen, "Quit!", 500, 700, white, 30)
self.gamePrint(self.screen, "Music?", 70, 700, white, 36)
self.gamePrint(self.screen, "On", 60, 750, white, 30)
self.gamePrint(self.screen, "Off", 115, 750, white, 30)
if(pygame.mouse.get_pressed() == (0,0,1)):
mouseX = pygame.mouse.get_pos()[0]
mouseY = pygame.mouse.get_pos()[1]
for menu in self.menuList:
if mouseX > menu.upperLeft.x and mouseX < menu.lowerRight.x:
if mouseY > menu.upperLeft.y and mouseY < menu.lowerRight.y:
self.selectOption(menu.type, menu, screen)
msElapsed = self.clock.tick(30)
self.crosshair.update(screen)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit(); sys.exit();
def selectOption(self, menuType, item, screen):
if menuType == "start":
self.initializeGame(screen);
if menuType == "quit":
pygame.quit();
sys.exit();
elif menuType == "music":
self.bMusic = item.value
def checkPlayerWalkingOnCells(self):
indexX = int(self.player.upperLeft.x / self.cellSizeX)
indexY = int(self.player.upperLeft.y / self.cellSizeY)
while(indexX < self.player.lowerRight.x / self.cellSizeX):
while(indexY < self.player.lowerRight.y / self.cellSizeY):
if(self.checkX(indexX) and self.checkY(indexY)):
if(self.cellSet[indexX][indexY].bIsInfected == True):
self.cellSet[indexX][indexY].cureInfection()
self.player.score += 10
indexY += 1
indexX += 1
def checkEnemyWalkingOnCells(self):
for enemy in self.enemyList:
if enemy.health > 0:
indexX = int(enemy.upperLeft.x / self.cellSizeX)
indexY = int(enemy.upperLeft.y / self.cellSizeY)
while (indexX < enemy.lowerRight.x / self.cellSizeX):
while (indexY < enemy.lowerRight.y / self.cellSizeY):
if (self.checkX(indexX) and self.checkY(indexY)):
if (self.cellSet[indexX][indexY].getLife() == 8):
self.cellSet[indexX][indexY].makeZombie()
indexY += 1
indexX += 1
def update(self, screen):
if self.bMusic == True:
if pygame.mixer.get_busy() == False:
self.playSong()
if self.gameState == gameState.PLAY_STATE:
if self.updateNumber >= self.cellUpdate:
self.updateNeighbors()
self.updateNumber = 0
else:
self.updateNumber += 1
self.player.update(screen, self.enemyList)
self.checkPlayerWalkingOnCells();
if self.playerAlive != True:
self.gameOver();
else:
self.checkPlayerWalkingOnCells()
for enemy in self.enemyList:
enemy.update(screen, self.player)
self.checkEnemyWalkingOnCells()
self.updateCells()
self.countCells()
#random creations of gliders
self.randomlyCreateGliders()
elif self.gameState == gameState.MENU_STATE:
self.updateMenu(screen)
elif self.gameState == gameState.GAME_OVER:
keypress = pygame.key.get_pressed()
if keypress[pygame.K_SPACE]:
self.initializeGame(screen)
elif self.gameState == gameState.WIN_STATE:
keypress = pygame.key.get_pressed()
if keypress[pygame.K_SPACE]:
self.incrementLevel(screen)
def drawHUD(self, screen):
#----CELLS ALIVE----#
color = white
if self.aliveCells < 1:
color = red
elif self.aliveCells < 100:
color = orange
gameText = "Cells Alive: " + str(self.aliveCells)
self.gamePrint(screen, gameText, 5, 700, color, 12)
#----CELLS DEAD----#
color = white
if self.deadCells >= 25:
color = red
elif self.deadCells >= 10:
color = orange
gameText = "Cells Dead: " + str(self.deadCells) + "/" + str(self.cellDeathLimit)
self.gamePrint(screen, gameText, 5, 750, color, 12)
#----INFECTED CELLS----#
color = white
if self.infectedCells >= 10:
color = red
gameText = "Cells Infected: " + str(self.infectedCells)
self.gamePrint(screen, gameText, 150, 700, color, 12)
#----LEVEL----#
color = white
gameText = "Level: " + str(self.level)
self.gamePrint(screen, gameText, 150, 750, color, 12)
#----PLAYER HP----#
tempY = 700
if self.player.health < 40:
color = red
elif self.player.health < 60:
color = orange
else:
color = white
gameText = "Health: " + str(self.player.health)
self.gamePrint(screen, gameText, 300, tempY, color, 12)
#----PLAYER SCORE----#
color = white
gameText = "Score: " + str(self.player.score)
self.gamePrint(screen, gameText, 400, tempY, color, 12)
tempY += 50
if self.gameState == gameState.GAME_OVER:
color = red
gameText = "GAME OVER!"
gameText1 = ("Press space to start a new game")
self.gamePrint(screen, gameText, 350, 380, color, 32)
self.gamePrint(screen, gameText1, 330, 410, color, 12)
elif self.gameState == gameState.WIN_STATE:
color = green
gameText = "You win!"
self.gamePrint(screen, gameText, 350, 380, color, 32)
def levelWin(self):
self.gameState = gameState.WIN_STATE
def countCells(self):
if self.bTimer == False:
self.time = pygame.time.get_ticks()
self.bTimer = True
else:
if self.time < pygame.time.get_ticks():
self.deadCells = 0
self.aliveCells = 0
self.infectedCells = 0
self.bTimer = False
for indexX in range(self.xCells):
for indexY in range(self.yCells):
cell = self.cellSet[indexX][indexY]
if cell.bDead == True:
self.cellDeath()
elif cell.getLife() == 8:
self.aliveCells += 1
elif cell.getLife() == 9:
self.infectedCells +=1
if self.aliveCells == 0:
self.gameOver()
if self.infectedCells <= 0:
enemyAlive = False
for enemy in self.enemyList:
if enemy.health >= 0:
enemyAlive = True
if enemyAlive == False:
self.levelWin()
def cellDeath(self):
self.deadCells += 1
if self.deadCells >= self.cellDeathLimit:
self.gameOver()
def draw(self, screen):
for indexX in range(self.xCells):
for indexY in range(self.yCells):
if (self.cellSet[indexX][indexY].getLife() != 0):
color = self.colorArray[int(self.cellSet[indexX][indexY].getLife())]
pygame.draw.rect(screen, color, (indexX * self.cellSizeX, indexY * self.cellSizeY, self.cellSizeX / self.cellSizeDivisor, self.cellSizeY / self.cellSizeDivisor))
if self.player.health > 0:
self.player.draw(screen)
for enemy in self.enemyList:
if enemy.health > 0:
enemy.draw(screen)
def updateCells(self):
for indexX in range(self.xCells):
for indexY in range(self.yCells):
self.cellSet[indexX][indexY].update()
def updateNeighbors(self):
self.dirtyCells = []
for indexX in range(self.xCells):
for indexY in range(self.yCells):
if self.cellSet[indexX][indexY].bConsidered == True:
self.updateCell(indexX, indexY)
for x in range(0,len(self.dirtyCells), 2):
self.updateCell(self.dirtyCells[x], self.dirtyCells[x+1])
def updateCell(self, indexX, indexY):
examinedCell = self.cellSet[indexX][indexY]
if examinedCell.bIsInfected != True and examinedCell.bDead == False:
examinedCell.bChecked = True
cellsNear = 0
for xDistance in range(3):
for yDistance in range(3):
x = indexX + xDistance - 1
y = indexY + yDistance - 1
if (xDistance == 1 and yDistance == 1):
doNothing = True
else:
if (self.checkX(x) and self.checkY(y)):
cellBeingChecked = self.cellSet[x][y]
if cellBeingChecked.getLife() == 8:
cellsNear += 1
elif cellBeingChecked.bIsInfected == True:
examinedCell.addInfection()
if examinedCell.getLife() == 8 and cellBeingChecked.bConsidered == False:
cellBeingChecked.bConsidered = True
self.dirtyCells.append(x)
self.dirtyCells.append(y)
examinedCell.setNeighbors(cellsNear)
def checkX(self,x):
if x >= 0 and x <= self.xCells - 1:
return True
else:
return False
def checkY(self,y):
if y >= 0 and y <= self.yCells - 1:
return True
else:
return False
def gameOver(self):
self.gameState = gameState.GAME_OVER
def playSong(self):
self.soundMaster.sound1.play()
def randomlyCreateGliders(self):
toBeCreated = random.randint(0, 50)
if toBeCreated == 0:
index1 = random.randint(10,self.xCells - 11)
index2 = random.randint(10,self.yCells - 11)
self.cellSet[index1 + 1][index2 + 1].makeAlive()
self.cellSet[index1 + 1][index2 + 2].makeAlive()
self.cellSet[index1 + 2][index2 + 2].makeAlive()
self.cellSet[index1 + 2][index2 + 3].makeAlive()
self.cellSet[index1 + 3][index2 + 2].makeAlive()
self.cellSet[index1 + 5][index2 + 1].makeAlive()
self.cellSet[index1 + 6][index2 + 1].makeAlive()
self.cellSet[index1 + 6][index2 + 2].makeAlive()
self.cellSet[index1 + 7][index2 + 1].makeAlive()
elif toBeCreated == 1:
index1 = random.randint(10,self.xCells - 11)
index2 = random.randint(10,self.yCells - 11)
self.cellSet[index1 + 1][index2 + 1].makeAlive()
self.cellSet[index1 + 1][index2 + 2].makeAlive()
self.cellSet[index1 + 2][index2 + 1].makeAlive()
self.cellSet[index1 + 2][index2 + 3].makeAlive()
self.cellSet[index1 + 3][index2 + 1].makeAlive()
elif toBeCreated == 2:
index1 = random.randint(10,self.xCells - 11)
index2 = random.randint(10,self.yCells - 11)
self.cellSet[index1 + 2][index2 + 1].makeAlive()
self.cellSet[index1 + 3][index2 + 1].makeAlive()
self.cellSet[index1 + 1][index2 + 2].makeAlive()
self.cellSet[index1 + 3][index2 + 2].makeAlive()
self.cellSet[index1 + 3][index2 + 3].makeAlive()
elif toBeCreated == 3:
index1 = random.randint(10,self.xCells - 11)
index2 = random.randint(10,self.yCells - 11)
self.cellSet[index1 + 2][index2 + 1].makeAlive()
self.cellSet[index1 + 1][index2 + 3].makeAlive()
self.cellSet[index1 + 2][index2 + 3].makeAlive()
self.cellSet[index1 + 3][index2 + 3].makeAlive()
self.cellSet[index1 + 3][index2 + 2].makeAlive()
elif toBeCreated == 4:
index1 = random.randint(10,self.xCells - 11)
index2 = random.randint(10,self.yCells - 11)
self.cellSet[index1 + 1][index2 + 1].makeAlive()
self.cellSet[index1 + 1][index2 + 2].makeAlive()
self.cellSet[index1 + 1][index2 + 3].makeAlive()
self.cellSet[index1 + 2][index2 + 3].makeAlive()
self.cellSet[index1 + 3][index2 + 2].makeAlive()
