added pong-12

Author: coltonoscopy

pong-11/main.lua

@@ -2,7 +2,7 @@
     GD50 2018
     Pong Remake
 
-    pong-10
+    pong-11
     "The Audio Update"
 
     -- Main Program --

pong-12/Ball.lua

@@ -0,0 +1,71 @@
+--[[
+    GD50 2018
+    Pong Remake
+
+    -- Ball Class --
+
+    Author: Colton Ogden
+    [email protected]
+
+    Represents a ball which will bounce back and forth between paddles
+    and walls until it passes a left or right boundary of the screen,
+    scoring a point for the opponent.
+]]
+
+Ball = Class{}
+
+function Ball:init(x, y, width, height)
+    self.x = x
+    self.y = y
+    self.width = width
+    self.height = height
+
+    -- these variables are for keeping track of our velocity on both the
+    -- X and Y axis, since the ball can move in two dimensions
+    self.dy = math.random(2) == 1 and -100 or 100
+    self.dx = math.random(2) == 1 and math.random(-80, -100) or math.random(80, 100)
+end
+
+--[[
+    Expects a paddle as an argument and returns true or false, depending
+    on whether their rectangles overlap.
+]]
+function Ball:collides(paddle)
+    -- first, check to see if the left edge of either is farther to the right
+    -- than the right edge of the other
+    if self.x > paddle.x + paddle.width or paddle.x > self.x + self.width then
+        return false
+    end
+
+    -- then check to see if the bottom edge of either is higher than the top
+    -- edge of the other
+    if self.y > paddle.y + paddle.height or paddle.y > self.y + self.height then
+        return false
+    end 
+
+    -- if the above aren't true, they're overlapping
+    return true
+end
+
+--[[
+    Places the ball in the middle of the screen, with an initial random velocity
+    on both axes.
+]]
+function Ball:reset()
+    self.x = VIRTUAL_WIDTH / 2 - 2
+    self.y = VIRTUAL_HEIGHT / 2 - 2
+    self.dy = math.random(2) == 1 and -100 or 100
+    self.dx = math.random(-50, 50)
+end
+
+--[[
+    Simply applies velocity to position, scaled by deltaTime.
+]]
+function Ball:update(dt)
+    self.x = self.x + self.dx * dt
+    self.y = self.y + self.dy * dt
+end
+
+function Ball:render()
+    love.graphics.rectangle('fill', self.x, self.y, self.width, self.height)
+end

pong-12/Paddle.lua

@@ -0,0 +1,62 @@
+--[[
+    GD50 2018
+    Pong Remake
+
+    -- Paddle Class --
+
+    Author: Colton Ogden
+    [email protected]
+
+    Represents a paddle that can move up and down. Used in the main
+    program to deflect the ball back toward the opponent.
+]]
+
+Paddle = Class{}
+
+--[[
+    The `init` function on our class is called just once, when the object
+    is first created. Used to set up all variables in the class and get it
+    ready for use.
+
+    Our Paddle should take an X and a Y, for positioning, as well as a width
+    and height for its dimensions.
+
+    Note that `self` is a reference to *this* object, whichever object is
+    instantiated at the time this function is called. Different objects can
+    have their own x, y, width, and height values, thus serving as containers
+    for data. In this sense, they're very similar to structs in C.
+]]
+function Paddle:init(x, y, width, height)
+    self.x = x
+    self.y = y
+    self.width = width
+    self.height = height
+    self.dy = 0
+end
+
+function Paddle:update(dt)
+    -- math.max here ensures that we're the greater of 0 or the player's
+    -- current calculated Y position when pressing up so that we don't
+    -- go into the negatives; the movement calculation is simply our
+    -- previously-defined paddle speed scaled by dt
+    if self.dy < 0 then
+        self.y = math.max(0, self.y + self.dy * dt)
+    -- similar to before, this time we use math.min to ensure we don't
+    -- go any farther than the bottom of the screen minus the paddle's
+    -- height (or else it will go partially below, since position is
+    -- based on its top left corner)
+    else
+        self.y = math.min(VIRTUAL_HEIGHT - self.height, self.y + self.dy * dt)
+    end
+end
+
+--[[
+    To be called by our main function in `love.draw`, ideally. Uses
+    LÖVE2D's `rectangle` function, which takes in a draw mode as the first
+    argument as well as the position and dimensions for the rectangle. To
+    change the color, one must call `love.graphics.setColor`. As of the
+    newest version of LÖVE2D, you can even draw rounded rectangles!
+]]
+function Paddle:render()
+    love.graphics.rectangle('fill', self.x, self.y, self.width, self.height)
+end

pong-12/class.lua

@@ -0,0 +1,98 @@
+--[[
+Copyright (c) 2010-2013 Matthias Richter
+
+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.
+
+Except as contained in this notice, the name(s) of the above copyright holders
+shall not be used in advertising or otherwise to promote the sale, use or
+other dealings in this Software without prior written authorization.
+
+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.
+]]--
+
+local function include_helper(to, from, seen)
+	if from == nil then
+		return to
+	elseif type(from) ~= 'table' then
+		return from
+	elseif seen[from] then
+		return seen[from]
+	end
+
+	seen[from] = to
+	for k,v in pairs(from) do
+		k = include_helper({}, k, seen) -- keys might also be tables
+		if to[k] == nil then
+			to[k] = include_helper({}, v, seen)
+		end
+	end
+	return to
+end
+
+-- deeply copies `other' into `class'. keys in `other' that are already
+-- defined in `class' are omitted
+local function include(class, other)
+	return include_helper(class, other, {})
+end
+
+-- returns a deep copy of `other'
+local function clone(other)
+	return setmetatable(include({}, other), getmetatable(other))
+end
+
+local function new(class)
+	-- mixins
+	class = class or {}  -- class can be nil
+	local inc = class.__includes or {}
+	if getmetatable(inc) then inc = {inc} end
+
+	for _, other in ipairs(inc) do
+		if type(other) == "string" then
+			other = _G[other]
+		end
+		include(class, other)
+	end
+
+	-- class implementation
+	class.__index = class
+	class.init    = class.init    or class[1] or function() end
+	class.include = class.include or include
+	class.clone   = class.clone   or clone
+
+	-- constructor call
+	return setmetatable(class, {__call = function(c, ...)
+		local o = setmetatable({}, c)
+		o:init(...)
+		return o
+	end})
+end
+
+-- interface for cross class-system compatibility (see https://github.com/bartbes/Class-Commons).
+if class_commons ~= false and not common then
+	common = {}
+	function common.class(name, prototype, parent)
+		return new{__includes = {prototype, parent}}
+	end
+	function common.instance(class, ...)
+		return class(...)
+	end
+end
+
+
+-- the module
+return setmetatable({new = new, include = include, clone = clone},
+	{__call = function(_,...) return new(...) end})