--- /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.
+
+# Graphical effects
+module effects
+
+intrude import geometry::points_and_lines
+import mnit::opengles1
+
+import moles
+
+# Position, or vector
+class Pos
+ super Point[Float]
+
+ # Addition of `self` and `other`
+ fun +(other: Pos): Pos do return new Pos(other.x + x, other.y + y)
+end
+
+redef class PointerEvent
+ # Convert to `Pos`
+ fun to_pos: Pos do return new Pos(x, y)
+end
+
+redef class Float
+ # Pretty alias to `pow`
+ private fun ^(other: Float): Float do return self.pow(other)
+end
+
+# Graphical effect
+abstract class Effect
+ # Time of creation since (appropriate) app lauch
+ var created_at: Float = app.clock.total.to_f
+
+ # Is this effect dead?
+ var dead = false
+
+ # Time to live of this effect, in seconds
+ var ttl: Float = ttl_base + ttl_rand.rand is lazy
+
+ # Time to live base value
+ private var ttl_base: Float
+
+ # Variation range to add to `ttl_base`
+ private var ttl_rand: Float
+
+ private fun update_and_draw(display: Display, t: Float) do end
+end
+
+# Full screen flash
+class Flash
+ super Effect
+
+ # Red value
+ var r: Float
+
+ # Green value
+ var g: Float
+
+ # Blue value
+ var b: Float
+
+ # Start alpha value
+ var a: Float
+
+ # Reduction in alpha value per seconds
+ var da: Float
+
+ redef fun update_and_draw(display, t)
+ do
+ var dt = t - created_at
+ var a = a - da * dt
+ if a <= 0.0 then
+ dead = true
+ return
+ end
+
+ native_flash(r, g, b, a, display.width.to_f, display.height.to_f)
+ end
+
+ private fun native_flash(r, g, b, a, w, h: Float) `{
+ GLfloat colors[] =
+ {
+ r, g, b, a,
+ r, g, b, a,
+ r, g, b, a,
+ r, g, b, a,
+ };
+ GLfloat coords[] =
+ {
+ 0.0, 0.0, 0.0,
+ 0.0, h, 0.0,
+ w, 0.0, 0.0,
+ w, h, 0.0,
+ };
+
+ glLoadIdentity();
+
+ glEnableClientState(GL_VERTEX_ARRAY);
+ glEnableClientState(GL_COLOR_ARRAY);
+
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ glDisable(GL_DEPTH_TEST);
+ glDisable(GL_TEXTURE_2D);
+
+ glVertexPointer(3, GL_FLOAT, 0, coords);
+ glColorPointer(4, GL_FLOAT, 0, colors);
+ glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+ glDisableClientState(GL_VERTEX_ARRAY);
+ glDisableClientState(GL_COLOR_ARRAY);
+ glDisable(GL_BLEND);
+
+ if ((mnit_opengles_error_code = glGetError()) != GL_NO_ERROR) {
+ fprintf(stderr, "Error drawing: %i\n", mnit_opengles_error_code);
+ }
+ `}
+end
+
+# Visible particle
+abstract class Particle
+ super Effect
+
+ # Effect image
+ var img: Image
+end
+
+# Particle moving along a cubic Bézier curve
+class CubicBezierParticle
+ super Particle
+
+ # Points on this curve, from the start to the end with the handles in the middle
+ #
+ # Require: `points.length == 4`
+ var points: Array[Pos]
+
+ redef fun update_and_draw(display, t)
+ do
+ assert points.length == 4
+
+ var dt = t - created_at
+ var p = dt / ttl
+
+ var i = 1.0-p
+ var bx = i*i*i * points[0].x + 3.0*i*i*p * points[1].x +
+ 3.0*i*p*p * points[2].x + p*p*p*points[3].x
+ var by = i*i*i * points[0].y + 3.0*i*i*p * points[1].y +
+ 3.0*i*p*p * points[2].y + p*p*p*points[3].y
+
+ img.scale = display_scale
+ if display isa Opengles1Display then display.color(1.0, 1.0, 1.0, p)
+ display.blit_centered(img, bx, by)
+ if display isa Opengles1Display then display.reset_color
+
+ if dt > ttl then dead = true
+ end
+end
+
+# Particle falling like a feather
+class FeatheryParticle
+ super Particle
+
+ # Origin of effect
+ var from: Pos
+
+ # Randomized variation so this particle is unique
+ var ddt: Float = pi.rand
+
+ # Direction: `-1.0` for left, `1.0` for right
+ var dir: Float = if 2.rand == 0 then -1.0 else 1.0
+
+ # Randomized variation on X
+ var ddx: Float = (4.0 - 8.0.rand)^2.0
+
+ # Randomized variation on Y
+ var ddy: Float = (12.0 - 24.0.rand)^2.0
+
+ redef fun update_and_draw(display, t)
+ do
+ var dt = t - created_at
+
+ var dx = ddx + 30.0*(dt+ddt).sin
+ dx *= dir
+ var dy = ddy + 20.0*dt + 16.0*(dt*2.0+ddt*2.0).cos
+ var pos = from + new Pos(dx, dy)
+
+ if display isa Opengles1Display then display.color(1.0, 1.0, 1.0, 5.0-5.0*dt/ttl)
+ display.blit_centered(img, pos.x, pos.y)
+ if display isa Opengles1Display then display.reset_color
+
+ if dt > ttl then dead = true
+ end
+end
+
+# Particles that start small then grow bigger and fade out
+private class BlowUpParticle
+ super Particle
+
+ # Origin/center of effect
+ var from: Pos
+
+ redef fun update_and_draw(display, t)
+ do
+ var dt = t - created_at
+ var p = dt/ttl
+
+ if display isa Opengles1Display then display.color(1.0, 1.0, 1.0, 2.0-p*2.0)
+
+ img.scale = p*4.0*display_scale
+ display.blit_centered(img, from.x, from.y)
+
+ if display isa Opengles1Display then display.reset_color
+
+ if dt > ttl then dead = true
+ end
+end
+
+redef class Screen
+ private var particles = new Array[Particle]
+ private var flashes = new Array[Flash]
+
+ redef fun draw_hud(display)
+ do
+ var t = app.clock.total.to_f
+
+ # Particles
+ for particle in particles do particle.update_and_draw(display, t)
+ for particle in particles.reverse_iterator do if particle.dead then
+ particles.remove particle
+ end
+
+ # Flashes
+ for flash in flashes do flash.update_and_draw(display, t)
+ for flash in flashes.reverse_iterator do if flash.dead then
+ flashes.remove flash
+ end
+
+ super
+ end
+
+ private var score_center = new Pos(48.0*display_scale, 32.0*display_scale) is lazy
+ private var score_entry = new Pos(48.0*display_scale, 256.0*display_scale) is lazy
+
+ private var score_history = new List[Int]
+ private var score_history_max_length = 60
+
+ redef fun draw_score(display, score)
+ do
+ # Use an history to smooth the score
+ score_history.add game.points
+ if score_history.length > score_history_max_length then score_history.shift
+ var sum = 0
+ for h in score_history do sum += h
+ var avg = sum.to_f/score_history.length.to_f
+ var d = game.points.to_f - avg
+
+ # Color the score according to positive or negative changes
+ var r = 1.0
+ var g = 1.0
+ var b = 1.0
+ if d > 0.0 then
+ r = 1.0-d.to_f/2.0
+ b = r
+ g = 1.0-d.to_f/10.0
+ else if d < 0.0 then
+ g = 1.0+d.to_f/5.0
+ b = g
+ end
+
+ if display isa Opengles1Display then display.color(r, g, b, 1.0)
+
+ # Draw the score itself
+ super(display, avg.to_i)
+
+ if display isa Opengles1Display then display.reset_color
+ end
+end
+
+redef class HoleContent
+ # Add a `CubicBezierParticle` from `event` to the score box with `img`
+ private fun bezier_to_score(img: Image, event: PointerEvent)
+ do
+ app.screen.particles.add new CubicBezierParticle(2.0, 0.0, img,
+ [event.to_pos, event.to_pos + new Pos(0.0, -128.0),
+ app.screen.score_entry, app.screen.score_center])
+ end
+end
+
+redef class Mole
+
+ # Number of hair particles
+ private var n_hair_on_hit = 20
+
+ redef fun hit(game, hole, event)
+ do
+ super
+
+ app.assets.hair.scale = display_scale
+ for i in n_hair_on_hit.times do
+ app.screen.particles.add new FeatheryParticle(2.0, 2.0, app.assets.hair, event.to_pos)
+ end
+
+ bezier_to_score(app.assets.point, event)
+ app.screen.particles.add new BlowUpParticle(0.5, 0.0, app.assets.point, event.to_pos)
+ end
+end
+
+redef class Trap
+ # Image for `CubicBezierParticle` effect towards the score board
+ protected fun penalty_img: Image do return app.assets.penalty_ten
+
+ # `Flash` effects on hit
+ protected fun flashes: Array[Flash] do
+ return [new Flash(0.5, 0.0, 1.0, 0.0, 0.0, 0.5, 2.0)]
+ end
+
+ redef fun hit(game, hole, event)
+ do
+ super
+
+ bezier_to_score(penalty_img, event)
+ app.screen.particles.add new BlowUpParticle(0.5, 0.0, penalty_img, event.to_pos)
+
+ app.screen.flashes.add_all flashes
+ end
+end
nitlanguage / nit.git / commitdiff