contrib/tinks: do not publish TankMoveEvents for dead tanks

[nit.git] / contrib / tinks / src / game / tanks.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
# See the License for the specific language governing permissions and
# limitations under the License.

# Tank and tank turret related logic
module tanks is serialize

import world

redef class TGame
        # All of the tanks in game
        var tanks = new TankSet

        redef fun do_turn
        do
                var turn = super
                for tank in tanks do tank.do_turn turn
                return turn
        end
end

# Stats of a tank kind, its config should be move to the `Story` if we want more than 1
class TankRule
        super Rule

        # Width of this tank
        var width: Float = 64.0/32.0

        # Height of this tank
        var length: Float = 100.0/32.0

        # Maximum `health` this tank can normally have
        var max_health = 4

        # Maximum speed of this tank (in world coordinate units per seconds)
        var max_speed = 2.0

        # Turret turning speed (in radians per second)
        var turret_turn_speed = 1.6

        # Waiting time between shots can be fired
        var turret_cooldown_time = 2.0

        # Maximum `direction_heading` heading, may be double
        var max_direction = 1.0
end

redef class Story
        # The main (and only) tank configuration in this game
        var tanks: Array[TankRule] = [new TankRule(self)]
end

# A tank!
class Tank
        super TTurnable
        super Ruled
        redef type R: TankRule

        # In world `Pos` of this entity
        var pos: Pos

        # Orientation of this entity
        var heading: Float

        # The turret mounted on this tank
        var turret = new Turret(self)

        # Commanded direction
        var direction_heading = 0.0

        # Commanded speed
        var direction_forwards = 0.0

        # Health of this tank, out of `rule.max_health`
        var health: Int = rule.max_health is lazy

        redef fun do_turn(turn)
        do
                var collisions = next_move_collisions(turn)

                if collisions.is_empty then
                        var next = normal_next_pos(turn)
                        self.pos = next.first
                        self.heading = next.second
                end

                turret.do_turn turn

                if health > 0 then
                        turn.add new TankMoveEvent(self, pos, direction_heading, direction_forwards, heading, turret.relative_heading)
                end
        end

        # What would be the next position if not blocked by terrain features?
        #
        # Returns a couple of the new position and heading.
        fun normal_next_pos(turn: TTurn): Couple[Pos, Float]
        do
                var heading = (heading + direction_heading * turn.dts).angle_normalize

                var speed = direction_forwards * rule.max_speed * turn.dts
                var pos = pos
                if speed != 0.0 then
                        pos += heading.to_vector(speed)
                end

                return new Couple[Pos, Float](pos, heading)
        end

        # Damage this tank, server-side
        fun hit(turn: TTurn)
        do
                var damage = 1
                var health = health - damage

                if health <= 0 then
                        destroy turn
                else
                        turn.add new TankHealthChange(self, health)
                end
        end

        # Destroy this tank, server-side
        fun destroy(turn: TTurn)
        do
                turn.add new TankDeathEvent(self)
                turn.game.world.explode(turn, pos, 3)
        end

        # Collisions on the next move
        fun next_move_collisions(turn: TTurn): HashSet[Feature]
        do
                var next = normal_next_pos(turn)
                var features = new HashSet[Feature]

                # Use the lines between the corners to detect collisions
                var corners = corners_at(next)
                var prev_corner = corners.last
                for corner in corners do
                        var feature = turn.game.world.first_collision(prev_corner, corner)
                        if feature != null then features.add feature
                        prev_corner = corner
                end

                return features
        end

        # Get the 4 corners at a `next` position
        fun corners_at(next: Couple[Pos, Float]): Array[Pos]
        do
                var next_pos = next.first
                var heading = next.second

                var corners = new Array[Pos]

                var hwy = rule.width/2.0 * (heading+pi/2.0).sin
                var hwx = rule.width/2.0 * (heading+pi/2.0).cos
                var hly = rule.length/2.0 * heading.sin
                var hlx = rule.length/2.0 * heading.cos
                corners.add new Pos(next_pos.x + hlx + hwx, next_pos.y + hly + hwy)
                corners.add new Pos(next_pos.x + hlx - hwx, next_pos.y + hly - hwy)
                corners.add new Pos(next_pos.x - hlx - hwx, next_pos.y - hly - hwy)
                corners.add new Pos(next_pos.x - hlx + hwx, next_pos.y - hly + hwy)

                return corners
        end
end

# A tank turret
class Turret
        super TTurnable

        # The `Tank` on which is mounted this turret
        var tank: Tank

        # Orientation of this turret relative to the tank
        var relative_heading = 0.0

        # Absolute orientation of this turret
        fun heading: Float do return (tank.heading+relative_heading).angle_normalize

        # Current target to aim for and fire upon
        var target: nullable Pos = null

        # Seconds left before the turret can open fire again
        var cooldown = 0.0

        redef fun do_turn(turn)
        do
                if cooldown > 0.0 then
                        cooldown = cooldown - turn.dts

                        if cooldown <= 0.0 then
                                cooldown = 0.0

                                # Notify clients
                                turn.add new TurretReadyEvent(tank)
                        end
                end

                var target = target
                if target != null then

                        var angle_to_target = tank.pos.atan2(target)
                        var d = (heading - angle_to_target).angle_normalize

                        var max_angle = tank.rule.turret_turn_speed * turn.dts
                        if d.abs < max_angle then
                                self.relative_heading = angle_to_target - tank.heading

                                if cooldown == 0.0 then
                                        # On target, fire
                                        fire turn
                                        self.target = null
                                end
                        else
                                # Turn towards target
                                if d < 0.0 then
                                        self.relative_heading += max_angle
                                else self.relative_heading -= max_angle
                        end
                end
        end

        # Open fire!
        fun fire(turn: TTurn)
        do
                var dst = target
                assert dst != null

                # Is there something between the tank and the target?
                var hit = turn.game.world.first_collision(tank.pos, dst)
                if hit != null then dst = hit.pos

                # Events!
                turn.add new OpenFireEvent(tank)
                turn.game.world.explode(turn, dst, 2)

                # The turret need time to reload, cooldown!
                cooldown = tank.rule.turret_cooldown_time
        end
end

redef class World
        redef fun explode(turn, center, force)
        do
                super

                for tank in game.tanks do
                        if tank.health == 0 then continue
                        if center.dist(tank.pos) <= force.to_f + 1.0 then
                                tank.hit turn
                        end
                end
        end
end

# A collection of `Tank` that could be optimized
class TankSet
        super HashSet[Tank]
end

# A `tank` centric order
abstract class TankOrder
        super TOrder

        # The `Tank` at the center of this order
        var tank: Tank
end

# A command to change the behavior of `tank`
class TankDirectionOrder
        super TankOrder

        # Desired direction, in [-1.0..1.0]
        var direction_heading: Float

        # Desired speed, in [-1.0..1.0]
        var direction_forwards: Float

        redef fun apply(game)
        do
                # TODO use events
                var direction_heading = direction_heading
                direction_heading = direction_heading.min(1.0).max(-1.0)
                tank.direction_heading = direction_heading*tank.rule.max_direction

                var direction_forwards = direction_forwards
                direction_forwards = direction_forwards.min(1.0).max(-1.0)
                tank.direction_forwards = direction_forwards*tank.rule.max_speed
        end
end

# Order to aim and fire at `target`
class AimAndFireOrder
        super TankOrder

        # Target for the turret
        var target: Pos

        redef fun apply(game)
        do
                tank.turret.target = target
        end
end

# A `tank` centric event
abstract class TankEvent
        super TEvent

        # The `Tank` at the center of this event
        var tank: Tank
end

# `tank` opens fire
class OpenFireEvent
        super TankEvent
end

# The turret of `tank` is ready to open fire
class TurretReadyEvent
        super TankEvent
end

# `tank` has been destroyed
class TankDeathEvent
        super TankEvent

        redef fun apply(game)
        do
                tank.health = 0
                game.tanks.remove tank
        end
end

# The health of `tank` changes to `new_health`
class TankHealthChange
        super TankEvent

        # The new health for `tank`
        var new_health: Int

        redef fun apply(game)
        do
                tank.health = new_health
        end
end

# A `tank` moved
#
# TODO this event is too big, divide in 2 or more and move more logic client-side
class TankMoveEvent
        super TankEvent

        # The position
        var pos: Pos

        # The direction of the "wheels"
        var direction_heading: Float

        # The speed
        var direction_forwards: Float

        # Orientation of the tank
        var tank_heading: Float

        # Orientation of the turret
        var turret_heading: Float

        redef fun apply(game)
        do
                tank.pos = pos
                tank.direction_heading = direction_heading
                tank.direction_forwards = direction_forwards
                tank.heading = tank_heading
                tank.turret.relative_heading = turret_heading
        end
end