niti: fix type in tool description

[nit.git] / examples / shoot / src / shoot_logic.nit

# 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 writable = 0

        # Number of basic bullets fired together
        var nbshoots: Int writable = 1

        # Time bebore the player shoot again a basic bullet (cooldown)
        # Shoot if 0
        var shoot_ttl = 0

        # Number of missiles
        var nbmissiles: Int writable = 0

        # 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 writable = false

        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
end

# Simple shooter of paris of basic bullets
class Enemy1
        super Enemy

        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 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

# Enem that shoot rings of basic bullets
class Enemy3
        super Enemy

        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 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 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 = 128 * 100
                self.height = 100 * 100
                self.x = scene.width / 2
                self.y = -100 * 100
                self.left_part = new BossPart(self, -48*100)
                self.right_part = new BossPart(self, 48*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 = 32 * 100
                self.height = 60 * 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 writable = null

        # The width of the whole scene
        var width: Int writable

        # The height of the whole scene
        var height: Int 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 writable = false
        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
        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