Kombinieren Sie Kacheln im Corona SDK zu einem Wort für ein Breakout-Spielraster?

Ich habe ein Spielprojekt, um Breakout neu zu implementieren . Ich möchte zwei Wörter anzeigen, jedes Wort in einer Zeile. Sie werden durch den Ziegelblock verbunden. Im Inneren ist die oberste Zeile der Vorname, links ausgerichtet. Die unterste Zeile ist der Nachname, rechts ausgerichtet. Sie werden aus Textfeldern eingegeben und wie folgt gerendert:

In jeder Sekunde, die vergeht, fügt der Bildschirm dem Raster eine konfigurierbare Anzahl von Steinen hinzu (z. B. fünf Steine ​​pro Sekunde), bis die beiden Wörter vollständig angezeigt werden. Ich habe einen Buchstaben des Alphabets angezeigt, der aus der Matrix (0,1) erstellt wurde.

... Aber ich weiß nicht, wie ich sie zu einem Wort zusammenfügen soll. Wie kann ich mich diesen Briefen anschließen?

Folgendes habe ich bisher erreicht:

Bricks.lua

local Bricks = display.newGroup() -- static object
local Events = require("Events")
local Levels = require("Levels")
local sound = require("Sound")
local physics = require("physics")
local Sprites = require("Sprites")
local Func = require("Func")


local brickSpriteData = 
{
    {
        name = "brick",
        frames = {Sprites.brick}
    },

    {
        name = "brick2",
        frames = {Sprites.brick2}
    },

    {
        name = "brick3",
        frames = {Sprites.brick3}
    },

}

-- animation table
local brickAnimations = {}

Sprites:CreateAnimationTable
{
    spriteData = brickSpriteData,
    animationTable = brickAnimations
}

-- get size from temp object for later use
local tempBrick = display.newImage('red_apple_20.png',300,500)
--local tempBrick = display.newImage('cheryGreen2.png',300,500)
local brickSize =
{
    width = tempBrick.width, 
    height = tempBrick.height
}
--tempBrick:removeSelf( )


----------------
-- Rubble -- needs to be moved to its own file
----------------

local rubbleSpriteData =
{
    {
        name = "rubble1",
        frames = {Sprites.rubble1}
    },

    {
        name = "rubble2",
        frames = {Sprites.rubble2}
    },

    {
        name = "rubble3",
        frames = {Sprites.rubble3}
    },

    {
        name = "rubble4",
        frames = {Sprites.rubble4}
    },

    {
        name = "rubble5",
        frames = {Sprites.rubble5}
    },

}

local rubbleAnimations = {}
Sprites:CreateAnimationTable
{
    spriteData = rubbleSpriteData,
    animationTable = rubbleAnimations
}

local totalBricksBroken = 0 -- used to track when level is complete
local totalBricksAtStart = 0

-- contains all brick objects
local bricks = {}


local function CreateBrick(data)

    -- random brick sprite
    local obj = display.newImage('red_apple_20.png')
    local objGreen = display.newImage('cheryGreen2.png')
    obj.name = "brick"
    obj.x = data.x --or display.contentCenterX
    obj.y = data.y --or 1000
    obj.brickType = data.brickType or 1
    obj.index = data.index

    function obj:Break()

        totalBricksBroken =  totalBricksBroken + 1
        bricks[self.index] = nil
        obj:removeSelf( )
        sound.play(sound.breakBrick)

    end

    function obj:Update()
        if(self == nil) then
            return
        end 

        if(self.y > display.contentHeight - 20) then
            obj:Break()
        end 
    end 
    if(obj.brickType ==1) then
        physics.addBody( obj, "static", {friction=0.5, bounce=0.5 } )
    elseif(obj.brickType == 2) then
        physics.addBody( objGreen,"static",{friction=0.2, bounce=0.5, density = 1 } )
    end 

    return obj
end

local currentLevel = testLevel
-- create level from bricks defined in an object
-- this allows for levels to be designed
local function CreateBricksFromTable(level)

    totalBricksAtStart = 0
    local activeBricksCount = 0
    for yi=1, #level.bricks do
        for xi=1, #level.bricks[yi] do
            -- create brick?
            if(level.bricks[yi][xi] > 0) then
                local xPos
                local yPos
                if(level.align == "center") then
                    --1100-((99*16)*0.5)
                    xPos = display.contentCenterX- ((level.columns * brickSize.width) * 0.5/3) + ((xi-1) * level.xSpace)--display.contentCenterX 
                    --xPos = 300 +(xi * level.xSpace)
                    yPos = 100 + (yi * level.ySpace)--100
                else
                    xPos = level.xStart + (xi * level.xSpace)
                    yPos = level.yStart + (yi * level.ySpace)
                end

                local brickData = 
                {
                    x = xPos,
                    y = yPos,
                    brickType = level.bricks[yi][xi],
                    index = activeBricksCount+1
                }
                bricks[activeBricksCount+1] = CreateBrick(brickData)

                activeBricksCount = activeBricksCount + 1

            end

        end 

    end

    totalBricks = activeBricksCount
    totalBricksAtStart = activeBricksCount


end

-- create bricks for level --> set from above functions, change function to change brick build type
local CreateAllBricks = CreateBricksFromTable
-- called by a timer so I can pass arguments to CreateAllBricks
local function CreateAllBricksTimerCall()
    CreateAllBricks(Levels.currentLevel)
end 
-- remove all brick objects from memory
local function ClearBricks()

    for i=1, #bricks do
        bricks[i] = nil
    end

end
-- stuff run on enterFrame event
function Bricks:Update()

-- update individual bricks
    if(totalBricksAtStart > 0) then
        for i=1, totalBricksAtStart do
            -- brick exists?
            if(bricks[i]) then
                bricks[i]:Update()
            end 
        end 
    end
    -- is level over?
    if(totalBricksBroken == totalBricks) then
        Events.allBricksBroken:Dispatch()
    end

end
----------------
-- Events
----------------
function Bricks:allBricksBroken(event)
    -- cleanup bricks
    ClearBricks()
    local t = timer.performWithDelay( 1000, CreateAllBricksTimerCall)
    --CreateAllBricks()
    totalBricksBroken = 0       

    -- play happy sound for player to enjoy
    sound.play(sound.win)

    print("You Win!")
end
Events.allBricksBroken:AddObject(Bricks)
CreateAllBricks(Levels.currentLevel)
return Bricks

Levels.lua

local Events = require("Events")
local Levels = {}
local function MakeLevel(data)
    local level = {}
    level.xStart = data.xStart or 100
    level.yStart = data.yStart or 100
    level.xSpace = data.xSpace or 23
    level.ySpace = data.ySpace or 23
    level.align = data.align or "center"
    level.columns = data.columns or #data.bricks[1]
    level.bricks = data.bricks --> required
    return level
end
Levels.test4 = MakeLevel
{
    bricks =
    {
        {0,2,0,0,2,0,0,2,0},
        {0,0,2,0,2,0,2,0,0},
        {0,0,0,0,2,0,0,0,0},
        {1,1,2,1,1,1,2,1,1},
        {0,0,0,0,1,0,0,0,0},
        {0,0,0,0,1,0,0,0,0},
        {0,0,0,0,1,0,0,0,0},
    }
}

Levels.test5 = MakeLevel
{
    bricks =
    {       
                    {0,0,0,1,0,0,0,0},
                     {0,0,1,0,1,0,0,0},
                     {0,0,1,0,1,0,0,0},
                     {0,1,0,0,0,1,0,0},
                     {0,1,1,1,1,1,0,0},
                     {1,0,0,0,0,0,1,0},
                     {1,0,0,0,0,0,1,0},
                     {1,0,0,0,0,0,1,0},
                     {1,0,0,0,0,0,1,0}
    }
}
-- Levels.test6 = MakeLevel2
-- {
--  bricks =
--  {
----A         "a" = {{0,0,0,1,0,0,0,0},
--                   {0,0,1,0,1,0,0,0},
--                   {0,0,1,0,1,0,0,0},
--                   {0,1,0,0,0,1,0,0},
--                   {0,1,1,1,1,1,0,0},
--                   {1,0,0,0,0,0,1,0},
--                   {1,0,0,0,0,0,1,0},
--                   {1,0,0,0,0,0,1,0},
--                   {1,0,0,0,0,0,1,0}},
----B
--            "b" = {{1,1,1,1,0,0,0},
--                   {1,0,0,0,1,0,0},
--                   {1,0,0,0,1,0,0},
--                   {1,0,0,0,1,0,0},
--                   {1,1,1,1,0,0,0},
--                   {1,0,0,0,1,0,0},
--                   {1,0,0,0,0,1,0},
--                   {1,0,0,0,0,1,0},
--                   {1,1,1,1,1,0,0}},
--...........
--.......
--...
-- --Z
--             "z"= {{1,1,1,1,1,1,1,0},
--                   {0,0,0,0,0,1,0,0},
--                   {0,0,0,0,1,0,0,0},
--                   {0,0,0,0,1,0,0,0},
--                   {0,0,0,1,0,0,0,0},
--                   {0,0,1,0,0,0,0,0},
--                   {0,0,1,0,0,0,0,0},
--                   {0,1,0,0,0,0,0,0},
--                   {1,1,1,1,1,1,1,0}} 
--  }
-- }
-- stores all levels in ordered table so that one can be selected randomly by index
Levels.levels = 
{
    --Levels.test4,
     Levels.test5
    -- Levels.test6,
}
function Levels:GetRandomLevel()
    return self.levels[math.random(#Levels.levels)]
end
Levels.notPlayedYet = {}
Levels.currentLevel = Levels:GetRandomLevel()
-- Events
function Levels:allBricksBroken(event)
    self.currentLevel = Levels:GetRandomLevel()
end
Events.allBricksBroken:AddObject(Levels)
return Levels

Die Arbeit, die ich bisher (wie oben) als externer Download geleistet habe: http://www.mediafire.com/download/1t89ftkbznkn184/Breakout2.rar

Im Interesse der tatsächlichen Beantwortung der Frage:

Ich bin mir nicht 100% sicher, was Sie unter "Wie kann ich diese Buchstaben verbinden" verstehen, aber wenn ich den Code durchblättere, habe ich eine Vermutung. Bitte klären Sie, ob er korrekt ist oder ob ich mich in Bezug auf Ihre Wünsche irre.

Szenario 1

Sie haben das im Screenshot dargestellte Bild nicht erfolgreich erreicht - Sie konnten einen Buchstaben zeichnen, aber nicht mehrere.

In diesem Fall müssen Sie besser verstehen, was Ihr Code tut. Die CreateBricksFromTableFunktion nimmt ein Level-Objekt auf, das von der MakeLevelFunktion aus einer Tabelle mit einer bricksEigenschaft erstellt wird. Hierbei handelt es sich um eine Tabelle mit Tabellen, die Zeilen mit Spalten darstellen und angeben, welcher Ziegelsteintyp an jeder Position vorhanden sein soll. In Ihrer auskommentierten Ebene haben Sie eine Tabelle erstellt, in der das bricksFeld ein Feld für jeden Buchstaben enthält. Die MakeLevelFunktion erwartet jedoch weiterhin ein bricksFeld, das direkt das Blockraster enthält. Sie müssen - wie Sie anscheinend versucht haben - eine MakeWordLevelFunktion (oder dergleichen) erstellen , die diese Buchstabenliste und ein Wort für jede Zeile verwendet und ein größeres Raster erstellt, indem Sie die entsprechenden Buchstaben in diese Zeile kopieren.

StackOverflow ist nicht Ihr Programmier-Tutor, und eine SO-Frage ist nicht das richtige Forum, um Leute dazu zu bringen, Code für Sie zu schreiben oder schrittweise zu erfahren, wie dies zu tun ist, aber ich werde Ihnen einen grundlegenden Überblick geben. Ihre Funktion würde ungefähr so ​​aussehen:

local function MakeWordLevel(data, line1, line2)
    local level = {}
    ...
    return level
end

Und dann müsste:

• Füllen Sie alle gleichen Eigenschaften aus, die MakeLeveldies tun
• Berechnen Sie, wie breit ( level.columns) die Ebene mit allen Buchstaben sein soll
• Erstellen Sie eine Tabelle im gleichen Format wie die bricksEigenschaften, aber groß genug, um alle Buchstaben aufzunehmen
• Gehen Sie die Eingabezeichenfolgen ( line1und line2) durch, suchen Sie die richtigen Buchstabendaten aus dem heutigen test6Array und kopieren Sie diese Daten in die große Tabelle
• Weisen Sie diese Tabelle als zu level.bricks

Diese Frage liegt bereits etwas außerhalb dessen, wofür StackOverflow gedacht ist, da sie fragt, wie eine Funktion implementiert werden soll, anstatt eine kleine, spezifische Programmieraufgabe zu erfüllen. Daher sollte jede weitere Nachverfolgung in einem Chatroom stattfinden - vielleicht im Hello World- Raum sei hilfreich.

Szenario 2:

Dies war meine ursprüngliche Vermutung, aber nachdem ich frühere Änderungen berücksichtigt und gelesen habe, bezweifle ich, dass dies die richtige Frage beantwortet

Möglicherweise möchten Sie einen festen "Hintergrund" aus beispielsweise roten Blöcken, der Ihre Buchstaben umgibt und das Feld zu einer festen "Wand" macht, deren Name eine andere Farbe hat. Und vielleicht möchten Sie, dass diese Steine ​​langsam einige auf einmal auftauchen.

In diesem Fall müssen Sie hauptsächlich nachverfolgen, welche Leerzeichen von den Namensbausteinen "eingenommen" werden. Es gibt viele Möglichkeiten, dies zu tun, aber ich würde mit einer Matrix beginnen, um den Überblick zu behalten - so groß wie das endgültige Spielfeld - voller Nullen. Wenn Sie dann die Steine ​​für den Namen hinzufügen, setzen Sie eine 1 an der x, y-Position in dieser Matrix entsprechend der Koordinate dieses Blocks.

Wenn Sie den Hintergrund ausfüllen möchten, überprüfen Sie jedes Mal, wenn Sie einen Block an einer Koordinate hinzufügen, diese "genommene" Matrix, bevor Sie versuchen, einen Block hinzuzufügen. Wenn er genommen ist (1), überspringen Sie ihn einfach und fahren Sie mit dem nächsten fort Koordinate.

Dies funktioniert, wenn Sie die Hintergrundblöcke nacheinander ausfüllen (z. B. von links nach rechts, von oben nach unten) oder wenn Sie sie zufällig hinzufügen möchten. Mit random möchten Sie auch die "genommene" Matrix weiter aktualisieren, damit Sie nicht zweimal versuchen, einen Block hinzuzufügen.

Das zufällige Ausfüllen stellt jedoch ein eigenes Problem dar - das Ausfüllen dauert im Laufe der Zeit immer länger, da immer mehr "genommene" Blöcke gefunden werden und ein neuer ausgewählt werden muss. Es gibt natürlich Lösungen dafür, aber ich werde diesen Weg nicht zu weit gehen, wenn ich nicht weiß, ob Sie das überhaupt wollen.

Ich verstehe Ihren Code nicht wirklich (oder lese ihn auch nicht), aber von dem, was ich sehe, ist es einfach, sie zu vollständigen Wörtern zusammenzufügen. Sie haben zwei Möglichkeiten.

Sie können sie direkt in Ihre Level- / Anzeigedaten "rendern", indem Sie sie einfach an die entsprechenden Stellen kopieren, wie folgt:

-- The level data.
local level = {}

-- Create the level data.
for row = 1, 25, 1 do
    local rowData = {}

    for column = 1, 80, 1 do
        rowData[column] = "."
    end

    level[row] = rowData
end

-- Now let us setup the letters.
local letters = {
    A = {
        {".",".",".","#",".",".",".","."},
        {".",".","#",".","#",".",".","."},
        {".",".","#",".","#",".",".","."},
        {".","#",".",".",".","#",".","."},
        {".","#","#","#","#","#",".","."},
        {"#",".",".",".",".",".","#","."},
        {"#",".",".",".",".",".","#","."},
        {"#",".",".",".",".",".","#","."},
        {"#",".",".",".",".",".","#","."}
    },
    B = {
        {"#","#","#","#",".",".","."},
        {"#",".",".",".","#",".","."},
        {"#",".",".",".","#",".","."},
        {"#",".",".",".","#",".","."},
        {"#","#","#","#",".",".","."},
        {"#",".",".",".","#",".","."},
        {"#",".",".",".",".","#","."},
        {"#",".",".",".",".","#","."},
        {"#","#","#","#","#",".","."}
    }
}

-- The string to print.
local text = "ABBA"

-- Let us insert the data into the level data.
for index = 1, #text, 1 do
    local char = string.sub(text, index, index)
    local charData = letters[char]

    local offset = index * 7

    for row = 1, 9, 1 do
        local rowData = charData[row]

        for column = 1, 7, 1 do
            level[row][offset + column] = rowData[column]
        end
    end
end

-- Print everything
for row = 1, 25, 1 do
    local rowData = level[row]

    for column = 1, 80, 1 do
        io.write(rowData[column])
    end
    print()

end

Sie speichern Ihre Briefe in einer Nachschlagetabelle und kopieren sie dann Stück für Stück in die Level-Daten. Hier habe ich die Zahlen durch Punkte und Zahlenzeichen ersetzt, um sie in der Befehlszeile schöner zu machen.

Alternativ dazu können Sie die Wörter auch in einen vorbereiteten Puffer "rendern" und diese dann mit derselben Logik in die Level-Daten einfügen.