reight 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 86f61ce22f69d112815dcccd0800f21f73183c45bc26a8aef3818dfae72cb556
+  data.tar.gz: 4f6ec4c31e86ec0007454fb7e2b4d1c40b8e952671f69347fd429d0e7906deca
+SHA512:
+  metadata.gz: 21497433b9c5736683a9ca12db7ed8d728325005b1ca2002e30d619ea97fd7f97c0bc677dd8cab0ed28af8d45aed684e70e83cc1d681f641b4c5077dbe7ccda1
+  data.tar.gz: ac2d9d3adbca86a3f18bc1d3a141465dd7787abff61f6ad17ffdb411385448d39b01141961f2ce7f673957f59620cc078d05240833ff5eb781df518decdba6fb

data/.github/workflows/release-gem.yml

@@ -0,0 +1,62 @@
+name: Release Gem
+
+on:
+  push:
+    tags: ['v[0-9]*']
+
+jobs:
+  release:
+    runs-on: macos-latest
+
+    steps:
+      - name: ruby 3.2
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.2
+
+      - name: checkout
+        uses: actions/checkout@v4
+
+      - name: setup gems
+        run: bundle install
+
+      - name: setup dependencies
+        run: "ruby -I.github/workflows -rutils -e 'setup_dependencies'"
+
+      - name: test
+        run: bundle exec rake quiet packages test
+
+      - name: create gem
+        id: gem
+        run: |
+          bundle exec rake gem
+          echo path=$(ruby -e 'print Dir.glob("*.gem").first') >> $GITHUB_OUTPUT
+
+      - name: create github release
+        id: release
+        uses: actions/create-release@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          tag_name: ${{ github.ref }}
+          release_name: ${{ github.ref }}
+
+      - name: upload to github release
+        uses: actions/upload-release-asset@v1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        with:
+          upload_url: ${{ steps.release.outputs.upload_url }}
+          asset_path: ./${{ steps.gem.outputs.path }}
+          asset_name:   ${{ steps.gem.outputs.path }}
+          asset_content_type: application/zip
+
+      - name: upload to rubygems
+        env:
+          GEM_HOST_API_KEY: ${{ secrets.RUBYGEMS_AUTH_TOKEN }}
+        run: |
+          mkdir -p $HOME/.gem
+          touch $HOME/.gem/credentials
+          chmod 0600 $HOME/.gem/credentials
+          printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
+          bundle exec rake upload

data/.github/workflows/tag.yml

@@ -0,0 +1,35 @@
+name: Tag
+
+on:
+  push:
+    branches: [master]
+
+jobs:
+  tag:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: ruby 3.2
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.2
+
+      - name: checkout
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.PAT }}
+
+      - name: setup dependencies
+        run: "ruby -I.github/workflows -rutils -e 'setup_dependencies only: :xot'"
+
+      - name: setup user name and email
+        run: |
+          git config --global user.email "xordog@gmail.com"
+          git config --global user.name "xord"
+
+      - name: tag versions
+        run: "ruby -I.github/workflows -rutils -e 'tag_versions'"
+
+      - name: push tags
+        run: git push origin --tags

data/.github/workflows/test.yml

@@ -0,0 +1,37 @@
+name: Test
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: macos-latest
+
+    steps:
+      - name: ruby 3.2
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.2
+
+      - name: checkout
+        uses: actions/checkout@v4
+
+      - name: setup gems
+        run: bundle install
+
+      - name: setup dependencies
+        run: "ruby -I.github/workflows -rutils -e 'setup_dependencies'"
+
+      - name: packages
+        run: bundle exec rake packages
+
+      - name: lib
+        run: bundle exec rake lib
+
+      - name: ext
+        run: bundle exec rake ext
+
+      - name: test
+        run: bundle exec rake test

data/.github/workflows/utils.rb

@@ -0,0 +1,56 @@
+RENAMES = {reflex: 'reflexion'}
+
+def sh(cmd)
+  puts cmd
+  system cmd
+end
+
+def setup_dependencies(build: true, only: nil)
+  gemspec_path = `git ls-files`.lines(chomp: true).find {|l| l =~ /\.gemspec$/}
+  return unless gemspec_path
+
+  gemspec = File.read gemspec_path
+  name    = File.basename gemspec_path, '.gemspec'
+
+  exts = File.readlines('Rakefile')
+    .map {|l| l[%r|^\s*require\W+(\w+)/extension\W+$|, 1]}
+    .compact
+    .reject {|ext| ext == name}
+  exts = exts & [only].flatten.map(&:to_s) if only
+
+  exts.each do |ext|
+    gem   = RENAMES[ext.to_sym].then {|s| s || ext}
+    ver   = gemspec[/add_dependency.*['"]#{gem}['"].*['"]\s*>=\s*([\d\.]+)\s*['"]/, 1]
+    opts  = '-c advice.detachedHead=false --depth 1'
+    clone = "git clone #{opts} https://github.com/xord/#{ext}.git ../#{ext}"
+
+    # 'rake subtree:push' pushes all subrepos, so cloning by new tag
+    # often fails before tagging each new tag
+    sh %( #{clone} --branch v#{ver} || #{clone} )
+    sh %( cd ../#{ext} && rake ext )
+  end
+end
+
+def tag_versions()
+  tags = `git tag`.lines chomp: true
+  vers = `git log --oneline ./VERSION`
+    .lines(chomp: true)
+    .map {|line| line.split.first[/^\w+$/]}
+    .map {|hash| [`git cat-file -p #{hash}:./VERSION 2>/dev/null`[/[\d\.]+/], hash]}
+    .select {|ver, hash| ver && hash}
+    .reverse
+    .to_h
+
+  changes = File.read('ChangeLog.md')
+    .split(/^\s*##\s*\[\s*v([\d\.]+)\s*\].*$/)
+    .slice(1..-1)
+    .each_slice(2)
+    .to_h
+    .transform_values(&:strip!)
+
+  vers.to_a.reverse.each do |ver, hash|
+    tag = "v#{ver}"
+    break if tags.include?(tag)
+    sh %( git tag -a -m \"#{changes[ver]&.gsub '"', '\\"'}\" #{tag} #{hash} )
+  end
+end

data/.gitignore

@@ -0,0 +1 @@
+*~

data/ChangeLog.md

@@ -0,0 +1,23 @@
+# reight ChangeLog
+
+
+## [v0.1.2] - 2025-01-14
+
+- User can change the file name of user scripts
+- Rename from 'bin/r8.rb' to 'bin/r8'
+- Change the file/directory structure of the source code
+- Update icon images
+- Update workflow files
+- Set minumum version for runtime dependency
+
+- Fix an error on first launch
+
+
+## [v0.1.1] - 2025-01-13
+
+- Update README.md
+
+
+## [v0.1] - 2025-01-13
+
+- Alpha version

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'rexml'
+gem 'rake'
+gem 'test-unit'
+gem 'yard'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 xord.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,62 @@
+
+# Reight - A Retro Game Engine for Ruby
+
+Reight is an open-source Ruby library inspired by the powerful [Processing](https://processing.org/) API, designed to make creative coding accessible and enjoyable for everyone. With support for both Mac and Windows, this library brings the joy of visual programming to Ruby developers.
+
+## Features
+
+- **Processing API Compatibility**: Leverage the well-known Processing API to create stunning visuals, animations, and interactive applications using Ruby.
+- **Cross-Platform**: Works seamlessly on both macOS and Windows environments.
+- **Ruby-Powered**: Enjoy the elegance and simplicity of Ruby while crafting creative projects.
+- **Extensible and Open**: Modify and extend the library to fit your unique needs.
+
+## Installation
+
+Install the gem via RubyGems:
+
+```bash
+gem install reight
+```
+
+Or add it to your Gemfile:
+
+```ruby
+gem 'reight'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+## Getting Started
+
+Here’s a simple example to get you started:
+
+```ruby
+# Create a window and draw something
+draw do
+  background 0
+	$sprites ||= project.maps.first.map(&:to_sprite)
+	sprite $sprites
+end
+```
+
+Run the script and watch your window come to life!
+
+```
+$ bundle exec r8 .
+```
+
+## Documentation
+
+Comprehensive documentation and guides can be found [here](https://www.rubydoc.info/gems/reight/0.1/index).
+
+## License
+
+This project is licensed under the [MIT License](LICENSE).
+
+---
+
+Happy coding with Ruby and Processing!

data/Rakefile

@@ -0,0 +1,30 @@
+# -*- mode: ruby -*-
+
+%w[../xot ../rucy ../beeps ../rays ../reflex ../processing ../rubysketch .]
+  .map  {|s| File.expand_path "#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'xot/rake'
+
+require 'xot/extension'
+require 'rucy/extension'
+require 'beeps/extension'
+require 'rays/extension'
+require 'reflex/extension'
+require 'processing/extension'
+require 'rubysketch/extension'
+require 'reight/extension'
+
+
+EXTENSIONS = [Xot, Rucy, Beeps, Rays, Reflex, Processing, RubySketch, Reight]
+
+default_tasks
+test_ruby_extension
+build_ruby_gem
+
+
+task :run do
+  libs = %w[xot rucy beeps rays reflex processing rubysketch]
+    .map {|lib| "-I#{ENV['ALL']}/#{lib}/lib"}
+  sh %( ruby #{libs.join ' '} -Ilib bin/r8 '#{ENV["path"] || "."}' )
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.2

data/bin/r8

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require 'reight'
+using Reight
+
+
+def r8 = $r8__
+
+def usage()
+  <<~END
+    USAGE: r8 [path]
+  END
+end
+
+Reight::CONTEXT__.tap do |c|
+  path = ARGV.shift or return puts usage
+  path = File.expant_path path, Dir.pwd if path.start_with?('/')
+  c.setup          {Reight::R8.new(path).setup}
+  c.draw           {r8.draw}
+  c.key_pressed    {r8.key_pressed}
+  c.key_released   {r8.key_released}
+  c.key_typed      {r8.key_typed}
+  c.mouse_pressed  {r8.mouse_pressed}
+  c.mouse_released {r8.mouse_released}
+  c.mouse_moved    {r8.mouse_moved}
+  c.mouse_dragged  {r8.mouse_dragged}
+  c.mouse_clicked  {r8.mouse_clicked}
+  c.double_clicked {r8.double_clicked}
+  c.mouse_wheel    {r8.mouse_wheel}
+  c.touch_started  {r8.touch_started}
+  c.touch_ended    {r8.touch_ended}
+  c.touch_moved    {r8.touch_moved}
+  c.window_moved   {r8.window_moved}
+  c.window_resized {r8.window_resized}
+end

data/lib/reight/all.rb

@@ -0,0 +1,59 @@
+module Reight
+  def self.to_snake_case(camel_case_names)
+    camel_case_names.map(&:to_s)
+      .map {[_1, _1.gsub(/([a-z])([A-Z])/) {"#{$1}_#{$2.downcase}"}]}
+  end
+
+  # alias snake_case methods
+  [Processing, RubySketch]
+    .map {|mod| mod.constants.map {mod.const_get _1}}
+    .flatten
+    .select {_1.class == Module || _1.class == Class}
+    .each do |klass|
+      Reight.to_snake_case(klass.instance_methods false)
+        .reject {|camel, snake| camel =~ /__$/}
+        .reject {|camel, snake| klass.method_defined? snake}
+        .each   {|camel, snake| klass.alias_method snake, camel}
+    end
+
+  w = (ENV['WIDTH']  || 500).to_i
+  h = (ENV['HEIGHT'] || 500).to_i
+  WINDOW__  = Processing::Window.new(w, h) {start}
+  CONTEXT__ = RubySketch::Context.new WINDOW__
+
+  excludes = Reight.to_snake_case(%i[
+    setup draw
+    keyPressed keyReleased keyTyped
+    mousePressed mouseReleased mouseMoved mouseDragged
+    mouseClicked doubleClicked mouseWheel
+    touchStarted touchEnded touchMoved
+    windowMoved windowResized motion
+  ]).flatten.uniq
+  refine Object do
+    (CONTEXT__.methods - Object.instance_methods - excludes)
+      .reject {_1 =~ /__$/} # methods for internal use
+      .each do |method|
+        define_method(method) do |*args, **kwargs, &block|
+          CONTEXT__.__send__(method, *args, **kwargs, &block)
+        end
+      end
+  end
+end# Reight
+
+
+require 'reight/extension'
+require 'reight/helpers'
+require 'reight/project'
+require 'reight/history'
+require 'reight/button'
+
+require 'reight/reight'
+require 'reight/chip'
+require 'reight/map'
+require 'reight/app'
+require 'reight/app/navigator'
+require 'reight/app/runner'
+require 'reight/app/sprite'
+require 'reight/app/map'
+require 'reight/app/sound'
+require 'reight/app/music'

data/lib/reight/app/map/brush.rb

@@ -0,0 +1,27 @@
+using Reight
+
+
+class Reight::MapEditor::Brush < Reight::MapEditor::BrushBase
+
+  def initialize(app, &block)
+    super app, icon: app.icon(1, 2, 8), &block
+    set_help left: name, right: 'Pick Chip'
+  end
+
+  def brush(cursor_from, cursor_to, chip)
+    x, y, = cursor_to
+    put_or_delete_chip x, y, chip
+    false
+  end
+
+  def canvas_pressed(...)
+    canvas.begin_editing
+    super
+  end
+
+  def canvas_released(...)
+    super
+    canvas.end_editing
+  end
+
+end# Brush

data/lib/reight/app/map/brush_base.rb

@@ -0,0 +1,54 @@
+using Reight
+
+
+class Reight::MapEditor::BrushBase < Reight::MapEditor::Tool
+
+  def brush(cursor_from, cursor_to, chip) = nil
+
+  def put_or_delete_chip(x, y, chip)
+    return false unless x && y && chip
+    m = canvas.map
+    return false if !@deleting && m[x, y]&.id == chip.id
+
+    result = false
+    m.each_chip x, y, chip.w, chip.h do |ch|
+      m.delete_chip ch
+      result |= history.append [:delete_chip, ch.pos.x, ch.pos.y, ch.id]
+    end
+    unless @deleting
+      m.put x, y, chip
+      result |= history.append [:put_chip, x, y, chip.id]
+    end
+    result
+  end
+
+  def canvas_pressed(x, y, button)
+    return unless button == LEFT
+    @cursor_from, @deleting = canvas.cursor.dup, chips.chip.empty?
+    @undo_prev              = brush @cursor_from, canvas.cursor, chips.chip
+  end
+
+  def canvas_released(x, y, button)
+    return unless button == LEFT
+  end
+
+  def canvas_moved(x, y)
+    update_cursor x, y
+  end
+
+  def canvas_dragged(x, y, button)
+    update_cursor x, y
+    return unless button == LEFT
+    app.undo flash: false if @undo_prev
+    @undo_prev = brush @cursor_from, canvas.cursor, chips.chip
+  end
+
+  def canvas_clicked(x, y, button)
+    pick_chip x, y if button == RIGHT
+  end
+
+  def update_cursor(x, y)
+    canvas.set_cursor x, y, chips.size, chips.size
+  end
+
+end# BrushBase

data/lib/reight/app/map/canvas.rb

@@ -0,0 +1,150 @@
+using Reight
+
+
+class Reight::MapEditor::Canvas
+
+  include Reight::Hookable
+
+  def initialize(app, map, path)
+    hook :tool_changed
+
+    @app, @map, @path      = app, map, path
+    @x, @y, @tool, @cursor = 0, 0, nil, nil, nil
+  end
+
+  attr_accessor :x, :y
+
+  attr_reader :map, :tool, :cursor
+
+  def save()
+    @app.project.save
+  end
+
+  def tool=(tool)
+    @tool = tool
+    tool_changed! tool
+  end
+
+  def set_cursor(x, y, w, h)
+    @cursor = correct_bounds x, y, w, h
+  end
+
+  def chip_at_cursor()
+    x, y, = cursor
+    map[@x + x, @y + y]
+  end
+
+  def begin_editing(&block)
+    @app.history.begin_grouping
+    block.call if block
+  ensure
+    end_editing if block
+  end
+
+  def end_editing()
+    @app.history.end_grouping
+    save
+  end
+
+  def sprite()
+    @sprite ||= Sprite.new.tap do |sp|
+      pos = -> {to_image sp.mouse_x, sp.mouse_y}
+      sp.draw           {draw}
+      sp.mouse_pressed  {mouse_pressed( *pos.call, sp.mouse_button)}
+      sp.mouse_released {mouse_released(*pos.call, sp.mouse_button)}
+      sp.mouse_moved    {mouse_moved(   *pos.call)}
+      sp.mouse_dragged  {mouse_dragged( *pos.call, sp.mouse_button)}
+      sp.mouse_clicked  {mouse_clicked( *pos.call, sp.mouse_button)}
+    end
+  end
+
+  private
+
+  def to_image(x, y)
+    return x, y unless @x && @y
+    return x - @x, y - @y
+  end
+
+  def correct_bounds(x, y, w, h)
+    x, y, w, h = [x, y, w, h].map &:to_i
+    return x / w * w, y / h * h, w, h
+  end
+
+  def draw()
+    sp = sprite
+
+    clip sp.x, sp.y, sp.w, sp.h
+    translate @x, @y
+
+    fill 0, 0, 0
+    no_stroke
+    rect(-@x, -@y, sp.w, sp.h)
+
+    draw_grids
+
+    map.each_chip(-@x, -@y, sp.w, sp.h, clip_by_chunk: true).each do |chip|
+      pos = chip.pos
+      copy chip.image, *chip.frame, pos.x, pos.y, chip.w, chip.h
+    end
+
+    if @cursor
+      no_fill
+      stroke 255, 255, 255
+      stroke_weight 1
+      rect(*@cursor)
+    end
+  end
+
+  def draw_grids()
+    push do
+      app    = Reight::App
+      sw, sh = app::SCREEN_WIDTH, app::SCREEN_HEIGHT
+      mw, mh = sw * 10, sh * 10
+      stroke 20
+      shape grid 8,      8,      mw, mh if @app.pressing?(SPACE)
+      stroke 50
+      shape grid sw / 2, sh / 2, mw, mh
+      stroke 100
+      shape grid sw,     sh,     mw, mh
+    end
+  end
+
+  def grid(xinterval, yinterval, xmax, ymax)
+    (@grids ||= {})[xinterval] ||= create_shape.tap do |sh|
+      sh.begin_shape LINES
+      (0..xmax).step(xinterval).each do |x|
+        sh.vertex x, 0
+        sh.vertex x, ymax
+      end
+      (0..ymax).step(yinterval).each do |y|
+        sh.vertex 0,    y
+        sh.vertex xmax, y
+      end
+      sh.end_shape
+    end
+  end
+
+  def mouse_pressed(...)
+    tool&.canvas_pressed(...)  unless hand?
+  end
+
+  def mouse_released(...)
+    tool&.canvas_released(...) unless hand?
+  end
+
+  def mouse_dragged(...)
+    if hand?
+      sp  = sprite
+      @x += sp.mouse_x - sp.pmouse_x
+      @y += sp.mouse_y - sp.pmouse_y
+    else
+      tool&.canvas_dragged(...)
+    end
+  end
+
+  def mouse_moved(...)   = tool&.canvas_moved(...)
+  def mouse_clicked(...) = tool&.canvas_clicked(...)
+
+  def hand? = @app.pressing?(SPACE)
+
+end# Canvas