ruby2d-camera 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fb4d1852c5d26e98334d2d1dff3f480c0ee51b0f3a0e0acfcd55f21bbb494d9b
+  data.tar.gz: c4829a8ece2fcc5b342e82ea1b21e4af317e59691a376ec61724a52ee233cfd2
+SHA512:
+  metadata.gz: ef598ebfb03a65bb732ffd2c257ff8e685f44f5838b92c2d866d0492a678b66c39649caf9703262669f7bdef7d514492bada4de1d146ebb84b310a90abd4b109
+  data.tar.gz: 5c65aab04d7c23de753f603114bd96e9352e8bf6fbe9f26fd37d5346d111322c6fd08b31a736aa1a0ceff414941b1068fe1a7a6aaf55e0ea9205376bff42d324

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 3.0
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: single_quotes
+
+Layout/LineLength:
+  Max: 120

data/.solargraph.yml

@@ -0,0 +1,15 @@
+---
+include:
+- "**/*.rb"
+exclude:
+- spec/**/*
+- test/**/*
+- vendor/**/*
+- ".bundle/**/*"
+require: []
+domains: []
+reporters:
+- rubocop
+require_paths: []
+plugins: []
+max_files: 5000

data/CHANGELOG.mdown

@@ -0,0 +1,11 @@
+###### [major.minor.bugfix] - year-month-day
+
+![Fixed](https://img.shields.io/badge/-Fixed-blue)
+![Added](https://img.shields.io/badge/-Added-brightgreen)
+![Changed](https://img.shields.io/badge/-Changed-yellow)
+![Deprecated](https://img.shields.io/badge/-Deprecated-orange)
+![Removed](https://img.shields.io/badge/-Removed-red)
+
+## [1.0.0](https://github.com/realtradam/ruby2d-camera/releases/tag/1.0.0) - 2021-08-08
+![Added](https://img.shields.io/badge/-Added-brightgreen)
+- Initial release

data/Gemfile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in ruby2d-camera.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "rubocop", "~> 1.7"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 realtradam
+
+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.mdown

@@ -0,0 +1,39 @@
+![ruby2d-camera logo](https://naked.catgirls.rodeo/images/ruby2d-camera.png)
+
+[![MIT License](https://img.shields.io/github/license/realtradam/FelFlame?label=license&style=flat)](https://github.com/realtradam/FelFlame/blob/master/LICENSE)
+[![Ko-Fi](https://img.shields.io/static/v1?message=Buy%20me%20a%20coffee&logo=kofi&labelColor=ff5e5b&color=434B57&logoColor=white&label=%20)](https://ko-fi.com/tradam)
+
+# Ruby2D Camera Gem
+
+With this gem you can easily add camera functionality into your games built with Ruby2D. Install it using `gem install ruby2d-camera` and then add it into your project with `require ruby2d/camera` at the top of your code, just below the line `require ruby2d`.
+
+`ruby run.rb` to run the demo.
+
+## How to use the camera:
+
+Create your object as if you would create it in Ruby2D except you need to prefix it with `Camera::`. For example to create a square you do `Camera::Square.new`. Any objects you create this way can be controlled and manipulated the same way that you control and manipulate them in Ruby2D with a few small additions. Any objects that do not have an x/y variable to move it now do have this, so that you may move the objects in the camera. Text objects also have a boolean that you can change named `center` which allows you to set the origin to be the horizontal center of the text rather then the edge.
+
+### To manipulate the camera there are 4 variables:
+
+- `Camera.zoom` Default: 1. This is a multiplier for how much you want the camera to be zoomed in(e.g 2 is 2x zoom, 0.5 is 0.5x zoom)
+- `Camera.x` and `Camera.y` Default: 0. This is the position the camera is centered on in the "world"
+- `Camera.angle` Default: 0. This is the angle of how much the camera is rotated(in degrees). It ranges from 0-360. Giving values outside of this range will automagically convert them to fit within the 0-360 range.
+
+## How it works:
+
+A single `Camera` module exists which keeps track of objects created with it. When you create an object with the camera it creates a special object that inherits the original object from Ruby2D and then adds additional functions. The Camera module then uses these functions to draw the various objects on the screen each frame, using the parameters you gave it.
+
+## Demo:
+
+Under the `example` directory you can find a (poorly coded) demo using this gem. Simply `ruby run.rb` in the example directory to start the demo.
+
+### Controls:
+
+WASD to move character  
+Q/E to rotate camera  
+Hold R to reset the rotation  
+Space to enter doors
+
+## Known Issues:
+
+Unfortunately text cannot be resized due to current limitations of Ruby2D, this will fixed when possible. This means zooming with text will look strange, centering the text somewhat alleviates this issue.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: :rubocop

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "ruby2d/camera"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/ruby2d/camera.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+# require_relative "camera/version"
+# require_relative "camera/triangle"
+require 'ruby2d'
+Dir[File.join(__dir__, 'camera', '*.rb')].sort.each { |file| require file }
+
+# Handles rendering objects relative
+# to a camera location
+module Ruby2D
+  module Camera
+    class << self
+      private
+
+      # Contains all objects that are tracked
+      def objects
+        @objects ||= []
+      end
+    end
+
+    def self.debug_x
+      @debug_x ||= 0
+    end
+
+    def self.debug_x=(debug_x)
+      @debug_x = debug_x
+    end
+
+    def self.debug_y
+      @debug_y ||= 0
+    end
+
+    def self.debug_y=(debug_y)
+      @debug_y = debug_y
+    end
+
+    # Adding objects so they are
+    # tracked by the Camera
+    def self.<<(item)
+      objects.push(item) unless objects.include?(item)
+      objects.sort_by! do |n|
+        n.z
+      end
+    end
+
+    def self.remove(item)
+      objects.delete(item) if objects.include?(item)
+    end
+
+    # Redraw all objects that
+    # are tracked by the Camera
+    def self._redraw(auto_purge: false)
+      objects.each(&:_draw)
+    end
+
+    # Variables changing Camera properties
+    def self._x(x)
+      @x += x
+    end
+
+    def self._y(y)
+      @y += y
+    end
+
+    def self.x
+      @x ||= 0
+    end
+
+    def self.x=(x)
+      @x = x
+    end
+
+    def self.y
+      @y ||= 0
+    end
+
+    def self.y=(y)
+      @y = y
+    end
+
+    def self.zoom
+      @zoom ||= 1.0
+    end
+
+    def self.zoom=(zoom)
+      @zoom = zoom
+    end
+
+    def self.angle
+      @angle ||= 0
+    end
+
+    def self.angle=(angle)
+      angle %= 360
+      @angle = angle
+    end
+  end
+end
+
+module Ruby2D
+  class Window
+    def update(&aproc)
+      @update_proc = (aproc << proc { Ruby2D::Camera._redraw })
+      true
+    end
+  end
+end

data/lib/ruby2d/camera/circle.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Ruby2D
+  module Camera
+    # Wraps existing variables as well as adding new methods
+    # so that it can be handled by the Camera Module
+    class Circle < Ruby2D::Circle
+      # Recalculates real coordiantes
+      # Use after changing variables
+      def _draw
+        return if @hide
+
+        angle = Camera.angle * (Math::PI / 180)
+        half_width = Window.width * 0.5
+        half_height = Window.height * 0.5
+        temp_radius = @radius * Camera.zoom
+        temp_x = (((@x - Ruby2D::Camera.x + radius) * Math.cos(angle)) - ((@y - Ruby2D::Camera.y + radius) * Math.sin(angle))) * Ruby2D::Camera.zoom + half_width
+        temp_y = (((@x - Ruby2D::Camera.x + radius) * Math.sin(angle)) + ((@y - Ruby2D::Camera.y + radius) * Math.cos(angle))) * Ruby2D::Camera.zoom + half_height
+        Ruby2D::Circle.draw(x: temp_x, y: temp_y,
+                            radius: temp_radius,
+                            sectors: sectors,
+                            color: [color.r, color.g, color.b, color.a])
+      end
+
+      def initialize(opts = {})
+        super(opts)
+        Ruby2D::Camera << self
+        Window.remove(self)
+      end
+
+      def remove
+        @hide = true
+      end
+
+      def add
+        @hide = false
+      end
+    end
+  end
+end

data/lib/ruby2d/camera/image.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Camera
+  # Wraps existing variables as well as adding new methods
+  # so that it can be handled by the Camera Module
+  class Image < Ruby2D::Image
+    # Recalculates real coordiantes
+    # Use after changing variables
+    def _draw
+      return if @hide
+
+      temp_angle = Camera.angle * (Math::PI / 180)
+      half_width = Window.width * 0.5
+      half_height = Window.height * 0.5
+      offset_x = @x + (@width / 2)
+      offset_y = @y + (@height / 2)
+      temp_x = (((offset_x - Camera.x) * Math.cos(temp_angle)) - ((offset_y - Camera.y) * Math.sin(temp_angle))) \
+        * Camera.zoom + half_width - (width * Camera.zoom / 2)
+      temp_y = (((offset_x - Camera.x) * Math.sin(temp_angle)) + ((offset_y - Camera.y) * Math.cos(temp_angle))) \
+        * Camera.zoom + half_height - (height * Camera.zoom / 2)
+      temp_rotate = rotate + Camera.angle
+      temp_width = width * Camera.zoom
+      temp_height = height * Camera.zoom
+      draw(x: temp_x, y: temp_y,
+           width: temp_width,
+           height: temp_height,
+           rotate: temp_rotate,
+           color: [color.r, color.g, color.b, color.a])
+    end
+
+    def initialize(path, opts = {})
+      super(path, opts)
+      Ruby2D::Camera << self
+      Window.remove(self)
+    end
+
+    def remove
+      @hide = true
+    end
+
+    def add
+      @hide = false
+    end
+  end
+end

data/lib/ruby2d/camera/line.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Ruby2D
+  module Camera
+    # Wraps existing variables as well as adding new methods
+    # so that it can be handled by the Camera Module
+    class Line < Ruby2D::Line
+      # Recalculates real coordiantes
+      # Use after changing variables
+      def _draw
+        return if @hide
+
+        angle = Camera.angle * (Math::PI / 180)
+        half_width = Window.width * 0.5
+        half_height = Window.height * 0.5
+        temp_x1 = (((x + @x1 - Camera.x) * Math.cos(angle)) - ((y + @y1 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y1 = (((x + @x1 - Camera.x) * Math.sin(angle)) + ((y + @y1 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        temp_x2 = (((x + @x2 - Camera.x) * Math.cos(angle)) - ((y + @y2 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y2 = (((x + @x2 - Camera.x) * Math.sin(angle)) + ((y + @y2 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        temp_width = width * Camera.zoom
+        Ruby2D::Line.draw(x1: temp_x1, y1: temp_y1,
+                          x2: temp_x2, y2: temp_y2,
+                          width: temp_width,
+                          color: [
+                            [color.r, color.g, color.b, color.a],
+                            [color.r, color.g, color.b, color.a],
+                            [color.r, color.g, color.b, color.a],
+                            [color.r, color.g, color.b, color.a]
+                          ],
+                          z: z)
+      end
+
+      def initialize(opts = {})
+        super(opts)
+        Ruby2D::Camera << self
+        Window.remove(self)
+      end
+
+      def remove
+        @hide = true
+      end
+
+      def add
+        @hide = false
+      end
+
+      # Methods for moving the shape
+      def x
+        @x ||= 0
+      end
+
+      attr_writer :x, :y
+
+      def y
+        @y ||= 0
+      end
+    end
+  end
+end

data/lib/ruby2d/camera/quad.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Ruby2D
+  module Camera
+    # Wraps existing variables as well as adding new methods
+    # so that it can be handled by the Camera Module
+    class Quad < Ruby2D::Quad
+      # Recalculates real coordiantes
+      # Use after changing variables
+      def _draw
+        return if @hide
+
+        angle = Camera.angle * (Math::PI / 180)
+        half_width = Window.width * 0.5
+        half_height = Window.height * 0.5
+        temp_x1 = (((x + x1 - Camera.x) * Math.cos(angle)) - ((y + y1 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y1 = (((x + x1 - Camera.x) * Math.sin(angle)) + ((y + y1 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        temp_x2 = (((x + x2 - Camera.x) * Math.cos(angle)) - ((y + y2 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y2 = (((x + x2 - Camera.x) * Math.sin(angle)) + ((y + y2 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        temp_x3 = (((x + x3 - Camera.x) * Math.cos(angle)) - ((y + y3 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y3 = (((x + x3 - Camera.x) * Math.sin(angle)) + ((y + y3 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        temp_x4 = (((x + x4 - Camera.x) * Math.cos(angle)) - ((y + y4 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y4 = (((x + x4 - Camera.x) * Math.sin(angle)) + ((y + y4 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        Ruby2D::Quad.draw(x1: temp_x1, y1: temp_y1,
+                          x2: temp_x2, y2: temp_y2,
+                          x3: temp_x3, y3: temp_y3,
+                          x4: temp_x4, y4: temp_y4,
+                          color: [
+                            [c1.r, c1.g, c1.b, c1.a],
+                            [c2.r, c2.g, c2.b, c2.a],
+                            [c3.r, c3.g, c3.b, c3.a],
+                            [c4.r, c4.g, c4.b, c4.a]
+                          ],
+                          z: z)
+      end
+
+      def initialize(opts = {})
+        super(opts)
+        Ruby2D::Camera << self
+        Window.remove(self)
+      end
+
+      def remove
+        @hide = true
+      end
+
+      def add
+        @hide = false
+      end
+
+      # Methods for moving the shape
+      def x
+        @x ||= 0
+      end
+
+      attr_writer :x, :y
+
+      def y
+        @y ||= 0
+      end
+    end
+  end
+end

data/lib/ruby2d/camera/rectangle.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Ruby2D
+  module Camera
+    # Wraps existing variables as well as adding new methods
+    # so that it can be handled by the Camera Module
+    class Rectangle < Ruby2D::Rectangle
+      # Recalculates real coordiantes
+      # Use after changing variables
+      def _draw
+        return if @hide
+
+        angle = Camera.angle * (Math::PI / 180)
+        half_width = Window.width * 0.5
+        half_height = Window.height * 0.5
+        temp_x1 = (((x + x1 - Camera.x) * Math.cos(angle)) - ((y + y1 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y1 = (((x + x1 - Camera.x) * Math.sin(angle)) + ((y + y1 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        temp_x2 = (((x + x2 - Camera.x) * Math.cos(angle)) - ((y + y2 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y2 = (((x + x2 - Camera.x) * Math.sin(angle)) + ((y + y2 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        temp_x3 = (((x + x3 - Camera.x) * Math.cos(angle)) - ((y + y3 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y3 = (((x + x3 - Camera.x) * Math.sin(angle)) + ((y + y3 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        temp_x4 = (((x + x4 - Camera.x) * Math.cos(angle)) - ((y + y4 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y4 = (((x + x4 - Camera.x) * Math.sin(angle)) + ((y + y4 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        Ruby2D::Quad.draw(x1: temp_x1, y1: temp_y1,
+                          x2: temp_x2, y2: temp_y2,
+                          x3: temp_x3, y3: temp_y3,
+                          x4: temp_x4, y4: temp_y4,
+                          color: [
+                            [c1.r, c1.g, c1.b, c1.a],
+                            [c2.r, c2.g, c2.b, c2.a],
+                            [c3.r, c3.g, c3.b, c3.a],
+                            [c4.r, c4.g, c4.b, c4.a]
+                          ],
+                          z: z)
+      end
+
+      def initialize(opts = {})
+        super(opts)
+        Ruby2D::Camera << self
+        Window.remove(self)
+        @x1 -= @x
+        @x2 -= @x
+        @x3 -= @x
+        @x4 -= @x
+        @y1 -= @y
+        @y2 -= @y
+        @y3 -= @y
+        @y4 -= @y
+      end
+
+      def remove
+        @hide = true
+      end
+
+      def add
+        @hide = false
+      end
+
+      # Methods for moving the shape
+      def x
+        @x ||= 0
+      end
+
+      attr_writer :x, :y
+
+      def y
+        @y ||= 0
+      end
+    end
+  end
+end

data/lib/ruby2d/camera/sprite.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Ruby2D
+  module Camera
+    # Wraps existing variables as well as adding new methods
+    # so that it can be handled by the Camera Module
+    class Sprite < Ruby2D::Sprite
+      # Recalculates real coordiantes
+      # Use after changing variables
+      def _draw
+        return if @hide
+
+        angle = Camera.angle * (Math::PI / 180)
+        half_width = Window.width * 0.5
+        half_height = Window.height * 0.5
+        offset_x = @x + (width / 2)
+        offset_y = @y + (height / 2)
+        temp_x = (((offset_x - Camera.x) * Math.cos(angle)) - ((offset_y - Camera.y) * Math.sin(angle))) \
+          * Camera.zoom + half_width - (width * Camera.zoom / 2)
+        temp_y = (((offset_x - Camera.x) * Math.sin(angle)) + ((offset_y - Camera.y) * Math.cos(angle))) \
+          * Camera.zoom + half_height - (height * Camera.zoom / 2)
+        temp_rotate = rotate + Camera.angle
+        temp_width = width * Camera.zoom
+        temp_height = height * Camera.zoom
+        case @flip
+        when :both
+          temp_x += temp_height
+          temp_y += temp_width
+          temp_width = -temp_width
+          temp_height = -temp_height
+          puts 'both'
+        when :horizontal
+          temp_y += temp_width
+          temp_height = -temp_height
+        when :vertical
+          temp_width = -temp_width
+          temp_x += temp_height
+        end
+        draw(x: temp_x, y: temp_y,
+             width: temp_width,
+             height: temp_height,
+             rotate: temp_rotate)
+        update
+      end
+
+      def initialize(path, opts = {})
+        super(path, opts)
+        Ruby2D::Camera << self
+        Window.remove(self)
+      end
+
+      def remove
+        @hide = true
+      end
+
+      def add
+        @hide = false
+      end
+    end
+  end
+end

data/lib/ruby2d/camera/square.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Ruby2D
+  module Camera
+    # Wraps existing variables as well as adding new methods
+    # so that it can be handled by the Camera Module
+    class Square < Ruby2D::Square
+      # Recalculates real coordiantes
+      # Use after changing variables
+      def _draw
+        return if @hide
+
+        angle = Camera.angle * (Math::PI / 180)
+        half_width = Window.width * 0.5
+        half_height = Window.height * 0.5
+        temp_x1 = (((x + x1 - Camera.x) * Math.cos(angle)) - ((y + y1 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y1 = (((x + x1 - Camera.x) * Math.sin(angle)) + ((y + y1 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        temp_x2 = (((x + x2 - Camera.x) * Math.cos(angle)) - ((y + y2 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y2 = (((x + x2 - Camera.x) * Math.sin(angle)) + ((y + y2 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        temp_x3 = (((x + x3 - Camera.x) * Math.cos(angle)) - ((y + y3 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y3 = (((x + x3 - Camera.x) * Math.sin(angle)) + ((y + y3 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        temp_x4 = (((x + x4 - Camera.x) * Math.cos(angle)) - ((y + y4 - Camera.y) * Math.sin(angle))) * Camera.zoom + half_width
+        temp_y4 = (((x + x4 - Camera.x) * Math.sin(angle)) + ((y + y4 - Camera.y) * Math.cos(angle))) * Camera.zoom + half_height
+        Ruby2D::Quad.draw(x1: temp_x1, y1: temp_y1,
+                          x2: temp_x2, y2: temp_y2,
+                          x3: temp_x3, y3: temp_y3,
+                          x4: temp_x4, y4: temp_y4,
+                          color: [
+                            [c1.r, c1.g, c1.b, c1.a],
+                            [c2.r, c2.g, c2.b, c2.a],
+                            [c3.r, c3.g, c3.b, c3.a],
+                            [c4.r, c4.g, c4.b, c4.a]
+                          ],
+                          z: z)
+      end
+
+      def initialize(opts = {})
+        super(opts)
+        Ruby2D::Camera << self
+        Window.remove(self)
+        @x1 -= @x
+        @x2 -= @x
+        @x3 -= @x
+        @x4 -= @x
+        @y1 -= @y
+        @y2 -= @y
+        @y3 -= @y
+        @y4 -= @y
+      end
+
+      def remove
+        @hide = true
+      end
+
+      def add
+        @hide = false
+      end
+
+      # Methods for moving the shape
+      def x
+        @x ||= 0
+      end
+
+      attr_writer :x, :y
+
+      def y
+        @y ||= 0
+      end
+    end
+  end
+end

data/lib/ruby2d/camera/text.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Ruby2D
+  module Camera
+    # Wraps existing variables as well as adding new methods
+    # so that it can be handled by the Camera Module
+    # TODO: note that text could not be resized at the current iteration
+    # of Ruby2D so the math needs to be changed compensate for this.
+    # When Ruby2D gets updated to allow text resizing the math will need
+    # to be corrected again(see image_wrapper.rb for reference, that has
+    # math that allows for resizing)
+    class Text < Ruby2D::Text
+      # Recalculates real coordiantes
+      # Use after changing variables
+      def _draw
+        return if @hide
+
+        angle = Camera.angle * (Math::PI / 180)
+        half_width = Window.width * 0.5
+        half_height = Window.height * 0.5
+        if center
+          offset_y = y + (Camera.zoom / 2)
+          offset_x = x + (Camera.zoom / 2)
+        else
+          offset_x = x + (width / Camera.zoom / 2)
+          offset_y = y + (height / Camera.zoom / 2)
+        end
+        temp_x = (((offset_x - Camera.x) * Math.cos(angle)) - ((offset_y - Camera.y) * Math.sin(angle))) \
+          * Camera.zoom + half_width - (width / 2)
+        temp_y = (((offset_x - Camera.x) * Math.sin(angle)) + ((offset_y - Camera.y) * Math.cos(angle))) \
+          * Camera.zoom + half_height - (height / 2)
+        temp_rotate = rotate + Camera.angle
+        # Workaround for resizing text
+        # TODO: resizing doesnt work at all even with workaround
+        temp_size = size # * Camera.zoom
+        self.size *= Camera.zoom
+        draw(x: temp_x, y: temp_y,
+             rotate: temp_rotate,
+             color: [color.r, color.g, color.b, color.a])
+        self.size = temp_size
+      end
+
+      def initialize(text, opts = {})
+        super(text, opts)
+        Ruby2D::Camera << self
+        Window.remove(self)
+      end
+
+      def remove
+        @hide = true
+      end
+
+      def add
+        @hide = false
+      end
+
+      attr_accessor :center
+    end
+  end
+end

data/lib/ruby2d/camera/triangle.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Ruby2D
+  module Camera
+    class Triangle < Ruby2D::Triangle
+      # Recalculates real coordiantes
+      # Use after changing variables
+      def _draw
+        return if @hide
+
+        angle = Ruby2D::Camera.angle * (Math::PI / 180)
+        half_width = Window.width * 0.5
+        half_height = Window.height * 0.5
+        temp_x1 = (((x + @x1 - Ruby2D::Camera.x) * Math.cos(angle)) - ((y + @y1 - Ruby2D::Camera.y) * Math.sin(angle))) * Ruby2D::Camera.zoom + half_width
+        temp_y1 = (((x + @x1 - Ruby2D::Camera.x) * Math.sin(angle)) + ((y + @y1 - Ruby2D::Camera.y) * Math.cos(angle))) * Ruby2D::Camera.zoom + half_height
+        temp_x2 = (((x + @x2 - Ruby2D::Camera.x) * Math.cos(angle)) - ((y + @y2 - Ruby2D::Camera.y) * Math.sin(angle))) * Ruby2D::Camera.zoom + half_width
+        temp_y2 = (((x + @x2 - Ruby2D::Camera.x) * Math.sin(angle)) + ((y + @y2 - Ruby2D::Camera.y) * Math.cos(angle))) * Ruby2D::Camera.zoom + half_height
+        temp_x3 = (((x + @x3 - Ruby2D::Camera.x) * Math.cos(angle)) - ((y + @y3 - Ruby2D::Camera.y) * Math.sin(angle))) * Ruby2D::Camera.zoom + half_width
+        temp_y3 = (((x + @x3 - Ruby2D::Camera.x) * Math.sin(angle)) + ((y + @y3 - Ruby2D::Camera.y) * Math.cos(angle))) * Ruby2D::Camera.zoom + half_height
+        Ruby2D::Triangle.draw(x1: temp_x1, y1: temp_y1,
+                              x2: temp_x2, y2: temp_y2,
+                              x3: temp_x3, y3: temp_y3,
+                              color: [
+                                [c1.r, c1.g, c1.b, c1.a],
+                                [c2.r, c2.g, c2.b, c2.a],
+                                [c3.r, c3.g, c3.b, c3.a]
+                              ],
+                              z: z)
+      end
+
+      def initialize(opts = {})
+        super(opts)
+        Ruby2D::Camera << self
+        Window.remove(self)
+        add
+      end
+
+      def remove
+        @hide = true
+      end
+
+      def add
+        @hide = false
+      end
+
+      # Methods for moving the shape
+      def x
+        @x ||= 0
+      end
+
+      attr_writer :x, :y
+
+      def y
+        @y ||= 0
+      end
+    end
+  end
+end

data/lib/ruby2d/camera/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ruby2d
+  module Camera
+    VERSION = '1.0.0'
+  end
+end

data/ruby2d-camera.gemspec

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "lib/ruby2d/camera/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby2d-camera"
+  spec.version       = Ruby2d::Camera::VERSION
+  spec.authors       = ["Tradam"]
+  spec.email         = ["ruby2d-camera@tradam.dev"]
+
+  spec.summary       = "A library for camera movement in the Ruby2D gem"
+  #spec.description   = "TODO: Write a longer description or delete this line."
+  spec.homepage      = "https://github.com/realtradam/ruby2d-camera"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.4.0"
+
+  #spec.metadata["allowed_push_host"] = "TODO: Set to 'https://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/realtradam/ruby2d-camera"
+  #spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{\A(?:test|spec|features|assets|example)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency "ruby2d", "~> 0.10"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/run.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+require 'ruby2d'
+require 'ruby2d/camera'
+require_relative 'house'
+require_relative 'room'
+
+Window.set(icon: './assets/blobcoolthink.png',
+           width: 1280,
+           height: 720,
+           background: 'blue')
+
+
+@player = Camera::Sprite.new('./assets/sprites/mainblob-128.png',
+                     x: 1920 / 1.1,
+                     y: 1080 / 1.1,
+                     width: 50,
+                     height: 50,
+                     clip_width: 128,
+                     loop: true,
+                     time: 1,
+                     z: 99,
+                     animations: {
+                       walk: 0...60,
+                       stand: 60...61
+                     })
+@shadow = Camera::Image.new(
+  'assets/blobshadow.png',
+  width: 52,
+  height: 10,
+  z: 4
+)
+#Camera << @shadow
+@player.play animation: :walk, loop: true
+#Camera << @player
+
+# UI
+Rectangle.new(
+  width: 350,
+  height: 135,
+  color: 'navy',
+  z: 100
+)
+@ui_pos_cam = Text.new(
+  'pos: 0,0',
+  x: 10,
+  y: 10,
+  color: 'teal',
+  z: 101
+)
+@ui_pos_ply = Text.new(
+  'pos: 0,0',
+  x: 10,
+  y: 40,
+  color: 'teal',
+  z: 101
+)
+@ui_zoom = Text.new(
+  'zoom: 0',
+  x: 10,
+  y: 70,
+  color: 'lime',
+  z: 101
+)
+@ui_rotation = Text.new(
+  'rotation: 0',
+  x: 10,
+  y: 100,
+  color: 'lime',
+  z: 101
+)
+Rectangle.new(
+  x: (Window.width - 120),
+  width: 120,
+  height: 45,
+  color: 'navy',
+  z: 100
+)
+@ui_fps = Text.new(
+  'fps: 60.00',
+  x: (Window.width - 110),
+  y: 10,
+  color: 'teal',
+  z: 101
+)
+
+
+
+# How fast the player can move
+@speed = 5
+
+# Initializing
+@player_movement_x = 0
+@player_movement_y = 0
+@pressed_space = false
+@scene_transition_into = false
+@scene_transition_out = false
+@indoors = false
+@house = nil
+@room = nil
+
+on :key do |event|
+  if event.key == 'w'
+    @player_movement_y -= @speed unless @scene_transition_into || @scene_transition_out
+  end
+  if event.key == 's'
+    @player_movement_y += @speed unless @scene_transition_into || @scene_transition_out
+  end
+  if event.key == 'd'
+    @player_movement_x += @speed unless @scene_transition_into || @scene_transition_out
+  end
+  if event.key == 'a'
+    @player_movement_x -= @speed unless @scene_transition_into || @scene_transition_out
+  end
+  if event.key == 'space'
+    @pressed_space = true unless @scene_transition_into || @scene_transition_out
+  end
+  if event.key == 'q'
+    Camera.angle += 1 unless @scene_transition_into || @scene_transition_out
+  end
+  if event.key == 'e'
+    Camera.angle -= 1 unless @scene_transition_into || @scene_transition_out
+  end
+  if event.key == 'r'
+    unless @scene_transition_into || @scene_transition_out || Camera.angle.zero?
+      if Camera.angle <= 180
+        if Camera.angle > 10
+          Camera.angle -= 10
+        else 
+          Camera.angle -=1
+        end
+      elsif
+        if Camera.angle < 350
+          Camera.angle += 10
+        else
+          Camera.angle += 1
+        end
+      end
+    end
+  end
+end
+
+update do
+  if (@player.x > 2371 && @player_movement_x.positive?) || (@player.x.negative? && @player_movement_x.negative?)
+    @player_movement_x = 0
+  end
+  if (@player.y > 1608 && @player_movement_y.positive?) || (@player.y.negative? && @player_movement_y.negative?)
+    @player_movement_y = 0
+  end
+  if !@player_movement_y.zero? == !@player_movement_x.zero?
+    @player_movement_x /= 1.4141
+    @player_movement_y /= 1.4141
+  end
+  @player.x += @player_movement_x
+  @player.y += @player_movement_y
+  if @player_movement_x.negative?
+    @player.play animation: :walk, loop: true
+  elsif @player_movement_x.positive? || !@player_movement_y.zero?
+    @player.play animation: :walk, loop: true, flip: :vertical
+  else
+    @player.play animation: :stand
+  end
+
+  if !@scene_transition_into && !@scene_transition_out
+    Camera.zoom += ((-[Math.sqrt(((@player.x + (@player.width / 2) - Camera.x)**2) + ((@player.y + (@player.width / 2) - Camera.y)**2)), 350].min * 0.004) + 2 - Camera.zoom) * 0.25
+    Camera.x += (@player.x + (@player.width / 2) - Camera.x) * 0.025
+    Camera.y += (@player.y + (@player.height / 2) - Camera.y) * 0.025
+  elsif @scene_transition_into
+    if Camera.zoom < 250
+      Camera.zoom *= 1.05
+      Camera.angle += 5
+    else
+      @scene_transition_into = false
+      @scene_transition_out = true
+      if @room.nil?
+        @house.remove
+        @house = nil
+        @indoors = true
+      else
+        @room.remove
+        @room = nil
+        @indoors = false
+      end
+      #Camera.remove @background
+      @background.remove
+      @background = nil
+    end
+    Camera.x += (@player.x + (@player.width / 2) - Camera.x) * 0.25
+    Camera.y += (@player.y + (@player.height / 2) - Camera.y) * 0.25
+  elsif @scene_transition_out
+    if !((Camera.zoom <= (@zoom_transition * 1.001)) && (Camera.angle == @angle_transition))
+      Camera.zoom /= 1.05
+      Camera.angle -= 5
+    else
+      @scene_transition_out = false
+    end
+  end
+
+  if @house.nil? && !@indoors
+    @house = House.new(750, 300)
+    @background = Camera::Image.new(
+      'assets/background.png',
+      x: 100, y: 100,
+      z: -1
+    )
+    #Camera << @background
+  elsif @room.nil? && @indoors
+    @room = Room.new(750,300)
+    @background = Camera::Rectangle.new(
+      color: 'black',
+      x: 0,
+      y: 0,
+      width: 1920,
+      height: 1080,
+      z: -1
+    )
+  end
+  @shadow.x = @player.x - 2
+  @shadow.y = @player.y + 42
+
+  #Camera.remove @house_text
+  @house_text&.remove
+  if @indoors
+    @house_text = @room.visted_by?(@player)
+  else
+    @house_text = @house.visted_by?(@player)
+  end
+  unless @house_text.nil?
+    #Camera << @house_text
+    @house_text.center = true
+  end
+  if !@house_text.nil? && @pressed_space && !@scene_transition_into && !@scene_transition_out
+    @scene_transition_into = true
+    @angle_transition = Camera.angle
+    @zoom_transition = Camera.zoom
+  end
+  @ui_pos_cam.text = "Camera Position: #{Camera.x.round(1)}, #{Camera.y.round(1)}"
+  @ui_pos_ply.text = "Player Position: #{@player.x.round(1)}, #{@player.y.round(1)}"
+  @ui_zoom.text = "Zoom: #{Camera.zoom.round(3)}"
+  @ui_fps.text = "FPS: #{Window.fps.round(2)}"
+  @ui_rotation.text = "Angle: #{Camera.angle}"
+  @player_movement_x = 0
+  @player_movement_y = 0
+  @pressed_space = false
+
+  #Camera.redraw
+end
+show

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: ruby2d-camera
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tradam
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-08-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby2d
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description:
+email:
+- ruby2d-camera@tradam.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".solargraph.yml"
+- CHANGELOG.mdown
+- Gemfile
+- LICENSE.txt
+- README.mdown
+- Rakefile
+- bin/console
+- bin/setup
+- lib/ruby2d/camera.rb
+- lib/ruby2d/camera/circle.rb
+- lib/ruby2d/camera/image.rb
+- lib/ruby2d/camera/line.rb
+- lib/ruby2d/camera/quad.rb
+- lib/ruby2d/camera/rectangle.rb
+- lib/ruby2d/camera/sprite.rb
+- lib/ruby2d/camera/square.rb
+- lib/ruby2d/camera/text.rb
+- lib/ruby2d/camera/triangle.rb
+- lib/ruby2d/camera/version.rb
+- ruby2d-camera.gemspec
+- run.rb
+homepage: https://github.com/realtradam/ruby2d-camera
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/realtradam/ruby2d-camera
+  source_code_uri: https://github.com/realtradam/ruby2d-camera
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.22
+signing_key:
+specification_version: 4
+summary: A library for camera movement in the Ruby2D gem
+test_files: []