def __init__(self, pos = (0,0), **images) : Projectile.__init__ (self, pos, **images) Weapon.__init__ (self, pos, **images) self._has_been_launched = False self.set_knockback_factor (5) self._damage = 5 self._name = "Bomb"
class ShotTracker:
def __init__(self, win, angle, velocity, height):
"""win is the GraphWin to display the shot. angle, velocity,
and height are initial projectile parameters.
"""
self.proj = Projectile(angle, velocity, height)
self.marker = Circle(Point(0, height), 3)
self.marker.setFill("red")
self.marker.setOutline("red")
self.marker.draw(win)
def update(self, dt):
"""Move the shot dt seconds farther along its flight"""
# update the projectile
self.proj.update(dt)
# move the circle to the new projectile location
center = self.marker.getCenter()
dx = self.proj.getX() - center.getX()
dy = self.proj.getY() - center.getY()
self.marker.move(dx, dy)
def getX(self):
"""return the current x coordinate of the shot's center"""
return self.proj.getX
def getY(self):
"""return the current y coordinate of the shot's center"""
return self.proj.getY()
def undraw(self):
"""undraw the shot"""
self.marker.undraw()
def main ():
#Introduction
print ("This program graphically depicts the flight of a cannonball. ")
print ()
#Get inputs
a = eval(input("Enter the launch angle in degrees: "))
v = eval(input("Enter the initial velocity in meters per second: "))
h = eval(input("Enter the initial height in meters: "))
#Create tracker
projectile = Projectile(a, v, h)
win = GraphWin(200, 200)
win.setCoords(0.0, 0.0, 25.0, 25.0)
tracker = Tracker(win, projectile)
time = 0.0
while projectile.getY() >= -5:
time += .0005
projectile.update(time)
tracker.update()
#Close window
win.getMouse()
win.close()
def set(cls, x, y, vel=0, angle=0, gravity=0):
if cls.all_p_stack.is_empty() != True:
p = cls.all_p_stack.pop()
Concrete_shot.add_to_class_lst(p, Megaman_object.hazards, p.ID)
p.grounded = False
p.is_shattered = False
Projectile.set(p, x, y, vel, angle=angle, gravity=gravity)
def __init__(self, watcher_pmx_name, watcher_vmd_name):
Projectile.__init__(self, watcher_pmx_name, watcher_vmd_name)
self.set_overwrite_bones([
'左上主砲X', 'PU主砲_砲身_U', 'PU主砲_砲身_U先', 'PU主砲_砲身_L', 'PU主砲_砲身_L先',
'右上主砲X', 'SU主砲_砲身_U', 'SU主砲_砲身_U先', 'SU主砲_砲身_L', 'SU主砲_砲身_L先'
])
self.set_point_mode('ARM')
def __init__(self, win, angle, velocity, height):
# displays initial projectile parameters
self.proj = Projectile(angle, velocity, height)
self.marker = Circle(Point(0, height), 3)
self.marker.setFill("red")
self.marker.setOutline("red")
self.marker.draw(win)
def make_projectile_down(time):
fire_ball = Projectile(player, "down")
projectile_add(fire_ball)
fire_ball.shoot_left(pygame.time.get_ticks())
engine.events[pygame.USEREVENT + evCnt()] = fire_ball.shoot_down
engine.collisions[dark_knight] = (fire_ball, dark_knight.getHit)
make_boss()
def main():
angle, vel, h0, time = getInputs()
cball = Projectile(angle, vel, h0)
while cball.getY >= 0:
cball.update(time)
print "The distance traveled is: %0.1f meters." %(cball.getX())
def xofangle(x):
myRamp = Ramp(100, 0)
myProjectile = Projectile(math.sqrt(2), x, 0, myRamp)
myProjectile.calcxtFall(0.00000000000000001)
return myProjectile.xFall
def __init__(self, main):
self.main = main
self.scr = self.main.scr
self.size = self.main.size
self.wsx = self.wsy = 0
self.vwsx = self.vwsy = 0
self.projectile = Projectile(self)
self.player = Player(self)
self.enemyC = Enemy(self)
self.effectC = Effect(self)
self.entitylist = []
self.bg = p.Color("black")
self.s1 = Slider({
"window": self.scr,
"pos": [500, 500, 50, 30],
"color": (0, 255, 200),
"color2": (255, 0, 55),
"colorindex": 100,
"steps": {
"startpoint": 1,
"endpoint": 10
},
"font": {
"size": 15,
"clicksize": 20
}
})
def __init__( self, window, angle, velocity, height ):
self.projectile = Projectile( angle, velocity, height )
self.ball = Circle( Point( 0, height ), 3 )
self.ball.setOutline( 'red' )
self.ball.setFill( 'red' )
self.ball.draw( window )
def __init__(self, game = None, parent = None, vel = Vec3()):
models = MODELS_PATH + "Bullet"
anims = {}
vel.normalize()
vel *= random.randint(15, 20)
Projectile.__init__(self, models, anims, "**/CollisionSphere", game, parent, parent.getPos(), vel)
def __init__(self, win, angle, velocity, height):
"""win is the GraphWin to display the shot. angle, velocity,
and height are initial procetile parameters."""
self.proj = Projectile(angle, velocity, height)
self.marker = Circle(Point(0, height), 3)
self.marker.setFill("red")
self.marker.setOutline("red")
self.marker.draw(win)
def __init__(self, width, height, x, y, owner=None): Projectile.__init__(self, 25, 25, x, y) self.owner = owner self.speed = 5 # initialize sprite lists ss = SpriteSheet(path.join(get_art_dir(), 'Monkey', 'Banana_spritesheet.png'), 8) self.sprites_throw_right = ss.get_sprites(size=(25, 25)) self.sprites_throw_left = [pygame.transform.flip(s, True, False) for s in self.sprites_throw_right]
def __init__(self, x, y, xvel, yvel, image):
Projectile.__init__(self, x, y, image)
self.rect = self.image.get_rect()
self.rect.width = 3
self.rect.height = 3
self.xvel = xvel
self.yvel = yvel
self.rect.x = x
self.rect.y = y
def read_projectile_trajectories(csv_file="Dataset.csv"):
projectiles = []
with open(csv_file, 'rb') as csvfile:
reader = csv.reader(csvfile, delimiter=',')
projectile = Projectile()
first_iteration = True
for row in reader:
time, along_x, along_y = int(row[0]), float(row[1]), float(row[2])
if not(first_iteration) and time == 0:
projectiles.append(projectile)
projectile = Projectile()
projectile.add_trajectory_point(time, along_x, along_y)
continue
projectile.add_trajectory_point(time, along_x, along_y)
first_iteration = False
if projectile.trajectory_points_count() != 0:
projectiles.append(projectile)
return projectiles
def render(screen, width, height, gamestate, selected_id, host, port):
raycaster = Raycaster(gamestate["players"], gamestate["walls"])
raycaster.update()
map_size = raycaster.get_map_size() + 1.0
if selected_id == 0:
for player in gamestate["players"]:
Game.render_vision(raycaster, player, screen, width, height, map_size, len(gamestate["players"]))
elif selected_id > 0 and selected_id - 1 < len(gamestate["players"]):
Game.render_vision(raycaster, gamestate["players"][selected_id - 1], screen, width, height, map_size,
len(gamestate["players"]))
Map.render(gamestate["walls"], screen, width, height, map_size)
for p in gamestate["players"]:
Player.render(p, raycaster, screen, width, height, map_size)
for projectile in gamestate["projectiles"]:
Projectile.render(projectile, screen, width, height, map_size)
for p in gamestate["players"]:
Player.render_font(p, screen, width, height, map_size)
myfont = pygame.font.SysFont("Arial", 22)
label = myfont.render("Ticks remaining: " + str(gamestate["remaining_ticks"]), 1, (255, 255, 255))
s = pygame.Surface((label.get_width() + 20, label.get_height() + 20), pygame.SRCALPHA) # per-pixel alpha
s.fill((45, 45, 45, 200))
screen.blit(s, (width // 2 - label.get_width() // 2 - 10, 0))
screen.blit(label, (width // 2 - label.get_width() // 2, 10))
myfont = pygame.font.SysFont("Arial", 16)
label = myfont.render("test", 1, (255, 255, 255))
line_height = label.get_height()
myfont = pygame.font.SysFont("Arial", 32)
label = myfont.render("Ranking-----", 1, (255, 255, 255))
line_width = label.get_width()
s = pygame.Surface((line_width + 20, line_height * (len(gamestate["ranking"]) + 2) + 40), pygame.SRCALPHA) # per-pixel alpha
s.fill((45, 45, 45, 200))
screen.blit(s, (0, 0))
myfont = pygame.font.SysFont("Arial", 32)
label = myfont.render("Ranking", 1, (255, 255, 255))
screen.blit(label, (10, 10))
myfont = pygame.font.SysFont("Arial", 16)
i = 2
sorted_x = sorted(gamestate["ranking"].items(), key=operator.itemgetter(1), reverse=True)
for key, value in sorted_x:
label = myfont.render(key + ": " + str(value), 1, (255, 255, 255))
screen.blit(label, (10, 10 + label.get_height() * 1.1 * i))
i += 1
myfont = pygame.font.SysFont("Arial", 32)
label = myfont.render(host + ":" + str(port), 1, (255, 255, 0))
s = pygame.Surface((label.get_width() + 20, label.get_height() + 20), pygame.SRCALPHA) # per-pixel alpha
s.fill((45, 45, 45, 200))
screen.blit(s, (width // 2 - label.get_width() // 2 - 10, height - label.get_height() - 20))
screen.blit(label, (width // 2 - label.get_width() // 2, height - label.get_height() - 10))
def __init__(self, character):
Projectile.__init__(self, self)
self.initial_x_coordinate = character.x_coordinate
self.initial_y_coordinate = character.y_coordinate
self.x_coordinate = character.x_coordinate
self.y_coordinate = character.y_coordinate
self.old_x_coordinate = self.x_coordinate
self.old_y_coordinate = self.y_coordinate
self.direction = character.direction
Projectile.projectile_count += 1
Projectile.piercing_projectile_list.append(self)
def handle_speed():
global actualLevel
time = pygame.time.get_ticks() // 1000
steep = time // gameConfigs["timeToIncreaseSpeed"]
if steep > actualLevel:
actualLevel += 1
if (Ship.speed <= gameConfigs["maxSpeed"]):
Ship.speedUp()
Enemy.speedUp()
Projectile.speedUp()
def enemies_fire():
for e in global_var.enemies:
if len(global_var.enemies) > 10:
if random.randint(0, 100) % 2 == 0:
global_var.projectiles.append(
Projectile(canvas, 'red', player, False,
e.enemieX0 + e.enemie_width // 2, e.enemieY1))
else:
global_var.projectiles.append(
Projectile(canvas, 'red', player, False,
e.enemieX0 + e.enemie_width // 2, e.enemieY1))
def main():
angle, vel, h0, time = getInputs()
window = GraphWin("window",250,250)
cball = Projectile(angle, vel, h0)
#Tracker(window,cball)
while cball.getY() >= 0:
cball.update(.001)
Tracker(window,cball)
window.getMouse()
window.close()
print("\nDistance traveled: {0:0.1f} meters.".format(cball.getX()))
def handle_speed():
global actualLevel
time = pygame.time.get_ticks() // 1000
steep = time // gameConfigs["timeToIncreaseSpeed"]
print(steep)
if steep > actualLevel:
actualLevel += 1
if (Ship.speed <= gameConfigs["maxSpeed"]):
Ship.speedUp()
Enemy.speedUp()
Projectile.speedUp()
def main ():
#Introduction
print ("This program uses a cannonball to shoot at a target.")
#Create graphics window
win = GraphWin(200, 200)
win.setCoords(0.0, 0.0, 25.0, 25.0)
target = Target(win)
flag = False
targetHit = False
while not flag:
#Get inputs
print ()
a = eval(input("Enter the launch angle in degrees: "))
v = eval(input("Enter the initial velocity in meters per second: "))
h = eval(input("Enter the initial height in meters: "))
#Create tracker
projectile = Projectile(a, v, h)
tracker = Tracker(win, projectile)
time = 0.0
while projectile.getY() >= -5:
time += .0005
projectile.update(time)
tracker.update()
#Calculate if cannonball hit target
points = target.points()
center = tracker.circ.getCenter()
center_x = center.getX()
center_y = center.getY()
radius = tracker.circ.getRadius()
for point in points:
x = point.getX()
y = point.getY()
square_dist = (center_x-x) ** 2 + (center_y-y) ** 2
if square_dist <= radius ** 2:
targetHit = True
if targetHit:
print ("\nYou hit the target!")
flag = True
else:
flag = False
print ("\nTry again!")
#Close window
win.getMouse()
win.close()
def shoot_projectile(self, tank):
if tank.direction == 'l':
start_pos = Position(tank.position.x - 1, tank.position.y)
self.game_level.projectiles.append(Projectile(start_pos, 'l'))
elif tank.direction == 'r':
start_pos = Position(tank.position.x + 1, tank.position.y)
self.game_level.projectiles.append(Projectile(start_pos, 'r'))
elif tank.direction == 'd':
start_pos = Position(tank.position.x, tank.position.y + 1)
self.game_level.projectiles.append(Projectile(start_pos, 'd'))
elif tank.direction == 'u':
start_pos = Position(tank.position.x, tank.position.y - 1)
self.game_level.projectiles.append(Projectile(start_pos, 'u'))
def main():
#Introduction
print("This program uses a cannonball to shoot at a target.")
#Create graphics window
win = GraphWin("Target", 200, 200)
win.setCoords(0.0, 0.0, 25.0, 25.0)
target = Target(win)
flag = False
targetHit = False
while not flag:
#Get inputs
print()
a = eval(input("Enter the launch angle in degrees: "))
v = eval(input("Enter the initial velocity in meters per second: "))
h = eval(input("Enter the initial height in meters: "))
#Create tracker
projectile = Projectile(a, v, h)
tracker = Tracker(win, projectile)
time = 0.0
while projectile.getY() >= -5:
time += .0005
projectile.update(time)
tracker.update()
#Calculate if cannonball hit target
points = target.points()
center = tracker.circ.getCenter()
center_x = center.getX()
center_y = center.getY()
radius = tracker.circ.getRadius()
for point in points:
x = point.getX()
y = point.getY()
square_dist = (center_x - x)**2 + (center_y - y)**2
if square_dist <= radius**2:
targetHit = True
if targetHit:
print("\nYou hit the target!")
flag = True
else:
flag = False
print("\nTry again!")
#Close window
win.getMouse()
win.close()
def main():
angle, vel, h0, time = getInputs()
cball = Projectile(angle, vel, h0)
while cball.getY() >= 0 and cball.getYv() >= 0:
cball.update(time)
print("\nDistance traveled: {0:0.1f} meters.".format(cball.getX()))
print("Max height: {0:0.1f} meters.".format(cball.getY()))
class BaseballTracker:
def __init__( self, window, angle, velocity, height ):
self.projectile = Projectile( angle, velocity, height )
self.ball = Circle( Point( 0, height ), 3 )
self.ball.setOutline( 'red' )
self.ball.setFill( 'red' )
self.ball.draw( window )
def update( self, timeInterval ):
prevX = self.projectile.getX()
prevY = self.projectile.getY()
self.projectile.update( timeInterval )
dx = self.projectile.getX() - prevX
dy = self.projectile.getY() - prevY
self.ball.move( dx, dy )
def clear( self ):
self.ball.undraw()
def getX( self ):
return self.projectile.getX()
def getY( self ):
return self.projectile.getY()
def main():
win = GraphWin("Projectile Tracker", 600, 600)
win.setCoords(0, 0, 1400, 1400)
missile = Projectile(45, 100, 0)
tracker = Tracker(win, missile, 1400)
while missile.getY() >= 0:
missile.update(.05)
dx = missile.getX()
dy = missile.getY()
tracker.move(dx, dy)
print("{}:{}".format(missile.getX(), missile.getY()))
def render_game(self, screen, width, height):
if self.selected_player == 0:
self.render_lobby(screen, width, height, False)
return
raycaster = Raycaster(self.players, self.walls)
raycaster.update()
map_size = raycaster.get_map_size() + 1.0
#self.render_vision(raycaster, self.player, screen, width, height, map_size)
Map.render(self.walls, screen, width, height, map_size)
#Map.render(raycaster.get_lines(), screen, width, height, map_size)
for p in self.players:
Player.render(p, raycaster, screen, width, height, map_size)
for projectile in self.projectiles:
Projectile.render(projectile, screen, width, height, map_size)
for p in self.players:
Player.render_font(p, screen, width, height, map_size)
myfont = pygame.font.SysFont("Arial", 22)
label = myfont.render("Ticks remaining: " + str(self.remaining_ticks), 1, (255, 255, 255))
s = pygame.Surface((label.get_width() + 20, label.get_height() + 20), pygame.SRCALPHA) # per-pixel alpha
s.fill((45, 45, 45, 200))
screen.blit(s, (width // 2 - label.get_width() // 2 - 10, 0))
screen.blit(label, (width // 2 - label.get_width() // 2, 10))
myfont = pygame.font.SysFont("Arial", 16)
label = myfont.render("test", 1, (255, 255, 255))
line_height = label.get_height()
myfont = pygame.font.SysFont("Arial", 32)
label = myfont.render("Ranking-----", 1, (255, 255, 255))
line_width = label.get_width()
s = pygame.Surface((line_width + 20, line_height * (len(self.ranking) + 2) + 40), pygame.SRCALPHA) # per-pixel alpha
s.fill((45, 45, 45, 200))
screen.blit(s, (0, 0))
myfont = pygame.font.SysFont("Arial", 32)
label = myfont.render("Ranking", 1, (255, 255, 255))
screen.blit(label, (10, 10))
myfont = pygame.font.SysFont("Arial", 16)
i = 2
sorted_x = sorted(self.ranking.items(), key=operator.itemgetter(1), reverse=True)
for key, value in sorted_x:
label = myfont.render(key + ": " + str(value), 1, (255, 255, 255))
screen.blit(label, (10, 10 + label.get_height() * 1.1 * i))
i += 1
def launch_projectile(self):
"""
Permet l'apparition des projectiles en jeu.
:return:
"""
# créer une nouvelle instance de la classe projectile
self.all_projectiles.add(Projectile(self))
def __init__(self, time):
self.xPos = 1195
self.yPos = -50
self.width = 300
self.height = 400
self.direction = 'e'
self.previousDirection = 'e'
self.speed = 0.05
self.health = 20
self.hurt = False
self.hurtTime = 0
self.changeInHp = 0
self.attacking = 0 # 0 = not, 1 = up, 2 = right, 3 = down, 4 = down
self.attackingTime = 0
self.floorTile = 3
self.base = Base(self.xPos, self.yPos, self.width, self.height, 50,
200)
self.pathTime = time
self.pathTimeUpdateRate = 1000
self.directions = ['n', 'ne', 'e', 'se', 's', 'sw', 'w', 'nw']
self.currentFrame = -1
self.currentTime = -1
self.projectiles = [Projectile(0, 0, 0, 0, 'none', 0, 0, 0, 0, 0)]
self.dying = False
self.dead = False
self.endOfOrange = False
def launch_projectile(self):
# creer une nouvelle instance de la classe Projectile
self.all_projectiles.add(Projectile(self))
# demarrer l'animation du lancer
self.start_animation()
# jouer le son
self.game.sound_manager.play('tir')
def __init__(self, main):
self.main = main
self.scr = self.main.scr
self.size = self.main.size
self.wsx = self.wsy = 0
self.vwsx = self.vwsy = 0
self.projectile = Projectile(self)
self.player = Player(self)
self.enemyC = Enemy(self)
self.effectC = Effect(self)
self.entitylist = []
self.bg = p.Color("black")
self.s1 = Slider(
{
"window": self.scr,
"pos": [500, 500, 50, 30],
"color": (0, 255, 200),
"color2": (255, 0, 55),
"colorindex": 100,
"steps": {"startpoint": 1, "endpoint": 10},
"font": {"size": 15, "clicksize": 20},
}
)
def update(self):
self.gunLastShot += 1
image = pygame.image.load("assets/images/player-ship.png")
imageMoveLeft = pygame.image.load("assets/images/player-ship-left.png")
imageMoveRight = pygame.image.load(
"assets/images/player-ship-right.png")
keys = pygame.key.get_pressed()
if keys[pygame.K_LEFT]:
self.x -= self.speed
super().__init__(self.screen, (self.x, self.y), imageMoveLeft)
if keys[pygame.K_RIGHT]:
self.x += self.speed
super().__init__(self.screen, (self.x, self.y), imageMoveRight)
if not keys[pygame.K_RIGHT] and not keys[pygame.K_LEFT]:
super().__init__(self.screen, (self.x, self.y), image)
if keys[pygame.K_SPACE] and self.gunLastShot > self.gunDelay:
self.gunLastShot = 0
pygame.mixer.music.load("assets/audios/gunshot.ogg")
pygame.mixer.music.play()
projectile = Projectile(self.screen,
(self.x + self.width // 2, self.y),
Projectile.UP)
ProjectileList.projectiles.append(projectile)
self.check_dead()
super().update()
def launch_projectile(self):
self.all_projectiles.add(Projectile(self))
# demarrer l'animation du lancer
self.start_animation()
# jouer le son
self.game.sound_manager.play('tir')
def update(self):
self.steep()
self.directionTime += 1
if (pygame.time.get_ticks() / 1000 > EnemiesList.lastSpawn + 5):
EnemiesList.randomSpawn(self.screen)
if random.randint(0, 1000) < 20:
pygame.mixer.music.load("assets/audios/gunshot2.ogg")
pygame.mixer.music.play()
projectile = Projectile(self.screen,
(self.x + self.width // 2, self.y),
Projectile.DOWN)
ProjectileEnemiesList.projectiles.append(projectile)
isInLeftBorder = self.x <= 0
isInRigthBorder = self.x >= gameConfigs["width"] - self.width
if isInLeftBorder or isInRigthBorder:
self.toggleDirection()
maxRand = gameConfigs["width"] // 2 + (self.directionTime * 3) // 1
valueToToggle = random.randint(gameConfigs["width"] // 3, maxRand)
if valueToToggle > gameConfigs["width"]:
self.toggleDirection()
self.resetDirectionTime()
self.check_dead()
super().update()
def launch_projectile(self,
target,
speed,
start=None,
dmg=0,
dmg_type='magical',
special_collision_func=None,
ending_func=None):
if start is None:
start = self.position
start_euc = self.board.get_hex_center_euc(start)
end_euc = self.board.get_hex_center_euc(target)
def collision_func(unit):
print("projectile colliding on ", unit.name, "from ", self.name)
if unit.team_id != self.team_id:
self.deal_damage(unit, dmg, dmg_type)
if special_collision_func:
special_collision_func(unit)
self.board.projectiles.add(
Projectile(self,
start_euc,
end_euc,
speed,
img='imgs/%s_ability.png' % self.name,
collision_func=collision_func,
ending_func=ending_func))
def specialAbility2(self):
"""
Rockets
:return: True if player has mana
"""
if self.mana >= 5:
if self.team == 'BLUE':
bigassbullet = Projectile(self.x, self.y, 4, 40, self.team, "assets/Rocket(blue).png")
if self.team == 'RED':
bigassbullet = Projectile(self.x, self.y, 4, 40, self.team, "assets/Rocket(red).png")
self.allprojectiles.add(bigassbullet)
self.bigassbullets.add(bigassbullet)
self.sprites.add(bigassbullet)
self.mana -= 5
self.manaspent += 5
return True
def launch_projectile(self):
"""Launch projectiles
PRE:/
POST: Use object of the class and add it to the attribut group
"""
self.all_projectile.add(Projectile(self))
def SpawnProjectile(position, angle, weaponDamage, weaponKnockback,
weaponProjectileSpeed, ID, source, crit):
angle += random.random() * 0.125 - 0.06125
damage = int(weaponDamage) + int(tables.projectileData[ID][2])
power = int(weaponProjectileSpeed)
velocity = (math.cos(angle) * power, math.sin(angle) * power)
knockback = int(weaponKnockback) + int(tables.projectileData[ID][3])
if commons.SOUND:
sound_manager.sounds[int(tables.projectileData[ID][9])].play()
projectiles.append(
Projectile(position,
velocity,
str(tables.projectileData[ID][1]),
ID,
source,
damage,
knockback,
crit,
int(tables.projectileData[ID][4]),
str(tables.projectileData[ID][6]),
GRAVITY=float(tables.projectileData[ID][7]),
DRAG=float(tables.projectileData[ID][8])))
def fire(self):
current_time = pygame.time.get_ticks()
if current_time - self.time_since_fire > 300:
self.time_since_fire = current_time
self.game.all_projectiles.add(
Projectile(self.game, self, self.get_pos(),
self.heading_point))
def launch_projectile(self):
# nouvelle instance de la class Projectile
self.all_projectile.add(
Projectile(self)) # ajout du projectile dans le groupe
self.start_animation() == True # demarre l'anim
# jouer le son
self.game.sound_manager.play("tir")
def fire(self):
angle_radians = math.radians(self.rotation)
ship_radius = self.image.width/2 + 5.0
bullet_x = self.x + math.sin(angle_radians) * ship_radius
bullet_y = self.y + (math.cos(angle_radians) * ship_radius)
new_bullet = Projectile(name="bullet",
img=self.weapon_projectile_image,
x=bullet_x, y=bullet_y, batch=self.batch)
new_bullet.velocity_x = (
self.velocity_x +
math.sin(angle_radians) * self.weapon_projectile_speed
)
new_bullet.velocity_y = (
self.velocity_y +
math.cos(angle_radians) * self.weapon_projectile_speed
)
self.new_objects.append(new_bullet)
def fire_saucer(self):
for saucer in self.saucers:
if saucer.counter > (30 * self.level_mod):
saucer.counter = 0
bullet1 = Projectile('bullet', 0, -10, 'computer')
bullet1.x = saucer.center_x - bullet1.width/2
bullet1.y = saucer.y - saucer.height/2
self.add_widget(bullet1)
bullet2 = Projectile('bullet', -7, -7, 'computer')
bullet2.x = saucer.center_x - bullet2.width/2 - saucer.width * .4
bullet2.y = saucer.y - saucer.height/2
self.add_widget(bullet2)
bullet3 = Projectile('bullet', 7, -7, 'computer')
bullet3.x = saucer.center_x - bullet3.width/2 + saucer.width * .4
bullet3.y = saucer.y - saucer.height/2
self.add_widget(bullet3)
else: saucer.counter += 1
def fire_drone(self):
for drone in self.drones:
if drone.counter > (30 * self.level_mod):
drone.counter = 0
bullet1 = Projectile('bullet', 0, -10, 'computer')
bullet1.x = drone.center_x - bullet1.width/2 + drone.width * .4
bullet1.y = drone.y
self.add_widget(bullet1)
bullet2 = Projectile('bullet', 0, -10, 'computer')
bullet2.x = drone.center_x - bullet2.width/2 - drone.width * .4
bullet2.y = drone.y
self.add_widget(bullet2)
else: drone.counter += 1
def __init__ (self, pos = (0,0), **images) : Projectile.__init__ (self, pos,**images) self.set_gravity (0) self.set_knockback_factor (5) self.set_damage (5) self._name = "Bullet"
def __init__(self):
Base.__init__(self)
self.visual = VisualObject(os.path.join("data", "banana.png"))
def update (self) : Projectile.update (self)
def __init__ (self, pos = (0,0), **images) : Projectile.__init__ (self, pos, **images) self._spread = .10 self._name = "Shotgun Shell"
def __init__(self, position, vecteur): Projectile.__init__(self, position, vecteur) self.posx, self.posy = (float(position[0]), float(position[1]))
def main():
# Draw the window to simulate green field and sky.
win = GraphWin("Shoot a Cannon!", 850,850)
win.setCoords(0,-50,700,700)
win.setBackground("lightblue")
ground = Rectangle(Point(0,-100),Point(700,0))
ground.setFill("green")
cloud1 = Oval(Point(153,420),Point(390,580))
cloud1.setFill("white")
cloud1.setWidth(2)
cloud2 = Oval(Point(23,232),Point(230,400))
cloud2.setFill("white")
cloud2.setWidth(2)
cloud3 = Oval(Point(434,370),Point(610,520))
cloud3.setFill("white")
cloud3.setWidth(2)
tangle = Text(Point(30,680), " Angle: ")
tvel = Text(Point(30,650), "Velocity:")
anginp = Entry(Point(70,680),3)
velinp = Entry(Point(70,650),3)
fbutton = CButton(win,Point(55,590),30,"FIRE!")
fbutton.activate()
quitbutton = CButton(win,Point(630,660),30,"Quit")
quitbutton.activate()
ground.draw(win)
cloud1.draw(win)
cloud2.draw(win)
cloud3.draw(win)
tangle.draw(win)
tvel.draw(win)
anginp.draw(win)
anginp.setText("0")
velinp.setText("0")
velinp.draw(win)
target = Target(win)
pt = win.getMouse()
shots = 0
while not quitbutton.clicked(pt):
try:
if fbutton.clicked(pt):
ang = float(anginp.getText())
vel = float(velinp.getText())
shot = Projectile(ang,vel,0)
ball = Tracker(win,shot)
while shot.getY() >= 0 and target.Hit(shot) == False and shot.getX() < 750:
sleep(.025)
shot.update(.1)
ball.update(win,shot)
target.Hit(shot)
if target.Hit(shot) == True:
shots += 1
wintxt = Text(Point(325,500), "You Hit the Target in %d shot(s)!" % shots)
wintxt.setSize(36)
wintxt.setTextColor("red")
wintxt.draw(win)
exit
shots += 1
except ValueError:
exit
pt = win.getMouse()
def take_damage(self, damage=0):
Projectile.take_damage(self, damage)
def __init__(self, pos, target, image, speed, damage):
Projectile.__init__(self, pos, target, image, speed, damage)
self.radius = 50
def update (self) : if self._has_been_launched : Projectile.update (self) else : Weapon.update (self)
def main():
angle, vel, h0, time = getInputs()
cball = Projectile(angle, vel, h0)
while cball.getY() >= 0:
cball.update(time)
print("\nDistance traveled: {0:0.1f} meters.".format(cball.getX()))
def launch (self, velocity) : Projectile.launch (self, velocity) self._has_been_launched = True
class World(object):
def __init__(self, main):
self.main = main
self.scr = self.main.scr
self.size = self.main.size
self.wsx = self.wsy = 0
self.vwsx = self.vwsy = 0
self.projectile = Projectile(self)
self.player = Player(self)
self.enemyC = Enemy(self)
self.effectC = Effect(self)
self.entitylist = []
self.bg = p.Color("black")
self.s1 = Slider(
{
"window": self.scr,
"pos": [500, 500, 50, 30],
"color": (0, 255, 200),
"color2": (255, 0, 55),
"colorindex": 100,
"steps": {"startpoint": 1, "endpoint": 10},
"font": {"size": 15, "clicksize": 20},
}
)
def restart(self):
self.__init__(self.main)
def shiftworld(self):
self.s1.pos[0] -= self.vwsx / 3.0
self.s1.pos[1] -= self.vwsy / 3.0
def update(self):
self.scr.fill(self.bg)
self.vwsx = self.player.vx
self.vwsy = self.player.vy
self.wsx += self.vwsx
self.wsy += self.vwsy
self.entitylist = [self.player] + [e for e in self.enemyC.opponentlist]
if self.main.holdingSpace:
self.player.shoot(
{
"dad": self.player,
"color": (0, 250, 100),
"colorindex": (0, 100, 50),
"angle": self.player.rotation,
"radius": 2,
"speed": 16,
"damage": 1.5,
"lifetime": 90,
"pos": self.player.pos,
}
)
self.player.update()
self.enemyC.update()
self.effectC.update()
self.projectile.udpate()
self.shiftworld()
Stars.update(self)
self.s1.update()
def draw(self):
Stars.draw()
self.s1.draw()
self.effectC.draw()
self.projectile.draw()
self.enemyC.draw()
self.player.draw()
Messages.message(self.scr, str(self.wsx) + " " + str(self.wsy), (10, 40), p.Color("magenta"))
Messages.message(self.scr, len(self.projectile.projectiles), (10, 70), p.Color("magenta"))
Messages.message(self.scr, self.enemyC.totaldied, (10, 100), p.Color("green"))
def _on_keyboard_down(self, keyboard, keycode, text, modifiers):
if keycode[1] == 'escape':
self.root_widget.close_app()
if keycode[1] == 'left':
self.ship.steer_x(-20)
elif keycode[1] == 'right':
self.ship.steer_x(20)
elif keycode[1] == 'up':
self.ship.steer_y(20)
elif keycode[1] == 'down':
self.ship.steer_y(-20)
elif keycode[1] == 'f' and not self.ship.is_shielded and self.ship.cooldown == 0:
self.ship.cooldown = 25
missile = Projectile('missile', 0, 10, 'human')
missile.score_bonus = 5
missile.size = 75, 75
missile.x = self.ship.get_center_x() - missile.width / 2
missile.y = self.ship.y + self.ship.height
self.add_widget(missile)
elif keycode[1] == 's' and not self.ship.is_shielded and self.ship.cooldown == 0:
# if self.sfx_laser.state == 'play':
# self.sfx_laser.stop()
self.ship.cooldown = 5
self.sfx_laser.play()
laser1 = Projectile('laser', 0, 20, 'human')
laser1.x = self.ship.x + self.ship.width * .35
laser1.y = self.ship.y + self.ship.height / 10
self.add_widget(laser1)
laser2 = Projectile('laser', 0, 20, 'human')
laser2.x = self.ship.x - self.ship.width * .35
laser2.y = self.ship.y + self.ship.height / 10
self.add_widget(laser2)
elif keycode[1] == 'd':
self.ship.toggle_shield()
# elif keycode[1] == 'q':
# self.ship.shield('green')
return True
def DoSkillSpell(mob,skillname):
from projectile import Projectile
from spell import SpawnSpell
player = mob.player
mobSkill = mob.mobSkillProfiles[skillname]
classSkill = mobSkill.classSkill
# Assert that mob knows the skill.
skillLevel = mob.skillLevels.get(skillname,0)
if not skillLevel:
return False
# Modify skill spells strength by skill level.
mod = float(skillLevel) / float(classSkill.maxValue)
# Clamp mod to produce at least 10% of maximum effect.
if mod < .1:
mod = .1
proto = classSkill.spellProto
# Get the appropriate target for this skill spell.
tgt = mob.target
if proto.target == RPG_TARGET_SELF:
tgt = mob
elif proto.target == RPG_TARGET_PARTY:
tgt = mob
elif proto.target == RPG_TARGET_ALLIANCE:
tgt = mob
elif proto.target == RPG_TARGET_PET:
tgt = mob.pet
elif player and proto.spellType&RPG_SPELL_HEALING and proto.target == RPG_TARGET_OTHER:
tgt = GetPlayerHealingTarget(mob,tgt,proto)
# If no valid target could be found, return in failure.
# Here's one last chance to still acquire one.
if not tgt:
if player:
if proto.spellType&RPG_SPELL_HARMFUL:
from command import CmdTargetNearest
CmdTargetNearest(mob,None,False,True)
tgt = mob.target
if not tgt:
player.sendGameText(RPG_MSG_GAME_DENIED,"$src's <a:Skill%s>%s</a> skill failed, no target.\\n"%(GetTWikiName(skillname),skillname),mob)
else:
tgt = mob
# Still no target, now definitely abort skill.
# If the mob is a player mob, message has already be sent.
if not tgt:
return False
# For harmful skill spells, check if target may
# be harmed at all. Abort if not.
if proto.spellType&RPG_SPELL_HARMFUL:
if not AllowHarmful(mob,tgt) and not proto.aoeRange:
if player:
player.sendGameText(RPG_MSG_GAME_DENIED,"$src's <a:Skill%s>%s</a> skill failed, no valid target.\\n"%(GetTWikiName(skillname),skillname),mob)
return False
if not player and not (mob.master and mob.master.player) and not IsKOS(mob,tgt):
return False
# If the skill spell isn't harmful and the target is hostile,
# retarget self.
if not proto.spellType&RPG_SPELL_HARMFUL and mob.target == tgt:
if tgt and IsKOS(tgt,mob):
tgt = mob
# Check for a skill raise.
if mob.character:
c = 10
if mobSkill.reuseTime > 180:
c = 5
if mobSkill.reuseTime > 180*2:
c = 3
mob.character.checkSkillRaise(skillname,c)
# Play animation and trigger particles if available.
if proto.animOverride:
mob.zone.simAvatar.mind.callRemote("playAnimation",mob.simObject.id,proto.animOverride)
if len(proto.particleNodes):
mob.zone.simAvatar.mind.callRemote("triggerParticleNodes",mob.simObject.id,proto.particleNodes)
# Launch a projectile if necessary, otherwise spawn skill spell.
if proto.projectile:
p = Projectile(mob,mob.target)
p.spellProto = proto
p.launch()
else:
SpawnSpell(proto,mob,tgt,tgt.simObject.position,mod,skillname)
# Return True, so skill was used.
return True
