*: remove newly superfluous static types on attributes

[nit.git] / contrib / tinks / src / client / client3d.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.

# 3D client for Tinks!
module client3d is
        app_name "Tinks! 3D"
        app_namespace "org.nitlanguage.tinks3d"
        app_version(1, 0, git_revision)

        android_api_target 10
        android_manifest """<uses-permission android:name="android.permission.INTERNET" />"""
end

import gamnit::depth

import base

redef class App

        # ---
        # Config

        # Maximum distance from the camera to hear events and display explosions
        private var far_dist2 = 2000.0

        # Approximate maximum distance from the camera to display features
        private var features_radius = 24

        # ---
        # Models

        # Models of rocks
        var models_rock = [
                new Model("models/Tall_Rock_1_01.obj"),
                new Model("models/Tall_Rock_2_01.obj"),
                new Model("models/Tall_Rock_3_01.obj"),
                new Model("models/Tall_Rock_4_01.obj")]

        # Models of trees
        var models_tree = [
                new Model("models/Oak_Dark_01.obj"),
                new Model("models/Oak_Green_01.obj"),
                new Model("models/Large_Oak_Dark_01.obj"),
                new Model("models/Large_Oak_Green_01.obj")]

        # Models of the debris left by a destroyed tank
        var models_debris = [
                new Model("models/debris0.obj"),
                new Model("models/debris1.obj")]

        # Model the health pickup
        var model_health = new Model("models/health.obj")

        # Model of the tank base (without the turret)
        var model_tank_base = new Model("models/tank.obj")

        # Model of the tank turret
        var model_tank_turret = new Model("models/tank-turret.obj")

        # Blast effect on the ground after an explosion
        private var blast_texture = new Texture("textures/blast.png")
        private var blast_material: TexturedMaterial do
                var mat = new TexturedMaterial([1.0]*4, [0.0]*4, [0.0]*4)
                mat.ambient_texture = blast_texture
                return mat
        end
        private var blast_model = new LeafModel(new Plane, blast_material)

        # ---
        # Particle effects

        # Explosion image for particle effect
        private var texture_explosion = new Texture("particles/explosion00.png")

        # Explosion particles
        var explosion_system = new ParticleSystem(20, explosion_program, texture_explosion)

        # Explosion image for particle effect
        private var texture_smoke = new Texture("particles/blackSmoke12.png")

        # Explosion particles
        var smoke_system = new ParticleSystem(200, smoke_program, texture_smoke)

        # ---
        # Sounds

        # Firing sound
        var turret_fire = new Sound("sounds/turret_fire.wav")

        # Turret is ready to fire sound
        var turret_ready = new Sound("sounds/turret_ready.mp3")

        # ---
        # Scene objects

        # Ground
        var ground: Actor is noinit
        private var ground_texture = new Texture("textures/fastgras01.png")

        # All `Feature` with an associated model, to be drawn on screen
        var features_in_sight = new Set[Feature]

        redef fun on_create
        do
                super

                # Show splash screen
                var logo = new Texture("textures/splash.png")
                show_splash_screen logo

                # Load everything
                for texture in all_root_textures do
                        texture.load
                        var error = texture.error
                        if error != null then print_error error
                end
                for model in models do
                        model.load
                        if model.errors.not_empty then print_error model.errors.join("\n")
                end

                # Modify all textures so they have a higher ambient color
                for model in models do
                        for leaf in model.leaves do
                                var mat = leaf.material
                                if mat isa TexturedMaterial then
                                        var mod = 0.25
                                        mat.ambient_color[0] = mat.diffuse_color[0] * mod
                                        mat.ambient_color[1] = mat.diffuse_color[1] * mod
                                        mat.ambient_color[2] = mat.diffuse_color[2] * mod

                                        var tex = mat.diffuse_texture
                                        if tex != null then mat.ambient_texture = tex
                                end
                        end
                end

                # Setup ground
                # TODO we may need to move this plane if the player goes far from the center
                var ground_mesh = new Plane
                ground_mesh.repeat_x = 1000.0
                ground_mesh.repeat_y = 1000.0

                var ground_material = new TexturedMaterial(
                        [0.0, 0.1, 0.0, 1.0], [0.4, 0.4, 0.4, 1.0], [0.0]*4)
                ground_material.diffuse_texture = ground_texture

                var ground_model = new LeafModel(ground_mesh, ground_material)
                var ground = new Actor(ground_model, new Point3d[Float](0.0, 0.0, 0.0))
                ground.scale = 5000.0

                self.ground = ground
                actors.add ground

                # Config the view
                world_camera.near = 0.1

                # Sky color
                glClearColor(100.0/256.0, 120.0/256.0, 224.0/256.0, 1.0)

                # Move the sun a bit off right above
                light.position.x = 1000.0
                light.position.z = 500.0

                # Register our two systems
                particle_systems.add explosion_system
                particle_systems.add smoke_system

                # Connect to server (or launch one) and assign models to rules
                var context = context
                context.game.story.assign_models
        end

        redef fun update(dt)
        do
                # Game logic
                var turn = context.do_turn
                for event in turn.events do event.client_react

                # Is the player alive?
                var local_player = context.local_player
                var local_tank = null
                if local_player != null then local_tank = local_player.tank

                if local_tank != null then
                        # Update camera position above the tank
                        var pos = local_tank.pos
                        world_camera.position.x = pos.x
                        world_camera.position.z = pos.y
                        world_camera.yaw = 1.5 * pi - local_tank.heading
                        world_camera.position.y = 1.8
                end
        end

        redef fun accept_event(event)
        do
                # Let `pressed_keys` be populated first
                var s = super

                var local_player = context.local_player
                var local_tank = null
                if local_player != null then local_tank = local_player.tank

                # Quit game?
                if event isa QuitEvent or (event isa KeyEvent and event.name == "escape") then
                        exit 0
                end

                if event isa KeyEvent then
                        # Move tank?
                        var direction_change = ["w", "a", "s", "d"].has(event.name)
                        if direction_change and local_tank != null and local_player != null then
                                var forward = pressed_keys.has("w")
                                var backward = pressed_keys.has("s")
                                var left = pressed_keys.has("a")
                                var right = pressed_keys.has("d")

                                # Cancel contradictory commands
                                if forward and backward then
                                        forward = false
                                        backward = false
                                end

                                if left and right then
                                        left = false
                                        right = false
                                end

                                # Set movement and direction
                                var move = 0.0
                                if forward then
                                        move = 0.5
                                else if backward then move = -0.5

                                var ori = 0.0
                                if left then
                                        ori = -local_tank.rule.max_direction/2.0
                                else if right then ori = local_tank.rule.max_direction/2.0

                                # Activate to invert the orientation on reverse, (for @R4p4Ss)
                                #if backward then ori = -ori

                                # Bonus when only moving or only turning
                                if not forward and not backward then ori *= 2.0
                                if not left and not right then move *= 2.0

                                # Give order
                                local_player.orders.add new TankDirectionOrder(local_tank, ori, move)
                                return true
                        end

                        # Open fire?
                        if event.name == "space" and local_tank != null and event.is_down then
                                if local_player == null then return false

                                # Open fire
                                var heading = local_tank.heading
                                var dist = 200.0
                                var target = new Pos(local_tank.pos.x + dist*heading.cos, local_tank.pos.y + dist*heading.sin)
                                local_player.orders.add new AimAndFireOrder(local_tank, target)
                        end
                end

                # Open fire with a target?
                if event isa PointerEvent and event.pressed and not event.is_move then
                        if local_player == null then return false

                        var display = display
                        if display == null then return false

                        if local_tank == null then
                                local_player.orders.add new SpawnTankOrder(local_player)
                                return true
                        end

                        # Compute approximate target
                        var dx = event.x / display.width.to_f
                        dx = dx * 2.0 - 1.0 # center of the screen
                        var fovx = display.aspect_ratio * world_camera.field_of_view_y
                        fovx *= 0.8
                        var heading = local_tank.heading + dx * fovx

                        var dy = event.y / display.height.to_f
                        dy = dy - 0.5
                        if dy >= 0.0 then
                                var ty = dy * world_camera.field_of_view_y
                                var dist = world_camera.position.y / ty.tan / 1.6
                                if dist > 200.0 then dist = 200.0

                                # Issue fire order
                                var target = new Pos(local_tank.pos.x + dist*heading.cos, local_tank.pos.y + dist*heading.sin)
                                local_player.orders.add new AimAndFireOrder(local_tank, target)
                        end
                end

                return s
        end
end

# ---
# Story and rules (meta game objects)

redef class FeatureRule
        # Models of different alternatives
        var models: Array[Model] is noinit
end

redef class TankRule
        # Models of the tank base
        var base_model: Model is noinit

        # Models of the turret
        var turret_model: Model is noinit
end

redef class Story

        # Assign models from `app` to the corresponding rules
        fun assign_models
        do
                tree.models = app.models_tree
                rock.models = app.models_rock
                debris.models = app.models_debris

                for tank in tanks do
                        tank.base_model = app.model_tank_base
                        tank.turret_model = app.model_tank_turret
                end

                health.models = [app.model_health]
        end
end

# ---
# Game entities

redef class Feature
        # Actor representing this feature, if in sight
        var actor: nullable Actor = null

        # Instantiate `actor` and add it to the 3D world
        fun add_actor_to_scene
        do
                app.features_in_sight.add self

                var actor = actor
                if actor != null then
                        # Reuse existing actor
                        if not app.actors.has(actor) then app.actors.add actor
                        return
                end

                # Apply a random model and rotation to new features
                actor = new Actor(rule.models.rand,
                        new Point3d[Float](pos.x, 0.0, pos.y))
                actor.yaw = 2.0*pi.rand
                actor.scale = 0.75

                self.actor = actor
                app.actors.add actor
        end

        # Remove `actor` from the `actors` list as it will net be used anymore
        fun destroy_actor
        do
                var actor = actor
                if actor != null then
                        app.actors.remove actor
                        self.actor = null
                end
        end
end

redef class Tank
        # Actors representing this tank, both the base and the turret
        var actors: Array[Actor] is lazy do
                var actors = new Array[Actor]
                var actor = new Actor(app.model_tank_base, new Point3d[Float](0.0, 0.0, 0.0))
                app.actors.add actor
                actors.add actor

                var tank_turret = new Actor(app.model_tank_turret, new Point3d[Float](0.0, 0.0, 0.0))
                app.actors.add tank_turret
                actors.add tank_turret
                return actors
        end
end

# ---
# Events

redef class TEvent
        private fun client_react do end
end

redef class FeatureChangeEvent
        redef fun client_react
        do
                var old_feature = old_feature
                if old_feature != null then old_feature.destroy_actor

                var feature = feature
                if feature != null then feature.add_actor_to_scene
        end
end

redef class ExplosionEvent
        redef fun client_react
        do
                for feature in destroyed_features do feature.destroy_actor

                # Particles
                app.explosion_system.add(new Point3d[Float](pos.x, 1.0, pos.y), 4096.0, 0.3)
                for i in 8.times do
                        app.explosion_system.add(
                                new Point3d[Float](pos.x & 1.0, 1.0 & 1.0, pos.y & 1.0),
                                2048.0 & 1024.0, 0.3 & 0.1)
                end

                # Blast mark on the ground
                var blast = new Actor(app.blast_model, new Point3d[Float](pos.x, 0.05 & 0.04, pos.y))
                blast.scale = 3.0
                blast.yaw = 2.0*pi.rand
                app.actors.add blast

                # Smoke
                for s in 32.times do
                        var dt = 0.2 * s.to_f + 0.1.rand
                        app.smoke_system.add(
                                new Point3d[Float](pos.x & 0.2, 0.0, pos.y & 0.2),
                                1024.0 & 512.0, 10.0 & 4.0, dt)
                end
        end
end

redef class OpenFireEvent
        redef fun client_react
        do
                if tank.pos.dist2_3d(app.world_camera.position) < app.far_dist2 then
                        # Within earshot
                        app.turret_fire.play

                        # Particle
                        var d = 1.7
                        var a = tank.turret.heading - 0.025 # Correct to center the art
                        var pos = new Point3d[Float](tank.pos.x + d*a.cos, 1.25, tank.pos.y + d*a.sin)
                        app.explosion_system.add(pos, 0.75*256.0, 0.15)
                end
        end
end

redef class TurretReadyEvent
        redef fun client_react
        do
                if tank.pos.dist2_3d(app.world_camera.position) < app.far_dist2 then
                        # Within earshot
                        app.turret_ready.play
                end
        end
end

redef class TankMoveEvent
        redef fun client_react
        do
                var pos = tank.pos
                for actor in tank.actors do
                        actor.center.x = pos.x
                        actor.center.z = pos.y
                end

                tank.actors[0].yaw = -tank.heading + pi
                tank.actors[1].yaw = -tank.turret.heading + pi

                # Keep going only for the local tank
                var local_player = app.context.local_player
                if local_player != tank.player then return

                var center = tank.pos
                var d = app.features_radius
                var l = center.x.to_i - d
                var r = center.x.to_i + d
                var t = center.y.to_i - d
                var b = center.y.to_i + d

                # Remove out of range features
                for feature in app.features_in_sight.to_a do
                        var x = feature.pos.x.to_i
                        var y = feature.pos.y.to_i
                        if x < l or x > r or y < t or y > b then
                                var actor = feature.actor
                                app.actors.remove actor
                                app.features_in_sight.remove feature
                        end
                end

                # Add newly in range features
                for x in [l..r[ do
                        for y in [t..b[ do
                                var feature = app.context.game.world[x, y]
                                if feature != null then
                                        feature.add_actor_to_scene
                                end
                        end
                end
        end
end

redef class TankDeathEvent
        redef fun client_react
        do
                for actor in tank.actors do app.actors.remove actor
                tank.actors.clear
        end
end

# ---
# Misc services

redef class Point[N]
        # Square of the distance to 3D coordinates `other`
        #
        # Same as `dist2` but using `other.z` as the Y value
        # to adapt from the flat plane on X/Y to X/Z.
        private fun dist2_3d(other: Point3d[Numeric]): N
        do
                var dx = other.x.sub(x)
                var dy = other.z.sub(y)
                var s = (dx.mul(dx)).add(dy.mul(dy))
                return x.value_of(s)
        end
end

redef class Float
        # Fuzzy value in `[self-variation..self+variation]`
        fun &(variation: Float): Float do return self - variation + 2.0*variation.rand
end