matrix - español - ¿Unir fichas en Corona SDK en una palabra para una grilla de juego Breakout?

corona sdk tutorial

Question

Tengo un proyecto de juego para volver a implementar Breakout . Quiero mostrar dos palabras, cada palabra en una línea. Se les une el bloque de ladrillos. En el interior, la línea superior es el primer nombre, alineado a la izquierda. La línea inferior es el apellido, alineado a la derecha. Se ingresan desde cuadros de texto y se representan como se muestra:

Cada segundo que pasa, la pantalla agregará un número configurable de ladrillos a la cuadrícula (por ejemplo, cinco ladrillos por segundo) hasta que las dos palabras aparezcan completas. Mostré una letra del alfabeto que se crea a partir de la matriz (0,1).

... Pero no sé cómo unirlos en una sola palabra. ¿Cómo puedo unirme a estas cartas?

Esto es lo que he llegado hasta ahora:

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

El trabajo que he realizado hasta ahora (igual que el anterior) como una descarga externa: http://www.mediafire.com/download/1t89ftkbznkn184/Breakout2.rar

Answer 1

En aras de responder realmente la pregunta:

No estoy 100% seguro de lo que quieres decir con "¿Cómo puedo unir estas letras?", Pero al hurgar en el código tengo una conjetura, así que aclara si es correcto o si estoy equivocado acerca de lo que querías.

escenario 1

No ha logrado con éxito la imagen ilustrada en la captura de pantalla: ha podido dibujar una letra, pero no varias.

En este caso, deberá comprender mejor qué está haciendo su código. La función CreateBricksFromTable toma un objeto Level, que es creado por la función MakeLevel partir de una tabla con una propiedad de bricks , que es una tabla de tablas que representan filas con columnas en ellas, mostrando qué tipo de ladrillo debe estar en cada posición. En su nivel comentado, ha creado una tabla donde el campo de bricks contiene un campo para cada letra, pero la función MakeLevel todavía espera un campo de bricks que contenga directamente la cuadrícula de bloques. Tendrá que, como parece haber intentado, crear una función MakeWordLevel (o similar) que tome esta lista de letras y una palabra para cada línea, y construya una cuadrícula más grande copiando las letras apropiadas.

no es su tutor de programación, y una pregunta SO no es el foro adecuado para que las personas escriban código para usted o se familiaricen con los detalles paso a paso de cómo hacerlo, pero le dejaré un resumen básico. Su función se vería así:

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

Y luego tendría que:

• MakeLevel las mismas propiedades que MakeLevel
• Calcule qué tan ancho ( level.columns ) debe ser el nivel con todas las letras
• Cree una tabla en el mismo formato que las propiedades de los bricks , pero lo suficientemente grande como para contener todas las letras
• line1 cadenas de entrada ( line1 y line1 ), encuentre los datos de letras correctos de lo que ahora es la matriz test6 y copie esos datos en la tabla grande
• Asigne esa tabla como level.bricks

Esta pregunta ya está un poco fuera de lo que está destinado, ya que pregunta cómo implementar una función en lugar de lograr una tarea de programación pequeña y específica, por lo que cualquier seguimiento adicional debería tener lugar en una sala de chat, tal vez la sala Hello World Se útil.

Escenario 2:

Esta fue mi suposición original, pero después de considerar y leer ediciones pasadas, dudo que esto responda la pregunta correcta

Es posible que desee un "fondo" sólido de, digamos, bloques rojos, rodeando sus letras y convirtiendo el campo en un "muro" sólido, con el nombre en un color diferente. Y es posible que desee que estos ladrillos aparezcan lentamente de a pocos.

En ese caso, lo principal que debe hacer es realizar un seguimiento de qué espacios son "ocupados" por los ladrillos de nombre. Hay muchas formas de hacer esto, pero comenzaría con una matriz para hacer un seguimiento de eso, tan grande como el campo de juego final, lleno de 0. Luego, a medida que agrega los ladrillos para el nombre, establezca un 1 en la ubicación x, y en esa matriz de acuerdo con la coordenada de ese bloque.

Cuando desee completar el fondo, cada vez que vaya a agregar un bloque en una coordenada, verifique esa matriz "tomada" antes de intentar agregar un bloque; si está tomado (1), simplemente omítalo y pase al siguiente coordinar.

Esto funciona si está completando los bloques de fondo secuencialmente (por ejemplo, de izquierda a derecha, de arriba a abajo), o si desea agregarlos al azar. Con random, también querrá seguir actualizando la matriz "tomada" para que no intente agregar un bloque dos veces.

Sin embargo, el relleno aleatorio presenta su propio problema: seguirá llevándose más tiempo a medida que avanza, ya que encontrará más y más bloques "tomados" y tendrá que elegir uno nuevo. Hay soluciones para esto, por supuesto, pero no iré demasiado lejos por ese camino cuando no sé si eso es lo que quieres.

Answer 2

Realmente no entiendo (o leo, para el caso) su código, pero por lo que veo unirlos en palabras completas es fácil. Tienes dos posibilidades.

Puede "representarlos" directamente en su nivel / datos de visualización, simplemente cópielos en los lugares apropiados, de esta manera:

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

Guarda las letras en una tabla de búsqueda y luego las copia, pieza por pieza, a los datos de nivel. Aquí reemplacé los números con puntos y signos numéricos para hacerlo más bonito en la línea de comando.

Alternativamente, también puede "renderizar" las palabras en un búfer preparado y luego insertarlas en los datos de nivel utilizando la misma lógica.