fbpx

Тетрис нарийвчлалын тоглоомын анхны хувилбарыг 1984 онд Советын Холбооны Энгийн Байгууламж, Алексей Пажитнов гэх ухаантай хамтран гаргасан. Уг тоглоомыг компьютер дээр тоглож болдог байсан бөгөөд, бүх аппаратуудад, операцион систем дээр суурьлуулагдаж, хэрэглэгчидийн анхан шатны дэмжлэгт тулгуурласан.

Тетрис нь хэдэн шошгоос тоглоход бэлэн тайван болохгүй зургуудыг тэгээгч нь зарлаж, олон баганаас бүрдэх хүчтэй нэг шошгоор хэрэглэгчид тэдгээр зургуудыг зайлшгүйгээр байрлуулдаг. Зургууд дарааллаж байрлуулалт хийгдэхэд, хэрэв зургуудыг зайлшгүйгээр байрлуулах боломжгүй болсон, уг баганы доод талын бөмбөгийг хамгийн доод дарааллаар тэмдэглэж өгч, тэмдгүүдээр илэрхийлэгдсэн.

Тоглогчид ажилтай үйл ажиллагаагаар зургуудыг бага багаар бариж, тэдгээрийг зүүн эсвэл баруун тийш гүйлгээх боломжтой. Зургууд байрлалыг шулуунаар шилжүүлж, буланд байрлуулах боломжтой бөгөөд, хэрэв зургуудыг бүгдээр нь олон доод дээр дуусталдах боломжгүй болсон, тоглогчид түүнийг буцаж байрлуулж болно.

Тетрисийн үйл ажиллагаагаар тоглогчид оноо авч, үргэлжлээ хэрэглээний чиглэлийг баримтлан байрлуулснаар оноог нэмэгдүүлж болно. Тоглогчид ихэвчлэн хэрэглээний дээд бүлэгт танилцагч гэж үзэгдэнэ.

Тэдгээр нь зарим анхан шатны байгууллагуудад уг тоглоомыг оролцуулахад хэрэглэдэг, түүнийг өөрийн аппарат, смартфон, компьютер дээр байршуулах эрхтэй компаниуд, татаж авч болох хэмжээнд тоглож болдог. Түүнийг сонирхсон шаардлагатай гар утасны аппаратууд, таблет, игрэн тоглоомын консол зэрэг утаснуудад байршуулж болох боломжтой.

Тетрис тоглоомын формат нь үндсэндээ нэгэн зургууд барилга, танхимыг бүгдээрээ хийж, олон хүн хамтдаа тоглох, харьцангуй байж болно. Үүнийг ашиглан бага багаар тэдгээрийг хамтдаа тоглож, тэдгээрийг хамгийн их оноотой тоглож болно.

Тетрис нь халдлагатай, дотоод шийдэлтэй, бэлэн зургуудыг ойлгож, хэрэглэгчдэд тохиромжтой, байгалийн хугацаанд бий болсон нарийвчлалын тоглоом юм. Түүний ойлголт, зэрэгцээ дэлхийн олон тоглоом хөгжүүлэгчид нь хөгжүүлж, тоглоомын ажлыг үргэлжлүүлж байна.

small basic code

GraphicsWindow.KeyDown = HandleKey
GraphicsWindow.BackgroundColor = GraphicsWindow.GetColorFromRGB( 253, 252, 251 )

While “True”
BOXES = 4 ‘ number of boxes per piece
BWIDTH = 25 ‘ box width in pixels
XOFFSET = 40 ‘ Screen X offset in pixels of where the board starts
YOFFSET = 40 ‘ Screen Y offset in pixels of where the board starts
CWIDTH = 10 ‘ Canvas Width, in number of boxes
CHEIGHT = 20 ‘ Canvas Height, in number of boxes.
STARTDELAY = 800
ENDDELAY = 175
PREVIEW_xpos = 13
PREVIEW_ypos = 2

GraphicsWindow.Clear()
GraphicsWindow.Title = “Small Basic Tetris”
GraphicsWindow.Height = 580
GraphicsWindow.Width = 700
GraphicsWindow.Show()

SetupTemplates()
SetupCanvas()
MainLoop()

GraphicsWindow.ShowMessage( “Game Over”, “Small Basic Tetris” )
EndWhile

Sub MainLoop
template = Text.Append(“template”, Math.GetRandomNumber(7))

CreatePiece() ‘ in: template ret: h
nextPiece = h

end = 0
sessionDelay = STARTDELAY
While end = 0
If sessionDelay > ENDDELAY Then
sessionDelay = sessionDelay – 1
EndIf

delay = sessionDelay

thisPiece = nextPiece

template = Text.Append(“template”, Math.GetRandomNumber(7))


CreatePiece() ‘ in: template ret: h
nextPiece = h
DrawPreviewPiece()

h = thisPiece

ypos = 0
done = 0
xpos = 3 ‘ always drop from column 3
CheckStop() ‘ in: ypos, xpos, h ret: done
If done = 1 Then
ypos = ypos – 1
MovePiece() ‘in: ypos, xpos, h
end = 1
EndIf

yposdelta = 0
While done = 0 Or yposdelta > 0
MovePiece() ‘in: ypos, xpos, h

‘ Delay, but break if the delay get set to 0 if the piece gets dropped
delayIndex = delay
While delayIndex > 0 And delay > 0
Program.Delay(10)
delayIndex = delayIndex – 10
EndWhile

If yposdelta > 0 Then
yposdelta = yposdelta – 1 ‘ used to create freespin, when the piece is rotated
Else
ypos = ypos + 1 ‘ otherwise, move the piece down.
EndIf

‘ Check if the piece should stop.
CheckStop() ‘ in: ypos, xpos, h ret: done
EndWhile
EndWhile
EndSub


Sub HandleKey
‘ Stop game
If GraphicsWindow.LastKey = “Escape” Then
Program.End()
EndIf

‘ Move piece left
If GraphicsWindow.LastKey = “Left” Then
moveDirection = -1
ValidateMove() ‘ in: ypos, xpos, h, moveDirection ret: invalidMove = 1 or -1 or 2 if move is invalid, otherwise 0
If invalidMove = 0 Then
xpos = xpos + moveDirection
EndIf
MovePiece() ‘in: ypos, xpos, h
EndIf

‘ Move piece right
If GraphicsWindow.LastKey = “Right” Then
moveDirection = 1
ValidateMove() ‘ in: ypos, xpos, h, moveDirection ret: invalidMove = 1 or -1 or 2 if move is invalid, otherwise 0
If invalidMove = 0 Then
xpos = xpos + moveDirection
EndIf
MovePiece() ‘in: ypos, xpos, h
EndIf

‘ Move piece down
If GraphicsWindow.LastKey = “Down” or GraphicsWindow.LastKey = “Space” Then
delay = 0
EndIf

‘ Rotate piece
If GraphicsWindow.LastKey = “Up” Then
basetemplate = Array.GetValue(h, -1) ‘ Array.GetValue(h, -1) = the template name
template = “temptemplate”
rotation = “CW”
CopyPiece() ‘in basetemplate, template, rotation

Array.SetValue(h, -1, template) ‘ Array.GetValue(h, -1) = the template name
moveDirection = 0
ValidateMove() ‘ in: ypos, xpos, h, moveDirection ret: invalidMove = 1 or -1 or 2 if move is invalid, otherwise 0

‘ See if it can be moved so that it will rotate.
xposbk = xpos
yposdelta = 0
While yposdelta = 0 And Math.Abs(xposbk – xpos) < 3 ‘ move up to 3 times only

‘ if the rotation move worked, copy the temp to “rotatedtemplate” and use that from now on
If invalidMove = 0 Then
basetemplate = template
template = “rotatedtemplate”
Array.SetValue(h, -1, template) ‘ Array.GetValue(h, -1) = the template name
rotation = “COPY”
CopyPiece() ‘in basetemplate, template, rotation
yposdelta = 1 ‘ Don’t move down if we rotate
MovePiece() ‘in: ypos, xpos, h
ElseIf invalidMove = 2 Then
‘ Don’t support shifting piece when hitting another piece to the right or left.
xpos = 99 ‘ exit the loop
Else
‘ if the rotated piece can’t be placed, move it left or right and try again.
xpos = xpos – invalidMove
ValidateMove() ‘ in: ypos, xpos, h, moveDirection ret: invalidMove = 1 or -1 or 2 if move is invalid, otherwise 0
EndIf
EndWhile

If invalidMove <> 0 Then
xpos = xposbk
Array.SetValue(h, -1, basetemplate) ‘ Array.GetValue(h, -1) = the template name
template = “”
EndIf
EndIf
EndSub


Sub DrawPreviewPiece
xpos = PREVIEW_xpos
ypos = PREVIEW_ypos
h = nextPiece

XOFFSETBK = XOFFSET
YOFFSETBK = YOFFSET
XOFFSET = XOFFSET + Array.GetValue(Array.GetValue(h, -1), “pviewx”) ‘ Array.GetValue(h, -1) = the template name
YOFFSET = YOFFSET + Array.GetValue(Array.GetValue(h, -1), “pviewy”) ‘ Array.GetValue(h, -1) = the template name
MovePiece() ‘in: ypos, xpos, h

XOFFSET = XOFFSETBK
YOFFSET = YOFFSETBK

EndSub


‘ creates template that’s a rotated basetemplate
Sub CopyPiece ‘in basetemplate, template, rotation
L = Array.GetValue(basetemplate, “dim”)

If rotation = “CW” Then
For i = 0 to BOXES – 1 ‘ x’ = y y’ = L – 1 – x
v = Array.GetValue(basetemplate, i)

‘x = Math.Floor(v/10)
‘y = Math.Remainder(v, 10)

‘ new x and y
x = (Math.Remainder(v, 10))
y = (L – 1 – Math.Floor(v/10))
Array.SetValue(template, i, x * 10 + y)
EndFor
‘ Count-Cockwise is not currently used
ElseIf rotation = “CCW” Then
For i = 0 to BOXES – 1 ‘ x’ = L – 1 – y y’ = x
v = Array.GetValue(basetemplate, i)
‘x = Math.Floor(v/10)
‘y = Math.Remainder(v, 10)

‘ new x and y
x = (L – 1 – Math.Remainder(v, 10))
y = Math.Floor(v/10)
Array.SetValue(template, i, x * 10 + y)
EndFor
ElseIf rotation = “COPY” Then
For i = 0 to BOXES – 1
Array.SetValue(template, i, Array.GetValue(basetemplate, i))
EndFor
Else
GraphicsWindow.ShowMessage(“invalid parameter”, “Error”)
Program.End()
EndIf

‘ Copy the remain properties from basetemplate to template.
Array.SetValue(template, “color”, Array.GetValue(basetemplate, “color”))
Array.SetValue(template, “dim”, Array.GetValue(basetemplate, “dim”))
Array.SetValue(template, “pviewx”, Array.GetValue(basetemplate, “pviewx”))
Array.SetValue(template, “pviewy”, Array.GetValue(basetemplate, “pviewy”))
EndSub


Sub CreatePiece ‘ in: template ret: h
‘ Create a new handle, representing an arrayName, that will represent the piece
hcount = hcount + 1
h = Text.Append(“piece”, hcount)

Array.SetValue(h, -1, template) ‘ Array.GetValue(h, -1) = the template name

GraphicsWindow.PenWidth = 1
GraphicsWindow.PenColor = “Black”
GraphicsWindow.BrushColor = Array.GetValue(template, “color”)

For i = 0 to BOXES – 1
s = Shapes.AddRectangle(BWIDTH, BWIDTH)
Shapes.Move(s, -BWIDTH, -BWIDTH) ‘ move off screen
Array.SetValue(h, i, s)
EndFor
EndSub

Sub MovePiece ‘in: ypos, xpos, h. ypos/xpos is 0-19, representing the top/left box coordinate of the piece on the canvas. h returned by CreatePiece
For i = 0 to BOXES – 1
v = Array.GetValue(Array.GetValue(h, -1), i) ‘ Array.GetValue(h, -1) = the template name
x = Math.Floor(v/10)
y = Math.Remainder(v, 10)

‘ Array.GetValue(h, i) = box for piece h.
‘ xpos/ypos = are topleft of shape. x/y is the box offset within the shape.
Shapes.Move(Array.GetValue(h, i), XOFFSET + xpos * BWIDTH + x * BWIDTH, YOFFSET + ypos * BWIDTH + y * BWIDTH)
EndFor
EndSub


Sub ValidateMove ‘ in: ypos, xpos, h, moveDirection ret: invalidMove = 1 or -1 or 2 if move is invalid, otherwise 0
i = 0
invalidMove = 0
While i < BOXES
v = Array.GetValue(Array.GetValue(h, -1), i) ‘ Array.GetValue(h, -1) = the template name

‘x/y is the box offset within the shape.
x = Math.Floor(v/10)
y = Math.Remainder(v, 10)

If (x + xpos + moveDirection) < 0 Then
invalidMove = -1
i = BOXES ‘ force getting out of the loop
EndIf

If (x + xpos + moveDirection) >= CWIDTH Then
invalidMove = 1
i = BOXES ‘ force getting out of the loop
EndIf

If Array.GetValue(“c”, (x + xpos + moveDirection) + (y + ypos) * CWIDTH) <> “.” Then
invalidMove = 2
i = BOXES ‘ force getting out of the loop
EndIf

i = i + 1
EndWhile
EndSub


Sub CheckStop ‘ in: ypos, xpos, h ret: done
done = 0
i = 0
While i < BOXES
v = Array.GetValue(Array.GetValue(h, -1), i) ‘ Array.GetValue(h, -1) = the template name

‘x/y is the box offset within the shape.
x = Math.Floor(v/10)
y = Math.Remainder(v, 10)

If y + ypos > CHEIGHT Or Array.GetValue(“c”, (x + xpos) + (y + ypos) * CWIDTH) <> “.” Then
done = 1
i = BOXES ‘ force getting out of the loop
EndIf

i = i + 1
EndWhile

‘ If we need to stop the piece, move the box handles to the canvas
If done = 1 Then
For i = 0 to BOXES – 1
v = Array.GetValue(Array.GetValue(h, -1), i) ‘ Array.GetValue(h, -1) = the template name
‘x = Math.Floor(v/10)
‘y = Math.Remainder(v, 10)
Array.SetValue(“c”, (Math.Floor(v/10) + xpos) + (Math.Remainder(v, 10) + ypos – 1) * CWIDTH, Array.GetValue(h, i))
EndFor

‘ 1 points for every piece successfully dropped
score = score + 1
PrintScore()

‘ Delete clared lines
DeleteLines()
EndIf
EndSub


Sub DeleteLines
linesCleared = 0

‘ Iterate over each row, starting from the bottom
For y = CHEIGHT – 1 to 0 Step -1

‘ Check to see if the whole row is filled
x = CWIDTH
While x = CWIDTH
x = 0
While x < CWIDTH
piece = Array.GetValue(“c”, x + y * CWIDTH)
If piece = “.” then
x = CWIDTH
EndIf
x = x + 1
EndWhile

‘ if non of them were empty (i.e “.”), then remove the line.
If x = CWIDTH Then

‘ Delete the line
For x1 = 0 to CWIDTH – 1
Shapes.Remove(Array.GetValue(“c”, x1 + y * CWIDTH))
EndFor
linesCleared = linesCleared + 1

‘ Move everything else down one.
For y1 = y To 1 Step -1
For x1 = 0 to CWIDTH – 1
piece = Array.GetValue(“c”, x1 + (y1 – 1) * CWIDTH)
Array.SetValue(“c”, x1 + y1 * CWIDTH, piece)
Shapes.Move(piece, Shapes.GetLeft(piece), Shapes.GetTop(piece) + BWIDTH)
EndFor
EndFor
EndIf
EndWhile
EndFor

If linesCleared > 0 Then
score = score + 100 * Math.Round(linesCleared * 2.15 – 1)
PrintScore()
EndIf
EndSub

Sub SetupCanvas
‘ GraphicsWindow.DrawResizedImage( Flickr.GetRandomPicture( “bricks” ), 0, 0, GraphicsWindow.Width, GraphicsWindow.Height)


GraphicsWindow.BrushColor = GraphicsWindow.BackgroundColor
GraphicsWindow.FillRectangle(XOFFSET, YOFFSET, CWIDTH*BWIDTH, CHEIGHT*BWIDTH)

Program.Delay(200)
GraphicsWindow.PenWidth = 1
GraphicsWindow.PenColor = “Pink”
For x = 0 To CWIDTH-1
For y = 0 To CHEIGHT-1
Array.SetValue(“c”, x + y * CWIDTH, “.”) ‘ “.” indicates spot is free
GraphicsWindow.DrawRectangle(XOFFSET + x * BWIDTH, YOFFSET + y * BWIDTH, BWIDTH, BWIDTH)
EndFor
EndFor

GraphicsWindow.PenWidth = 4
GraphicsWindow.PenColor = “Black”
GraphicsWindow.DrawLine(XOFFSET, YOFFSET, XOFFSET, YOFFSET + CHEIGHT*BWIDTH)
GraphicsWindow.DrawLine(XOFFSET + CWIDTH*BWIDTH, YOFFSET, XOFFSET + CWIDTH*BWIDTH, YOFFSET + CHEIGHT*BWIDTH)
GraphicsWindow.DrawLine(XOFFSET, YOFFSET + CHEIGHT*BWIDTH, XOFFSET + CWIDTH*BWIDTH, YOFFSET + CHEIGHT*BWIDTH)

GraphicsWindow.PenColor = “Lime”
GraphicsWindow.DrawLine(XOFFSET – 4, YOFFSET, XOFFSET – 4, YOFFSET + CHEIGHT*BWIDTH + 6)
GraphicsWindow.DrawLine(XOFFSET + CWIDTH*BWIDTH + 4, YOFFSET, XOFFSET + CWIDTH*BWIDTH + 4, YOFFSET + CHEIGHT*BWIDTH + 6)
GraphicsWindow.DrawLine(XOFFSET – 4, YOFFSET + CHEIGHT*BWIDTH + 4, XOFFSET + CWIDTH*BWIDTH + 4, YOFFSET + CHEIGHT*BWIDTH + 4)

GraphicsWindow.PenColor = “Black”
GraphicsWindow.BrushColor = “Pink”
x = XOFFSET + PREVIEW_xpos * BWIDTH – BWIDTH
y = YOFFSET + PREVIEW_ypos * BWIDTH – BWIDTH
GraphicsWindow.FillRectangle(x, y, BWIDTH * 5, BWIDTH * 6)
GraphicsWindow.DrawRectangle(x, y, BWIDTH * 5, BWIDTH * 6)

GraphicsWindow.FillRectangle(x – 20, y + 190, 310, 170)
GraphicsWindow.DrawRectangle(x – 20, y + 190, 310, 170)

GraphicsWindow.BrushColor = “Black”
GraphicsWindow.FontItalic = “False”
GraphicsWindow.FontName = “Comic Sans MS”
GraphicsWindow.FontSize = 16
GraphicsWindow.DrawText(x, y + 200, “Game control keys:”)
GraphicsWindow.DrawText(x + 25, y + 220, “Left Arrow = Move piece left”)
GraphicsWindow.DrawText(x + 25, y + 240, “Right Arrow = Move piece right”)
GraphicsWindow.DrawText(x + 25, y + 260, “Up Arrow = Rotate piece”)
GraphicsWindow.DrawText(x + 25, y + 280, “Down Arrow = Drop piece”)
GraphicsWindow.DrawText(x, y + 320, “Press to stop game”)

Program.Delay(200) ‘ without this delay, the above text will use the fontsize of the score

GraphicsWindow.BrushColor = “Black”
GraphicsWindow.FontName = “Georgia”
GraphicsWindow.FontItalic = “True”
GraphicsWindow.FontSize = 36
GraphicsWindow.DrawText(x – 20, y + 400, “Small Basic Tetris”)
Program.Delay(200) ‘ without this delay, the above text will use the fontsize of the score
GraphicsWindow.FontSize = 16
GraphicsWindow.DrawText(x – 20, y + 440, “ver.0.1”)

Program.Delay(200) ‘ without this delay, the above text will use the fontsize of the score
score = 0
PrintScore()
EndSub


Sub PrintScore
GraphicsWindow.PenWidth = 4
GraphicsWindow.BrushColor = “Pink”
GraphicsWindow.FillRectangle(500, 65, 153, 50)
GraphicsWindow.BrushColor = “Black”
GraphicsWindow.DrawRectangle(500, 65, 153, 50)
GraphicsWindow.FontItalic = “False”
GraphicsWindow.FontSize = 32
GraphicsWindow.FontName = “Impact”
GraphicsWindow.BrushColor = “Black”
GraphicsWindow.DrawText(505, 70, Text.Append(Text.GetSubText( “00000000”, 0, 8 – Text.GetLength( score ) ), score))
EndSub


Sub SetupTemplates
‘ each piece has 4 boxes.
‘ the index of each entry within a piece represents the box number (1-4)
‘ the value of each entry represents to box zero-based box coordinate within the piece: tens place is x, ones place y

‘_X_
‘_X_
‘_XX

Array.SetValue(“template1”, 0, 10)
Array.SetValue(“template1”, 1, 11)
Array.SetValue(“template1”, 2, 12)
Array.SetValue(“template1”, 3, 22)
Array.SetValue(“template1”, “color”, “Yellow”)
Array.SetValue(“template1”, “dim”, 3)
Array.SetValue(“template1”, “pviewx”, -12)
Array.SetValue(“template1”, “pviewy”, 12)


‘_X_
‘_X_
‘XX_
Array.SetValue(“template2”, 0, 10)
Array.SetValue(“template2”, 1, 11)
Array.SetValue(“template2”, 2, 12)
Array.SetValue(“template2”, 3, 02)
Array.SetValue(“template2”, “color”, “Magenta”)
Array.SetValue(“template2”, “dim”, 3)
Array.SetValue(“template2”, “pviewx”, 12)
Array.SetValue(“template2”, “pviewy”, 12)


‘_X_
‘XXX
‘_
Array.SetValue(“template3”, 0, 10)
Array.SetValue(“template3”, 1, 01)
Array.SetValue(“template3”, 2, 11)
Array.SetValue(“template3”, 3, 21)
Array.SetValue(“template3”, “color”, “Gray”)
Array.SetValue(“template3”, “dim”, 3)
Array.SetValue(“template3”, “pviewx”, 0)
Array.SetValue(“template3”, “pviewy”, 25)


‘XX_
‘XX_
‘_
Array.SetValue(“template4”, 0, 00)
Array.SetValue(“template4”, 1, 10)
Array.SetValue(“template4”, 2, 01)
Array.SetValue(“template4”, 3, 11)
Array.SetValue(“template4”, “color”, “Cyan”)
Array.SetValue(“template4”, “dim”, 2)
Array.SetValue(“template4”, “pviewx”, 12)
Array.SetValue(“template4”, “pviewy”, 25)


‘XX_
‘_XX
‘_
Array.SetValue(“template5”, 0, 00)
Array.SetValue(“template5”, 1, 10)
Array.SetValue(“template5”, 2, 11)
Array.SetValue(“template5”, 3, 21)
Array.SetValue(“template5”, “color”, “Green”)
Array.SetValue(“template5”, “dim”, 3)
Array.SetValue(“template5”, “pviewx”, 0)
Array.SetValue(“template5”, “pviewy”, 25)


‘_XX
‘XX_
‘_
Array.SetValue(“template6”, 0, 10)
Array.SetValue(“template6”, 1, 20)
Array.SetValue(“template6”, 2, 01)
Array.SetValue(“template6”, 3, 11)
Array.SetValue(“template6”, “color”, “Blue”)
Array.SetValue(“template6”, “dim”, 3)
Array.SetValue(“template6”, “pviewx”, 0)
Array.SetValue(“template6”, “pviewy”, 25)


‘_X
‘_X
‘_X
‘_X
Array.SetValue(“template7”, 0, 10)
Array.SetValue(“template7”, 1, 11)
Array.SetValue(“template7”, 2, 12)
Array.SetValue(“template7”, 3, 13)
Array.SetValue(“template7”, “color”, “Red”)
Array.SetValue(“template7”, “dim”, 4)
Array.SetValue(“template7”, “pviewx”, 0)
Array.SetValue(“template7”, “pviewy”, 0)

EndSub

Python code

import random
 
“”
10 x 20 square grid
shapes: S, Z, I, O, J, L, T
represented in order by 0 – 6
“”
 
pygame.font.init()
 
# GLOBALS VARS
s_width = 800
s_height = 700
play_width = 300  # meaning 300 // 10 = 30 width per block
play_height = 600  # meaning 600 // 20 = 20 height per blo ck
block_size = 20
 
top_left_x = (s_widthplay_width) // 2
top_left_y = s_heightplay_height50
 
 
# SHAPE FORMATS
 
shape = [ # redesigned
[[“…..”,
      “…..”,
      “.000.”,
      “.000.”,
      “…..”],
    
     [“…..”,
      “..00.”,
      “..00.”,
      “..00.”,
      “…..”]],
 
[     [“…..”,
      “…..”,
      “.00..”,
      “..0..”,
      “…..”],
 
     [“…..”,
     “…..”,
      “..0..”,
      “.00..”,
      “…..”],
 
      [“…..”,
      “…..”,
      “.0…”,
      “.00..”,
      “…..”],
 
      [“…..”,
      “…..”,
      “.00..”,
      “.0…”,
      “…..”]],
 
      [[“…..”,
      “…..”,
      “..00.”,
      “..0..”,
      “…..”],
 
     [“…..”,
     “…..”,
      “..00.”,
      “…0.”,
      “…..”],
 
      [“…..”,
      “…..”,
      “…0.”,
      “..00.”,
      “…..”],
 
      [“…..”,
      “…..”,
      “..0..”,
      “..00.”,
      “…..”],
 
      ],
 
[ [“..0..”,
      “..0..”,
      “..0..”,
      “..0..”,
      “…..”],
     [“…..”,
      “0000.”,
      “…..”,
      “…..”,
      “…..”]],
 
[ [“…..”,
      “..0..”,
      “..0..”,
      “..0..”,
      “…..”],
     [“…..”,
      “.000.”,
      “…..”,
      “…..”,
      “…..”]],
 
[ [“…..”,      
      “.00..”,
      “.00..”,
      “…..”]],
 
[ [“…..”,      
      “…..”,
      “..00.”,
      “…..”,
      “…..”],
      [“…..”,      
      “…0.”,
      “…0.”,
      “…..”,
      “…..”],
      ],
[[“…..”,
      “.0…”,
      “.000.”,
      “…..”,
      “…..”],
     [“…..”,
      “..00.”,
      “..0..”,
      “..0..”,
      “…..”],
     [“…..”,
      “…..”,
      “.000.”,
      “…0.”,
      “…..”],
     [“…..”,
      “..0..”,
      “..0..”,
      “.00..”,
      “…..”]],
 
[[“…..”,
      “…0.”,
      “.000.”,
      “…..”,
      “…..”],
     [“…..”,
      “..0..”,
      “..0..”,
      “..00.”,
      “…..”],
     [“…..”,
      “…..”,
      “.000.”,
      “.0…”,
      “…..”],
     [“…..”,
      “.00..”,
      “..0..”,
      “..0..”,
      “…..”]],
 
[[“…..”,
      “..0..”,
      “.000.”,
      “..0..”,
      “…..”]],
 
[[“…..”,
      “..0..”,
      “.000.”,
      “…..”,
      “…..”],
     [“…..”,
      “..0..”,
      “..00.”,
      “..0..”,
      “…..”],
     [“…..”,
      “…..”,
      “.000.”,
      “..0..”,
      “…..”],
     [“…..”,
      “..0..”,
      “.00..”,
      “..0..”,
      “…..”]]
     ]
 
shapes = [x for x in shape]
 
class Piece(object):
    rows = 20
    columns = 10
    def __init__(self, column, row, shape):
        self.x = column
        self.y = row
        self.shape = shape
        self.color = (129,200,128)
        self.rotation = 0  # number from 0-3
 
 
def create_grid(locked_positions={}):
    grid = [[(0,0,0) for x in range(10)] for x in range(20)]
 
    for i in range(len(grid)):
        for j in range(len(grid[i])):
            if (j,i) in locked_positions:
                c = locked_positions[(j,i)]
                grid[i][j] = c
    return grid
 
 
def convert_shape_format(shape):
    positions = []
    format = shape.shape[shape.rotation % len(shape.shape)]
 
    for i, line in enumerate(format):
        row = list(line)
        for j, column in enumerate(row):
            if column == “0”:
                positions.append((shape.x + j, shape.y + i))
 
    for i, pos in enumerate(positions):
        positions[i] = (pos[0]2, pos[1]4)
 
    return positions
 
 
def valid_space(shape, grid):
    accepted_positions = [[(j, i) for j in range(10) if grid[i][j] == (0,0,0)] for i in range(20)]
    accepted_positions = [j for sub in accepted_positions for j in sub]
    formatted = convert_shape_format(shape)
 
    for pos in formatted:
        if pos not in accepted_positions:
            if pos[1] >1:
                return False
 
    return True
 
 
def check_lost(positions):
    for pos in positions:
        x, y = pos
        if y < 1:
            return True
    return False
 
 
def get_shape():
    global shapes, shape_colors
 
    return Piece(5, 0, random.choice(shapes))
 
 
def draw_text_middle(text, size, color, surface):
    font = pygame.font.SysFont(“comicsans”, size, bold=True)
    label = font.render(text, 1, color)
 
    surface.blit(label, (top_left_x + play_width/2(label.get_width() / 2), top_left_y + play_height/2label.get_height()/2))
 
 
def draw_grid(surface, row, col):
    sx = top_left_x
    sy = top_left_y
    for i in range(row):
        pygame.draw.line(surface, (128,128,128), (sx, sy+ i*30), (sx + play_width, sy + i * 30))  # horizontal lines
        for j in range(col):
            pygame.draw.line(surface, (128,128,128), (sx + j * 30, sy), (sx + j * 30, sy + play_height))  # vertical lines
 
 
def clear_rows(grid, locked):
    # need to see if row is clear the shift every other row above down one
 
    inc = 0
    for i in range(len(grid)1,1,1):
        row = grid[i]
        if (0, 0, 0) not in row:
            inc += 1
            # add positions to remove from locked
            ind = i
            for j in range(len(row)):
                try:
                    del locked[(j, i)]
                except:
                    continue
    if inc > 0:
        for key in sorted(list(locked), key=lambda x: x[1])[::1]:
            x, y = key
            if y < ind:
                newKey = (x, y + inc)
                locked[newKey] = locked.pop(key)
 
 
def draw_next_shape(shape, surface):
    font = pygame.font.SysFont(“comicsans”, 30)
    label = font.render(“Next Shape”, 1, (128,128,128))
 
    sx = top_left_x + play_width + 50
    sy = top_left_y + play_height/2100
    format = shape.shape[shape.rotation % len(shape.shape)]
 
    for i, line in enumerate(format):
        row = list(line)
        for j, column in enumerate(row):
            if column == “0”:
                pygame.draw.rect(surface, shape.color, (sx + j*30, sy + i*30, 30, 30), 0)
 
    surface.blit(label, (sx + 10, sy30))
 
 
def draw_window(surface):
    surface.fill((0,0,32))
    # Tetris Title
    #font = pygame.font.SysFont(“comicsans”, 48)
    #label = font.render(“TETRIS”, 1, (255,255,255))
 
    #surface.blit(label, (top_left_x + play_width / 2 – (label.get_width() / 2), 30))
 
    for i in range(len(grid)):
        for j in range(len(grid[i])):
            pygame.draw.rect(surface, grid[i][j], (top_left_x + j* 30, top_left_y + i * 30, 30, 30), 0)
 
    # draw grid and border
    draw_grid(surface, 27, 10)
    pygame.draw.rect(surface, (128, 128, 128), (top_left_x, top_left_y, play_width, play_height), 5)
    #pygame.display.update()
 
 
def main():
    global grid
 
    locked_positions = {}  # (x,y):(255,0,0)
    grid = create_grid(locked_positions)
 
    change_piece = False
    run = True
    current_piece = get_shape()
    next_piece = get_shape()
    clock = pygame.time.Clock()
    fall_time = 0
 
    while run:
        fall_speed = 0.27
 
        grid = create_grid(locked_positions)
        fall_time += clock.get_rawtime()
        clock.tick()
 
        # PIECE FALLING CODE
        if fall_time/1000 >= fall_speed:
            fall_time = 0
            current_piece.y += 1
            if not (valid_space(current_piece, grid)) and current_piece.y > 0:
                current_piece.y -= 1
                change_piece = True
 
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                run = False
                pygame.display.quit()
                quit()
 
            if event.type == pygame.KEYDOWN:
 
                if event.key == pygame.K_LEFT:
                    current_piece.x -= 1
                    if not valid_space(current_piece, grid):
                        current_piece.x += 1
 
                elif event.key == pygame.K_RIGHT:
                    current_piece.x += 1
                    if not valid_space(current_piece, grid):
                        current_piece.x -= 1
                elif event.key == pygame.K_UP:
                    # rotate shape
                    current_piece.rotation = current_piece.rotation + 1 % len(current_piece.shape)
                    if not valid_space(current_piece, grid):
                        current_piece.rotation = current_piece.rotation1 % len(current_piece.shape)
 
                if event.key == pygame.K_DOWN:
                    # move shape down
                    current_piece.y += 1
                    if not valid_space(current_piece, grid):
                        current_piece.y -= 1
 
                if event.key == pygame.K_SPACE:
                   while valid_space(current_piece, grid):
                       current_piece.y += 1
                   current_piece.y -= 1
                   #print(convert_shape_format(current_piece))”””  # todo fix
 
 
        shape_pos = convert_shape_format(current_piece)
 
        # add piece to the grid for drawing
        for i in range(len(shape_pos)):
            x, y = shape_pos[i]
            if y >1:
                grid[y][x] = current_piece.color
 
        # IF PIECE HIT GROUND
        if change_piece:
            for pos in shape_pos:
                p = (pos[0], pos[1])
                locked_positions[p] = current_piece.color
            current_piece = next_piece
            next_piece = get_shape()
            change_piece = False
 
            # call four times to check for multiple clear rows
            clear_rows(grid, locked_positions)
 
        draw_window(win)
        draw_next_shape(next_piece, win)
        pygame.display.update()
 
        # Check if user lost
        if check_lost(locked_positions):
            run = False
 
    draw_text_middle(“You Lost”, 40, (255,255,255), win)
    pygame.display.update()
    pygame.time.delay(2000)
 
 
def main_menu():
    run = True
    while run:
        win.fill((0,0,0))
        draw_text_middle(“Press any key to begin.”, 60, (255, 255, 255), win)
        pygame.display.update()
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                run = False
 
            if event.type == pygame.KEYDOWN:
                main()
    pygame.quit()
 
 
win = pygame.display.set_mode((s_width, s_height))
#win = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
pygame.display.set_caption(“Tetris”)
main_menu()  # start game

Leave a Reply