linted code

4 files changed, 135 insertions, 95 deletions

diff --git a/.solargraph.yml b/.solargraph.yml
new file mode 100644
index 0000000..e0cd022
--- /dev/null
+++ b/.solargraph.yml
@@ -0,0 +1,15 @@
+---
+include:
+- "**/*.rb"
+exclude:
+- spec/**/*
+- test/**/*
+- vendor/**/*
+- ".bundle/**/*"
+require: []
+domains: []
+reporters:
+- rubocop
+require_paths: []
+plugins: []
+max_files: 5000
diff --git a/animator.rb b/animator.rb
index 9fae771..f1cacd0 100644
--- a/animator.rb
+++ b/animator.rb
@@ -1,55 +1,90 @@
+# frozen_string_literal: true
 
+# A square but it moves on its own
 class AnimatedSquare
-  def initialize(x: '0', y: '0', size: 10, color: 'random')
-    @speed = (1..5).to_a.sample
-    @square = Square.new(x: x, y: y, size: size, color: color)
-    @axis = (0..1).to_a.sample
-    if @axis == 0
-      @range = [(((x-(250..500).to_a.sample)..x).to_a.sample),((x..(x+(250..500).to_a.sample)).to_a.sample)]
-    else
-      @range = [(((y-(250..500).to_a.sample)..y).to_a.sample),((y..(y+(250..500).to_a.sample)).to_a.sample)]
-    end
+  def initialize(x: '0',
+                 y: '0',
+                 size: 10,
+                 color: 'random')
+    @square = Square.new(x: x,
+                         y: y,
+                         size: size,
+                         color: color)
+  end
+
+  attr_writer :speed
+
+  def speed
+    @speed ||= (1..5).to_a.sample
+  end
+
+  def axis
+    @axis ||= (0..1).to_a.sample
+  end
+
+  def range
+    @range ||= if axis.zero?
+                 [((x - (250..500).to_a.sample)..x).to_a.sample,
+                  (x..(x + (250..500).to_a.sample)).to_a.sample]
+               else
+                 [((y - (250..500).to_a.sample)..y).to_a.sample,
+                  (y..(y + (250..500).to_a.sample)).to_a.sample]
+               end
   end
+
+  def square
+    @square = Square.new
+  end
+
   def x
     @square.x
   end
-  def x= x
+
+  def x=(x)
     @square.x = x
   end
 
   def y
     @square.y
   end
-  def y= y
+
+  def y=(y)
     @square.y = y
   end
 
   def size
     @square.size
   end
-  def size= size
+
+  def size=(size)
     @square.size = size
   end
 
-
-
   def update(offset, zoom)
-    width_zoom_offset = Window.width/2 * (zoom-1)
-    height_zoom_offset = Window.height/2 * (zoom-1)
-    if @axis == 0
-      @square.x += @speed * zoom
-      if @square.x >= ((@range[1] - offset[0]))
-        @speed = -(@speed.abs)
-      elsif @square.x <= ((@range[0] - offset[0]))
-        @speed = @speed.abs
-      end
+    #width_zoom_offset = Window.width/2 * (zoom-1)
+    #height_zoom_offset = Window.height/2 * (zoom-1)
+    puts
+    p @square
+    puts
+    p @speed
+    puts
+    p zoom
+    puts
+    puts
+    if axis.zero?
+      @square.x += speed * zoom
+      self.speed = if @square.x >= ((range[1] - offset[0]))
+                     -speed.abs
+                   elsif @square.x <= ((range[0] - offset[0]))
+                     speed.abs
+                   end
     else
-      @square.y += @speed * zoom
-      if @square.y >= ((@range[1] - offset[1]))
-        @speed = -(@speed.abs)
-      elsif @square.y <= ((@range[0] - offset[1]))
-        @speed = @speed.abs
-      end
+      @square.y += speed * zoom
+      self.speed = if @square.y >= ((range[1] - offset[1]))
+                     -speed.abs
+                   elsif @square.y <= ((range[0] - offset[1]))
+                     speed.abs
+                   end
     end
   end
 end
diff --git a/camera.rb b/camera.rb
index be1e3f0..b3cd116 100644
--- a/camera.rb
+++ b/camera.rb
@@ -1,87 +1,78 @@
+# frozen_string_literal: true
 
+# Simulates a moving camera by manipulating objects it knows
 class Camera
+  class <<self
+    attr_writer :elasticity
+
+    private
+
+    attr_writer :camera_position, :zoom_level
+  end
+
+  def self.elasticity
+    @elasticity ||= 1
+  end
+
+  def self.camera_position
+    @camera_position ||= [0, 0]
+  end
 
   def self.zoom_level
     @zoom_level ||= 1
   end
 
-  def self.zoom_by zoom
+  def self.zoom_by(zoom)
     objects.each do |object|
       object.size *= zoom
       object.x *= zoom
       object.y *= zoom
     end
-    self.move_by(Window.width/2 * (zoom-1),Window.height/2 * (zoom-1))
+    move_by(Window.width / 2 * (zoom - 1),
+            Window.height / 2 * (zoom - 1))
     self.zoom_level *= zoom
   end
 
-  def self.zoom_to zoom
-    self.zoom_by(zoom/self.zoom_level)
-  end
-  
-  def self.elasticity
-    @elasticity ||= 1
-  end
-
-  def self.elasticity= speed
-    @elasticity = speed
+  def self.zoom_to(zoom)
+    zoom_by(zoom / self.zoom_level)
   end
 
-  def self.follow item
-    self.move_to((item.x - (Window.width / 2))/self.elasticity,
-                 (item.y - (Window.height / 2))/self.elasticity)
+  def self.follow(item)
+    move_to((item.x - (Window.width / 2)) / elasticity,
+            (item.y - (Window.height / 2)) / elasticity)
   end
 
   def self.objects
     @objects ||= []
   end
 
-  def self.<< item
-    unless self.objects.include?(item)
-      self.objects.push(item)
-    end
+  def self.<<(item)
+    objects.push(item) unless objects.include?(item)
   end
 
-  def self.add item
+  def self.add(item)
     self << item
   end
 
-  def self.remove item
-    if self.objects.include?(item)
-      self.objects.delete(item)
-    end
+  def self.remove(item)
+    objects.delete(item) if objects.include?(item)
   end
 
-  
-  def self.move_by(x,y)
-    self.camera_position[0] += x
-    self.camera_position[1] += y
+  def self.move_by(x, y)
+    camera_position[0] += x
+    camera_position[1] += y
     objects.each do |object|
       object.x -= x
       object.y -= y
     end
   end
-  def self.move_to(x,y)
-    self.camera_position = [x+camera_position[0],y+camera_position[1]]
+
+  def self.move_to(x, y)
+    self.camera_position = [x + camera_position[0],
+                            y + camera_position[1]]
     objects.each do |object|
       object.x -= x
       object.y -= y
     end
   end
-  
-  def self.camera_position
-    @camera_position ||= [0,0]
-  end
-
-  private
-
-  def self.camera_position= array
-    @camera_position = array
-  end
-
-  def self.zoom_level= value
-    @zoom_level = value
-  end
-
-  
 end
diff --git a/run.rb b/run.rb
index e8d6d0f..4605459 100644
--- a/run.rb
+++ b/run.rb
@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ruby2d'
 require_relative 'camera'
 require_relative 'animator'
@@ -6,13 +8,15 @@ require_relative 'animator'
 @player =  Image.new('assets/player.png')
 @squares = []
 
+# Use this to add a few extra methods to an Image
 module SizableImage
   def size
-    self.width
+    width
   end
-  def size= value
-    self.height *= (value / self.width)
-    self.width *= (value / self.width)
+
+  def size=(size)
+    self.height *= (size / width)
+    self.width *= (size / width)
   end
 end
 
@@ -30,9 +34,12 @@ Camera.elasticity = 10
 
 # If you want to use a camera, you need all elements in the world to be known to it
 # Exeptions would be things such as UI elements where you want them statically placed on the screen
-(1..25).each do
-  @squares << AnimatedSquare.new(x: (0..1920).to_a.sample, y: (0..1080).to_a.sample, size: (10..50).to_a.sample, color: 'random')
-  Camera << @squares.last 
+25.times do
+  @squares << AnimatedSquare.new(x: (0..1920).to_a.sample,
+                                 y: (0..1080).to_a.sample,
+                                 size: (10..50).to_a.sample,
+                                 color: 'random')
+  Camera << @squares.last
 end
 
 
@@ -60,8 +67,6 @@ on :key do |event|
   if event.key == 's'
     @y_move += @speed * Camera.zoom_level
   end
-
-
   if event.key == 'j'
     @cam_x_move -= @speed
     @is_follow = false
@@ -78,11 +83,9 @@ on :key do |event|
     @cam_y_move += @speed
     @is_follow = false
   end
-
   if event.key == 'f'
     @is_follow = true
   end
-
 end
 
 on :key do |event|
@@ -105,31 +108,27 @@ update do
 
   if @zoom_by != 1
     Camera.zoom_by @zoom_by
+    @zoom_by = 1
   end
-  @zoom_by = 1
-
   # Need to use the cameras position as an offset to keep the shapes range of movement working
   # Need to make the zoom also give an offset
+  require 'debug'
   @squares.each do |square|
-    square.update(Camera.camera_position,Camera.zoom_level)
+    square.update(Camera.camera_position, Camera.zoom_level)
   end
-  
-  
+
   # Alternating between follow and manual control
   if @is_follow
     Camera.follow @player
   else
-    Camera.move_by(@cam_x_move,@cam_y_move)
+    Camera.move_by(@cam_x_move, @cam_y_move)
   end
 
-  
   # This function will teleport the camera directory to those coordinates
   # It is used by Camera.follow but you can use it yourself too!
   #Camera.move_to(50,50)
   @cam_x_move = 0
   @cam_y_move = 0
-
 end
 
 show
-