rubysketch-solitaire 0.1.0

data/RubySolitaire/Assets.xcassets/AccentColor.colorset/Contents.json

@@ -0,0 +1,11 @@
+{
+  "colors" : [
+    {
+      "idiom" : "universal"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

data/RubySolitaire/Assets.xcassets/AppIcon.appiconset/Contents.json

@@ -0,0 +1,98 @@
+{
+  "images" : [
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "2x",
+      "size" : "60x60"
+    },
+    {
+      "idiom" : "iphone",
+      "scale" : "3x",
+      "size" : "60x60"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "20x20"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "29x29"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "40x40"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "1x",
+      "size" : "76x76"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "76x76"
+    },
+    {
+      "idiom" : "ipad",
+      "scale" : "2x",
+      "size" : "83.5x83.5"
+    },
+    {
+      "idiom" : "ios-marketing",
+      "scale" : "1x",
+      "size" : "1024x1024"
+    }
+  ],
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

data/RubySolitaire/Assets.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

data/RubySolitaire/BridgingHeader.h

@@ -0,0 +1,10 @@
+#ifndef BridgingHeader_h
+#define BridgingHeader_h
+
+
+#import <CRuby.h>
+#import <RubySketch.h>
+#import "../src/ios/view_controller.h"
+
+
+#endif /* BridgingHeader_h */

data/RubySolitaire/GameView.swift

@@ -0,0 +1,47 @@
+import SwiftUI
+
+func getDocumentDir() -> URL {
+    return FileManager.default.urls(for: .documentDirectory, in: .userDomainMask).first!
+}
+
+class GameViewController : ReflexViewController {
+    override func viewDidLoad() {
+        super.viewDidLoad()
+
+        let mainBundleDir = Bundle.main.bundlePath
+
+        CRuby.evaluate("""
+            Encoding.default_internal = Encoding::UTF_8
+            Encoding.default_external = Encoding::UTF_8
+            Warning[:experimental]    = false
+
+            %w[
+                lib
+            ].each do |lib|
+                $LOAD_PATH.unshift File.join '\(mainBundleDir)', lib
+            end
+
+            Dir.chdir '\(getDocumentDir().path)'
+        """)
+
+        RubySketch.setup()
+        RubySketch.setActiveReflexViewController(self)
+
+        RubySketch.start("\(mainBundleDir)/main.rb");
+    }
+}
+
+struct GameView: View {
+    var body: some View {
+        GameViewControllerWrapper()
+    }
+}
+
+struct GameViewControllerWrapper : UIViewControllerRepresentable {
+    func makeUIViewController(context: Context) -> some UIViewController {
+        return GameViewController()
+    }
+
+    func updateUIViewController(_ uiViewController: UIViewControllerType, context: Context) {
+    }
+}

data/RubySolitaire/Preview Content/Preview Assets.xcassets/Contents.json

@@ -0,0 +1,6 @@
+{
+  "info" : {
+    "author" : "xcode",
+    "version" : 1
+  }
+}

data/RubySolitaire/RubySolitaireApp.swift

@@ -0,0 +1,10 @@
+import SwiftUI
+
+@main
+struct RubySolitaireApp: App {
+    var body: some Scene {
+        WindowGroup {
+            GameView()
+        }
+    }
+}

data/RubySolitaireTests/RubySolitaireTests.swift

@@ -0,0 +1,28 @@
+import XCTest
+@testable import RubySolitaire
+
+class RubySolitaireTests: XCTestCase {
+
+    override func setUpWithError() throws {
+        // Put setup code here. This method is called before the invocation of each test method in the class.
+    }
+
+    override func tearDownWithError() throws {
+        // Put teardown code here. This method is called after the invocation of each test method in the class.
+    }
+
+    func testExample() throws {
+        // This is an example of a functional test case.
+        // Use XCTAssert and related functions to verify your tests produce the correct results.
+        // Any test you write for XCTest can be annotated as throws and async.
+        // Mark your test throws to produce an unexpected failure when your test encounters an uncaught error.
+        // Mark your test async to allow awaiting for asynchronous code to complete. Check the results with assertions afterwards.
+    }
+
+    func testPerformanceExample() throws {
+        // This is an example of a performance test case.
+        self.measure {
+            // Put the code you want to measure the time of here.
+        }
+    }
+}

data/RubySolitaireUITests/RubySolitaireUITests.swift

@@ -0,0 +1,35 @@
+import XCTest
+
+class RubySolitaireUITests: XCTestCase {
+
+    override func setUpWithError() throws {
+        // Put setup code here. This method is called before the invocation of each test method in the class.
+
+        // In UI tests it is usually best to stop immediately when a failure occurs.
+        continueAfterFailure = false
+
+        // In UI tests it’s important to set the initial state - such as interface orientation - required for your tests before they run. The setUp method is a good place to do this.
+    }
+
+    override func tearDownWithError() throws {
+        // Put teardown code here. This method is called after the invocation of each test method in the class.
+    }
+
+    func testExample() throws {
+        // UI tests must launch the application that they test.
+        let app = XCUIApplication()
+        app.launch()
+
+        // Use recording to get started writing UI tests.
+        // Use XCTAssert and related functions to verify your tests produce the correct results.
+    }
+
+    func testLaunchPerformance() throws {
+        if #available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 7.0, *) {
+            // This measures how long it takes to launch your application.
+            measure(metrics: [XCTApplicationLaunchMetric()]) {
+                XCUIApplication().launch()
+            }
+        }
+    }
+}

data/RubySolitaireUITests/RubySolitaireUITestsLaunchTests.swift

@@ -0,0 +1,25 @@
+import XCTest
+
+class RubySolitaireUITestsLaunchTests: XCTestCase {
+
+    override class var runsForEachTargetApplicationUIConfiguration: Bool {
+        true
+    }
+
+    override func setUpWithError() throws {
+        continueAfterFailure = false
+    }
+
+    func testLaunch() throws {
+        let app = XCUIApplication()
+        app.launch()
+
+        // Insert steps here to perform after app launch but before taking a screenshot,
+        // such as logging into a test account or navigating somewhere in the app
+
+        let attachment = XCTAttachment(screenshot: app.screenshot())
+        attachment.name = "Launch Screen"
+        attachment.lifetime = .keepAlways
+        add(attachment)
+    }
+}

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/rubysketch/solitaire/background.rb

@@ -0,0 +1,34 @@
+using RubySketch
+
+
+class Background < Scene
+
+  def initialize()
+    super
+    @start = now
+  end
+
+  def draw()
+    pushStyle do
+      checker.set :time, now - @start
+      shader checker
+      rect 0, 0, width, height
+    end
+  end
+
+  private
+
+  def checker()
+    @checker ||= createShader nil, <<~END
+      varying vec4 vertTexCoord;
+      uniform float time;
+      void main() {
+        float t = mod(time, 32.0) * 16.0;
+        float x = mod(vertTexCoord.x + t, 32.0) < 16.0 ? 1.0 : 0.0;
+        float y = mod(vertTexCoord.y + t, 32.0) < 16.0 ? 1.0 : 0.0;
+        gl_FragColor = x != y ? vec4(0.6, 0.9, 0.7, 1) : vec4(0.7, 0.9, 0.6, 1);
+      }
+    END
+  end
+
+end# Background

data/lib/rubysketch/solitaire/card.rb

@@ -0,0 +1,256 @@
+using RubySketch
+
+
+class Card
+
+  include HasSprite
+  include Enumerable
+  include Comparable
+
+  MARKS = %i[heart diamond clover spade]
+
+  def initialize(game, mark, number)
+    @game, @mark, @number = game, mark, number
+    @state, @open         = :close, 0
+    @place = @next = nil
+  end
+
+  attr_reader :mark, :number, :place
+
+  attr_accessor :next
+
+  def each(&block)
+    return to_enum :each unless block
+    card = self
+    while card
+      next_ = card.next
+      block.call card
+      card = next_
+    end
+    self
+  end
+
+  def hover(rise = 100, base: self.z)
+    self.z = base + rise
+  end
+
+  def name()
+    @name ||= "#{mark}_#{number}"
+  end
+
+  def id()
+    @id ||= "id:#{name}"
+  end
+
+  def place=(place)
+    @place           = place
+    self.next&.place = place
+  end
+
+  def pos=(pos)
+    old = self.pos.dup
+    super
+    self.next&.pos += self.pos - old
+    self.pos
+  end
+
+  def x=(x)
+    self.pos = createVector x, self.y, self.z
+    self.x
+  end
+
+  def y=(y)
+    self.pos = createVector self.x, y, self.z
+    self.y
+  end
+
+  def z=(z)
+    self.pos = createVector self.x, self.y, z
+    self.z
+  end
+
+  def open(sec = 0)
+    @state = :open
+    animate(sec) {|t| @open = 180 * t}
+    self
+  end
+
+  def opened?()
+    @state == :open
+  end
+
+  def close(sec = 0)
+    @state = :close
+    animate(sec) {|t| @open = 180 * (1.0 - t)}
+    self
+  end
+
+  def closed?()
+    @state == :close
+  end
+
+  def color()
+    self.class.markColor mark
+  end
+
+  def count()
+    reduce(0) {|n| n + 1}
+  end
+
+  def last?()
+    place.last == self
+  end
+
+  def canDrop?()
+    @game.canDrop? self
+  end
+
+  def <=>(o)
+    number != o.number ? number <=> o.number :
+                           mark <=> o.mark
+  end
+
+  def sprite()
+    @sprite ||= Sprite.new(0, 0, *spriteSize, image: closedImage).tap do |sp|
+      sp.pivot = [rand, rand]
+      sp.angle = rand -5.0..5.0
+      sp.update do
+        sp.image = @open > 90 ? openedImage : closedImage
+      end
+      sp.draw do |&draw|
+        push do
+          px, py = *sp.pivot
+          translate  px,  py
+          rotate    -sp.angle
+          translate  2,  5
+          rotate     sp.angle
+          translate -px, -py
+          fill 0, 50
+          rect 0, 0, w, h, 4
+        end
+        translate  sp.w / 2,  sp.h / 2
+        rotate @open
+        translate -sp.w / 2, -sp.h / 2
+        image sp.image, 0, 0, w, h
+      end
+      sp.mousePressed do
+        mousePressed sp.mouseX, sp.mouseY
+      end
+      sp.mouseReleased do
+        mouseReleased sp.mouseX, sp.mouseY, sp.clickCount
+      end
+      sp.mouseDragged do
+        x, y = sp.mouseX, sp.mouseY
+        mouseDragged x, y, x - sp.pmouseX, y - sp.pmouseY
+      end
+    end
+  end
+
+  def inspect()
+    "#<Card #{name}>"
+  end
+
+  private
+
+  def mousePressed(x, y)
+    @prevPlace = place
+    @startPos  = createVector x, y, self.z
+    hover
+  end
+
+  def mouseReleased(x, y, clickCount)
+    self.z = @startPos.z if @startPos
+    pos    = sprite.to_screen createVector x, y
+    @game.cardDropped pos.x, pos.y, self, @prevPlace if
+      @prevPlace && clickCount == 0
+  end
+
+  def mouseDragged(x, y, dx, dy)
+    self.pos += createVector x - @startPos.x, y - @startPos.y if @startPos
+  end
+
+  def openedImage()
+    @openedImage ||= createGraphics(*self.class.cardSize).tap do |g|
+      c, w, h, m     = self.class, g.width, g.height, 16# margin
+      image          = c.cardImage
+      nx, ny, nw, nh = c.numberRect number
+      mx, my, mw, mh = c.markRect mark
+      mnh            = m + nh
+      mxx, myy       = (w - mw) / 2, mnh + ((h - mnh) - mh) / 2
+      g.beginDraw
+      g.angleMode DEGREES
+      g.translate  w / 2,  h / 2
+      g.rotate 180
+      g.translate -w / 2, -h / 2
+      g.copy image, 896,  0, w,  h,  0,   0,   w,  h
+      g.tint *c.markColor(mark)
+      g.copy image, nx, ny,  nw, nh, m,   m,   nw, nh
+      g.copy image, mx, my,  mw, mh, mxx, myy, mw, mh
+      g.endDraw
+    end
+  end
+
+  def closedImage()
+    self.class.closedImages[3]
+  end
+
+  def spriteSize()
+    self.class.spriteSize
+  end
+
+  def self.closedImages()
+    @closedImages ||= (0..3).map {|n| n * 256}.map do |x|
+      createGraphics(*cardSize).tap do |g|
+        w, h = g.width, g.height
+        g.beginDraw
+        g.copy cardImage, x, 256, w, h, 0, 0, w, h
+        g.endDraw
+      end
+    end
+  end
+
+  def self.cardImage()
+    @cardImage ||= loadImage dataPath 'card.png'
+  end
+
+  def self.cardSize()
+    [164, 252]
+  end
+
+  def self.spriteSize()
+    @spriteSize ||= cardSize.then do |cw, ch|
+      ncolumns   = 7
+      size       = [width, height].min
+      cardWidth  = (size - margin * (ncolumns + 1)) / ncolumns
+      [cardWidth, cardWidth * (ch.to_f / cw.to_f)]
+    end
+  end
+
+  def self.margin()
+    @marin ||= [width, height].min * 0.02
+  end
+
+  def self.markRect(mark)
+    w = h = 128
+    [MARKS.index(mark) * w, 0, w, h]
+  end
+
+  def self.numberRect(number)
+    w = h = 64
+    [(number - 1) * w, 128, w, h]
+  end
+
+  def self.markColor(mark)
+    MARKS[0, 2].include?(mark) ? [255, 111, 61] : [62, 79, 60]
+  end
+
+  def __find_or_last_and_prev(card = nil)
+    prev, it = nil, self
+    while it.next
+      break if it == card
+      prev, it = it, it.next
+    end
+    return it, prev
+  end
+
+end# Card