def shoot_arrow(self):
new_arrow_sprite = Projectile(self.arrow_sprites[self.character.state],
12, self.character.state, self)
new_arrow_sprite.center_y = self.character.center_y
new_arrow_sprite.center_x = self.character.center_x
self.character_projectile_list.append(new_arrow_sprite)
self.character.arrows -= 1
def __init__(self, pos, board_dim, player_id):
self.id = player_id
self.pos = pos
self.rotation = 0
self.board_dim = board_dim
self.shape_size = (len(self.shape_image[0]), len(self.shape_image))
self.projectile = Projectile((0, 0), board_dim)
def reset(self):
ObstacleGenerator.deadProjectiles = 0
ObstacleGenerator.liveProjectiles = []
ObstacleGenerator.liveObstacles = []
ObstacleGenerator.deadObstacles = 0
ObstacleGenerator.hits = 0
ObstacleGenerator.prevT = pygame.time.get_ticks()
ObstacleGenerator.fails = 0
Obstacle.fails = 0
ObstacleGenerator.p_out_of_bounds = 0
Projectile.reset()
def click(self, event):
if not self.good_shots:
self.good_shots.append(
Projectile(self.hero.x, self.hero.y, event.x + self.camera.x,
event.y + self.camera.y, 'Good_shots',
self.good_shots))
print(event.x, event.y)
def readGameControls(self):
#read in events from queue - IN GAME CONTROLS
for event in pygame.event.get():
#on QUIT event, exit the game loop
if event.type == pygame.QUIT:
self.runningGame = False
#if a key is pressed, act based on library definition
elif event.type == pygame.KEYDOWN and event.key in self.key_map:
self.key_map[event.key][0]()
#if a key is released, act based on library definition
elif event.type == pygame.KEYUP and event.key in self.key_map:
self.key_map[event.key][1]()
#if a space bar is pressed, fire the projectile
#if p is pressed, pause the game
elif event.type == pygame.KEYDOWN:
self.keyPresses = pygame.key.get_pressed()
#if a space bar is pressed, fire the projectile
if self.keyPresses[K_SPACE] == 1:
self.bullet = Projectile(
[self.player.rect.x + 17, self.player.rect.y])
self.spriteList.add(self.bullet)
self.projectileList.add(self.bullet)
self.projectileSound.play()
#if p is pressed, pause the game
elif self.keyPresses[K_p] == 1:
self.pausedGame = not self.pausedGame
def launch_projectile(self):
# instance projectile
self.all_projectiles.add(Projectile(self))
#demarer l'animation du lancer
self.start_animation()
#jouer le son
self.game.sound_manager.play('tir')
def shoot(self, user, mousePos):
currentTime = pygame.time.get_ticks()
if currentTime - self.lastShot > self.weaponCooldown:
direction = (mousePos[0] - user.pos[0], mousePos[1] - user.pos[1]) \
if mousePos != user.pos else (1, 1)
self.lastShot = currentTime
user.projectiles.add(Projectile(user.pos,
super().normalize_vector(direction),
5, 2000, (0, 0, 255)))
def takeMoney(self, vertex):
for v in self.nodes.getNeighbors(vertex):
n = self.nodes[v]
nv = self.nodes[vertex]
n.changeVal(n.value - 1)
# nv.changeVal(nv.value + 1)
self.projectiles.append(
Projectile((n.x, n.y), (nv.x, nv.y), vertex, n.color,
textures.projectile_t.copy(), 9))
def shoot_projectile(self):
if self._current_charge >= self._cooldown:
self._current_charge = 0
projectile = Projectile(self._projectile_speed,
self.x + self.size * sin(self.direction),
self.y + self.size * cos(self.direction),
self.direction, self._projectile_radius,
self.tank_index)
return projectile
def shoot(self, playerPos):
currentTime = pygame.time.get_ticks()
if currentTime - self.lastShot > self.weaponCooldown:
direction = (playerPos[0] - self.pos[0],
playerPos[1] - self.pos[1])
self.lastShot = currentTime
self.projectiles.add(
Projectile(self.pos, normalize_vector(direction), 3, 500,
(255, 0, 0)))
def shoot(self, user, mousePos):
currentTime = pygame.time.get_ticks()
if currentTime - self.lastShot > self.weaponCooldown:
direction = (mousePos[0] - user.pos[0], mousePos[1] - user.pos[1]) \
if mousePos != user.pos else (1, 1)
self.lastShot = currentTime
theta = math.radians(random.random()*self.spreadArc - self.spreadArc/2)
projDir = super().rotate_vector(direction, theta)
user.projectiles.add(Projectile(user.pos,
super().normalize_vector(projDir),
6, 1000, (194, 54, 16)))
def buildTower(self, tower, loc):
s = self.towerProps[tower]
t = s['projectile']
self.towers.append(
Tower(
s['range'], s['appearance'], s['fireRate'],
Projectile(loc[0], loc[1], t['damage'], t['appearance'],
t['speed'], t['effects']), (loc[0], loc[1]),
s['shop']))
self.money -= s['cost']
self.towerCanFire.append(False)
def shoot(self, user, mousePos):
currentTime = pygame.time.get_ticks()
if currentTime - self.lastShot > self.weaponCooldown:
direction = (mousePos[0] - user.pos[0], mousePos[1] - user.pos[1]) \
if mousePos != user.pos else (1, 1)
self.lastShot = currentTime
arcDifference = self.spreadArc / (self.projectilesCount - 1)
for proj in range(self.projectilesCount):
theta = math.radians(arcDifference*proj - self.spreadArc/2)
projDir = super().rotate_vector(direction, theta)
user.projectiles.add(Projectile(user.pos,
super().normalize_vector(projDir),
7, 500, (232, 144, 42)))
def enemy_shoot():
for enemy in enemies:
if enemy.enemy_type == 1:
if enemy.shoot_count[0] == fps * 4:
enemy.get_direction(player.rect.x, player.rect.y)
enemy_bullets.append(Projectile(enemy.rect.x, enemy.rect.y - 20, enemy.direction - 5, True))
enemy.shoot_count[0] = 0
else:
enemy.shoot_count[0] += 1
for bullet in enemy_bullets:
all_sprites.add(bullet)
bullet.update_enemy()
def shootMg(self, clickedVel):
if self.base.counter % 10 == 0:
targetVel = (clickedVel - self.getMuzzlePos()).normalize()
shot = Projectile(
self.getMuzzlePos(),
targetVel,
self.projectileSpeed * 2,
"mg",
(self.getMuzzlePos() - clickedVel).length(),
False,
2,
)
return shot
return
def attack(self, player):
if random.randint(1, 100) <= 5:
xDisp = self.bounding_radius * cos((self.rot + 90) * pi / 180)
yDisp = self.bounding_radius * sin((self.rot + 90) * pi / 180)
projectile = Projectile(
self.rot + 90, self.range, texture=self.projectileTexture,
x=self.x + xDisp, y=self.y + yDisp)
projectile.vt = 50
self.projectiles.append(projectile)
def update(self, dt, player):
self.x += self.vx * dt
self.y += self.vy * dt
if self.poison != 0:
self.health -= self.poison
self.poisonTime -= dt
self.rgba = (0, 1, 0, 1)
if self.poisonTime < 0:
self.poison = 0
self.poisonTime = 0
self.rgba = (1, 1, 1, 1)
if self.vx != 0 or self.vy != 0:
if self.animTime > self.animRate:
if self.texture == resources.deathJellyImages[1]:
self.texture = resources.deathJellyImages[0]
else:
self.texture = resources.deathJellyImages[1]
self.animTime = 0
else:
self.animTime += dt
self.collideAngle = None
def shoot(self, clickedVel, type):
if (not self.lOS): return
targetVel = (clickedVel - self.getMuzzlePos()).normalize()
if ((not self.base.readyToFire)
or (self.pos - clickedVel).length() < self.generator.length()):
return
if type == "shell":
shot = Projectile(self.getMuzzlePos(), targetVel,
self.projectileSpeed, "shell",
(self.pos - clickedVel).length())
self.base.recoil(shot)
elif type == "homing":
shot = HomingProjectile(self.getMuzzlePos(), targetVel)
self.base.homingCount -= 1
self.base.readyToFire = False
self.base.reloadCounter = 0
return shot
def shoot(add_bullet, rapid_temp):
now = pygame.time.get_ticks()
if add_bullet and now - player.last >= 1000/player.rapid:#(fps / player.rapid) == rapid_temp:
bullets.append(Projectile(player.rect.x, player.rect.y, player.direction, True))
player.last = pygame.time.get_ticks()
if (fps / player.rapid) == rapid_temp:
rapid_temp = 0
for bullet in bullets:
if bullet.rect.x > resolution[0] or bullet.rect.x < -50 or bullet.rect.y < -50 or bullet.rect.y > resolution[1] - level.image.get_height():
if bullet.rect.y > resolution[1] - level.image.get_height():
bullet.miss()
bullets.pop(bullets.index(bullet))
all_sprites.remove(bullet)
else:
bullet.update()
all_sprites.add(bullet)
rapid_temp += 1
return rapid_temp
def check_keys():
"""Check for key presses."""
# one bullet at a time:
global bullet_lag
global weapons_lag
if weapons_lag > 0:
weapons_lag += 1
if weapons_lag == 30:
weapons_lag = 0
if bullet_lag > 0:
bullet_lag += 1
if bullet_lag == 10:
bullet_lag = 0
keys = pg.key.get_pressed()
if keys[pg.K_LEFT]:
plyr.moveLeft()
elif keys[pg.K_RIGHT]:
plyr.moveRight(DISPLAY_SIZE[0])
else:
plyr.standing = True
if keys[pg.K_UP] or plyr.isJump:
plyr.jump()
# When space bar is pressed, the bullet is fired based on direction of Player
if keys[pg.K_SPACE]:
if bullet_lag == 0:
bullet_lag += 1
facing = 1
if len(bullets) < 5: # This will make sure we cannot exceed 5 bullets on the screen at once
bullets.append(
Projectile(round(plyr.x + plyr.width // 2), round(plyr.y + plyr.height // 2), plyr.weapon.radius, plyr.weapon.color,
plyr.weapon.vel, plyr.weapon.damage, facing))
if keys[pg.K_q]:
if weapons_lag == 0:
weapons_lag += 1
if plyr.weapon == pistol:
plyr.weapon = big_gun
else:
plyr.weapon = pistol
def fireprojectile(self):
newprojectile = Projectile(self.screen,
r'Assets\imgs\bullet1.png',
movespeed=-8,
startPosition=(self.currentPos[0],
self.currentPos[1] - 14))
mps = pygame.time.get_ticks() / 1000 - self.firedAt / 1000
if self.currentAmmo > 0:
if mps > 1 and self.currentAmmo < self.ammoMax:
self.currentAmmo += 1
if mps > .4:
self.firedAt = pygame.time.get_ticks()
SpaceShipSprite.liveProjectiles.append(newprojectile)
self.currentAmmo -= 1
else:
self.action_status = -1
else:
if mps >= self.ammoCounter:
self.currentAmmo = self.ammoMax
self.fireprojectile()
else:
self.action_status = -1
def shoot(self, spawn_list, bullets, shot):
self.is_shooting = True
shot.play()
if self.right is True:
self.image = pygame.image.load('images/faces/drori_shoot_right.png')
elif self.left is True:
self.image = pygame.image.load('images/faces/drori_shoot_left.png')
if self.left is True:
direction = -1
bullet_image = 'images/bullets/defaultbulletl.png'
else:
direction = 1
bullet_image = 'images/bullets/defaultbullet.png'
for child in spawn_list:
if self.start_y + self.height > child.hit_box[1] and \
self.start_y < child.hit_box[1] + child.hit_box[2]:
bullet_image = child.bullet
bullets.append(Projectile(self.start_x + (self.width // 2), self.start_y
+ (self.height // 2), bullet_image, direction, bullets))
def main():
angle, vel, h0, time = getInputs()
win = GraphWin("Face", 600, 400)
win.setCoords(0,0,30,30)
objToTrack = Projectile(angle, vel, h0)
p1 = Point(objToTrack.getX(),objToTrack.getY())
circleTracker = Circle(p1, 0.3)
circleTracker.setFill('red')
circleTracker.draw(win)
win.getMouse()
px = objToTrack.getX()
py = objToTrack.getY()
while objToTrack.getY() >= 0:
objToTrack.update(time)
dx = objToTrack.getX() - px
dy = objToTrack.getY() - py
Circle(p1, 0.1).draw(win)
p1.move(dx, dy)
px = objToTrack.getX()
py = objToTrack.getY()
win.getMouse()
win.close()
def main():
pygame.init()
win = pygame.display.set_mode((1000, 720))
pygame.display.set_caption("Colossal Man")
clock = pygame.time.Clock()
shootFreq = 0
font = pygame.font.SysFont('comicsans', 30, True)
running = True
index = 0
font1 = pygame.font.SysFont('comimcsans', 18)
text = font1.render('Health: ', True, (0, 0, 0))
def endScreen():
font2 = pygame.font.SysFont('comimcsans', 100)
text2 = font2.render('You Win !', True, (255, 0, 0))
win.blit(text2, ((500 // 2) - (text.get_width() // 2), (500 // 2) - 50))
pygame.display.update()
i = 0
while i < 150:
pygame.time.delay(10)
i += 1
pygame.quit()
subprocess.call("python " + "gameGUI.py")
with open("currentLevel", "a") as f:
f.truncate(0)
quit()
def redrawGameWindow():
win.blit(bg, (0, 0))
player.draw(win)
for airEnemy in aeroEnemy:
airEnemy.draw(win)
for gob in enemies:
gob.draw(win)
for bullet in bullets:
bullet.draw(win)
for platform in platforms:
platform.draw(win)
# draw health
win.blit(text, (25, 25))
pygame.draw.rect(win, (0, 255, 0), (90, 25, player.health, 10))
pygame.display.update()
first = True
breakLoop = False
isBreak = False
charAirEnemyLeft = True
charEnemyLeft = True
while running:
# check if game is finished
for gob in enemies:
if gob.visible:
charEnemyLeft = True
break
else:
charEnemyLeft = False
for airEnemy in aeroEnemy:
if airEnemy.visible:
charAirEnemyLeft = True
break
else:
charAirEnemyLeft = False
if not charAirEnemyLeft and not charEnemyLeft:
print("bye bye")
endScreen()
# check if enemy attacked player
for gob in enemies:
if gob.visible:
if abs(player.x - gob.x) < 30 and abs(player.y - gob.y) < 15:
player.health -= 1
if player.health <= 0:
gameover(win)
c = 0
if shootFreq > 0:
shootFreq += 1
if shootFreq > 5:
shootFreq = 0
clock.tick(27)
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
for bullet in bullets:
if bullet.x > 1000 - bullet.vel or bullet.x < bullet.vel:
bullets.pop(bullets.index(bullet))
else:
for gob in enemies:
if bullet.x in range(gob.x, gob.x + 20) and gob.visible:
if bullet.y + bullet.radius > gob.hitbox[1]:
gob.hit()
bullets.pop(bullets.index(bullet))
for airEnemy in aeroEnemy:
if bullet.x in range(airEnemy.x, airEnemy.x + 20) and airEnemy.visible:
if abs(bullet.y + bullet.radius - airEnemy.hitbox[1]) < 35:
airEnemy.hit()
print(airEnemy.hitbox[1], bullet.y)
bullet.x += 5 * bullet.facing
keys = pygame.key.get_pressed()
if keys[pygame.K_SPACE] and shootFreq == 0:
if player.left:
facing = -1
elif player.right:
facing = 1
else:
facing = 1
if len(bullets) < 6:
bullets.append(
Projectile(round(player.x + player.width // 2), round(player.y + player.height // 2), 5, 4, facing))
if keys[pygame.K_LEFT] and player.x > player.vel:
player.x -= player.vel
player.left = True
player.right = False
player.standing = False
elif keys[pygame.K_RIGHT] and player.y < 1000 - player.vel:
player.x += player.vel
player.left = False
player.right = True
player.standing = False
else:
player.walkCount = 0
player.standing = True
if not player.isJump:
if keys[pygame.K_UP]:
player.isJump = True
elif player.onPlatform and player.isJump:
if player.jumpCount >= -10:
if player.jumpCount < 0:
for i in range(int((player.jumpCount ** 2) * 0.5)):
player.y -= - 1
for platform in platforms:
if player.y == (platform.y - platform.width * 2) and player.x in range(platform.x,
platform.x + platform.length) and platform != \
platforms[index]:
index = platforms.index(platform)
player.jumpCount = 10
player.isJump = False
isBreak = True
player.y -= 5
if isBreak:
break
else:
for i in range(int((player.jumpCount ** 2) * 0.5)):
player.y -= 1
for platform in platforms:
if player.y == (platform.y - platform.width * 2) and player.x in range(platform.x,
platform.x + platform.length) and platform != \
platforms[index]:
index = platforms.index(platform)
player.jumpCount = 10
player.isJump = False
isBreak = True
player.y -= 5
if isBreak:
break
if isBreak:
break
if not isBreak:
player.jumpCount -= 1
isBreak = False
else:
player.jumpCount = 10
player.isJump = False
# jump and check if on platform
else:
if player.jumpCount >= -10:
if player.jumpCount < 0:
for i in range(int((player.jumpCount ** 2) * 0.5)):
player.y -= - 1
for platform in platforms:
if player.y == (platform.y - platform.width * 2) and player.x in range(platform.x,
platform.x + platform.length):
index = platforms.index(platform)
player.isJump = False
player.onPlatform = True
breakLoop = True
player.jumpCount = 10
break
if breakLoop:
break
else:
for i in range(int((player.jumpCount ** 2) * 0.5)):
player.y -= 1
for platform in platforms:
if player.y == (platform.y - platform.width * 2) and player.x in range(platform.x,
platform.x + platform.length):
index = platforms.index(platform)
print(platforms.index(platform))
player.isJump = False
player.onPlatform = True
player.jumpCount = 10
breakLoop = True
break
if breakLoop:
break
if not breakLoop:
player.jumpCount -= 1
else:
player.jumpCount = 10
player.isJump = False
breakLoop = False
redrawGameWindow()
if first:
player.draw(win)
first = False
if player.onPlatform:
c = 0
breakout = False
if platforms[index].x - 32 > player.x and not player.isJump or player.x > platforms[index].x + platforms[
index].length - 16 and not player.isJump:
print('beamed', player.isJump)
while player.y < originalY:
player.y += 0.5
c += 0.5
for platform in platforms:
if player.y == (platform.y - platform.width * 2) and player.x in \
range(platform.x,
platform.x + platform.length):
breakout = True
index = platforms.index(platform)
player.onPlatform = True
if c > 450 or breakout:
break
if not breakout:
player.onPlatform = False
player.jumpCount = 10
player.isJump = False
pygame.quit()
def shoot(self, player, fireballs): if self.coolDown > FRAMERATE * 2: self.coolDown = 0 fireballs.append(Projectile(self.posXY, self.directionToPoint(player.posXY))) self.coolDown += 2 return fireballs
from Projectile import Projectile
from time import sleep
startingVelocity = float(
input("What is the initial velocity of the projective? "))
angle = float(input("What angle was the projectile launched at? "))
starting_height = float(input("What was the starting height of the object? "))
myProjectile = Projectile(startingVelocity, angle, starting_height, 1)
y_displacement = starting_height
seconds = 0
while myProjectile.secondly_motion(seconds)["y"] >= 0:
myProjectile.secondly_motion(seconds)
print("At t =", str(round(seconds, 2)), "seconds, x =",
str(round(myProjectile.secondly_motion(seconds)["x"], 2)), "and y =",
str(round(myProjectile.secondly_motion(seconds)["y"], 2)))
seconds += 1
sleep(1)
print("The ball hit the ground again at x =",
round(myProjectile.find_delta_x(myProjectile.find_zero()), 2), "after",
myProjectile.find_zero(), "seconds.")
def update(self):
speed_mult = 1
if self.keyboard.is_pressed("sprint"):
speed_mult = 2
if self.keyboard.is_pressed("dash"):
if not self.dashing:
self.change_y += 2
self.dashing = True
if self.keyboard.is_pressed("l"):
pass
# self.level.reset = True
if self.keyboard.is_pressed("down"):
self.change_y -= 0.1
self.crawling = True
speed_mult *= 0.5
else:
self.crawling = False
if self.keyboard.is_pressed("attack"):
if self.curr_attack_speed == 0:
extra_y_dir = 0
if self.keyboard.is_pressed("up"):
extra_y_dir = 4
elif self.keyboard.is_pressed("down"):
extra_y_dir = -4
attack_x = (self.change_x) * 4
attack_y = (self.change_y + extra_y_dir) * 3
attack_angle = int(
math.atan2(attack_y, attack_x) / math.pi * 180)
card = Projectile(
Textures.SPRITESHEET[3 + int((attack_angle % 360) / 45) +
16], self.center_x, self.center_y,
attack_x, attack_y)
self.level.add_entity_to_list(card, self.level.entities)
self.curr_attack_speed = self.max_attack_speed
Sounds.play(Sounds.SHOOT)
if self.curr_attack_speed > 0:
self.curr_attack_speed -= 1
if self.keyboard.is_pressed("jump"):
if self.level.physics_engine.can_jump(1):
# if self.level.engine.can_jump(self, 1):
if not self.jumping:
Sounds.play(Sounds.JUMP)
self.level.physics_engine.jump(self.jump_height)
self.jumping = True
# elif self.level.engine.can_jump(self, -1):
elif self.level.physics_engine.can_jump(-1):
self.jumping = False
self.curr_jump_height = 0
if self.curr_jump_height > self.max_jump_height:
self.jumping = False
self.curr_jump_height = 0
elif self.curr_jump_height >= self.min_jump_height:
self.jumping = False
self.curr_jump_height = 0
if self.jumping:
self.change_y = self.jump_height
self.curr_jump_height += self.jump_height
if self.keyboard.is_pressed("left"):
self.change_x = -self.movespeed * speed_mult
elif self.keyboard.is_pressed("right"):
self.change_x = self.movespeed * speed_mult
else:
if self.change_x > 1:
self.change_x -= 1
self.not_mirrored = True
elif self.change_x < -1:
self.change_x += 1
self.not_mirrored = False
else:
self.change_x = 0
if self.dashing:
if self.change_x > 0:
self.change_x = self.movespeed * speed_mult * 1.5
elif self.change_x < 0:
self.change_x = -self.movespeed * speed_mult * 1.5
self.curr_dash_frame += 1
if self.curr_dash_frame >= self.dash_frame_speed * len(
self.dash_textures):
self.curr_dash_frame = 0
self.dashing = False
elif self.crawling:
self.curr_crawl_frame += 1
if self.curr_crawl_frame >= self.crawl_frame_speed * len(
self.crawl_textures):
self.curr_crawl_frame = 0
else:
self.walk_count += 1
if self.walk_count >= len(
self.walking_textures) * self.walk_frame_speed:
self.walk_count = 0
if self.curr_invis_frame > 0 and self.curr_invis_frame % 12 < 6:
self.texture = Textures.get_texture(15, 15)
elif self.change_x > 0:
if self.dashing:
self.texture = self.dash_textures[self.curr_dash_frame //
self.dash_frame_speed]
elif self.crawling:
self.texture = self.crawl_textures[self.curr_crawl_frame //
self.crawl_frame_speed]
else:
self.texture = self.walking_textures[self.walk_count //
self.walk_frame_speed]
# self.player_dir = True
elif self.change_x < 0:
if self.dashing:
self.texture = self.dash_textures_mirrored[
self.curr_dash_frame // self.dash_frame_speed]
elif self.crawling:
self.texture = self.crawl_textures_mirrored[
self.curr_crawl_frame // self.crawl_frame_speed]
else:
self.texture = self.walking_textures_mirrored[
self.walk_count // self.walk_frame_speed]
# self.player_dir = False
else:
if self.not_mirrored:
if self.crawling:
self.texture = self.crawl_textures[0]
else:
self.texture = self.idle_texture
else:
if self.crawling:
self.texture = self.crawl_textures_mirrored[0]
else:
self.texture = self.idle_texture_mirrored
super().update()
def __init__(self):
## Resources:
self.Soil = Resource("Soil Pile", "Common")
self.Wood = Resource("Wood Block", "Common")
self.Vine = Resource("Vine", "Common")
self.Fruit = Resource("Fruit", "Common")
self.Rock = Resource("Rock", "Common")
self.Water = Resource("Water Supply", "Common")
self.Sand = Resource("Sand Pile", "Common")
self.Cacti = Resource("Cacti Block", "Common")
self.Iron = Resource("Iron Nugget", "Uncommon")
self.Bone = Resource("Bone", "Common")
self.Diamond = Resource("Diamond", "Uncommon")
self.Stone = Resource("Stone", "Common")
self.Gold = Resource("Gold Nugget", "Uncommon")
self.Emerald = Resource("Emerald", "Uncommon")
self.Quartz = Resource("Quartz Shard", "Uncommon")
self.Explosive = Resource("Explosive", "Common")
## Items:
self.HarvesterArmor = Item("Harvester's Armor", None, "Rare")
self.Protector = Item("Protector", None, "Legendary")
self.Strawman = Item("Strawman", None, "Rare")
self.Coffin = Item("Coffin", None, "Legendary")
self.Ladder = Item("Ladder", None, "Rare")
MobRepellant = Item("Mob Repellent", None, "Legendary")
self.BottledWave = Item("Bottled Wave", None, "Rare")
self.BottledWind = Item("Bottled Wind", None, "Legendary")
self.Glider = Item("Glider", None, "Rare")
self.Binoculars = Item("Binoculars", None, "Legendary")
## Projectiles:
self.WoodenBall = Projectile("Wooden Ball", {"Wood": 5}, ["Arm"], 13,
"Common")
self.StoneBall = Projectile("Stone Ball", {
"Wood": 5,
"Stone": 2
}, ["Arm"], 15, "Common")
self.IronBall = Projectile("Iron Ball", {
"Wood": 5,
"IronIngot": 2
}, ["Arm"], 17, "Common")
self.DiamondBall = Projectile("Diamond Ball", {
"Wood": 5,
"Diamond": 2
}, ["Arm"], 25, "Uncommon")
self.WoodenArrow = Projectile("Wooden Arrow", {"Wood": 3},
["Bow", "CrossBow"], 17, "Common")
self.StoneArrow = Projectile("Stone Arrow", {
"Stone": 2,
"Wood": 3
}, ["Bow", "CrossBow"], 20, "Common")
self.IronArrow = Projectile("Iron Arrow", {
"IronIngot": 1,
"Wood": 3
}, ["Bow", "CrossBow"], 23, "Common")
self.DiamondArrow = Projectile("Diamond Arrow", {
"Diamond": 1,
"Wood": 3
}, ["Bow", "CrossBow"], 26, "Uncommon")
self.SoilClump = Projectile("Soil Clump", {"Soil": 4},
["CombatBucket"], 38, "Common")
self.SandClump = Projectile("Sand Clump", {"Sand": 4},
["CombatBucket"], 38, "Common")
self.CactusClump = Projectile("Cactus Clump", {"Cacti": 2},
["CombatBucket"], 55, "Common")
self.WoodSpike = Projectile("Wood Spike", {"Wood": 2}, ["Slingshot"],
17, "Common")
self.StoneSpike = Projectile("Stone Spike", {"Stone": 3},
["Slingshot"], 19, "Common")
self.IronSpike = Projectile("Iron Spike", {
"IronIngot": 1,
"Wood": 1
}, ["Slingshot"], 21, "Common")
self.DiamondSpike = Projectile("Diamond Spike", {
"Diamond": 1,
"Wood": 1
}, ["Slingshot"], 26, "Uncommon")
self.CannonBall = Projectile("Cannon Ball", {
"Wood": 10,
"Stone": 15
}, ["Cannon"], 125, "Common")
self.Rocket = Projectile("Rocket", {
"Iron": 15,
"Explosive": 5
}, ["RocketLauncher"], 150, "Rare")
self.Missile = Projectile("Missile", {
"Iron": 15,
"Explosive": 10
}, ["MissileLauncher"], 200, "Rare")
## Weapons:
self.Arm = Weapon("Arm", None, "Range", 1, 90, None, 2, False,
"Common")
self.Bow = Weapon("Bow", {
"Wood": 8,
"Vine": 1
}, "Range", 1.25, 60, None, 3, False, "Common")
self.Crossbow = Weapon("Crossbow", {
"Wood": 10,
"Vine": 2
}, "Range", 1.25, 60, None, 3, True, "Common")
self.CombatBucket = Weapon("Combat Bucket", {"IronIngot: 12"}, "Range",
1.75, 100, None, 0, False, "Uncommon")
self.Slingshot = Weapon("Slingshot", {
"Wood": 8,
"Vine": 1
}, "Range", 0.75, 90, None, 1, False, "Common")
self.Cannon = Weapon("Cannon", {
"Iron": 1,
"Wood": 200,
"Explosive": 2
}, "Range", 10, 100, None, 1, False, "Uncommon")
self.RocketLauncher = Weapon("Rocket Launcher", {
"Iron": 20,
"Stone": 185,
"Wood": 15,
"Explosive": 6
}, "Range", 25, 100, None, 6, True, "Rare")
self.MissileLauncher = Weapon("Missile Launcher", {
"Iron": 50,
"Stone": 200,
"Wood": 50,
"Explosive": 8
}, "Range", 40, 100, None, 8, True, "Legendary")
self.Fists = Weapon("Fists", None, "Melee", 0.5, 100, 5, 0, None,
"Common")
self.BoneBlade = Weapon("Bone Blade", {"Bone": 3}, "Melee", 1.25, 90,
10, 0, None, "Common")
self.BoneStriker = Weapon("Bone Striker", {"Bone": 8}, "Melee", 1.25,
90, 25, 0, None, "Uncommon")
self.WoodenSword = Weapon("Wooden Sword", {"Wood": 8}, "Melee", 1, 80,
17, 0, None, "Common")
self.StoneSword = Weapon("Stone Sword", {
"Stone": 10,
"Wood": 3
}, "Melee", 1, 80, 20, 0, None, "Common")
self.IronSword = Weapon("Iron Sword", {
"IronIngot": 10,
"Wood": 3
}, "Melee", 1, 80, 23, 0, None, "Uncommon")
self.DiamondSword = Weapon("Diamond Sword", {
"Diamond": 10,
"Wood": 3
}, "Melee", 1, 80, 26, 0, None, "Rare")
self.WoodenAxe = Weapon("Wooden Axe", {"Wood": 9}, "Melee", 1.5, 70,
26, 0, None, "Common")
self.StoneAxe = Weapon("Stone Axe", {
"Stone": 10,
"Wood": 4
}, "Melee", 1.5, 70, 30, 0, None, "Common")
self.IronAxe = Weapon("Iron Axe", {
"IronIngot": 10,
"Wood": 4
}, "Melee", 1.5, 70, 34, 0, None, "Uncommon")
self.DiamondAxe = Weapon("Diamond Axe", {
"Diamond": 10,
"Wood": 4
}, "Melee", 1.5, 70, 38, 0, None, "Rare")
self.WoodenSpear = Weapon("Wooden Spear", {"Wood": 10}, "Melee", 1.75,
60, 30, 1, None, "Common")
self.StoneSpear = Weapon("Stone Spear", {
"Stone": 10,
"Wood": 5
}, "Melee", 1.75, 60, 35, 1, None, "Common")
self.IronSpear = Weapon("Iron Spear", {
"IronIngot": 10,
"Wood": 5
}, "Melee", 1.75, 60, 40, 1, None, "Uncommon")
self.DiamondSpear = Weapon("Diamond Spear", {
"Diamond": 10,
"Wood": 5
}, "Melee", 1.75, 60, 45, 1, None, "Rare")
self.WoodenBoomerang = Weapon("Wooden Boomerang", {"Wood": 12},
"Melee", 3, 90, 40, 2, None, "Common")
self.StoneBoomerang = Weapon("Stone Boomerang", {
"Stone": 10,
"Wood": 6
}, "Melee", 3, 90, 50, 2, None, "Common")
self.IronBoomerang = Weapon("Iron Boomerang", {
"IronIngot": 10,
"Wood": 6
}, "Melee", 3, 90, 60, 2, None, "Uncommon")
self.DiamondBoomerang = Weapon("Diamond Boomerang", {
"Diamond": 10,
"Wood": 6
}, "Melee", 3, 90, 70, 2, None, "Rare")
self.Bomb = Weapon("Bomb", {
"Stone": 25,
"Wood": 25,
"Explosive": 5
}, "Melee", 15, 100, 100, 0, None, "Common")
self.Grenade = Weapon("Grenade", {
"Stone": 4,
"Wood": 4,
"Explosive": 2
}, "Melee", 8, 100, 75, 0, None, "Common")
self.Dynamite = Weapon("Dynamite", {"Explosive": 1}, "Melee", 1, 100,
50, None, False, "Common")
## Mobs:
self.Fighter = Mob()
self.Predator = Mob()
self.Goblin = Mob()
self.Destroyer = Mob()
self.Annihilator = Mob()
self.Troll = Mob()
self.Raider = Mob()
self.Minion = Mob()
self.Zombie = Mob()
self.Defender = Mob()
self.Guardian = Mob()
self.Skeleton = Mob()
self.Hunter = Mob()
self.Assasin = Mob()
self.Ghoul = Mob()
## Animals:
self.Chicken = Animal()
self.Rabbit = Animal()
self.Cow = Animal()
self.Fish = Animal()
self.Sheep = Animal()
## Biomes:
self.Forest = Biome("Forest", "into a", self.Wood, self.Soil,
self.Soil, self.Fighter, self.Fighter,
self.Fighter, self.Chicken, None, None, "Common")
self.Jungle = Biome("Jungle", "into a", self.Wood, self.Soil,
self.Emerald, self.Fighter, self.Fighter,
self.Predator, self.Chicken, None, None,
"Uncommon")
self.Grove = Biome("Grove", "into a", self.Wood, self.Fruit,
self.Emerald, self.Fighter, self.Predator,
self.Fighter, self.Chicken, None, None, "Rare")
self.Garden = Biome("Garden", "into a", self.Wood, self.Emerald,
self.Gold, self.Fighter, self.Predator,
self.Goblin, self.Chicken, self.HarvesterArmor,
self.Protector, "Legendary")
self.Desert = Biome("Desert", "into a", self.Sand, self.Stone,
self.Stone, self.Destroyer, self.Destroyer,
self.Destroyer, self.Rabbit, None, None, "Common")
self.Tundra = Biome("Tundra", "into a", self.Sand, self.Stone,
self.Iron, self.Destroyer, self.Destroyer,
self.Annihilator, self.Rabbit, None, None,
"Uncommon")
self.Badland = Biome("Badland", "into a", self.Sand, self.Cacti,
self.Iron, self.Destroyer, self.Annihilator,
self.Destroyer, self.Rabbit, None, None, "Rare")
self.Temple = Biome("Temple", "into a", self.Sand, self.Iron,
self.Diamond, self.Destroyer, self.Annihilator,
self.Troll, self.Rabbit, self.Strawman,
self.Coffin, "Legendary")
self.Prairie = Biome("Prairie", "into a", self.Soil, self.Water,
self.Water, self.Raider, self.Raider, self.Raider,
self.Cow, None, None, "Common")
self.Meadow = Biome("Meadow", "into a", self.Soil, self.Water,
self.Diamond, self.Raider, self.Raider,
self.Minion, self.Cow, None, None, "Uncommon")
self.Swamp = Biome("Swamp", "into a", self.Soil, self.Vine,
self.Diamond, self.Raider, self.Minion, self.Raider,
self.Cow, None, None, "Rare")
self.Fort = Biome("Fort", "into a", self.Soil, self.Diamond,
self.Quartz, self.Raider, self.Minion, self.Zombie,
self.Cow, self.Ladder, MobRepellant, "Legendary")
self.Lake = Biome("Lake", "into a", self.Water, self.Sand, self.Water,
self.Defender, self.Defender, self.Defender,
self.Fish, None, None, "Common")
self.Beach = Biome("Beach", "into a", self.Water, self.Sand, self.Gold,
self.Defender, self.Defender, self.Guardian,
self.Fish, None, None, "Uncommon")
self.Island = Biome("Island", "onto an", self.Water, self.Bone,
self.Gold, self.Defender, self.Guardian,
self.Defender, self.Fish, None, None, "Rare")
self.Shipwreck = Biome("Shipwreck", "into a", self.Water, self.Gold,
self.Emerald, self.Defender, self.Guardian,
self.Skeleton, self.Fish, self.BottledWave,
self.BottledWind, "Legendary")
self.Mountain = Biome("Mountain", "onto a", self.Stone, self.Wood,
self.Sand, self.Hunter, self.Hunter, self.Hunter,
self.Sheep, None, None, "Common")
self.Canyon = Biome("Canyon", "into a", self.Stone, self.Wood,
self.Quartz, self.Hunter, self.Hunter,
self.Assasin, self.Sheep, None, None, "Uncommon")
self.Cave = Biome("Cave", "into a", self.Stone, self.Explosive,
self.Quartz, self.Hunter, self.Assasin, self.Hunter,
self.Sheep, None, None, "Rare")
self.Monument = Biome("Monument", "into a", self.Stone, self.Iron,
self.Quartz, self.Hunter, self.Assasin,
self.Ghoul, self.Sheep, self.Glider,
self.Binoculars, "Legendary")
## Environments:
self.Woodlands = Environment(self.Forest, self.Jungle, self.Grove,
self.Garden)
self.Plains = Environment(self.Desert, self.Tundra, self.Badland,
self.Temple)
self.Grasslands = Environment(self.Prairie, self.Meadow, self.Swamp,
self.Fort)
self.Waterlands = Environment(self.Lake, self.Beach, self.Island,
self.Shipwreck)
self.Rockylands = Environment(self.Mountain, self.Canyon, self.Cave,
self.Monument)
## Player:
self.Player = Character(
"Player 1", 0, [], [],
[[time() - COLLECT_DELAY for square in range(51)]
for row in range(51)], 100, 100, {}, None, None, [26, 26],
"North", time())
## Other:
self.items = [eval("self." + item) for item in ITEMS
] #### Consider making this the inventory (0)
#### self.biomes = [eval("self." + item) for item in BIOMES]
## Startup:
self.startup()
cannon.shoot(projectile)
rel_pos = []
while projectile.pos[1] >= castle.pos[1]:
physics.timestep(projectile)
rel_pos.append(physics.distance(projectile, castle))
scores = (2 - np.array(rel_pos)) / 2
return max(scores) if len(rel_pos) > 0 else 0.0
ball = Projectile(2.0)
impulse = np.array([0.08, 0.05])
castle = Castle()
physics = Physics(0.001)
cannons = generateInitialPopulation(100)
for i in range(100):
scores = []
for cannon in cannons:
scores.append(score(cannon))
if i % 10 == 0:
def launch_projectile(self):
# Création nouvelle instance de projectile
self.all_projectiles.add(Projectile(self))
self.start_anmation()
# Jouer le son
self.game.sound_manager.play("tir")
def keyLogger(self):
keys = pygame.key.get_pressed()
if self.shootLoop > 0:
self.shootLoop += 1
if self.shootLoop > 3:
self.shootLoop = 0
if (keys[pygame.K_LEFT] and self.x > 0):
self.x = self.x - self.charSize
self.left = True
self.right = False
self.standing = False
if (keys[pygame.K_RIGHT]
and self.x < self.width - (self.charSize + 20)):
self.x = self.x + self.charSize
self.left = False
self.right = True
self.standing = False
if (keys[pygame.K_SPACE] and self.shootLoop == 0
and len(self.bullets) < 5):
self.bullet.play()
if self.left:
facing = -1
else:
facing = +1
self.bullets.append(
Projectile(self.x + self.charSize // 2,
self.y + self.charSize // 2, 6, (0, 0, 0), facing))
self.shootLoop = 1
else:
self.standing = True
self.walkCount = 0
if keys[pygame.K_UP] and not self.inJump:
self.inJump = True
self.left = False
self.right = False
self.walkCount = 0
if self.inJump:
if self.JumpCount >= -10:
if self.JumpCount < 0:
neg = -1
else:
neg = 1
self.y -= self.JumpCount**2 * 0.5 * neg
self.JumpCount -= 1
else:
self.JumpCount = 10
self.inJump = False
pygame.display.init()
width = 800
height = 800
framerate = 30 # frames/s
simulation_time_step = 0.01 # s
screen = pygame.display.set_mode((width, height))
screen.fill((255, 255, 255))
pygame.display.set_caption("Ballistic Trajectory Simulator")
projectile = Projectile(
mass,
radius,
(initial_velocity[0], initial_velocity[1] * -1),
(0, height / 2),
drag_coefficient,
)
atmospheric_density = 1.225 # kg/m^3
simulating = True
async def simulation_loop():
previous_time = datetime.datetime.now()
global simulating
while simulating:
projectile.step(simulation_time_step, atmospheric_density,
scale_factor)
for event in pygame.event.get():
if event.type == pygame.QUIT: sys.exit()
elif event.type == pygame.KEYDOWN:
if (event.key == pygame.K_UP or event.key == pygame.K_w):
man.direction("up")
elif (event.key == pygame.K_DOWN or event.key == pygame.K_s):
man.direction("down")
elif (event.key == pygame.K_RIGHT or event.key == pygame.K_d):
man.direction("right")
elif (event.key == pygame.K_LEFT or event.key == pygame.K_a):
man.direction("left")
#-------------------------------------------------------------------------------
if (event.key == pygame.K_SPACE):
if man.havePistol == True:
projectiles += [
Projectile(10, man.rect.center, man.heading,
screenSize)
]
if man.ammo > 0:
man.ammo -= 1
elif man.ammo <= 0:
man.ammo += 20
if man.ammo == 0 or man.ammo <= 0:
man.haveNothing = True
man.havePistol = False
print "Ammo:", man.ammo
#-----------------------------------------------------------------------------------
for zombie in zombies:
if man.haveStick:
if zombie.distToPoint(