rubysketch-solitaire 0.1.0

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

@@ -0,0 +1,116 @@
+using RubySketch
+
+
+EASINGS = {
+  linear:  lambda { |x| x },
+   sineIn: lambda { |x| 1.0 - Math.cos(x * Math::PI / 2) },
+  sineOut: lambda { |x|       Math.sin(x * Math::PI / 2) },
+
+     quadIn: lambda { |x|    quadIn x },
+    cubicIn: lambda { |x|   cubicIn x },
+    quartIn: lambda { |x|   quartIn x },
+    quintIn: lambda { |x|   quintIn x },
+     circIn: lambda { |x|    circIn x },
+     backIn: lambda { |x|    backIn x },
+     expoIn: lambda { |x|    expoIn x },
+  elasticIn: lambda { |x| elasticIn x },
+   bounceIn: lambda { |x| 1.0 - bounceOut(1.0 - x) },
+
+     quadOut: lambda { |x| 1.0 -    quadIn(1.0 - x) },
+    cubicOut: lambda { |x| 1.0 -   cubicIn(1.0 - x) },
+    quartOut: lambda { |x| 1.0 -   quartIn(1.0 - x) },
+    quintOut: lambda { |x| 1.0 -   quintIn(1.0 - x) },
+     circOut: lambda { |x| 1.0 -    curcIn(1.0 - x) },
+     backOut: lambda { |x| 1.0 -    backIn(1.0 - x) },
+     expoOut: lambda { |x| 1.0 -    expoIn(1.0 - x) },
+  elasticOut: lambda { |x| 1.0 - elasticIn(1.0 - x) },
+   bounceOut: lambda { |x| bounceOut x },
+
+     sineInOut: lambda { |x| x < 0.5 ?    sineIn(x) :    sineOut(x) },
+     quadInOut: lambda { |x| x < 0.5 ?    quadIn(x) :    quadOut(x) },
+    cubicInOut: lambda { |x| x < 0.5 ?   cubicIn(x) :   cubicOut(x) },
+    quartInOut: lambda { |x| x < 0.5 ?   quartIn(x) :   quartOut(x) },
+    quintInOut: lambda { |x| x < 0.5 ?   quintIn(x) :   quintOut(x) },
+     circInOut: lambda { |x| x < 0.5 ?    circIn(x) :    circOut(x) },
+     backInOut: lambda { |x| x < 0.5 ?    backIn(x) :    backOut(x) },
+     expoInOut: lambda { |x| x < 0.5 ?    expoIn(x) :    expoOut(x) },
+  elasticInOut: lambda { |x| x < 0.5 ? elasticIn(x) : elasticOut(x) },
+   bounceInOut: lambda { |x| x < 0.5 ?  bounceIn(x) :  bounceOut(x) }
+}
+
+def quadIn(x)
+  x ** 2
+end
+
+def cubicIn(x)
+  x ** 3
+end
+
+def quartIn(x)
+  x ** 4
+end
+
+def quintIn(x)
+  x ** 5
+end
+
+def circIn(x)
+  1.0 - Math.sqrt(1.0 - x ** 2)
+end
+
+def backIn(x)
+  2.70158 * x ** 3 - 1.70158 * x ** 2
+end
+
+def expoIn(x)
+  x == 0 ? 0.0 : 2.0 ** (10.0 * x - 10.0)
+end
+
+def elasticIn(x)
+  c = Math::PI * 2.0 / 3.0
+  case x
+  when 0 then 0
+  when 1 then 1
+  else -(2 ** (10.0 * x - 10.0)) * Math.sin((x * 10.0 - 10.75) * c)
+  end
+end
+
+def bounceOut(x)
+  n1, d1 = 7.5625, 2.75
+  case
+  when x < 1.0 / d1 then                  n1 * x * x
+  when x < 2.0 / d1 then x -= 1.5   / d1; n1 * x * x + 0.75;
+  when x < 2.5 / d1 then x -= 2.25  / d1; n1 * x * x + 0.9375;
+  else                   x -= 2.625 / d1; n1 * x * x + 0.984375;
+  end
+end
+
+
+def animate(name = unique, seconds, ease: :expoOut, &block)
+  fun = EASINGS[ease]
+  start = now
+  eachDrawBlock = lambda do
+    t = (now - start) / seconds
+    if t >= 1.0
+      block.call fun.call(1.0), true, 1.0
+    else
+      block.call fun.call(t), false, t
+      startTimer name, 0, &eachDrawBlock
+    end
+  end
+  startTimer name, 0, &eachDrawBlock
+end
+
+def animateValue(name = unique, seconds, from:, to:, **kwargs, &block)
+  animate name, seconds, **kwargs do |t, finished, tt|
+    block.call lerp(from, to, t), finished, t, tt
+  end
+end
+
+def move(obj, toPos, seconds, **kwargs, &block)
+  from, to = obj.pos.dup, toPos.dup
+  animate seconds, **kwargs do |t, *args|
+    obj.pos = Vector.lerp(from, to, t)
+    block&.call t, *args
+  end
+end

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

@@ -0,0 +1,67 @@
+using RubySketch
+
+
+class Button < Sprite
+
+  include CanDisable
+
+  def initialize(
+    label, *args, rgb: 200, width: 1, fontSize: 24, round: 5, **kwargs, &block)
+
+    super 0, 0, 44 * width, 44, *args, **kwargs, &block
+    @label, @rgb, @fontSize, @round = label, [rgb].flatten, fontSize, round
+    @click = nil
+    setup
+  end
+
+  def clicked(&block)
+    @click = block
+    nil
+  end
+
+  private
+
+  def setup()
+    pressing = false
+    mousePressed  {pressing = true}
+    mouseReleased {pressing = false}
+
+    draw do
+      offset  = 5
+      y       = pressing ? (offset - (enabled? ? 2 : 3.5)) : 0
+      h       = self.h - y
+      offset -= y
+      fill *@rgb.map {|n| n - 20}
+      rect 0, y, w, h, *@round
+      fill *@rgb
+      rect 0, y, w, h - offset, *@round
+      fill enabled? ? 255 : 180
+      textAlign CENTER, CENTER
+      textSize @fontSize
+      text @label, 0, y, w, h - offset
+    end
+
+    mouseClicked do
+      if enabled?
+        @click.call if @click
+      else
+        shake
+      end
+      sound.play gain: 0.5
+    end
+  end
+
+  def shake(strength = 10)
+    strength = strength.to_f
+    x        = self.x
+    animate 0.3 do |t, finished|
+      self.x = x + (finished ? 0 : strength * (1.0 - t))
+      strength *= -1
+    end
+  end
+
+  def sound()
+    @sound ||= loadSound dataPath 'button.mp3'
+  end
+
+end# Button

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

@@ -0,0 +1,103 @@
+using RubySketch
+
+
+class Dialog < Scene
+
+  def initialize(background: 0, alpha: 100, z: 1000)
+    super
+    @background, @alpha = background, 0
+    overlay.z = z
+    animate 0.2 do |t|
+      @alpha = alpha * t
+    end
+  end
+
+  def addElement(sprite)
+    elements.push sprite
+    addSprite sprite if active?
+    updateLayout
+  end
+
+  def addLabel(label, rgb: [255], fontSize: 24, align: CENTER)
+    bounds = textFont.textBounds label, 0, 0, fontSize
+    addElement Sprite.new(0, 0, bounds.w, bounds.h).tap {|sp|
+      sp.z = overlay.z
+      sp.draw do
+        textAlign align, CENTER
+        textSize fontSize
+        fill *rgb
+        text label, 0, 0, sp.w, sp.h
+      end
+    }
+  end
+
+  def addButton(label, *args, **kwargs, &block)
+    addElement Button.new(label, *args, **kwargs).tap {|b|
+      b.z = overlay.z
+      b.clicked &block
+    }
+  end
+
+  def addSpace(height)
+    addElement Sprite.new(0, 0, 1, height).tap {|sp|
+      sp.draw {}
+    }
+  end
+
+  def close()
+    delay {parent.remove self}
+  end
+
+  def sprites()
+    super + [overlay, *elements]
+  end
+
+  def elements()
+    @elements ||= []
+  end
+
+  def draw()
+    sprite overlay, *elements
+    super
+  end
+
+  def resized(w, h)
+    updateLayout
+  end
+
+  private
+
+  MARGIN = 10
+
+  def overlay()
+    @overlay ||= Sprite.new(0, 0, width, height).tap do |sp|
+      sp.update do
+        sp.w = width
+        sp.h = height
+      end
+      sp.draw do
+        fill *@background, @alpha
+        rect 0, 0, sp.w, sp.h
+      end
+    end
+  end
+
+  def cancelButton()
+    @cancelButton ||= Button.new('CLOSE', width: 3, fontSize: 28).tap do |sp|
+      sp.z = overlay.z
+      sp.clicked {close}
+    end
+  end
+
+  def updateLayout()
+    w, h      = width, height
+    allHeight = elements.map(&:height).reduce {|a, b| a + MARGIN + b} || 0
+    y         = (h - allHeight) / 2
+    elements.each do |e|
+      e.x = (w - e.w) / 2
+      e.y = y
+      y  += e.h + MARGIN
+    end
+  end
+
+end# Dialog

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

@@ -0,0 +1,94 @@
+class History
+
+  include CanDisable
+
+  def initialize(undos = [], redos = [])
+    super()
+    @undos, @redos = undos, redos
+    @group         = nil
+  end
+
+  def push(*actions)
+    return if actions.empty? || disabled?
+    if @group
+      @group.push *actions
+    else
+      @undos.push actions
+      @redos.clear
+      update
+    end
+  end
+
+  def group(&block)
+    @group = group = [] unless @group
+    block.call
+  ensure
+    if group
+      @group = nil
+      push *group
+    end
+  end
+
+  def undo(&block)
+    actions = @undos.pop || return
+    actions.reverse.each {|action| block.call action}
+    @redos.push actions
+    update
+  end
+
+  def redo(&block)
+    actions = @redos.pop || return
+    actions.each {|action| block.call action}
+    @undos.push actions
+    update
+  end
+
+  def canUndo?()
+    !@undos.empty?
+  end
+
+  def canRedo?()
+    !@redos.empty?
+  end
+
+  def updated(&block)
+    @updated = block
+  end
+
+  def to_h(&dumpObject)
+    {
+      version: 1,
+      undos: self.class.dump(@undos, &dumpObject),
+      redos: self.class.dump(@redos, &dumpObject)
+    }
+  end
+
+  def self.load(hash, &restoreObject)
+    undos = restore hash['undos'], &restoreObject
+    redos = restore hash['redos'], &restoreObject
+    self.new undos, redos
+  end
+
+  private
+
+  def update()
+    @updated.call if @updated
+  end
+
+  def self.dump(xdos, &dumpObject)
+    xdos.map do |actions|
+      actions.map do |action, *args|
+        [action.to_s, *args.map {|obj| dumpObject.call(obj) || obj}]
+      end
+    end
+  end
+
+  def self.restore(xdos, &restoreObject)
+    xdos.map do |actions|
+      actions.map do |action, *args|
+        [action.intern, *args.map {|obj| restoreObject.call(obj) || obj}]
+      end
+    end
+  end
+
+end# History

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

@@ -0,0 +1,71 @@
+using RubySketch
+
+
+class Particle
+
+  include HasSprite
+
+  def initialize()
+    @sprites = []
+    @pool    = []
+  end
+
+  attr_reader :sprites
+
+  def new(x, y, w, h, &block)
+    sp = newSprite x, y, w, h
+    addSprite sp
+    @sprites.push sp
+    block.call sp if block
+    sp
+  end
+
+  def delete(sprite)
+    @sprites.delete sprite
+    removeSprite sprite
+    @pool.push sprite
+    sprite
+  end
+
+  def draw()
+    drawSprite @sprites
+  end
+
+  private
+
+  def newSprite(x, y, w, h)
+    popSprite(x, y, w, h) || ParticleSprite.new(self, x, y, w, h)
+  end
+
+  def popSprite(x, y, w, h)
+    @pool.pop&.tap do |sp|
+      sp.frame = [x, y, w, h]
+    end
+  end
+
+end# Particle
+
+
+class ParticleSprite < Sprite
+
+  def initialize(owner, *args, rgb: [255], alpha: 255, **kwargs, &block)
+    @owner, @rgb, @alpha = owner, rgb, alpha
+    super(*args, **kwargs, &block)
+    draw do |&draw|
+      fill *@rgb, @alpha
+      draw.call
+    end
+  end
+
+  attr_accessor :rgb, :alpha
+
+  def frame=(frame)
+    self.pos  = frame[0, 2]
+    self.size = frame[2, 2]
+  end
+
+  def delete()
+    @owner.delete self
+  end
+
+end# ParticleSprite

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

@@ -0,0 +1,128 @@
+using RubySketch
+
+
+class Scene
+
+  def initialize(name = self.class.name, *scenes)
+    @name     = name
+    @scenes   = []
+    @active   = self.class == RootScene
+    @prevSize = [width, height]
+    resized *@prevSize
+    scenes.each {|scene| add scene}
+  end
+
+  attr_reader :name, :parent
+
+  def add(scene)
+    @scenes.push scene
+    scene.parent = self
+    scene.activated if active?
+    scene
+  end
+
+  def remove(scene)
+    @scenes.delete scene
+    scene.deactivated if active?
+    scene.parent = nil
+    scene
+  end
+
+  def transition(to, effect = nil, *args, **kwargs)
+    if effect
+      add effect.new(to, *args, **kwargs)
+    else
+      parent.add to
+      parent.remove self
+    end
+    to
+  end
+
+  def emitParticle(x, y, w, h, sec = nil, &block)
+    par   = particle.new x, y, w, h
+    start = now
+    par.update do
+      time   = now - start
+      t      = sec ? time / sec : nil
+      result = block&.call time, t
+      if result == false || (t || 1) >= 1
+        par.update {}
+        par.delete
+      end
+    end
+    par
+  end
+
+  def sprites()
+    particle.sprites
+  end
+
+  def particle()
+    @particle ||= Particle.new
+  end
+
+  def update()
+    size = [width, height]
+    if size != @prevSize
+      resized(*size)
+      @prevSize = size
+    end
+  end
+
+  def draw()
+    update
+    @scenes.each do |scene|
+      push {scene.draw}
+    end
+    push do
+      blendMode ADD
+      particle.draw
+    end
+  end
+
+  def resized(w, h)
+  end
+
+  def activated()
+    @active = true
+    @scenes.each {|scene| scene.activated}
+    sprites.each {|sprite| addSprite sprite}
+  end
+
+  def deactivated()
+    sprites.each {|sprite| removeSprite sprite}
+    @scenes.each {|scene| scene.deactivated}
+    @active = false
+  end
+
+  def active?()
+    @active
+  end
+
+  def mousePressed(x, y, button)
+    @scenes.each {|scene| scene.mousePressed x, y, button}
+  end
+
+  def mouseReleased(x, y, button)
+    @scenes.each {|scene| scene.mouseReleased x, y, button}
+  end
+
+  def mouseMoved(x, y, dx, dy)
+    @scenes.each {|scene| scene.mouseMoved x, y, dx, dy}
+  end
+
+  def mouseDragged(x, y, dx, dy)
+    @scenes.each {|scene| scene.mouseDragged x, y, dx, dy}
+  end
+
+  protected
+
+  def parent=(scene)
+    @parent = scene
+  end
+
+end# Scene
+
+
+class RootScene < Scene
+end# RootScene

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

@@ -0,0 +1,37 @@
+using RubySketch
+
+
+class Score
+
+  include CanDisable
+
+  def initialize(**definitions)
+    super()
+    @defs, @value = {}, 0
+    define **definitions
+  end
+
+  attr_accessor :value
+
+  def define(**definitions)
+    definitions.each do |name, score|
+      @defs[name.intern] = score
+    end
+  end
+
+  def add(name)
+    return if disabled?
+    value   = @defs[name.intern]
+    @value += value.to_i if value
+    @value  = 0          if @value < 0
+  end
+
+  def to_h()
+    {score: @value}
+  end
+
+  def load(hash)
+    @value = hash['score']
+  end
+
+end# Score

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

@@ -0,0 +1,31 @@
+class Settings
+
+  def initialize(path)
+    @path = path or raise 'invalid path'
+    @hash = load path
+  end
+
+  def []=(key, value)
+    hash[key] = value
+    save @path
+  end
+
+  def [](key)
+    hash[key]
+  end
+
+  private
+
+  def hash()
+    @hash ||= {}
+  end
+
+  def save(path)
+    File.write path, hash.to_json
+  end
+
+  def load(path)
+    @hash = File.exist?(path) ? JSON.parse(File.read path) : {}
+  end
+
+end# Settings

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

@@ -0,0 +1,48 @@
+using RubySketch
+
+
+class Shake
+
+  def initialize(length, vector)
+    @length, @vector = length, vector
+  end
+
+  def update()
+    @length *=  0.8 if @length
+    @vector *= -0.8 if @vector
+    v = vector
+    @length = @vector = nil if v && v.mag < 1
+  end
+
+  def vector()
+    return nil unless @length || @vector
+    v  = @vector&.dup&.rotate(rand -20.0...20.0) || Vector.random2D
+    v *= @length if @length
+    v
+  end
+
+end# Shake
+
+
+def shake(obj, length = nil, vector: nil)
+  shake = Shake.new length, vector
+  pos   = obj.pos.dup
+  fun = -> do
+    v = shake.vector
+    break obj.pos = pos unless v
+    obj.pos = pos + v
+    shake.update
+    delay {fun.call}
+  end
+  fun.call
+end
+
+def shakeScreen(length = nil, vector: nil)
+  $shake = Shake.new length, vector
+end
+
+def drawShake()
+  v = $shake&.vector
+  translate v.x, v.y if v
+  $shake&.update
+end

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

@@ -0,0 +1,6 @@
+using RubySketch
+
+
+def loadSound(path)
+  Beeps::Sound.load path
+end