+++ /dev/null
-# This file is part of NIT ( http://www.nitlanguage.org ).
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Space shooter.
-# This program is a fun game but also a good example of the scene2d module
-module shoot_logic
-
-import scene2d
-
-# The ship of the player
-class Player
- super Sprite
-
- # Where the player is going
- var going_target = new GoingTarget
-
- # Activate the `going_target`
- fun goes_to(x,y: Int, speed: Int)
- do
- going_target.x = x
- going_target.y = y
- going_target.active = true
- var angle = angle_to(going_target)
- set_velocity(angle, speed)
- end
-
- # Current forture of the player
- var money: Int = 0 is writable
-
- # Number of basic bullets fired together
- var nbshoots: Int = 1 is writable
-
- # Time bebore the player shoot again a basic bullet (cooldown)
- # Shoot if 0
- var shoot_ttl = 0
-
- # Number of missiles
- var nbmissiles: Int = 0 is writable
-
- # Time bebore the player shoot again a missile (cooldown)
- # Shoot if 0
- var missile_ttl = 0
-
- # Remainind time when the player is protected from impacts
- var protected_ttl = 0
-
- # The associated play scene
- # (mainly used to registed shoots)
- var scene: PlayScene
-
- init(scene: PlayScene) do
- self.scene = scene
- self.width = 2400
- self.height = 2400
- end
-
- redef fun update
- do
- super
-
- # Out of screen?
- if self.y < 0 then
- self.y = 0
- self.vy = 0
- else if self.y > scene.height then
- self.y = scene.height
- self.vy = 0
- end
- if self.x < 0 then
- self.x = 0
- self.vx = 0
- else if self.x > scene.width then
- self.x = scene.width
- self.vx = 0
- end
-
- # Update of the player protection if any
- if protected_ttl > 0 then protected_ttl -= 1
-
- # Need to shoot basic bullets?
- if shoot_ttl > 0 then
- shoot_ttl -= 1
- else
- shoot_ttl = 30
- for i in [0..nbshoots[ do
- var shoot = new Shoot(scene)
- shoot.x = x
- shoot.y = top
- shoot.vy = -500
- shoot.vx = (i - nbshoots / 2) * 100
- scene.player_shoots.add(shoot)
- end
- end
-
- # Need to shoot missiles?
- if missile_ttl > 0 then
- missile_ttl -= 1
- else if nbmissiles > 0 then
- missile_ttl = 500 / nbmissiles
- var shoot = new Missile(scene)
- shoot.x = x
- shoot.y = top
- shoot.vy = -300
- shoot.vx = 0
- scene.player_shoots.add(shoot)
- end
-
- end
-
- # Time before the player is respawned by the scene
- var respawn_ttl: Int = 0
-
- fun hit
- do
- if self.protected_ttl > 0 then return
- self.scene.explosion(self.x, self.y, 10)
- self.exists = false
-
- # Reset the position for respawn
- self.x = scene.width / 2
- self.y = scene.height - 10000
- self.vx = 0
- self.vy = 0
- self.respawn_ttl = 50
- end
-
-end
-
-# Sprites that may be hit by the player.
-# Eq. enemies, bullets, loots, etc.
-class Hitable
- super Sprite
-
- # What do do when self is hit by the player.
- # By defaut, do nothing
- fun hit_by_player(player: Player) do end
-end
-
-# Destination for the player (pointer position)
-class GoingTarget
- super Hitable
-
- # true in on move, false if player is at rest
- var active = false is writable
-
- init do
- self.width = 500
- self.height = 500
- end
-
- redef fun hit_by_player(player)
- do
- if not active then return
- active = false
- player.vx = 0
- player.vy = 0
- end
-end
-
-# A bullet shooted by a ship
-class Shoot
- super Hitable
-
- # Was the shoot fired by an enemy.
- # Since there is no frendly fire, it is important to distinguish ownership
- var enemy: Bool = false
-
- # The scene of the sprite
- # Is used with bound limits
- var scene: PlayScene
-
- init(scene: PlayScene)
- do
- self.scene = scene
- self.width = 800
- self.height = 800
- end
-
- redef fun update
- do
- super
-
- # Out of screen ?
- if self.y < -100 * 100 or self.y > scene.height + 10000 or self.x < -100 * 100 or self.x > scene.width + 10000 then
- self.exists = false
- end
- end
-
- redef fun hit_by_player(player)
- do
- player.hit
- self.exists = false
- end
-end
-
-# A advanced bullet that aims a target (player or enemy)
-class Missile
- super Shoot
-
- # The target aquired by the missile
- var target: nullable Sprite = null
-
- # When ttl is 0 then the angle stay fixed
- # The angle is updated toward the target if ttl>0
- var ttl: Int = 200
-
- redef fun update
- do
- super
-
- # Do we still update the angle ?
- if ttl <= 0 then return
- ttl -= 1
-
- # Do we have a target?
- var target = self.target
- if target == null or not target.exists then return
-
- # Just update the angle
- var angle = self.angle_to(target)
- self.set_velocity(angle, 300)
- end
-end
-
-# A enemy ship
-# Various enemies exists, each kind has its own subclass
-abstract class Enemy
- super Hitable
-
- # The scene of the ship
- # Is used to store created bullets or to get info about the player
- var scene: PlayScene
-
- # Time bebore the enemy shoot again (cooldown)
- # Shoot if 0
- # The default value is used as a grace period to avoid a first shoot on
- # the first update
- var shoot_ttl = 50
-
- init(scene: PlayScene)
- do
- self.width = 2400
- self.height = 2400
- self.scene = scene
- scene.enemies.add(self)
- end
-
- redef fun update
- do
- super
-
- # Out of screen ?
- if self.y > scene.height + 10000 or self.x < -100 * 100 or self.x > scene.width + 10000 then
- # Note: no control on the top to let ennemies appear
- self.exists = false
- end
-
- # Need to shoot?
- if shoot_ttl > 0 then
- shoot_ttl -= 1
- else
- shoot
- end
- end
-
- # Each enemy has its own kind of shoot strategy
- # Note: is automatically called by update when shoot_ttl is expired
- fun shoot do end
-
- # Money given when the enemy is destroyed
- fun loot: Int is abstract
-
- # What to do when the enemy is hit by a player shoot (or by the player himself)?
- # By default it kill the enemy in an explosion and generate a loot
- fun hit
- do
- self.exists = false
- scene.explosion(self.x, self.y, 5)
- if 100.rand < 3 then
- var upmissile = new UpMissile(scene)
- upmissile.x = self.x
- upmissile.y = self.y
- upmissile.vx = 0
- upmissile.vy = 0
- scene.loots.add(upmissile)
- scene.hitables.add(new LootArea(upmissile, 2000))
- else
- for i in [0..self.loot[ do
- var money = new Money(scene)
- money.x = self.x
- money.y = self.y
- money.set_velocity(100.rand.to_f*pi/50.0, (500+self.loot).rand)
- scene.loots.add(money)
- scene.hitables.add(new LootArea(money, 2000))
- end
- end
- end
-
- redef fun hit_by_player(player)
- do
- player.hit
- hit
- end
-end
-
-# Basic enemy, do not shoot
-class Enemy0
- super Enemy
-
- redef fun loot do return 3
-
- redef init(scene)
- do
- self.width = 3600
- self.height = 3600
- end
-end
-
-# Simple shooter of pairs of basic bullets
-class Enemy1
- super Enemy
-
- redef init(scene)
- do
- self.width = 4400
- self.height = 4400
- end
-
- redef fun shoot
- do
- # Next shoot
- shoot_ttl = 50
-
- # two bullets shoot each time
- for dx in [-11, 11] do
- var shoot = new Shoot(scene)
- shoot.enemy = true
- shoot.x = self.x + dx * 100
- shoot.y = self.bottom
- shoot.vy = 500
- scene.enemy_shoots.add(shoot)
- end
- end
-
- redef fun loot do return 5
-end
-
-# Enemy that shoot missiles
-class Enemy2
- super Enemy
-
- redef init(scene)
- do
- self.width = 6000
- self.height = 6000
- end
-
- redef fun shoot
- do
- # Next shoot
- shoot_ttl = 200
-
- # The missile targets the player
- var shoot = new Missile(scene)
- shoot.enemy = true
- shoot.x = self.x
- shoot.y = self.bottom
- shoot.vy = 500
- shoot.target = scene.player
- scene.enemy_shoots.add(shoot)
- end
-
- redef fun loot do return 10
-end
-
-# Enemy that shoot rings of basic bullets
-class Enemy3
- super Enemy
-
- redef init(scene)
- do
- self.width = 5800
- self.height = 5800
- end
-
- redef fun shoot
- do
- # Next shoot
- shoot_ttl = 50
-
- for i in [0..10[ do
- var shoot = new Shoot(scene)
- shoot.enemy = true
- shoot.x = self.x
- shoot.y = self.bottom
- shoot.set_velocity(pi/5.0*i.to_f, 500)
- scene.enemy_shoots.add(shoot)
- end
- end
-
- redef fun loot do return 20
-end
-
-# Enemy with a turret that shoot burst of bullets toward the player
-class Enemy4
- super Enemy
-
- # The angle of the turret
- var angle: Float = 0.0
-
- redef init(scene)
- do
- self.width = 4200
- self.height = 4200
- end
-
- redef fun update
- do
- super
-
- # Rotate the turret toward the player
- var target = scene.player
- if target.exists then
- angle = self.angle_to(target)
- end
- end
-
- # Shoots come in burst
- var nbshoots: Int = 0
-
- redef fun shoot
- do
- # Next shoot: is there still bullets in the burst?
- if self.nbshoots < 10 then
- # Is ther
- self.nbshoots += 1
- shoot_ttl = 5
- else
- self.nbshoots = 0
- shoot_ttl = 80
- end
-
- # Shoot with the turret angle
- var shoot = new Shoot(scene)
- shoot.enemy = true
- shoot.x = self.x
- shoot.y = self.y
- shoot.set_velocity(angle, 500)
- scene.enemy_shoots.add(shoot)
- end
-
- redef fun loot do return 20
-end
-
-# Enemy that rush directly on the player
-class EnemyKamikaze
- super Enemy
-
- redef init(scene)
- do
- self.width = 3200
- self.height = 3200
- end
-
- redef fun update
- do
- super
-
- # Try to target the player
- var target = scene.player
- if not target.exists then return
-
- var angle = self.angle_to(target)
- self.set_velocity(angle, 600)
- end
-
- redef fun loot do return 5
-end
-
-# The boss has two semi-independent arms
-class Boss
- super Enemy
-
- # Left arm
- var left_part: BossPart
-
- # Right arm
- var right_part: BossPart
-
- init(scene)
- do
- super
- self.width = 140 * 100
- self.height = 96 * 100
- self.x = scene.width / 2
- self.y = -100 * 100
- self.left_part = new BossPart(self, -66*100)
- self.right_part = new BossPart(self, 66*100)
- end
-
- var flick_ttl: Int = 0
-
- redef fun update
- do
- if flick_ttl > 0 then flick_ttl -= 1
-
- # Path of the boss (down then left<->right)
- if self.y < 20000 then
- self.vx = 0
- self.vy = 100
- else if self.vx == 0 then
- self.vx = 100
- self.vy = 0
- else if self.x > scene.width - 10000 and self.vx > 0 then
- self.vx = -self.vx
- else if self.x < 10000 and self.vx < 0 then
- self.vx = -self.vx
- end
-
- super
- end
-
- redef fun shoot
- do
- # Do not shoot if not ready
- if self.vy != 0 then return
-
- # Try to target the player
- var target = scene.player
- if not target.exists then return
-
- # Next shoot: burst if no arms remains
- if left_part.exists or right_part.exists then
- shoot_ttl = 60
- else
- shoot_ttl = 20
- end
-
- # Shoot the player with a basic bullet
- var shoot = new Shoot(scene)
- shoot.enemy = true
- shoot.x = self.x
- shoot.y = self.bottom
- var angle = shoot.angle_to(target)
- shoot.set_velocity(angle, 500)
- scene.enemy_shoots.add(shoot)
- end
-
- redef fun loot do return 100
-
- var live: Int = 20
-
- redef fun hit
- do
- # Protected while an arm remains
- if left_part.exists or right_part.exists then return
-
- if live > 0 then
- live -= 1
- flick_ttl = 2
- else
- super
- scene.explosion(self.x, self.y, 30)
- end
- end
-end
-
-# An arm of a boss
-class BossPart
- super Enemy
-
- # The associated boss
- var boss: Boss
-
- # Relative x coordonate (center to center) of the arm
- var relx: Int
-
- # Relative y coordonate (center to center) of the arm
- var rely: Int = 36 * 100
-
- var live: Int = 10
-
- init(boss: Boss, relx: Int)
- do
- self.boss = boss
- self.relx = relx
- super(boss.scene)
- self.width = 38 * 100
- self.height = 48 * 100
-
- # Alternate the shoots of the arms
- if relx > 0 then
- shoot_ttl += 300
- end
- self.x = boss.x + relx
- self.y = boss.y + rely
- end
-
- redef fun update
- do
- self.x = boss.x + relx
- self.y = boss.y + rely
-
- super
-
- if flick_ttl > 0 then flick_ttl -= 1
- end
-
- redef fun shoot
- do
- # Do not shoot if not ready
- if self.boss.vy != 0 then return
-
- # Next shoot
- shoot_ttl = 600
-
- # Shoot a missile that targets the player
- var shoot = new Missile(scene)
- shoot.enemy = true
- shoot.x = self.x
- shoot.y = self.bottom
- shoot.vy = 500
- shoot.target = scene.player
- scene.enemy_shoots.add(shoot)
- end
-
- var flick_ttl: Int = 0
-
- redef fun hit
- do
- if live > 0 then
- live -= 1
- flick_ttl = 2
- else
- super
- end
- end
-
- redef fun loot do return 10
-end
-
-# Whatever reward or bonus that can be picked by the player
-abstract class Loot
- super Hitable
-
- var scene: PlayScene
-
- init(scene: PlayScene)
- do
- self.scene = scene
- self.width = 400
- self.height = 400
- end
-
- # Magnet effect: The loot will move to the target if set
- # See LootArea for details
- var target: nullable Sprite = null
-
- redef fun update
- do
- super
-
- # Out of screen ?
- if self.y > scene.height + 10000 then
- self.exists = false
- end
-
- var target = self.target
- if target == null then
- # Not magneted: deploy
-
- # Heavy fuild friction to stops the explosion
- # Loots are placed with a explosion, see `Enemy::hit'
- self.vx = self.vx*7/8
- self.vy = self.vy*7/8
-
- # Background scroling
- self.y += 50
-
- else if target.exists then
- # Magneted: rush toward the target
- var angle = self.angle_to(target)
- self.set_velocity(angle, 800)
-
- else
- # Magneted but dead target: reset the loot
- self.vx = 0
- self.vy = 0
- self.target = null
- end
- end
-end
-
-# Basic money loot
-class Money
- super Loot
-
- redef fun hit_by_player(player)
- do
- self.exists = false
- player.money += 1
- if player.money > 100 then
- player.money -= 100
- player.nbshoots += 1
- end
- end
-end
-
-# Increase the number of missiles
-class UpMissile
- super Loot
-
- redef fun hit_by_player(player)
- do
- self.exists = false
- player.nbmissiles += 1
- end
-end
-
-# A loot area is an invisible field used to implement the magnet effets of loots
-# The principle is:
-# * the loot is an invisible sprite with a hitbox larger than the loot hitbox
-# * the lootbox remains centered on the loot
-# * when the player hit the lootarea, then the loot is set to target the player
-# * when the player hit the loot, then the player gains effectively the loot
-class LootArea
- super Hitable
-
- # The associated loot
- var loot: Loot
-
- init(loot: Loot, radius: Int)
- do
- self.loot = loot
- self.width = radius * 2 + loot.width
- self.height = radius * 2 + loot.height
- end
-
- redef fun update
- do
- # position remains centered on the loot
- self.x = loot.x
- self.y = loot.y
-
- # No area if no loot
- if not loot.exists then self.exists = false
-
- # the super is useless but it is a good practice to call it
- super
- end
-
- redef fun hit_by_player(player)
- do
- # Kill the area
- self.exists = false
-
- # The loot now targets the player
- loot.target = player
- end
-end
-
-# A non interactive element of an explosion
-# A real explosion is made of many Explosion object
-# Use the `PlayScene::explosion` method to generate a full explosion
-class Explosion
- super Sprite
-
- # Time before the sprite vanishes
- var ttl: Int = 10
-
- redef fun update
- do
- # Heavy fuild friction to stops the explosion
- self.vx = self.vx*7/8
- self.vy = self.vy*7/8
-
- # Background scrolling
- self.y += 50
-
- super
-
- # Vanishes?
- if ttl > 0 then
- ttl -= 1
- else
- exists = false
- end
- end
-end
-
-# A star is a non-interactive background element
-# Stars are used to simulate a continuous global scroling
-class Star
- super Sprite
-
- # The scene of the sprite
- # Is used with bound limits
- var scene: ShotScene
-
- init(scene: ShotScene)
- do
- self.scene = scene
- # Randomely places stars on the plane
- self.x = scene.width.rand
- self.y = scene.height.rand
- self.vy = 40.rand + 11
- end
-
- redef fun update
- do
- super
-
- # Replace the star on the top
- if self.y > scene.height then
- self.y = 200.rand * -100
- self.x = scene.width.rand
- self.vy = 40.rand + 11
- end
- end
-end
-
-class ShotScene
- super Scene
-
- # When a scene need to be replaced, just assign the next_scene to a non null value
- var next_scene: nullable ShotScene = null is writable
-
- # The width of the whole scene
- var width: Int is writable
-
- # The height of the whole scene
- var height: Int is writable
-
- init(w,h: Int)
- do
- width = w
- height = h
- end
-end
-
-# The main play state
-class PlayScene
- super ShotScene
-
- # The player ship
- var player: Player
-
- # Shoots of the player
- var player_shoots = new LiveGroup[Shoot]
-
- # Enemy ships
- var enemies = new LiveGroup[Enemy]
-
- # Soots of the enemy
- var enemy_shoots = new LiveGroup[Shoot]
-
- # Collectible loots
- var loots = new LiveGroup[Loot]
-
- # Non active stuff like explosions
- var pasive_stuff = new LiveGroup[LiveObject]
-
- # Background stuff like stars
- var background = new LiveGroup[LiveObject]
-
- # All other hitable sprites
- var hitables = new LiveGroup[Hitable]
-
- # All sprites
- var sprites = new LiveGroup[LiveObject]
-
- init(w,h)
- do
- super
- self.player = new Player(self)
- player.x = self.width / 2
- player.y = self.height - 10000
- self.sprites.add(background)
- self.sprites.add(pasive_stuff)
- self.sprites.add(loots)
- self.sprites.add(player_shoots)
- self.sprites.add(enemy_shoots)
- self.sprites.add(enemies)
- self.sprites.add(self.player)
- self.sprites.add(hitables)
-
- for i in [0..100[ do
- background.add(new Star(self))
- end
-
- hitables.add(player.going_target)
- end
-
- # Generate an explosion
- fun explosion(x, y: Int, radius: Int)
- do
- # Project explosion parts from the given position
- # The strong friction and the short ttl of each part will achieve the effect
- for i in [0..radius[ do
- var ex = new Explosion
- ex.x = x
- ex.y = y
- ex.set_velocity(100.rand.to_f*pi/50.0, (50*radius).rand)
- ex.ttl += radius.rand
- pasive_stuff.add(ex)
- end
- end
-
- var enemy_remains: Int = 15
- var boss_wait_ttl: Int = 0
- var boss: nullable Boss
-
- redef fun update
- do
- sprites.gc
- sprites.update
-
- if enemy_remains == 0 then
- if boss_wait_ttl > 0 then
- boss_wait_ttl -= 1
- else if boss == null then
- boss = new Boss(self)
- enemy_remains = 15
- else if not boss.exists then
- boss = null
- end
- else if 100.rand < 1 then
- enemy_remains -= 1
- if enemy_remains == 0 then
- boss_wait_ttl = 500
- end
- var rnd = 100.rand
- var enemy: Enemy
- if rnd < 40 then
- enemy = new Enemy0(self)
- else if rnd < 60 then
- enemy = new Enemy1(self)
- else if rnd < 70 then
- enemy = new EnemyKamikaze(self)
- else if rnd < 90 then
- enemy = new Enemy2(self)
- else if rnd < 95 then
- enemy = new Enemy3(self)
- else
- enemy = new Enemy4(self)
- end
- enemy.x = (self.width - 20000).rand + 10000
- enemy.vy = 200.rand + 100
- if 10.rand < 3 then
- enemy.vx = 200.rand - 100
- end
- end
-
- for ps in player_shoots do
- if not ps.exists then continue
- var target: nullable Enemy = null
- var td = 100000 # big int
- for e in enemies do
- if not e.exists then continue
- if ps.overlaps(e) then
- ps.exists = false
- e.hit
- end
- var d = (e.x - ps.x).abs + (e.y - ps.y).abs
- if td > d then
- target = e
- td = d
- end
- end
- if ps isa Missile and (ps.target == null or not ps.target.exists) then
- ps.target = target
- end
- end
-
- for e in enemies do
- if not e.exists then continue
- if player.exists and player.overlaps(e) then
- e.hit_by_player(player)
- end
- end
- for s in enemy_shoots do
- if not s.exists then continue
- if player.exists and player.overlaps(s) then
- s.hit_by_player(player)
- end
- end
- for l in loots do
- if not l.exists then continue
- if player.exists and player.overlaps(l) then
- l.hit_by_player(player)
- end
- end
- for l in hitables do
- if not l.exists then continue
- if player.exists and player.overlaps(l) then
- l.hit_by_player(player)
- end
- end
- if not player.exists then
- if player.respawn_ttl > 0 then
- player.respawn_ttl -= 1
- else
- player.exists = true
- player.protected_ttl = 100
- self.sprites.add(self.player)
- end
- end
- end
-end
-
-###
-
-class MenuScene
- super ShotScene
-
- var sprites = new LiveGroup[LiveObject]
-
- init(w,h)
- do
- super
- for i in [0..100[ do
- sprites.add(new Star(self))
- end
- end
-
- var play: Bool = false is writable
- var ttl: Int = 50
-
- redef fun update
- do
- sprites.update
-
- if not play then return
- if ttl > 0 then
- ttl -= 1
- return
- end
- next_scene = new PlayScene(width,height)
- end
-end
-
-fun headless_run
-do
- srand_from 0
- print "Headless run"
- # Only run the playscene
- var scene = new PlayScene(80000,60000)
- # beefup the player
- scene.player.nbshoots = 5
- scene.player.nbmissiles = 5
- # play
- print "Play"
- var turns = 10
- if args.length > 0 then
- turns = args.first.to_i
- end
- for i in [0..turns[ do
- for j in [0..10000[ do
- scene.update
- end
- print "{i}: money={scene.player.money} enemies={scene.enemies.length} shoots={scene.player_shoots.length}"
- end
- print "Game Over"
-end
-
-headless_run
nitlanguage / nit.git / blobdiff