rubysketch-solitaire 0.1.0

data/lib/rubysketch/solitaire/common/timer.rb

@@ -0,0 +1,35 @@
+$timers = {}
+
+def startTimer(name = unique, seconds, &block)
+  $timers[name] = [now + seconds, block]
+  name
+end
+
+def startInterval(name = unique, seconds, now: false, &block)
+  block.call if now
+  startTimer name, seconds do
+    block.call
+    startInterval name, seconds, &block
+  end
+end
+
+def stopTimer(name)
+  $timers.delete name
+end
+
+def getTimer(name)
+  $timers[name]
+end
+
+def delay(&block)
+  startTimer 0, &block
+end
+
+def fireTimers()
+  now_ = now
+  blocks = []
+  $timers.delete_if do |_, (time, block)|
+    (now_ >= time).tap { blocks.push block if _1 }
+  end
+  blocks.each { _1.call }
+end

data/lib/rubysketch/solitaire/common/transitions.rb

@@ -0,0 +1,149 @@
+using RubySketch
+
+
+class TransitionEffect < Scene
+
+  def initialize(
+    nextScene, sec: 1,
+     secOut: nil,       secIn: nil,
+    easeOut: :expoOut, easeIn: :expoIn,
+    &block)
+
+    super()
+    @nextScene, @easeOut, @easeIn = nextScene, easeOut, easeIn
+    @secOut = secOut || sec / 2.0
+    @secIn  = secIn  || sec / 2.0
+    @phase  = :out
+  end
+
+  attr_reader :phase
+
+  def effect(t)
+  end
+
+  def activated()
+    super
+    start do
+      case @phase
+      when :out
+        pa = parent
+        pa.remove self
+        @phase = :in
+        @nextScene.add self
+        pa.transition @nextScene
+      when :in
+        parent.remove self
+      end
+    end
+  end
+
+  private
+
+  def start(&block)
+    sec  = out? ? @secOut  : @secIn
+    ease = out? ? @easeOut : @easeIn
+    animate sec, ease: ease do |t, finished|
+      effect (out? ? t : 1.0 - t)
+      block.call if finished
+    end
+  end
+
+  def out?()
+    @phase == :out
+  end
+
+end# TransitionEffect
+
+
+class Fade < TransitionEffect
+
+  def initialize(*args, rgb: 0, **kwargs, &block)
+    super(*args, easeIn: :expoOut, **kwargs)
+    @rgb, @alpha = rgb, 0
+  end
+
+  def effect(t)
+    @alpha = 255 * t
+  end
+
+  def draw()
+    super
+    fill *@rgb, @alpha
+    noStroke
+    rect 0, 0, width, height
+  end
+
+end# Fade
+
+
+class Curtain < TransitionEffect
+
+  def initialize(*args, rgb: 0, **kwargs, &block)
+    super(*args, easeIn: :expoOut, **kwargs)
+    @rgb = rgb
+    @y = @h = 0
+  end
+
+  def effect(t)
+    @y, @h =
+      case phase
+      when :out then [height * (1.0 - t), height]
+      when :in  then [0,                  height * t]
+      end
+  end
+
+  def draw()
+    super
+    fill *@rgb
+    noStroke
+    rect 0, @y, width, @h
+  end
+
+end# Fade
+
+
+class Pixelate < TransitionEffect
+
+  def initialize(*args, **kwargs, &block)
+    super *args, sec: 1, easeOut: :cubicOut, easeIn: :cubicIn, **kwargs, &block
+  end
+
+  def activated()
+    super
+    filter pixelate
+  end
+
+  def deactivated()
+    super
+    filter nil
+  end
+
+  def effect(t)
+    pixelate.set :resolution,   width, height
+    pixelate.set :pixelateSize, map(t, 0.0, 1.0, 1, 32)
+  end
+
+  private
+
+  def pixelate()
+    @checker ||= createShader nil, <<~END
+      uniform sampler2D texMap;
+      uniform vec3 texMax;
+      uniform vec2 resolution;
+      uniform float pixelateSize;
+      varying vec4 vertTexCoord;
+      varying vec4 vertColor;
+      void main() {
+        vec2 r     = resolution;
+        float ps   = pixelateSize;
+        vec2 coord = (floor(vertTexCoord.xy * r / ps) + 0.5) * ps / r;
+        if (coord.x >= texMax.x) coord.x = texMax.x - 1. / r.x;
+        if (coord.y >= texMax.y) coord.y = texMax.y - 1. / r.y;
+
+        vec4 col     = texture2D(texMap, coord);
+        gl_FragColor = vec4(col.rgb, 1.) * vertColor;
+      }
+    END
+  end
+
+end# Pixelate

data/lib/rubysketch/solitaire/common/utils.rb

@@ -0,0 +1,89 @@
+def now()
+  Time.now.to_f
+end
+
+def unique()
+  Object.new.object_id
+end
+
+def dataPath(path)
+  File.expand_path "../../../../data/#{path}", __dir__
+end
+
+
+module Processing
+  class Vector
+    def xy()
+      self.class.new x, y
+    end
+  end
+end
+
+
+module CanDisable
+
+  def initialize(*a, **k, &b)
+    super
+    @enabled = true
+  end
+
+  def enable(state = true)
+    return if state == @enabled
+    @enabled = state
+    @enabled ? enabled : disabled
+  end
+
+  def disable(&block)
+    old = enabled?
+    enable false
+    if block
+      begin
+        block.call
+      ensure
+        enable old
+      end
+    end
+  end
+
+  def enabled?()
+    @enabled
+  end
+
+  def disabled?()
+    !enabled?
+  end
+
+  def enabled()
+  end
+
+  def disabled()
+  end
+
+end# CanDisable
+
+
+module HasSprite
+
+  extend Forwardable
+
+  def_delegators :sprite,
+    :pos, :pos=, :x, :x=, :y, :y=, :z, :z=, :center, :center=,
+    :left, :left=, :top, :top=, :right, :right=, :bottom, :bottom=,
+    :size, :width, :width=, :height, :height=, :depth, :w, :w=, :h, :h=, :d,
+    :angle, :angle=
+
+  alias l  left
+  alias l= left=
+  alias t  top
+  alias t= top=
+  alias r  right
+  alias r= right=
+  alias b  bottom
+  alias b= bottom=
+
+  def hit?(x, y)
+    s = sprite
+    s.x <= x && x < (s.x + s.w) && s.y <= y && y < (s.y + s.h)
+  end
+
+end# HasSprite

data/lib/rubysketch/solitaire/extension.rb

@@ -0,0 +1,25 @@
+module RubySketch
+
+  module Solitaire
+
+    module Extension
+
+      module_function
+
+      def name()
+        super.split('::')[-2]
+      end
+
+      def version()
+        File.read(root_dir 'VERSION')[/[\d\.]+/]
+      end
+
+      def root_dir(path = '')
+        File.expand_path "../../../#{path}", __dir__
+      end
+
+    end# Extension
+
+  end# Solitaire
+
+end# RubySketch