LÖVE

Code: Select all

-- size of the screen
Width, Height = love.graphics.getDimensions( )

-- table with the middle
Sun = {x=Width/2, y=Height/2}

-- list of planets
Planets = {}

function addPlanet (middle, radius, phi, omega)
	local t = love.timer.getTime()
	local planet = 
		{
			middle = middle,
			omega=omega,
			radius=radius,
			phi=phi,
			x = middle.x + radius*math.cos (t*omega + phi),
			y = middle.y + radius*math.sin (t*omega + phi),
		}
	
	table.insert (Planets, planet)
	
	return planet
end

Mercury = addPlanet (Sun, 50, 2*math.pi*math.random(), 100/50)
Venus = addPlanet (Sun, 100, 2*math.pi*math.random(), 100/100)
Earth = addPlanet (Sun, 200, 2*math.pi*math.random(), 100/200)
Moon = addPlanet (Earth, 35, 2*math.pi*math.random(), 50/35)

 
function love.update(dt)
	local t = love.timer.getTime()
	for i, planet in ipairs (Planets) do
		planet.x = planet.middle.x + planet.radius*math.cos (t*planet.omega + planet.phi)
		planet.y = planet.middle.y + planet.radius*math.sin (t*planet.omega + planet.phi)
	end
end


function love.draw()
	love.graphics.setColor(1,1,0)
	love.graphics.circle ('fill', Sun.x, Sun.y, 5)
	love.graphics.setColor(1,1,1)
	for i, planet in ipairs (Planets) do
		love.graphics.circle ('line', planet.middle.x, planet.middle.y, planet.radius)
		love.graphics.circle ('fill', planet.x, planet.y, 5)
	end
end

Code: Select all

    rotator.getVx = function(self, vx)
        return math.cos(self.time_alive)*radius+vx
    and

   rotator.getVy = function (self, vy)
        return math.sin(self.time_alive)*radius+vy
    end

    rotator. update = function (self, dt)
        ...
       
       self.x = self.x + self:getVx(self.vx)*dt+ (self.parent.x-self.parent.old_x)
        ... the same thing for y ...
        ...
    end
end

Code: Select all

    rotator.getVx = function(self, vx)
        return math.cos(self.time_alive)*radius+vx-parent.vx
    and

   rotator.getVy = function (self, vy)
        return math.sin(self.time_alive)*radius+vy-parent.vy
    end
 
    --- and  other variants of this don't work too
    --- like only applying -/+ if the obj vx and parent vx are 
    --- in different directions

Code: Select all

function rotator:getVxVy ()
	local angle = self.angle
	return self.radius * math.cos(angle), self.radius * math.sin(angle) -- maybe [sin, cos] or [cos, -sin]
end

-- update
local vx, vy = rotator:getVxVy ()
rotator.x = rotator.x = dt*vx
rotator.y = rotator.y = dt*vy
rotator.angle = rotator.angle + dt*rotator.angularVelocity

Code: Select all

function rotator:update (dt, x, y) -- x and y here are position of the rotation's center
	self.angle = self.angle + dt*self.angularVelocity
	local radius, angle = self.radius, self.angle
	self.x = x + radius * math.cos (angle)
	self.y = y + radius * math.sin (angle)
end

-- update
if player and player.rotators then
	for i, rotator in ipairs (player.rotators) do
		rotator:update (dt, player.x, player.y)
	end
end

-- draw
for i, rotator in ipairs (player.rotators) do
	love.graphics.circle ("fill", rotator.x, rotator.y, 3)
end