LÖVE

Code: Select all

function Entity:applyImpulseY(imp)
    self.vy = self.vy + imp
    --self:set("vy","+",imp)
end

function Entity:applyImpulseX(imp)
    self.vx = self.vx + imp
    --self:set("vx","+",imp)
    
end

function Entity:applyImpulse(impX,impY)
    self:applyImpulseX(impX)
    self:applyImpulseY(impY)
end

function Entity:changeVelocityByImpulse(col)
    
        local other = col.other
        if not other.isTile then
            --push
            local y,x = col.normal.y, col.normal.x
            if y<0 and self.vy>other.vy then
                other:applyImpulseY(self.vy)
            elseif y<0 and self.vy<other.vy then
                self:applyImpulseY(other.vy)
            end
            
            if y>0 and self.vy<other.vy then
                other:applyImpulseY(self.vy)
            elseif y>0 and self.vy>other.vy then
                self:applyImpulseY(other.vy)
            end
            
            if x<0 and self.vx>other.vx then
                other:applyImpulseX(self.vx)
            elseif x<0 and self.vx<other.vx then
                self:applyImpulseX(other.vx)
            end
            
            if x>0 and self.vx<other.vx then
                other:applyImpulseX(self.vx)
            elseif x>0 and self.vx>other.vx then
                self:applyImpulseX(other.vx)
            end
        end
end


function Entity:changeVelocityByCollisionNormal(nx, ny, bounciness)
  local bounciness = bounciness or self.elasticity
  if not bounciness or bounciness == 0 then
      return
  end
  local vx, vy = self.vx, self.vy

  if (nx < 0 and vx > 0) or (nx > 0 and vx < 0) then
    vx = -vx * bounciness
    self.bounced.x = true
  end
  
  if (ny < 0 and vy > 0) or (ny > 0 and vy < 0) then
    vy = -vy * bounciness
    self.bounced.y = true
  end

  self.vx, self.vy = vx, vy
end

function Entity:resolveCollision(col)
    self:changeVelocityByCollisionNormal(col.normal.x, col.normal.y)
    if col.normal.y == -1 then
        if not self.isMini and not self.isPlayer and not self.isDebris then
                self.gravity = 0
                self.vy = 0
                self.onGround = true
            
        end
    else
        self.onGround = false
    end
    
    self:changeVelocityByImpulse(col)
end

function Entity:move(x,y)
    local actualX, actualY, collisions, len = self.world:move(self,x,y,
    self.checkCollision)
    local col
    for e = 1, len do
        col = collisions[e]
        self:resolveCollision(col)
    end
    
    self.x, self.y = actualX, actualY
end

function Entity:update(dt)
    local vx, vy = self.x+self.vx*dt,self.y+self.vy*dt
    self:move(vx,vy,dt)
end

Code: Select all

function Entity:checkCollision(other)
    if not other.isBackground then--any thing solid, including walls
        return "slide"
    end
end