Rejoignez les tuiles Corona SDK en un seul mot pour une grille de jeu Breakout ?

Question

J'ai un projet de jeu de ré-implémenter Breakout. Je veux afficher deux mots, chaque mot sur une ligne. Ils sont rejoints par le bloc de briques. À l'intérieur, la ligne du haut est le premier nom, aligné à gauche. La ligne de fond est que le nom de famille, aligné à droite. Ils sont d'entrée de zones de texte, et rendu comme indiqué:

Chaque seconde qui passe, l'écran ajouter un nombre configurable de briques à la grille (par exemple, cinq briques par seconde) jusqu'à ce que les deux mots s'affichent complet. J'ai affiché une lettre de l'alphabet qui est créé à partir de la matrice(0,1).

...Mais je ne sais pas comment les joindre en un seul mot. Comment puis-je adhérer à ces lettres?

C'est ce que j'ai obtenu jusqu'à présent:

Les briques.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

Niveaux.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

Le travail que j'ai fait jusqu'à présent (même que ci-dessus) comme un lien de téléchargement externe: http://www.mediafire.com/download/1t89ftkbznkn184/Breakout2.rar

Answer 1

Dans l'intérêt de répondre à la question:

Je ne suis pas 100% sûr de ce que tu veux dire par "Comment puis-je adhérer à ces lettres", mais de piquer à travers le code, j'ai une supposition, donc merci de préciser si elle est exacte ou si je me trompe sur ce que tu voulais.

Scénario 1

Vous n'avez pas réussi à atteindre l'image montre la capture d'écran, vous avez été en mesure de rédiger une lettre, mais pas plusieurs.

Dans ce cas, vous aurez besoin d'avoir une meilleure compréhension de ce que votre code est en train de faire. L' CreateBricksFromTable fonction prend en un objet de Niveau, qui est créé par l' MakeLevel fonction à partir d'une table avec un bricks de la propriété, qui est un tableau de tableaux qui représentent des lignes avec les colonnes en eux, montrant ce type de brique doit être à chaque position. Dans votre commenté de niveau, vous avez créé un tableau où l' bricks champ contient un champ pour chaque lettre, mais l' MakeLevel de la fonction s'attend à un bricks champ qui contient directement la grille de blocs. Vous aurez pour - comme il semble que vous avez tenté - créer un MakeWordLevel de la fonction (ou similaire) qui prend cette lettre la liste, et d'un mot de chaque ligne, et construit un réseau plus large par la copie des lettres.

StackOverflow n'est pas votre programmation tuteur, et DONC, la question n'est pas le bon forum pour avoir des gens d'écrire du code pour vous ou entrant dans l'étape par étape les détails de la façon de le faire, mais je vais vous laisser un schéma de base. Votre fonction ressemblerait à quelque chose comme ceci:

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

Et puis:

• Remplir toutes les mêmes propriétés que l' MakeLevel ne
• De calculer combien de large (level.columns) le niveau devrait être avec toutes les lettres
• Créer une table dans le même format que l' bricks propriétés, mais assez grand pour contenir toutes les lettres
• Aller à travers les chaînes d'entrée (line1 et line2), de trouver la bonne lettre de données à partir de ce qui est maintenant l' test6 tableau, et copier les données dans le tableau de grande taille
• Attribuer cette table en tant que level.bricks

Cette question est déjà un peu en dehors de ce que StackOverflow est prévu pour qu'il pose des questions sur la façon de mettre en œuvre une fonctionnalité plutôt que de réaliser une petite, une programmation spécifique de la tâche, de sorte que toute poursuite de suivi devrait avoir lieu dans un salon de discussion, peut - être le Hello World chambre serait utile.

Scénario 2:

C'était mon premier deviner, mais après examen et la lecture des dernières modifications, je doute, c'est de répondre à la bonne question

Vous voudrez peut-être un solide "arrière-plan" de, disons, les blocs rouges, autour de vos lettres et de rendre le champ en un solide "mur", avec le nom d'une couleur différente. Et vous souhaiterez ces briques lentement pour montrer un peu à la fois.

Dans ce cas, la principale chose que vous devez faire est de garder une trace de ce que les espaces sont "pris" par le nom de briques. Il y a beaucoup de façons de le faire, mais je voudrais commencer par une matrice de garder une trace de qui - aussi grand que le dernier terrain de jeu plein de 0. Puis, à mesure que vous ajoutez les briques pour le nom, mettre un 1 à la localisation x,y dans cette matrice en fonction de ce bloc de coordonnées.

Lorsque vous voulez remplir l'arrière-plan, chaque fois que vous allez à ajouter un bloc à coordonner, vérifier que les "prises" de la matrice avant d'essayer d'ajouter un bloc - si elle est prise (1), puis il suffit de sauter et aller à la prochaine coordonner.

Cela fonctionne si vous êtes le remplissage de l'arrière-plan des blocs de manière séquentielle (dire, de gauche à droite, de haut en bas), ou si vous souhaitez les ajouter au hasard. Au hasard, vous voulez également de garder la mise à jour de la "prise" de la matrice de sorte que vous n'essayez pas d'ajouter un bloc à deux reprises.

Le remplissage aléatoire, cependant, présente son propre problème, il va continuer à prendre plus de temps pour remplir comme il va, parce qu'il va trouver de plus en plus de "prise" de blocs et d'avoir à choisir un nouveau. Il y a des solutions, bien sûr, mais je ne vais pas aller trop loin dans cette voie quand je ne sais pas si c'est encore ce que vous voulez.

Answer 2

Je ne comprends pas vraiment (ou de lire) votre code, mais de ce que je vois à se joindre à eux dans les mots est facile. Vous avez deux possibilités.

Vous pouvez "rendu" directement dans votre niveau/affichage de données, il suffit de les copier dans les endroits appropriés, comme ceci:

-- 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

Vous vous sauver des lettres dans une table de recherche, puis les copier, morceau par morceau, au niveau des données. Ici j'ai remplacé le nombre de points et le nombre de signes pour le rendre plus joli sur la ligne de commande.

Alternativement, vous pouvez également "rendre" les mots dans un tampon, puis insérez-la dans le niveau de données en utilisant la même logique.