Slammer Fall Codea Example

Main.lua

--# Emitter
Emitter = class()

function Emitter:init(args)
    self.particleMesh = mesh()
    self.particleMesh.texture = args.tex
    self.minLife = args.minLife or 1
    self.maxLife = args.maxLife or 1
    self.spread = args.spread or 360
    self.angle = args.angle or 0
    self.minSpeed = args.minSpeed or 10
    self.maxSpeed = args.maxSpeed or 50
    self.minSize = args.minSize or 10
    self.maxSize = args.maxSize or 15
    self.growth = args.growth or 1
    self.startColor = args.startColor or color(255, 255, 255, 255)
    self.endColor = args.endColor or color(0, 0, 0, 0)
    self.streak = args.streak or false
    self.streakMult = args.streakMult or 2
    self.accel = args.accel or vec2(0,0)
    self.rAccel = args.rAccel or vec2(0,0) 
    
    self.particles = {}
    self.pCount = 0
    for i = 1,100 do
        table.insert(self.particles, Particle())
    end
end

function Emitter:emit(pos,count)
    for i = 1,#self.particles do
        local p = self.particles[i]
        if p.dead then
            self.pCount = math.max(i, self.pCount)
            p.dead = false
            p.pos = pos
            p.life = math.random(self.minLife, self.maxLife)
            p.size = math.random(self.minSize, self.maxSize)
            p.maxLife = p.life
            p.vel = vec2(0, math.random(self.minSpeed, self.maxSpeed))
            p.vel = p.vel:rotate(math.rad(self.angle + math.random(-self.spread/2, self.spread/2)))
            count = count - 1
            if count == 0 then return end
        end
    end
end

function Emitter:draw()
    -- update
    self.particleMesh:clear()
    for i = 1,self.pCount do
        local p = self.particles[i]
        if not p.dead then
            p.prevPos = p.pos
            p.pos = p.pos + p.vel * DeltaTime
            p.vel = p.vel + (self.accel + vec2(math.random(-self.rAccel.x, self.rAccel.x), math.random(-self.rAccel.y, self.rAccel.y)))  * DeltaTime
            p.life = math.max(0, p.life - DeltaTime)
            p.size = p.size + DeltaTime * self.growth
            if p.life == 0 then p.dead = true end
            local interp = p.life / p.maxLife
           
            p.col.r = interp * self.startColor.r + (1-interp) * self.endColor.r
            p.col.g = interp * self.startColor.g + (1-interp) * self.endColor.g
            p.col.b = interp * self.startColor.b + (1-interp) * self.endColor.b
            p.col.a = interp * self.startColor.a + (1-interp) * self.endColor.a
            local ind = self.particleMesh:addRect(p.pos.x, p.pos.y, p.size, p.size)
            self.particleMesh:setRectColor(ind, p.col)
            if self.streak then
                local dir = (p.pos - p.prevPos)
                local len = dir:len()
                local pos = (p.pos + p.prevPos) * 0.5
                local ang = math.atan2(dir.y, dir.x)
                self.particleMesh:setRect(ind, pos.x, pos.y, p.size * self.streakMult, p.size, ang)
            end
        end
    end
    self.particleMesh:draw()
end


Particle = class()

function Particle:init()
    self.pos = vec2(0,0)
    self.prevPos = vec2(0,0)
    self.vel = vec2(0,0)
    self.life = 0
    self.maxLife = 0
    self.dead = true
    self.col = color(0, 0, 0, 255)
    self.size = 0
end

--# SlammerPod
SlammerPod = class()

function SlammerPod:init(x,y)
    self.name = "pod"
    self.health = 1
    
    self.chassis = createBox(x, y, 60, 80)
    self.chassis.gravityScale = 1
    self.chassis.density = 3
    self.chassis.fixedRotation = true
    self.chassis.info = self
    
    self.rock = createCircle(self.chassis.x,self.chassis.y - 150, 35)
    self.rock.density = 0.75
    self.rock.info = self
    owners[self.rock] = self
    self.rock.angularDamping = 0.1
    
    self.rope = physics.joint(ROPE, self.chassis, self.rock, self.chassis.position, self.rock.position, 150)
    debugDraw:addJoint(self.rope)
    
    self.links = {}
    local lc = 10
    local len = (self.chassis.y - self.rock.y) / lc
    local p = self.chassis.position - vec2(0, len/2)
    local prev = self.chassis
    for i = 1,lc do
        local link = createBox(p.x, p.y, 5, len)
        link.mask = {10}
        local j = physics.joint(REVOLUTE, prev, link, p + vec2(0, len/2))
        prev = link
        debugDraw:addJoint(j)
        table.insert(self.links, link)
        p.y = p.y - len
    end
    local j = physics.joint(REVOLUTE, prev, self.rock, self.rock.position)
    debugDraw:addJoint(j)
    
    self.stick = VirtualStick({
        moved = function(v) self:stickMoved(v) end, 
        released = function(v) self:stickReleased(v) end,
        radius = 80,
        deadZoneRadius = 10,
    })
    self.stick:activate()
    self.dir = vec2(0,0)
    
    self.anim = 0.0
    
    --sprite("Cargo Bot:Smoke Particle")
    self.sparks = Emitter({tex = "Tyrian Remastered:Bullet Fire A",
                           minSize = 5, 
                           maxSize = 5,
                           minSpeed = 100,
                           maxSpeed = 150,
                           accel = vec2(0,-1000),
                           rAccel = vec2(1500,1500),
                           streak = true,
                           streakMult = 3})
                    
    self.smoke = Emitter({tex = "Cargo Bot:Smoke Particle",
                           minSize = 5, 
                           maxSize = 25,
                           minSpeed = 0,
                           maxSpeed = 0,
                           accel = vec2(0,1000),
                           rAccel = vec2(1500,1500),
                           })
end

function SlammerPod:stickMoved(v)
    self.dir = v
end

function SlammerPod:stickReleased(v)
    self.dir = vec2(0,0)
end

function SlammerPod:draw()
    
    self.anim = self.anim + DeltaTime
    
    local gain = 250 * self.chassis.mass
    local damp = 0.75
    local vel = self.chassis.linearVelocity
    self.chassis:applyForce(gain * self.dir - damp * vel)
    self.chassis.linearDamping = vel:len() / 50
    
    pushMatrix()
    translate(self.chassis.x, self.chassis.y)

    rotate(self.chassis.angle)
    sprite("Tyrian Remastered:Part H", 0, 0, 60)

    pushMatrix()
    rotate(self.anim * 100)
    sprite("Tyrian Remastered:Orb 2", 0,0,30)
    popMatrix()
    
    popMatrix()  
    
    pushMatrix()
    translate(self.rock.x, self.rock.y)
    rotate(self.rock.angle)
    sprite("Tyrian Remastered:Mine Spiked Huge", 0, 0, self.rock.radius * 2.5)
    popMatrix()   
    
    for k,v in ipairs(self.links) do
        pushMatrix() 
        translate(v.x,v.y)
        rotate(v.angle)
        sprite("Tyrian Remastered:Ring", 0,0,15,25)     
        popMatrix()
    end
    
    self.sparks:draw()
    
    --self.()stick:draw()
end

function SlammerPod:hit(other, contact, first)
    if contact.state == BEGAN then
        local imp = math.max(0, (contact.normalImpulse-25) / 25)
        if imp > 0.0 then
            self.sparks:emit(contact.position, 10)
            sound(SOUND_HIT, 47051, imp)   
            if other and other.damage then other:damage(imp) end
        end
    end
end

--# Worm
Worm = class()

function Worm:init(x,y,t)
    self.name = "worm"
    
    -- you can accept and set parameters here
    self.body = createCircle(x,y,35)
    self.body.info = self
    self.body.gravityScale = 0
    self.target = t
    self.dir = vec2(0,0)
    self.health = 1
    self.power = 1
    self.stun = 0
    
    self.base = physics.body(CIRCLE, 35)
    self.base.fixedRotation = true
    self.base.gravityScale = 0
    self.base.position = self.body.position
    self.base.mask = {15}
    self.servo = physics.joint(REVOLUTE, self.base, self.body, self.base.position)
    self.servo.enableMotor = true
    self.servo.maxMotorTorque = 1000
    self.motorSpeed = 0
end

function Worm:draw()
    self.dir = (self.target.chassis.position - self.body.position) 
    self.dir = self.dir:normalize()   
    -- Codea does not automatically call this method
    local gain = 29.400 * self.body.mass * self.power
    local damp = 0.75 * self.power
    local vel = self.body.linearVelocity
    self.body:applyForce(gain * self.dir - damp * vel)
    self.body.linearDamping = vel:len() / 100 * self.power
    self.body.gravityScale = 1-self.power
    
    local tAng = math.atan2(self.dir.y, self.dir.x) + math.pi/2
    self.servo.motorSpeed = (tAng - math.rad(self.servo.jointAngle)) * 100
    --if self.power == 0
    
    pushMatrix()
    translate(self.body.x, self.body.y)
    rotate(self.body.angle)
    sprite("Tyrian Remastered:Organic Claw", 0,-14,60)
    sprite("Tyrian Remastered:Part N")
    popMatrix()
    
    fill(120, 30, 30, 255)
    rect(self.body.x,self.body.y+50,50,10)
    fill(255, 0, 0, 255)
    rect(self.body.x,self.body.y+50,50*self.health,10)
end

function Worm:damage(dmg)
    self.health = math.max(0, self.health - dmg)
    if self.health == 0 then
        self.power = 0
        self.servo.enableMotor = false
        sound(SOUND_RANDOM, 41402, 1)
        
    end
end


WormPart = class()

function WormPart:init(x,y,r,worm,parent)
    self.body = physics.body(CIRCLE, r)
    self.body.x = x
    self.body.y = y
    
    self.worm = worm
    self.health = 1
end



--# Main
supportedOrientations(LANDSCAPE_ANY)
--displayMode(FULLSCREEN)
physics.resume()

-- Use this function to perform your initial setup
function setup()    
    debugDraw = PhysicsDebugDraw()
    
    -- test classes
    -- to add your own, make sure to define setup() and cleanup() 
    -- in addition to draw() and touched()
    tests = {Test1()}
    iparameter("test_number", 1, #tests)
    iparameter("use_accelerometer", 0, 1)

    currentTestIndex = 1
    currentTest = nil
    setTest(currentTestIndex)
    
    defaultGravity = physics.gravity()
end

function setTest(t)
    if currentTest then
        if currentTest.cleanup then
            currentTest:cleanup()
        end
        cleanup()
    end
    
    currentTestIndex = t
    currentTest = tests[t]
    currentTest:setup()
end

function nextTest()
    local t = currentTestIndex + 1
    if t > #tests then
        t = 1
    end
    setTest(t)
end

function createCircle(x,y,r)
    local circle = physics.body(CIRCLE, r)
    -- enable smooth motion
    circle.interpolate = true
    circle.x = x
    circle.y = y
    circle.restitution = 0.25
    debugDraw:addBody(circle)
    return circle
end

function createBox(x,y,w,h)
    -- polygons are defined by a series of points in counter-clockwise order
    local box = physics.body(POLYGON, vec2(-w/2,h/2), vec2(-w/2,-h/2), vec2(w/2,-h/2), vec2(w/2,h/2))
    box.interpolate = true
    box.x = x
    box.y = y
    box.restitutions = 0.25
    debugDraw:addBody(box)
    return box
end

function createGround()
    local ground = physics.body(POLYGON, vec2(0,20), vec2(0,0), vec2(WIDTH,0), vec2(WIDTH,20))
    ground.type = STATIC
    debugDraw:addBody(ground)
    return ground
end

function cleanup()
    debugDraw:clear()
end

-- This function gets called once every frame
function draw()
    -- This sets the background color to black
    background(0, 0, 0)
    
    if test_number ~= currentTestIndex then
        setTest(test_number)
    end
    
    currentTest:draw()
    --debugDraw:draw()
    
    local str = string.format("Test %d - %s", currentTestIndex, currentTest.title)
    
    text(str, WIDTH/2, HEIGHT - 20)
    
    if use_accelerometer == 1 then
        physics.gravity(Gravity)
    else
        --physics.gravity(defaultGravity)
    end
end

function touched(touch)
    if debugDraw:touched(touch) == false then
        currentTest:touched(touch)
    end
end

function collide(contact)
    --debugDraw:collide(contact)
    if currentTest.collide then
        currentTest:collide(contact)
    end
end

--# Test1
Test1 = class()

function Test1:init()
    self.title = "SlammerFall"
end

function Test1:setup()    
    POD = 0
    WORM = 1
    
    owners = {}
    
    self.levelWidth = 1024*4
    self.levelHeight = 768*2

    self.stars = mesh()
    self.stars.texture = "SpaceCute:Star"
    self.stars2 = mesh()
    self.stars2.texture = "SpaceCute:Star"
    for i = 1,200 do
        local size = math.random(5,15)
        self.stars:addRect(math.random(0,self.levelWidth), math.random(0,self.levelHeight), size,size)
       self.stars2:addRect(math.random(0,self.levelWidth*2), math.random(0,self.levelHeight*2), size,size) 
    end
     
    self.pod = SlammerPod(self.levelWidth/2, HEIGHT/2)    
    self.worm1 = Worm(self.levelWidth, HEIGHT, self.pod)
    self.worm1.name = "worm1"
    self.worm2 = Worm(self.levelWidth/2, HEIGHT, self.pod)
    self.worm2.name = "worm2"
    self.worm3 = Worm(9, HEIGHT, self.pod)
    self.worm3.name = "worm3"
    
    self.camPos = self.pod.chassis.position
    
    self.landMesh = mesh()
    local points = {vec2(0,0)}
    for x = 0,self.levelWidth,50 do
        table.insert(points, vec2(x,50 + math.random(0, 25)))
    end
    table.insert(points, vec2(self.levelWidth, 0))
    self.landMesh.vertices = triangulate(points)
    self.landMesh:setColors(128, 128, 128)
    self.land = physics.body(CHAIN, true, unpack(points))
    self.land.type = STATIC
    self.land.restitution = 0.3
    
    self.leftBarrier = physics.body(EDGE, vec2(0,0), vec2(0,self.levelHeight))
    self.rightBarrier = physics.body(EDGE, vec2(self.levelWidth,0), vec2(self.levelWidth,self.levelHeight))
    self.topBarrier = physics.body(EDGE, vec2(0,self.levelHeight), vec2(self.levelWidth,self.levelHeight))
end

function Test1:draw()
    -- Codea does not automatically call this method
    
    pushMatrix()
    local interp = 0.95
    self.camPos = self.camPos * interp + self.pod.chassis.position * (1-interp)
    self.camPos.x = math.max(self.camPos.x, WIDTH/2)
    self.camPos.x = math.min(self.camPos.x, self.levelWidth - WIDTH/2)
    self.camPos.y = math.max(self.camPos.y, HEIGHT/2)
    self.camPos.y = math.min(self.camPos.y, self.levelHeight - HEIGHT/2)
    
    pushMatrix()
    translate(-self.camPos.x/2 + WIDTH/2, -self.camPos.y/2 + HEIGHT/2)
    self.stars2:draw()
    popMatrix()
    
    translate(-self.camPos.x + WIDTH/2, -self.camPos.y + HEIGHT/2)
    
    self.stars:draw()
    self.landMesh:draw()
    self.pod:draw()
    self.worm1:draw()
    self.worm2:draw()
    self.worm3:draw()
    
    popMatrix()
end

function Test1:collide(contact)
    if contact.state ~= BEGAN then return end

    local infoA = contact.bodyA.info
    local infoB = contact.bodyB.info
    
    if infoA and infoA.hit then
        infoA:hit(infoB, contact, true)
    end
    if infoB and infoB.hit then
        infoB:hit(infoA, contact, false)
    end
end

--# PhysicsDebugDraw
PhysicsDebugDraw = class()

function PhysicsDebugDraw:init()
    self.bodies = {}
    self.joints = {}
    self.touchMap = {}
    self.contacts = {}
end

function PhysicsDebugDraw:addBody(body)
    table.insert(self.bodies,body)
end

function PhysicsDebugDraw:addJoint(joint)
    table.insert(self.joints,joint)
end

function PhysicsDebugDraw:clear()
    -- deactivate all bodies
    
    for i,body in ipairs(self.bodies) do
        body:destroy()
    end
  
    for i,joint in ipairs(self.joints) do
        joint:destroy()
    end      
    
    self.bodies = {}
    self.joints = {}
    self.contacts = {}
    self.touchMap = {}
end

function PhysicsDebugDraw:draw()
    
    pushStyle()
    smooth()
    strokeWidth(5)
    stroke(128,0,128)
    
    local gain = 2.0
    local damp = 0.5
    for k,v in pairs(self.touchMap) do
        local worldAnchor = v.body:getWorldPoint(v.anchor)
        local touchPoint = v.tp
        local diff = touchPoint - worldAnchor
        local vel = v.body:getLinearVelocityFromWorldPoint(worldAnchor)
        v.body:applyForce( (1/1) * diff * gain - vel * damp, worldAnchor)
        
        line(touchPoint.x, touchPoint.y, worldAnchor.x, worldAnchor.y)
    end
    
    stroke(0,255,0,255)
    strokeWidth(5)
    for k,joint in pairs(self.joints) do
        local a = joint.anchorA
        local b = joint.anchorB
        line(a.x,a.y,b.x,b.y)
    end
    
    stroke(255,255,255,255)
    noFill()
    
    
    for i,body in ipairs(self.bodies) do
        pushMatrix()
        translate(body.x, body.y)
        rotate(body.angle)
    
        if body.type == STATIC then
            stroke(255,255,255,255)
        elseif body.type == DYNAMIC then
            stroke(150,255,150,255)
        elseif body.type == KINEMATIC then
            stroke(150,150,255,255)
        end
    
        if body.shapeType == POLYGON then
            strokeWidth(5.0)
            local points = body.points
            for j = 1,#points do
                a = points[j]
                b = points[(j % #points)+1]
                line(a.x, a.y, b.x, b.y)
            end
        elseif body.shapeType == CHAIN or body.shapeType == EDGE then
            strokeWidth(5.0)
            local points = body.points
            for j = 1,#points-1 do
                a = points[j]
                b = points[j+1]
                line(a.x, a.y, b.x, b.y)
            end      
        elseif body.shapeType == CIRCLE then
            strokeWidth(5.0)
            line(0,0,body.radius-3,0)
            strokeWidth(2.5)
            ellipse(0,0,body.radius*2)
        end
        
        popMatrix()
    end 
    
    stroke(255, 0, 0, 255)
    fill(255, 0, 0, 255)

    for k,v in pairs(self.contacts) do
        for m,n in ipairs(v.points) do
            ellipse(n.x, n.y, 10, 10)
        end
    end
    
    popStyle()
end

function PhysicsDebugDraw:touched(touch)
    local touchPoint = vec2(touch.x, touch.y)
    if touch.state == BEGAN then
        for i,body in ipairs(self.bodies) do
            if body.type == DYNAMIC and body:testPoint(touchPoint) then
                self.touchMap[touch.id] = {tp = touchPoint, body = body, anchor = body:getLocalPoint(touchPoint)} 
                return true
            end
        end
    elseif touch.state == MOVING and self.touchMap[touch.id] then
        self.touchMap[touch.id].tp = touchPoint
        return true
    elseif touch.state == ENDED and self.touchMap[touch.id] then
        self.touchMap[touch.id] = nil
        return true;
    end
    return false
end

function PhysicsDebugDraw:collide(contact)
    if contact.state == BEGAN then
        self.contacts[contact.id] = contact
    elseif contact.state == MOVING then
        self.contacts[contact.id] = contact
    elseif contact.state == ENDED then
        self.contacts[contact.id] = nil
    end
end

--# Controller
-- Base class for controllers
--
-- Controllers translate touch events into callbacks to functions
-- that do something in the app. (Model/View/Controller style).
--
-- Controllers can draw a representation of their current state on
-- the screen, but you can choose not to.
--
-- A controller can be installed as the global handler for touch
-- events by calling its activate() method

Controller = class()

function Controller:activate()
    touched = function(t)
        self:touched(t)
    end
end

function Controller:draw()
    -- nothing
end

-- Utility functions

function touchPos(t)
    return vec2(t.x, t.y)
end

function clamp(x, min, max)
    return math.max(min, math.min(max, x))
end

function clampAbs(x, maxAbs)
    return clamp(x, -maxAbs, maxAbs)
end

function clampLen(vec, maxLen)
    return vec:normalize() * math.min(vec:len(), maxLen)
end

-- projects v onto the direction represented by the given unit vector
function project(v, unit)
    return v:dot(unit)
end

function sign(x)
    if x == 0 then
        return 0
    elseif x < 0 then
        return -1
    elseif x > 0 then
        return 1
    else
        return x -- x is NaN
    end
end

function doNothing()
end

--# VirtualStick
-- A virtual analogue joystick with a dead-zone at the center,
-- which activates wherever the user touches their finger
--
-- Arguments:
--     radius - radius of the stick (default = 100)
--     deadZoneRadius - radius of the stick's dead zone (default = 25)
--     moved(v) - Called when the stick is moved
--         v : vec2 - in the range vec2(-1,-1) and vec2(1,1)
--     pressed() - Called when the user starts using the stick (optional)
--     released() - Called when the user releases the stick (optional)

VirtualStick = class(Controller)

function VirtualStick:init(args)
    self.radius = args.radius or 100
    self.deadZoneRadius = args.deadZoneRadius or 25
    self.releasedCallback = args.released or doNothing
    self.steerCallback = args.moved or doNothing
    self.pressedCallback = args.pressed or doNothing
end

function VirtualStick:touched(t)
    local pos = touchPos(t)
    
    if t.state == BEGAN and self.touchId == nil then
        self.touchId = t.id
        self.touchStart = pos
        self.stickOffset = vec2(0, 0)
        self.pressedCallback()
    elseif t.id == self.touchId then
        if t.state == MOVING then
            self.stickOffset = clampLen(pos - self.touchStart, self.radius)
            self.steerCallback(self:vector())
        elseif t.state == ENDED then
            self:reset()
            self.releasedCallback()
        end
    end
end

function VirtualStick:vector()
    local stickRange = self.radius - self.deadZoneRadius
    local stickAmount = math.max(self.stickOffset:len() - self.deadZoneRadius, 0)
    local stickDirection = self.stickOffset:normalize()
    
    return stickDirection * (stickAmount/stickRange)
end

function VirtualStick:reset()
    self.touchId = nil
    self.touchStart = nil
    self.stickOffset = nil
end

function VirtualStick:draw()
    if self.touchId ~= nil then
        pushStyle()
        ellipseMode(RADIUS)
        strokeWidth(1)
        stroke(255, 255, 255, 255)
        noFill()
        
        pushMatrix()
        translate(self.touchStart.x, self.touchStart.y)
        ellipse(0, 0, self.radius, self.radius)
        ellipse(0, 0, self.deadZoneRadius, self.deadZoneRadius)
        translate(self.stickOffset.x, self.stickOffset.y)
        ellipse(0, 0, 25, 25)
        popMatrix()
        
        popStyle()
    end
end