corona sdk,rotating both instances of same display object class - class

I have created a lua file called moonclass.lua
which created a display object of a moon
i have created two instances of this class, aka two moons,
these were created in level1.lua
however when i try to rotate both moons, only the last moon that is created will rotate, regardless of which one i refer the rotation to.
moonclasss.lua below:
local moon = {}
local moon_mt = { __index = moon } -- metatable
local sprite
function moon.new(name) -- constructor
local newMoon = {
name = name or "unnamed",
}
return setmetatable( newMoon, moon_mt)
end
function moon:draw(x,y,group)
sprite = display.newImage("image/moon.png")
sprite.x = x
sprite.y = y
physics.addBody( sprite, "dynamic", { density=1, friction=0.8, bounce=0.05, radius=145 } )
group:insert (sprite)
end
function moon:talk() print( self.name .. " is called." )end
function moon:y(y)
sprite.y = sprite.y + y
return y
end
function moon:x(x)
sprite.x = sprite.x + x
return x
end
function moon:rotate(r)
sprite.rotation = sprite.rotation + r
return sprite
end
return moon
and level1.lua:
local storyboard = require ("storyboard")
local scene = storyboard.newScene()
storyboard.purgeScene ("menu")
display.setStatusBar( display.HiddenStatusBar )
local physics = require("physics")
physics.start()
physics.setGravity(0, 0)
function scene:createScene(event)
local group = self.view
local background = display.newGroup()
local foreground = display.newGroup()
group:insert(background)
group:insert(foreground)
--BACKGROUND
backgroundimage = display.newImage("image/galaxy background.png")
foreground:insert(backgroundimage)
backgroundimage.x = display.contentWidth/2
backgroundimage.y = display.contentWidth/-1
require "starclass"
require "controls"
local moon = require ("moonclass")
local moon1 = moon.new("moon1")
moon1:draw(0,400,foreground)
local moon2 = moon.new("moon2")
moon2:draw(300,400,foreground)
moon1:talk()
moon2:talk()
local platform = require "platformclass"
platform.draw(512,200,foreground)
local platform2 = require "platformclass"
platform2.draw(50,0,foreground)
local rocket = require "rocketclass"
rocket.draw(200,600,foreground)
function gameloop(event)
--if (rockety > -1920 and rockety < 320) then
--foreground.y = rockety + 320
--end
moon2:rotate(1)
moon1:rotate(-2)
end
Runtime:addEventListener("enterFrame", gameloop)
end
-- ENTER SCENE --
function scene:enterScene (event)
--local chapter1level1 = require("scene objects").loadlevelenterscene()
end
-- EXIT SCENE --
function scene.exitScene(event)
controlthrust:removeEventListener( "touch", thrust)
controlleft:removeEventListener( "touch", rotateleft)
controlright:removeEventListener( "touch", rotateright)
Runtime:removeEventListener("enterFrame", gameloop)
end
scene:addEventListener("createScene", scene)
scene:addEventListener("enterScene", scene)
scene:addEventListener("exitScene", scene)
return scene

local moon = require("moonclass")
local moon2 = require ("moonclass")
These lines return the same object.
require does not load a module twice.
Second require simply returns the value that was returned by the first require.
You must define a constructor function and call it to create new object.
EDIT :
local moon = {}
local moon_mt = { __index = moon } -- metatable
function moon.new(name) -- constructor
local newMoon = {
name = name or "unnamed"
}
return setmetatable( newMoon, moon_mt)
end
function moon:draw(x,y,group)
self.sprite = display.newImage("image/moon.png")
self.sprite.x = x
self.sprite.y = y
physics.addBody( self.sprite, "dynamic", { density=1, friction=0.8, bounce=0.05, radius=145 } )
group:insert (self.sprite)
end
function moon:talk() print( self.name .. " is called." )end
function moon:y(y)
self.sprite.y = self.sprite.y + y
return y
end
function moon:x(x)
self.sprite.x = self.sprite.x + x
return x
end
function moon:rotate(r)
self.sprite.rotation = self.sprite.rotation + r
return self.sprite
end
return moon

Related

Attempt to index nil to 'Takedamage'

the thing is that im making a combat system, and there is the situation with line 56 that says: enemyHumanoid:TakeDamage(Damage) and the error says: ServerScriptService.CombatSystem:56: attempt to index nil with 'TakeDamage' and i dont know what to do (also this is the entire code)
local rp = game:GetService("ReplicatedStorage")
local Combat = rp:WaitForChild("Combat")
local Debris = game:GetService("Debris")
local Animations = script:WaitForChild("Animations")
local Meshes = script:WaitForChild("Meshes")
local anims =
{
Animations:WaitForChild("Right"),
Animations:WaitForChild("Left"),
Animations:WaitForChild("Gut"),
Animations:WaitForChild("Kick"),
}
local limbs =
{
"RightHand",
"LeftHand",
"RightHand",
"RightFoot"
}
local Damage = 10
Combat.OnServerEvent:Connect(function(player,count)
local Character = player.Character
local Humanoid = Character:WaitForChild("Humanoid")
local attack = Humanoid:LoadAnimation(anims[count])
attack:Play()
local Limb = Character:WaitForChild(limbs[count])
local folder = Instance.new("Folder",Character)
folder.Name = player.Name.."Melee"
local Hitbox = Meshes:WaitForChild("Hitbox"):Clone()
Hitbox.CFrame = Limb.CFrame
Hitbox.Parent = folder
Debris:AddItem(Hitbox,.5)
local weld = Instance.new("ManualWeld")
weld.Part0 = Hitbox
weld.Part1 = Limb
weld.C0 = weld.Part0.CFrame:ToObjectSpace(weld.Part1.CFrame)
weld.Parent = weld.Part0
Hitbox.Touched:Connect(function(Hit)
if Hit:IsA("BasePart") then
if not Hit:IsDescendantOf(Character) then
local enemyHumanoid = Hitbox.Parent:FindFirstChild("Humanoid")
if Humanoid then
Hitbox:Destroy()
enemyHumanoid:TakeDamage(Damage)
end
end
end
end)
Combat:FireClient(player)
end)
i haven't try a lot but it keeps getting errors
Welcome to StackOverflow! :FindFirstChild("Humanoid") returns nil if the Humanoid doesn't exist, which is why enemyHumanoid:TakeDamage() isn't working. Try using this snippet in place of the current Hitbox.Touched function:
Hitbox.Touched:Connect(function(Hit)
if Hit:IsA("BasePart") and not Hit:IsDescendantOf(Character) then
local enemyHumanoid = Hitbox.Parent:FindFirstChild("Humanoid")
if Humanoid then
Hitbox:Destroy()
if enemyHumanoid then -- Make sure enemyHumanoid exists and isn't nil
enemyHumanoid:TakeDamage(Damage)
end
end
end
end)

How to use timer.performWithDelay with a method call

I'm using a Lua class to create two objects, each of which must check where the other is to determine their movement. I'm attempting to use timer.performWithDelay to have them check every second, but for some reason when I try to do this, the line
o.moveCheckTimer = timer.performWithDelay(1000, o:moveCheck, 0)
in the class constructor throws an error stating that "Function arguments are expected near ','".
I have attempted to use an anonymous function like this:
o.moveCheckTimer = timer.performWithDelay(1000, function() o:moveCheck() end, 0)
but that causes the timer of both objects to only call the function for the most recent object that was created and not for itself (also very confusing behavior, and if anyone knows why this happens I would love to learn why).
I have dug through the API and info on method calls thoroughly, but I can't seem to find anything that uses them both together, and I feel like I'm missing something.
How can I use the method call as the listener for this timer?
Here is the full constructor:
Melee = {}
Melee.__index = Melee
function Melee:new(id, name, lane, side)
local o = {}
setmetatable(o, Melee)
o.id = id
o.name = name
o.lane = lane
o.side = side
if name == "spearman" then
o.maxhp = 100
o.range = 1
o.damage = {10, 20}
o.imageName = "images/rebels/spearman.png"
else
error("Attempted to create melee unit with undefined name")
end
o.hp = o.maxhp
--Display self
o.image = display.newImageRect(mainGroup, "images/rebels/spearman.png", 80, 80)
o.image.x = 0
o.image.y = lanes[lane]
o.image.anchorY = 1
if side == 2 then
o.image.xScale = -1
o.image:setFillColor(0.8)
o.image.x = display.contentWidth - 100
end
--Move and attack
local destination = display.contentWidth
if side == 2 then
destination = 0
end
o.moving = 1
o.movement = transition.to(o.image, {x = destination, time = 30000+math.random(-200,200)})
o.moveCheckTimer = timer.performWithDelay(1000, o:moveCheck, 0)
--o.attackTimer = timer.performWithDelay(1000, self:attack, 0)
return o
end

whats the difference between class and instance?

whats the difference between class and instance in lua?
I know classes are like the template and the instance is the object created from the template but I am wondering what the difference in code is.
my goal is to make a system that works like this..
--class.widget.lua----------------------------------------------------------
local class = require "class"
local widget = class("class.widget")
function widget:create()
--create variables here
end
function widget:update()
--update variables here
end
function widget:render()
--widget render
end
return widget
--class.widget.button.lua---------------------------------------------------
local class = require "class"
local widget = require "class.widget"
local button = class("button", widget)
function button:create(x, y)
base:create()
--create variables here
end
function button:update()
base:update()
--update variables here
end
function button:render()
base:render()
--widget render
end
return button
--main.lua------------------------------------------------------------------
local button = require "class.widget.button.lua"
button1 = button(0, 0)
button2 = button(0, 16)
even though this hasn't been answered, this right here is working exactly the way I want it to
I am posting it here if anybody wants to use it
EDIT: this is a better version for both me and any one looking for a good lua class
return function(name, base)
local class = {}
--private vars
class.__name = name
class.__base = base
class.__index = class
class.__event = "create"
--events
class.onCreate = function(inst) end
class.onUpdate = function(inst) end
class.onRender = function(inst) end
class.onDelete = function(inst) end
--functions
class.create = function(inst) inst.__event = "create" inst:onCreate() end
class.update = function(inst) inst.__event = "update" inst:onUpdate() end
class.render = function(inst) inst.__event = "render" inst:onRender() end
class.delete = function(inst) inst.__event = "delete" inst:onDelete() end
class.getBase = function(inst) return inst.__base end
class.getName = function(inst) return inst.__name end
class.inheritEvent = function(inst)
if inst.__event == "create" then inst.__base:create() end
if inst.__event == "update" then inst.__base:update() end
if inst.__event == "render" then inst.__base:render() end
if inst.__event == "delete" then inst.__base:delete() end
end
--constructor
local MT = {}
MT.__index = base
function MT:__call(_, ...)
local inst = setmetatable({}, class)
inst:create(inst, ...)
return inst
end
return setmetatable(class, MT)
end

attempt to index global 'physics' (a nil value)

I'm new with corona/lua and i'm i can't find a solution to this thing. I'm trying to spawn a object that fall from top to down and should stop at the bottom of the screen. Then i'll create the touch event etc etc..
but for now the problem is that i recieve this error:
attempt to index global 'physics' (a nil value)
and objects ofc doesn't fall down.
here is my code:
-----------------------------------------------------------------------------------------
--
-- main.lua
--
-----------------------------------------------------------------------------------------
local buttonY = display.contentWidth * 0.02
local buttonWidth = display.contentWidth * 0.1
local buttonHeight = display.contentWidth * 0.1
background = display.newImage("graphics/background.jpg")
local localGroup = display.newGroup()
local spawnTable = {}
function spawnLattina(params)
local object = display.newImage(params.image, params.buttonX,50);
object.objTable = params.objTable;
object.index = #object.objTable+1;
object.name = "object:".. object.index;
--fisica
if params.hasBody then
object.density = params.density or 0;
object.friction = params.friction or 0;
object.bounce = params.bounce or 0;
object.isSensor = params.isSensor or false;
object.bodyType = params.bodyType or "dynamic";
print(object.density .. " Friction: ".. object.friction .."bodyType: "..object.bodyType)
physics.addBody(object, object.bodyType,
{density = object.density,
friction = object.friction,
bounce = object.bounce}
)
end
object.group = params.group or nil
object.group:insert(object)
object.objTable[object.index] = object
return object
end
for i = 1, 2 do
local spawns = spawnLattina(
{
image = "graphics/lattina.png",
objTable = spawnTable,
buttonX = math.random(50,480),
hasBody = true,
density = 0,
friction = 12,
bodyType = "static",
group = localGroup,
}
)
end
You haven't started the physics engine. Write the following lines on the top of your class:
local physics = require "physics"
physics.start()
Keep Coding.................. :)

How to create a class, subclass and properties in Lua?

I'm having a hard time grokking classes in Lua. Fruitless googling led me to ideas about meta-tables, and implied that third-party libraries are necessary to simulate/write classes.
Here's a sample (just because I've noticed I get better answers when I provide sample code):
public class ElectronicDevice
{
protected bool _isOn;
public bool IsOn { get { return _isOn; } set { _isOn = value; } }
public void Reboot(){_isOn = false; ResetHardware();_isOn = true; }
}
public class Router : ElectronicDevice
{
}
public class Modem :ElectronicDevice
{
public void WarDialNeighborhood(string areaCode)
{
ElectronicDevice cisco = new Router();
cisco.Reboot();
Reboot();
if (_isOn)
StartDialing(areaCode);
}
}
Here is my first attempt to translate the above using the technique suggested by Javier.
I took the advice of RBerteig. However, invocations on derived classes still yield: "attempt to call method 'methodName' (a nil value)"
--Everything is a table
ElectronicDevice = {};
--Magic happens
mt = {__index=ElectronicDevice};
--This must be a constructor
function ElectronicDeviceFactory ()
-- Seems that the metatable holds the fields
return setmetatable ({isOn=true}, mt)
end
-- Simulate properties with get/set functions
function ElectronicDevice:getIsOn() return self.isOn end
function ElectronicDevice:setIsOn(value) self.isOn = value end
function ElectronicDevice:Reboot() self.isOn = false;
self:ResetHardware(); self.isOn = true; end
function ElectronicDevice:ResetHardware() print('resetting hardware...') end
Router = {};
mt_for_router = {__index=Router}
--Router inherits from ElectronicDevice
Router = setmetatable({},{__index=ElectronicDevice});
--Constructor for subclass, not sure if metatable is supposed to be different
function RouterFactory ()
return setmetatable ({},mt_for_router)
end
Modem ={};
mt_for_modem = {__index=Modem}
--Modem inherits from ElectronicDevice
Modem = setmetatable({},{__index=ElectronicDevice});
--Constructor for subclass, not sure if metatable is supposed to be different
function ModemFactory ()
return setmetatable ({},mt_for_modem)
end
function Modem:WarDialNeighborhood(areaCode)
cisco = RouterFactory();
--polymorphism
cisco.Reboot(); --Call reboot on a router
self.Reboot(); --Call reboot on a modem
if (self.isOn) then self:StartDialing(areaCode) end;
end
function Modem:StartDialing(areaCode)
print('now dialing all numbers in ' .. areaCode);
end
testDevice = ElectronicDeviceFactory();
print("The device is on? " .. (testDevice:getIsOn() and "yes" or "no") );
testDevice:Reboot(); --Ok
testRouter = RouterFactory();
testRouter:ResetHardware(); -- nil value
testModem = ModemFactory();
testModem:StartDialing('123'); -- nil value
Here's an example literal transcription of your code, with a helpful Class library that could be moved to another file.
This is by no means a canonical implementation of Class; feel free to define your object model however you like.
Class = {}
function Class:new(super)
local class, metatable, properties = {}, {}, {}
class.metatable = metatable
class.properties = properties
function metatable:__index(key)
local prop = properties[key]
if prop then
return prop.get(self)
elseif class[key] ~= nil then
return class[key]
elseif super then
return super.metatable.__index(self, key)
else
return nil
end
end
function metatable:__newindex(key, value)
local prop = properties[key]
if prop then
return prop.set(self, value)
elseif super then
return super.metatable.__newindex(self, key, value)
else
rawset(self, key, value)
end
end
function class:new(...)
local obj = setmetatable({}, self.metatable)
if obj.__new then
obj:__new(...)
end
return obj
end
return class
end
ElectronicDevice = Class:new()
function ElectronicDevice:__new()
self.isOn = false
end
ElectronicDevice.properties.isOn = {}
function ElectronicDevice.properties.isOn:get()
return self._isOn
end
function ElectronicDevice.properties.isOn:set(value)
self._isOn = value
end
function ElectronicDevice:Reboot()
self._isOn = false
self:ResetHardware()
self._isOn = true
end
Router = Class:new(ElectronicDevice)
Modem = Class:new(ElectronicDevice)
function Modem:WarDialNeighborhood(areaCode)
local cisco = Router:new()
cisco:Reboot()
self:Reboot()
if self._isOn then
self:StartDialing(areaCode)
end
end
If you were to stick to get/set methods for properties, you wouldn't need __index and __newindex functions, and could just have an __index table. In that case, the easiest way to simulate inheritance is something like this:
BaseClass = {}
BaseClass.index = {}
BaseClass.metatable = {__index = BaseClass.index}
DerivedClass = {}
DerivedClass.index = setmetatable({}, {__index = BaseClass.index})
DerivedClass.metatable = {__index = DerivedClass.index}
In other words, the derived class's __index table "inherits" the base class's __index table. This works because Lua, when delegating to an __index table, effectively repeats the lookup on it, so the __index table's metamethods are invoked.
Also, be wary about calling obj.Method(...) vs obj:Method(...). obj:Method(...) is syntactic sugar for obj.Method(obj, ...), and mixing up the two calls can produce unusual errors.
There are a number of ways you can do it but this is how I do (updated with a shot at inheritance):
function newRGB(r, g, b)
local rgb={
red = r;
green = g;
blue = b;
setRed = function(self, r)
self.red = r;
end;
setGreen = function(self, g)
self.green= g;
end;
setBlue = function(self, b)
self.blue= b;
end;
show = function(self)
print("red=",self.red," blue=",self.blue," green=",self.green);
end;
}
return rgb;
end
purple = newRGB(128, 0, 128);
purple:show();
purple:setRed(180);
purple:show();
---// Does this count as inheritance?
function newNamedRGB(name, r, g, b)
local nrgb = newRGB(r, g, b);
nrgb.__index = nrgb; ---// who is self?
nrgb.setName = function(self, n)
self.name = n;
end;
nrgb.show = function(self)
print(name,": red=",self.red," blue=",self.blue," green=",self.green);
end;
return nrgb;
end
orange = newNamedRGB("orange", 180, 180, 0);
orange:show();
orange:setGreen(128);
orange:show();
I don't implement private, protected, etc. although it is possible.
If you don't want to reinvent the wheel, there is a nice Lua library implementing several object models. It's called LOOP.
The way I liked to do it was by implementing a clone() function.
Note that this is for Lua 5.0. I think 5.1 has more built-in object oriented constructions.
clone = function(object, ...)
local ret = {}
-- clone base class
if type(object)=="table" then
for k,v in pairs(object) do
if type(v) == "table" then
v = clone(v)
end
-- don't clone functions, just inherit them
if type(v) ~= "function" then
-- mix in other objects.
ret[k] = v
end
end
end
-- set metatable to object
setmetatable(ret, { __index = object })
-- mix in tables
for _,class in ipairs(arg) do
for k,v in pairs(class) do
if type(v) == "table" then
v = clone(v)
end
-- mix in v.
ret[k] = v
end
end
return ret
end
You then define a class as a table:
Thing = {
a = 1,
b = 2,
foo = function(self, x)
print("total = ", self.a + self.b + x)
end
}
To instantiate it or to derive from it, you use clone() and you can override things by passing them in another table (or tables) as mix-ins
myThing = clone(Thing, { a = 5, b = 10 })
To call, you use the syntax :
myThing:foo(100);
That will print:
total = 115
To derive a sub-class, you basically define another prototype object:
BigThing = clone(Thing, {
-- and override stuff.
foo = function(self, x)
print("hello");
end
}
This method is REALLY simple, possibly too simple, but it worked well for my project.
It's really easy to do class-like OOP in Lua; just put all the 'methods' in the __index field of a metatable:
local myClassMethods = {}
local my_mt = {__index=myClassMethods}
function myClassMethods:func1 (x, y)
-- Do anything
self.x = x + y
self.y = y - x
end
............
function myClass ()
return setmetatable ({x=0,y=0}, my_mt)
Personally, I've never needed inheritance, so the above is enough for me. If it's not enough, you can set a metatable for the methods table:
local mySubClassMethods = setmetatable ({}, {__index=myClassMethods})
local my_mt = {__index=mySubClassMethods}
function mySubClassMethods:func2 (....)
-- Whatever
end
function mySubClass ()
return setmetatable ({....}, my_mt)
update:
There's an error in your updated code:
Router = {};
mt_for_router = {__index=Router}
--Router inherits from ElectronicDevice
Router = setmetatable({},{__index=ElectronicDevice});
Note that you initialize Router, and build mt_for_router from this; but then you reassign Router to a new table, while mt_for_router still points to the original Router.
Replace the Router={} with the Router = setmetatable({},{__index=ElectronicDevice}) (before the mt_for_router initialization).
Your updated code is wordy, but should work. Except, you have a typo that is breaking one of the metatables:
--Modem inherits from ElectronicDevice
Modem = setmetatable({},{__index,ElectronicDevice});
should read
--Modem inherits from ElectronicDevice
Modem = setmetatable({},{__index=ElectronicDevice});
The existing fragment made the Modem metatable be an array where the first element was almost certainly nil (the usual value of _G.__index unless you are using strict.lua or something similar) and the second element is ElectronicDevice.
The Lua Wiki description will make sense after you've grokked metatables a bit more. One thing that helps is to build a little infrastructure to make the usual patterns easier to get right.
I'd also recommend reading the chapter on OOP in PiL. You will want to re-read the chapters on tables and metatables too. Also, I've linked to the online copy of the 1st edition, but owning a copy of the 2nd is highly recommended. There is also a couple of articles in the Lua Gems book that relate. It, too, is recommended.
Another simple approach for subclass
local super = require("your base class")
local newclass = setmetatable( {}, {__index = super } )
local newclass_mt = { __index = newclass }
function newclass.new(...) -- constructor
local self = super.new(...)
return setmetatable( self, newclass_mt )
end
You still can use the functions from superclass even if overwritten
function newclass:dostuff(...)
super.dostuff(self,...)
-- more code here --
end
don't forget to use ONE dot when pass the self to the superclass function