Tutorial #04: Lua Card Game
We demonstrate how the card game from Tutorial #03: Card Game can be created solely with Lua.
For this tutorial it is assumed that the reader already has basic knowledge about Lua programming.
- Note
- You need to add the optional Lua add-on to your project in order to be able to use Lua scripts. The easiest way to configure add-ons is by using the Murl Dashboard and the command Project / Configure Project.
Resource Package
We use a copy of the resources game.murlres from tutorial #03.
Additionally we add script resources to the package and store them in a separate lua folder.
data/packages/game.murlres/lua/card_game_logic.luadata/packages/game.murlres/lua/card_game_card_instance.lua
The script resources have to be added to the package like any other resource file.
<?xml version="1.0" ?>
<!-- Copyright 2014 Spraylight GmbH -->
<Package id="game">
<!-- Animation resources -->
<Resource id="anim_game_screen" fileName="anim_game_screen.xml"/>
<!-- Bitmap resources -->
<Resource id="gfx_clubs" fileName="gfx_clubs.png"/>
<Resource id="planes_clubs" fileName="planes_clubs.xml"/>
<Resource id="gfx_diamonds" fileName="gfx_diamonds.png"/>
<Resource id="planes_diamonds" fileName="planes_diamonds.xml"/>
<Resource id="gfx_hearts" fileName="gfx_hearts.png"/>
<Resource id="planes_hearts" fileName="planes_hearts.xml"/>
<Resource id="gfx_misc" fileName="gfx_misc.png"/>
<Resource id="planes_misc" fileName="planes_misc.xml"/>
<Resource id="gfx_spades" fileName="gfx_spades.png"/>
<Resource id="planes_spades" fileName="planes_spades.xml"/>
<!-- Font resources -->
<Resource id="arial_color_24_glyphs" fileName="fonts/arial_color_24_glyphs.murl"/>
<Resource id="arial_color_24_map" fileName="fonts/arial_color_24_map.png"/>
<Resource id="arial_color_48_glyphs" fileName="fonts/arial_color_48_glyphs.murl"/>
<Resource id="arial_color_48_map" fileName="fonts/arial_color_48_map.png"/>
<!-- Graph resources -->
<Resource id="graph_camera" fileName="graph_camera.xml"/>
<Resource id="graph_game_card" fileName="graph_game_card.xml"/>
<Resource id="graph_game_card_suit" fileName="graph_game_card_suit.xml"/>
<Resource id="graph_game_screen" fileName="graph_game_screen.xml"/>
<Resource id="graph_materials" fileName="graph_materials.xml"/>
<Resource id="graph_textures" fileName="graph_textures.xml"/>
<!-- Lua resources -->
<Resource id="lua_card_game_logic" fileName="lua/card_game_logic.lua" enableCompression="yes"/>
<Resource id="lua_card_game_card_instance" fileName="lua/card_game_card_instance.lua" enableCompression="yes"/>
<!-- Graph instances -->
<Instance graphResourceId="graph_materials"/>
<Instance graphResourceId="graph_textures"/>
<Instance graphResourceId="graph_camera"/>
<!-- Script instances -->
<Instance scriptResourceId="lua_card_game_logic"/>
</Package>
The resource lua_card_game_logic is instantiated with <Instance scriptResourceId="lua_card_game_logic"/>. This means that the script automatically will be added as a logic processer after the package has been loaded and is processed like any other logic processor.
Scene Graph
The second script resource lua_card_game_card_instance is used as a script controller of a graph node.
<?xml version="1.0" ?>
<!-- Copyright 2014 Spraylight GmbH -->
<Graph>
<Namespace id="{cardName}" activeAndVisible="no"
controller="ScriptLogicController"
controller.scriptResourceId="game:lua_card_game_card_instance">
<Transform id="position">
<Reference targetId="/textures/{cardName}"/>
<SubState>
<TextureState textureId="/textures/tex_misc"/>
<Transform axisX="0" axisY="1" axisZ="0" angle="180 deg">
<Switch id="back_switch">
<Reference targetId="/textures/black_back"/>
<Reference targetId="/textures/red_back"/>
</Switch>
</Transform>
</SubState>
<Button id="button" sizeX="90" sizeY="130"/>
</Transform>
</Namespace>
</Graph>
Thus for every card graph instance also a lua_card_game_card_instance script instance is created. After a graph node has been initialized the corresponding controller script is processed on every logic tick.
Application
A pure Lua application uses a small portion of generic C++ code to initially load the first Lua script. This script has to implement the IApp class in Lua and needs to be stored in the packages folder.
data/packages/lua_card_game_app.lua
- Note
- Hint: A pure Lua application with all necessary code parts can easily be created with the Murl Dashboard by using the Create Project command and the Lua template.
The program flow is almost identical to the C++ program from tutorial #03.
-- Copyright 2014 Spraylight GmbH
-- Open Lua standard libraries
local luaAddon = Murl.Addons.Lua.Factory.GetAddon()
luaAddon:OpenLibrary("math")
luaAddon:OpenLibrary("string")
luaAddon:OpenLibrary("table")
luaAddon:OpenLibrary("utf8")
-- Parameter for Murl.IApp
local name = ...
-- print("\nLUA IApp new '" .. name .. "'")
-- Murl IApp callbacks
local mainIApp =
{
Configure = function (self, engineConfig, fileInterface)
-- print("LUA IApp Configure")
local appConfig = engineConfig:GetAppConfiguration()
local platformConfig = engineConfig:GetPlatformConfiguration()
engineConfig:SetProductName("LuaCardGame")
appConfig:SetWindowTitle("LuaCardGame powered by Murl Engine")
appConfig:SetSystemDebugInfoItems(Murl.IEnums.STATISTIC_ITEM_FRAMES_PER_SECOND)
if (platformConfig:IsTargetClassMatching(Murl.IEnums.TARGET_CLASS_COMPUTER)) then
if (platformConfig:IsOperatingSystemMatching(Murl.IEnums.OPERATING_SYSTEM_WINDOWS)) then
engineConfig:SetVideoApi(Murl.IEnums.VIDEO_API_DX90)
end
appConfig:SetDisplaySurfaceSize(1024, 768)
appConfig:SetLockWindowAspectEnabled(true)
appConfig:SetFullScreenEnabled(false)
elseif (platformConfig:IsTargetClassMatching(Murl.IEnums.TARGET_CLASS_HANDHELD)) then
-- set landscape orientation
appConfig:SetScreenOrientation(Murl.IEnums.SCREEN_ORIENTATION_LANDSCAPE_1)
-- enable landscape orientations
appConfig:SetAllowedScreenOrientations(Murl.IEnums.SCREEN_ORIENTATIONS_LANDSCAPE)
-- enable auto rotation
appConfig:SetAutoRotationActive(true)
appConfig:SetOrientationActive(true)
-- enable multi touch
appConfig:SetMultiTouchActive(true)
end
engineConfig:SetDeactivatedAppRunState(Murl.IEnums.APP_RUN_STATE_PAUSED)
return true
end,
IsUserConfigurationMatching = function (self, userConfigId)
-- print("LUA IApp IsUserConfigurationMatching", userConfigId)
return false
end,
RegisterCustomAddonClasses = function (self, addonRegistry)
-- print("LUA IApp RegisterCustomAddonClasses")
return true
end,
UnregisterCustomAddonClasses = function (self, addonRegistry)
-- print("LUA IApp UnregisterCustomAddonClasses")
return true
end,
Init = function (self, appState)
-- print("LUA IApp Init")
local loader = appState:GetLoader()
loader:AddPackage("startup", Murl.ILoader.LOAD_MODE_STARTUP)
loader:AddPackage("game", Murl.ILoader.LOAD_MODE_BACKGROUND)
return true
end,
DeInit = function (self, appState)
-- print("\nLUA IApp DeInit")
return true
end
}
return Murl.IApp.new(mainIApp)
This script is loaded and executed immediately when the program starts. The script has to return a IApp object.
- In the first section (line 4) Lua standard libraries are loaded.
- In the second section (line 11) the parameters are evaluated. The Lua application script gets exactly one parameter containing the name of the script resource.
- In the third section (line 15) a Lua function table is created. These functions act as callback functions and have the same meaning as the equally named C++
IAppmethods. - In the last section (line 92) an instance of the
IAppclass with the callback function table is created and returned.
Afterwards the Lua callback functions in mainIApp are executed like otherwise the equally named C++ methods.
The function Configure() (line 17) contains the same program as the C++ method in card_game_app.cpp from tutorial #03. The same applies for the function Init() (line 75) which loads the resource packages.
Lua programming syntactically slightly differs from C++ programming but almost all Murl classes are mapped to equally named Lua tables. A complete documentation of all Lua tables can be found in the download section in the MurlEngineLuaAPI archive.
Card Instance Script
Our game has 54 card instances where each can be controlled separately. To keep it simple we implement a script which can control exactly one card. This script is used as a graph node controller as shown above in the sub graph graph_game_card.xml.
-- Copyright 2014 Spraylight GmbH
-- Parameters for Logic IAppGraph
local resourceId, nodeId = ...
-- print("\nLUA IAppGraph new", resourceId, nodeId)
-- Logic IAppGraph callbacks
local logicIAppGraph =
{
mNodeObserver = Murl.Logic.StaticFactory.CreateNodeObserver(),
mNamespaceNode = Murl.Logic.NamespaceNode.new(),
mTransformNode = Murl.Logic.TransformNode.new(),
mButton = Murl.Logic.ButtonNode.new(),
mBackSwitch = Murl.Logic.SwitchNode.new(),
mStepableObserver = Murl.Logic.StaticFactory.CreateStepableObserver(),
mPositionAnim = Murl.Logic.AnimationVector.new(),
mRotationAnim = Murl.Logic.AnimationVector.new(),
mIsShowingFront = false,
OnPostInit = function (self, state)
-- print("LUA IAppGraph OnInit", nodeId)
self.mNodeObserver:Add(self.mNamespaceNode:GetReference(state:GetCurrentGraphNode()))
if (not self.mNamespaceNode:IsValid()) then
return false
end
self.mNodeObserver:Add(self.mTransformNode:GetReference(self.mNamespaceNode:FindNode("position")))
self.mNodeObserver:Add(self.mButton:GetReference(self.mNamespaceNode:FindNode("button")))
self.mNodeObserver:Add(self.mBackSwitch:GetReference(self.mNamespaceNode:FindNode("back_switch")))
if (not self.mNodeObserver:AreValid()) then
return false
end
self.mPositionAnim:AddKey(0.0, Murl.Math.Vector.new(Murl.Math.Vector.ZERO_POSITION), Murl.IEnums.INTERPOLATION_EASE_OUT)
self.mPositionAnim:AddKey(1.0, Murl.Math.Vector.new(Murl.Math.Vector.ZERO_POSITION))
self.mRotationAnim:AddKey(0.0, Murl.Math.Vector.new(), Murl.IEnums.INTERPOLATION_LINEAR)
self.mRotationAnim:AddKey(0.5, Murl.Math.Vector.new(), Murl.IEnums.INTERPOLATION_EASE_OUT)
self.mRotationAnim:AddKey(1.0, Murl.Math.Vector.new());
self.mStepableObserver:Add(self.mPositionAnim:GetStepable())
self.mStepableObserver:Add(self.mRotationAnim:GetStepable())
self:SetBack(CARDBACKSIDE_BLACK)
self:EnableButton(false)
self:SetCardPosition(self.mTransformNode:GetPosition(), false, 0)
self.mIsShowingFront = true
return true
end,
OnPreDeInit = function (self, state)
-- print("LUA IAppGraph OnDeInit", nodeId)
local ret = true
if (not self.mNodeObserver:RemoveAll()) then
ret = false
end
return ret
end,
OnPreProcessTick = function (self, state)
self.mStepableObserver:ProcessTick(state)
if (self.mPositionAnim:IsOrWasRunning()) then
self.mTransformNode:SetPosition(self.mPositionAnim:GetCurrentValue())
end
if (self.mRotationAnim:IsOrWasRunning()) then
local currentRotation = self.mRotationAnim:GetCurrentValue()
self.mTransformNode:SetRotation(currentRotation.x, currentRotation.y, currentRotation.z)
end
end,
SetObtained = function (self, isObtained)
self.mNamespaceNode:GetNodeInterface():SetActiveAndVisible(isObtained)
end,
SetSortDepth = function (self, sortDepth)
self.mTransformNode:SetDepthOrder(sortDepth)
end,
SetBack = function (self, backSide)
if (backSide == CARDBACKSIDE_RED) then
self.mBackSwitch:SetIndex(1)
else
self.mBackSwitch:SetIndex(0)
end
end,
SetCardPosition = function (self, position, showFront, duration)
self.mTransformNode:SetPosition(position)
if (showFront) then
if (not self.mIsShowingFront) then
if (duration > 0) then
self.mRotationAnim:ModifyKeyValue(0, Murl.Math.Vector.new(0, -Murl.Math.PI, 0, 0))
self.mRotationAnim:ModifyKeyValue(1, Murl.Math.Vector.new(0, -Murl.Math.HALF_PI, 0, 0))
self.mRotationAnim:ModifyKeyValue(2, Murl.Math.Vector.new(0, 0, 0, 0))
self.mRotationAnim:ModifyKeyTime(1, duration / 2)
self.mRotationAnim:ModifyKeyTime(2, duration)
self.mRotationAnim:StartForward()
else
self.mTransformNode:SetRotation(0, 0, 0)
end
end
else
if (self.mIsShowingFront) then
if (duration > 0) then
self.mRotationAnim:ModifyKeyValue(0, Murl.Math.Vector.new(0, 0, 0, 0))
self.mRotationAnim:ModifyKeyValue(1, Murl.Math.Vector.new(0, Murl.Math.HALF_PI, 0, 0))
self.mRotationAnim:ModifyKeyValue(2, Murl.Math.Vector.new(0, Murl.Math.PI, 0, 0))
self.mRotationAnim:ModifyKeyTime(1, duration / 2)
self.mRotationAnim:ModifyKeyTime(2, duration)
self.mRotationAnim:StartForward()
else
self.mTransformNode:SetRotation(0, Murl.Math.PI, 0)
end
end
end
self.mIsShowingFront = showFront
end,
MoveCardToPosition = function (self, position, showFront, duration)
self.mPositionAnim:SetKey(0, 0.0, self.mTransformNode:GetPosition(), Murl.IEnums.INTERPOLATION_EASE_OUT)
self.mPositionAnim:SetKey(1, duration, position)
self.mPositionAnim:StartForward()
if (showFront) then
if (mIsShowingFront) then
self.mRotationAnim:ModifyKeyValue(0, Murl.Math.Vector.new(0, 0, 0, 0))
self.mRotationAnim:ModifyKeyValue(1, Murl.Math.Vector.new(0, -1.0, 0.25, 0))
self.mRotationAnim:ModifyKeyValue(2, Murl.Math.Vector.new(0, 0, 0, 0))
else
self.mRotationAnim:ModifyKeyValue(0, Murl.Math.Vector.new(0, Murl.Math.PI, 0, 0))
self.mRotationAnim:ModifyKeyValue(1, Murl.Math.Vector.new(0, Murl.Math.HALF_PI, 0.5, 0))
self.mRotationAnim:ModifyKeyValue(2, Murl.Math.Vector.new(0, 0, 0, 0))
end
else
if (mIsShowingFront) then
self.mRotationAnim:ModifyKeyValue(0, Murl.Math.Vector.new(0, 0, 0, 0))
self.mRotationAnim:ModifyKeyValue(1, Murl.Math.Vector.new(0, Murl.Math.HALF_PI, 0.5, 0))
self.mRotationAnim:ModifyKeyValue(2, Murl.Math.Vector.new(0, Murl.Math.PI, 0, 0))
else
self.mRotationAnim:ModifyKeyValue(0, Murl.Math.Vector.new(0, Murl.Math.PI, 0, 0))
self.mRotationAnim:ModifyKeyValue(1, Murl.Math.Vector.new(0.5, Murl.Math.PI - 0.5, 0.5, 0))
self.mRotationAnim:ModifyKeyValue(2, Murl.Math.Vector.new(0, Murl.Math.PI, 0, 0))
end
end
self.mRotationAnim:ModifyKeyTime(1, duration / 2)
self.mRotationAnim:ModifyKeyTime(2, duration)
self.mRotationAnim:StartForward()
self.mIsShowingFront = showFront
end,
IsMoving = function (self)
return self.mPositionAnim:IsOrWasRunning()
end,
EnableButton = function (self, enable)
self.mButton:SetEnabled(enable)
end,
WasPressed = function (self)
return self.mButton:WasPressed()
end,
}
-- add this instance to the global card instances table
table.insert(mCards, logicIAppGraph)
return Murl.Logic.IAppGraph.new(logicIAppGraph)
This script is automatically created and processed when the corresponding graph node is loaded. The script should return a Logic.IAppGraph object.
- In the first section (line 4) the Lua parameters are evaluated. The Lua controller script gets exactly two parameters. The first parameter is the name (id) of the script resource and the second parameter is the name (id) of the controller node.
- In the second section (line 8) a lua function table is created. This functions act as callback functions and have the same meaning as the equally named C++
Logic::IAppGraphmethods. - In the third section (line 175) the function table is added to a global table
mCardsto allow the logic code to access the individual card instances. - Finally (line 177) an instance of the
Logic.IAppGraphclass is created and returned
The functions and variables of the logic.IAppGraph table correspond to the methods and member variables of the card_game_card_instance.cpp from Tutorial #03.
Script Processor
The logic processor instance is instantiated directly in the package.xml as already shown above.
-- Copyright 2014 Spraylight GmbH
-- Parameters for Logic IAppProcessor
local resourceId, replication = ...
-- print("\nLUA IAppProcessor new", resourceId, replication)
-- the global table holding all card instances
mCards = {}
CARDBACKSIDE_BLACK = 0
CARDBACKSIDE_RED = 1
-- Logic IAppProcessor callbacks
local logicIAppProcessor =
{
STATE_IDLE = 0,
STATE_DEAL = 1,
STATE_PLAY = 2,
mStateMachine = 0,
mCardsPerSuit = 13,
mCardSizeX = 90,
mCardSizeY = 130,
mScreenTimeline = Murl.Logic.TimelineNode.new(),
mGameInfoText = Murl.Logic.TextGeometryNode.new(),
mStackButton = Murl.Logic.ButtonNode.new(),
mRng = Murl.Util.TT800.new(),
mCardDistribution = Murl.UInt32Array.new(),
mCardsToDeal = Murl.SInt32Array.new(),
mCardStack = Murl.SInt32Array.new(),
mCardTray = Murl.SInt32Array.new(),
mPlayfield = Murl.SInt32Array.new(),
mGameStartTimeout = Murl.Logic.Timeframe.new(),
mGameEndTimeout = Murl.Logic.Timeframe.new(),
mDealCount = 0,
mNumberOfGamesPlayed = 0,
OnInit = function (self, state)
-- print("\nLUA IAppProcessor OnInit", resourceId)
state:GetLoader():UnloadPackage("startup")
local root = state:GetGraphRoot()
local processor = state:GetCurrentProcessor()
processor:AddGraphNode(self.mScreenTimeline:GetReference(root, "/game_screen/screen_timeline"))
processor:AddGraphNode(self.mGameInfoText:GetReference(root, "/game_screen/info_text"))
processor:AddGraphNode(self.mStackButton:GetReference(root, "/game_screen/stack_button"))
if (not processor:AreGraphNodesValid()) then
return false
end
self.mScreenTimeline:Start(0.0, 0.5)
processor:AddStepable(self.mGameStartTimeout:GetStepable())
processor:AddStepable(self.mGameEndTimeout:GetStepable())
return true
end,
OnDeInit = function (self, state)
-- print("\nLUA IAppProcessor OnDeInit", resourceId)
local ret = true
return ret
end,
OnProcessTick = function (self, state)
if (self.mScreenTimeline:WasRunning()) then
self:EnterDeal(state)
end
local deviceHandler = state:GetDeviceHandler()
if (deviceHandler:WasRawButtonPressed(Murl.RAWBUTTON_BACK)) then
deviceHandler:TerminateApp()
end
--print("State", self.mStateMachine)
if (self.mStateMachine == self.STATE_DEAL) then
self:ProcessTickDeal(state)
elseif (self.mStateMachine == self.STATE_PLAY) then
self:ProcessTickPlay(state)
end
end,
OnRunStateChanged = function (self, state, currentState, previousState)
-- print("\nLUA IAppProcessor OnRunStateChanged", resourceId)
if (self.mGameStartTimeout:IsOrWasRunning()) then
return
end
if (currentState == Murl.IEnums.APP_RUN_STATE_PAUSED) then
self.mGameInfoText:SetText("- Paused -")
if (self.mStateMachine == self.STATE_PLAY) then
self:UpdatePlayfield(0.0, true)
end
elseif (currentState == Murl.IEnums.APP_RUN_STATE_RUNNING) then
self.mGameInfoText:SetText("- Play -")
if (self.mStateMachine == self.STATE_PLAY) then
self:UpdatePlayfield(0.3, false)
end
end
end,
EnterDeal = function (self, state)
-- print("\nLUA IAppProcessor EnterDeal", resourceId)
self.mStateMachine = self.STATE_DEAL
self.mNumberOfGamesPlayed = self.mNumberOfGamesPlayed + 1
self:ShuffleCards(self.mNumberOfGamesPlayed % 3)
self.mDealCount = 0
self.mGameStartTimeout:Start(1.0)
self.mGameInfoText:SetText("")
end,
ProcessTickDeal = function (self, state)
-- print("LUA IAppProcessor ProcessTickDeal", resourceId)
if (self.mGameStartTimeout:IsRunning()) then
return
end
if (self.mCardsToDeal:GetCount() > 0) then
local index = self.mCardsToDeal:Pop()
local n = self.mCardStack:GetCount()
self.mCardStack:Add(index)
mCards[index + 1]:SetObtained(true)
mCards[index + 1]:SetSortDepth(n + 1)
mCards[index + 1]:SetCardPosition(self:GetStackPosition(n), false, 0)
mCards[index + 1]:EnableButton(false)
if ((self.mNumberOfGamesPlayed % 2) == 0) then
mCards[index + 1]:SetBack(CARDBACKSIDE_RED)
else
mCards[index + 1]:SetBack(CARDBACKSIDE_BLACK)
end
elseif (self.mDealCount < self.mPlayfield:GetCount()) then
local index = self.mCardStack:Pop()
local showFront = (self.mDealCount >= 18)
mCards[index + 1]:SetSortDepth(self.mDealCount + 1000)
mCards[index + 1]:MoveCardToPosition(self:GetPlayfieldPosition(self.mDealCount), showFront, 0.5)
mCards[index + 1]:EnableButton(showFront)
self.mPlayfield[self.mDealCount] = index
self.mGameStartTimeout:Start(0.1)
self.mDealCount = self.mDealCount + 1
else
self:MoveToTray(self.mCardStack:Pop())
self:UpdateStackButton()
self:EnterPlay(state)
end
end,
EnterPlay = function (self, state)
-- print("\nLUA IAppProcessor EnterPlay", resourceId)
self.mStateMachine = self.STATE_PLAY
self.mGameInfoText:SetText("- Play -")
end,
ProcessTickPlay = function (self, state)
-- print("LUA IAppProcessor ProcessTickPlay", resourceId)
if (self.mGameEndTimeout:IsRunning()) then
return
end
if (self.mGameEndTimeout:WasRunning()) then
self:EnterDeal(state)
return
end
local canAnyMoveToTray = false
local isPlayfieldEmpty = true
for i, index in Murl.ipairs(self.mPlayfield) do
if (index >= 0) then
isPlayfieldEmpty = false
if (mCards[index + 1].mIsShowingFront) then
local canMoveToTray = self:CanMoveToTray(index)
if (canMoveToTray) then
canAnyMoveToTray = true
end
if (mCards[index + 1]:WasPressed()) then
if (canMoveToTray) then
self:MoveToTray(index)
self.mPlayfield[i] = -1
self:UpdatePlayfield(0.3, false)
end
end
end
end
end
if (isPlayfieldEmpty) then
-- Pyramid complete
self.mGameInfoText:SetText("Congratulations!")
self.mGameEndTimeout:Start(3.0)
elseif (self.mCardStack:GetCount() > 0) then
if (self.mStackButton:WasPressed()) then
self:MoveToTray(self.mCardStack:Pop())
self:UpdateStackButton()
end
else
if (not canAnyMoveToTray) then
-- No more moves
self.mGameInfoText:SetText("Game Over")
self.mGameEndTimeout:Start(3.0)
end
end
end,
UpdateStackButton = function (self)
local additionalSizeX = self.mCardStack:GetCount() * 4
if (additionalSizeX > 0) then
self.mStackButton:SetScaleFactorX(self.mCardSizeX + additionalSizeX)
self.mStackButton:SetScaleFactorY(self.mCardSizeY + 4)
local position = self:GetStackPosition(0)
position.x = position.x + (additionalSizeX / 2)
self.mStackButton:GetTransformInterface():SetPosition(position)
end
end,
GetStackPosition = function (self, index)
local position = Murl.Math.Vector.new(Murl.Math.Vector.ZERO_POSITION)
position.x = -400 + (index * 4)
position.y = -260
return position
end,
GetTrayPosition = function (self, index)
local position = Murl.Math.Vector.new(Murl.Math.Vector.ZERO_POSITION)
position.x = 200 + (index * 2)
position.y = -260
return position
end,
GetPlayfieldPosition = function (self, index)
local position = Murl.Math.Vector.new(Murl.Math.Vector.ZERO_POSITION)
local DISTANCE_X = self.mCardSizeX + 10
local DISTANCE_Y = self.mCardSizeY - 50
if (index < 3) then
position.x = (index * 3) * DISTANCE_X - (6 * DISTANCE_X / 2)
position.y = DISTANCE_Y + DISTANCE_Y / 2
elseif (index < 9) then
position.x = (index - 3) * DISTANCE_X - (7 * DISTANCE_X / 2)
position.x = position.x + (Murl.Math.Floor((index - 3) / 2) * DISTANCE_X)
position.y = DISTANCE_Y / 2
elseif (index < 18) then
position.x = (index - 9) * DISTANCE_X - (8 * DISTANCE_X / 2)
position.y = -DISTANCE_Y / 2
else
position.x = (index - 18) * DISTANCE_X - (9 * DISTANCE_X / 2)
position.y = -DISTANCE_Y - DISTANCE_Y / 2
end
position.y = position.y + 100
return position
end,
IsCardFree = function (self, index)
-- Playfield index
-- 0 1 2
-- 3 4 5 6 7 8
-- 9 10 11 12 13 14 15 16 17
-- 18 19 20 21 22 23 24 25 26 27
local left = -1
if (index < 3) then
left = (index * 2) + 3
elseif (index < 9) then
left = (Murl.Math.Floor((index - 3) / 2)) + index + 6
elseif (index < 18) then
left = index + 9
end
local right = -1
if (left >= 0) then
right = left + 1
end
local free = true
if (left >= 0 and left < self.mPlayfield:GetCount()) then
if (self.mPlayfield[left] >= 0) then
free = false
end
end
if (right >= 0 and right < self.mPlayfield:GetCount()) then
if (self.mPlayfield[right] >= 0) then
free = false
end
end
return free
end,
CanMoveToTray = function (self, index)
local isValid = false
local trayCard = self.mCardTray:Top()
if (trayCard >= 4 * self.mCardsPerSuit or index >= 4 * self.mCardsPerSuit) then
-- Joker
isValid = true
else
local playCard = index % self.mCardsPerSuit
local trayCardPlus = (trayCard + 1) % self.mCardsPerSuit
local trayCardMinus = (trayCard + self.mCardsPerSuit - 1) % self.mCardsPerSuit
if (playCard == trayCardPlus or playCard == trayCardMinus) then
isValid = true
end
end
return isValid
end,
MoveToTray = function (self, index)
local n = self.mCardTray:GetCount()
self.mCardTray:Add(index)
mCards[index + 1]:SetSortDepth(n + 2000)
mCards[index + 1]:MoveCardToPosition(self:GetTrayPosition(n), true, 0.5)
mCards[index + 1]:EnableButton(false)
end,
UpdatePlayfield = function (self, duration, isPause)
for i, index in Murl.ipairs(self.mPlayfield) do
if (index >= 0) then
local isFree = false
if (not isPause) then
isFree = self:IsCardFree(i)
end
local card = mCards[index + 1]
card:SetSortDepth(i + 1000)
card:SetCardPosition(self:GetPlayfieldPosition(i), isFree, duration)
if (isFree) then
card:EnableButton(true)
end
end
end
end,
ShuffleCards = function (self, numberOfJokers)
for _, card in ipairs(mCards) do
card:SetObtained(false)
end
if (numberOfJokers > 2) then
numberOfJokers = 2
end
self.mCardDistribution:Empty()
self.mCardDistribution:SetCount(#mCards - 2 + numberOfJokers, 1)
self.mCardsToDeal:Empty()
for _ in Murl.ipairs(self.mCardDistribution) do
local index
index, self.mCardDistribution = self.mRng:DrawNoReplacement(self.mCardDistribution)
self.mCardsToDeal:Add(index)
end
self.mCardStack:Empty()
self.mCardTray:Empty()
self.mPlayfield:Empty()
self.mPlayfield:SetCount(28, -1)
end
}
return Murl.Logic.IAppProcessor.new(logicIAppProcessor)
This script is automatically loaded and processed when the corresponding resource package is loaded. The script should return an instance of the Logic.IAppProcessor class.
- In the first section (line 4) the parameters are evaluated. The Lua script gets exactly two parameters. The first parameter is the name of the script resource and the second parameter is the replication number.
- In the second section (line 14) a Lua function table is created. The functions act as callback functions and have the same meaning as the equally named C++ methods of the
Logic::IAppProcessorclass. - Finally (line 364) an instance of the
Logic.IAppProcessorclass is created and returned.
The functions and variables of the logicIAppProcessor table correspond to the methods and member variables of the card_game_logic.cpp from Tutorial #03.
The most obvious difference between the Lua implementation and the C++ implementation is the creation and initialization of the card instances, which in the Lua implementation occur automatically when the graph nodes are created.
Lua Card Game output window