mirror of
https://github.com/eddyem/stm32samples.git
synced 2025-12-06 18:55:13 +03:00
315 lines
9.0 KiB
C
315 lines
9.0 KiB
C
/*
|
|
* This file is part of the TETRIS project.
|
|
* Copyright 2021 Edward V. Emelianov <edward.emelianoff@gmail.com>.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "adcrandom.h"
|
|
#include "buttons.h"
|
|
#include "screen.h"
|
|
#include "tetris.h"
|
|
|
|
#include "usb.h"
|
|
#include "proto.h"
|
|
|
|
// backround color
|
|
#define BACKGROUND_COLOR (COLOR_BLACK)
|
|
#define CUP_COLOR (COLOR_LRED)
|
|
|
|
// height of cup
|
|
#define CUPHEIGHT (30)
|
|
#define CUPWIDTH (20)
|
|
// screen coordinate of x=0 @ cup
|
|
#define CUPX0 (1)
|
|
// screen coordinate of y=0 @ cup (Y grows upside down)
|
|
#define CUPY0 (0)
|
|
// coordinates of "NEXT figure"
|
|
#define NEXTX0 (30)
|
|
#define NEXTY0 (4)
|
|
#define xmax (CUPWIDTH-1)
|
|
#define ymax (CUPHEIGHT-1)
|
|
|
|
// min speed
|
|
#define MAXSTEPMS (199)
|
|
// max speed / drop speed
|
|
#define MINSTEPMS (19)
|
|
// each NXTSPEEDSCORE of score the speed will be increased
|
|
#define NXTSPEEDSCORE (50)
|
|
|
|
extern uint32_t Tms;
|
|
|
|
// get coordinates by figure member
|
|
#define GETX(u) (((u) >> 4) - 2)
|
|
#define GETY(u) (((u) & 0xf) - 2)
|
|
|
|
typedef struct{
|
|
uint8_t f[4];
|
|
uint8_t color;
|
|
} figure;
|
|
|
|
// L: 00, 01, 02, 10 + 2 = 0x22, 0x23, 0x24, 0x32
|
|
static const figure L = {
|
|
.f = {0x22, 0x23, 0x24, 0x32},
|
|
.color = COLOR_LBLUE
|
|
};
|
|
// J: 00, 01, 02, -10 + 2 = 0x22, 0x23, 0x24, 0x12
|
|
static const figure J = {
|
|
.f = {0x22, 0x23, 0x24, 0x12},
|
|
.color = COLOR_BLUE
|
|
};
|
|
// O: 00, 01, 10, 11 + 2 = 0x22, 0x23, 0x32, 0x33
|
|
static const figure O = {
|
|
.f = {0x22, 0x23, 0x32, 0x33},
|
|
.color = COLOR_YELLOW
|
|
};
|
|
|
|
// I: 0-1, 00, 01, 02 + 2 = 0x21, 0x22, 0x23, 0x24
|
|
static const figure I = {
|
|
.f = {0x21, 0x22, 0x23, 0x24},
|
|
.color = COLOR_CYAN
|
|
};
|
|
|
|
// S: -10, 00, 01, 11 + 2 = 0x12, 0x22, 0x23, 0x33
|
|
static const figure S = {
|
|
.f = {0x12, 0x22, 0x23, 0x33},
|
|
.color = COLOR_LGREEN
|
|
};
|
|
|
|
// Z: -11, 01, 00, 10 + 2 = 0x13, 0x23, 0x23, 0x32
|
|
static const figure Z = {
|
|
.f = {0x13, 0x23, 0x23, 0x32},
|
|
.color = COLOR_GREEN
|
|
};
|
|
|
|
// T: -10, 01, 00, 10 + 2 = 0x12, 0x23, 0x22, 0x32
|
|
static const figure T = {
|
|
.f = {0x12, 0x23, 0x22, 0x32},
|
|
.color = COLOR_PURPLE
|
|
};
|
|
|
|
#define FIGURESNUM (7)
|
|
static const figure *figures[FIGURESNUM] = {&L, &J, &O, &I, &S, &Z, &T};
|
|
static figure curfigure, nextfigure;
|
|
|
|
// current figure coordinates
|
|
static int xf, yf;
|
|
// next score the speed will be encreased
|
|
static uint32_t nextSpeedScore = 0;
|
|
|
|
|
|
// chk if figure can be put to (x,y); @return 1 if empty
|
|
static int chkfigure(int x, int y, const figure *F){
|
|
if(x < 0 || x > xmax) return 0;
|
|
if(y < 0 || y > ymax) return 0;
|
|
for(int i = 0; i < 4; ++i){
|
|
int xn = x + GETX(F->f[i]), yn = y + GETY(F->f[i]);
|
|
if(yn > ymax || yn < 0) return 0;
|
|
if(xn < 0 || xn > xmax || yn < 0) return 0; // border
|
|
if(GetPix(xn ,yn) != BACKGROUND_COLOR) return 0; // occupied
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
// clear figure from old location
|
|
static void clearfigure(int x, int y){
|
|
USB_send("Clear @ "); USB_send(u2str(x)); USB_send(", "); USB_send(u2str(y)); USB_send("\n");
|
|
for(int i = 0; i < 4; ++i){
|
|
int xn = x + GETX(curfigure.f[i]), yn = y + GETY(curfigure.f[i]);
|
|
if(xn < 0 || xn > xmax || yn < 0 || yn > ymax) continue; // out of cup
|
|
DrawPix(xn, yn, BACKGROUND_COLOR);
|
|
}
|
|
}
|
|
|
|
// put figure into new location
|
|
static void putfigure(int x, int y, figure *F){
|
|
USB_send("Put @ "); USB_send(u2str(x)); USB_send(", "); USB_send(u2str(y)); USB_send("\n");
|
|
for(int i = 0; i < 4; ++i){
|
|
int xn = x + GETX(F->f[i]), yn = y + GETY(F->f[i]);
|
|
if(xn < 0 || xn > xmax || yn < 0 || yn > ymax) continue; // out of cup
|
|
DrawPix(xn, yn, F->color);
|
|
}
|
|
}
|
|
|
|
// dir=-1 - right, =1 - left
|
|
static void rotatefigure(int dir, figure *F){
|
|
figure nF = {.color = F->color};
|
|
for(int i = 0; i < 4; ++i){
|
|
int x = GETX(F->f[i]), y = GETY(F->f[i]), xn, yn;
|
|
if(dir > 0){ // CW
|
|
xn = y; yn = -x;
|
|
USB_send("Rotate CW\n");
|
|
}else if(dir < 0){ // CCW
|
|
xn = -y; yn = x;
|
|
USB_send("Rotate CCW\n");
|
|
}
|
|
nF.f[i] = ((xn + 2) << 4) | (yn + 2);
|
|
}
|
|
*F = nF;
|
|
}
|
|
|
|
// check cup for full lines & delete them; return number of deleted lines
|
|
static int checkandroll(){
|
|
int upper = 0, ret = 0;
|
|
for(int y = 0; y < CUPHEIGHT; ++y){
|
|
int N = 0;
|
|
for(int x = 0; x < CUPWIDTH; ++x)
|
|
if(GetPix(x, y) != BACKGROUND_COLOR) ++N;
|
|
if(N == 0) upper = y;
|
|
else if(N == CUPWIDTH){ // full line - roll all upper
|
|
++ret;
|
|
for(int yy = y; yy <= upper; --yy){
|
|
uint8_t *ptr = &screenbuf[(yy+CUPY0)*SCREEN_WIDTH + CUPX0];
|
|
for(int x = 0; x < CUPWIDTH; ++x, ++ptr)
|
|
*ptr = ptr[-CUPWIDTH]; // copy upper row into the current
|
|
}
|
|
++upper;
|
|
}
|
|
}
|
|
USB_send("Roll="); USB_send(u2str(ret)); USB_send("\n");
|
|
return ret;
|
|
}
|
|
|
|
// get random number of next figure
|
|
static int getrand(){
|
|
static int oldnum[2] = {-1, -1};
|
|
int r = getRand() % FIGURESNUM;
|
|
if(r == oldnum[1]) r = getRand() % FIGURESNUM;
|
|
if(r == oldnum[0]) r = getRand() % FIGURESNUM;
|
|
oldnum[0] = oldnum[1];
|
|
oldnum[1] = r;
|
|
return r;
|
|
}
|
|
|
|
// return 0 if cannot move
|
|
static int mvfig(int *x, int *y, int dx){
|
|
register int xx = *x, yy = *y;
|
|
int xnew = xx+dx, ynew = yy+1, ret = 1;
|
|
clearfigure(xx, yy);
|
|
if(chkfigure(xnew, ynew, &curfigure)){
|
|
xx = xnew; yy = ynew;
|
|
*x = xx; *y = yy;
|
|
}else ret = 0;
|
|
putfigure(xx, yy, &curfigure);
|
|
return ret;
|
|
}
|
|
|
|
// dir == -1 - left, 1 - right
|
|
static void rotfig(int x, int y, int dir){
|
|
if(!dir) return;
|
|
figure newF = curfigure;
|
|
rotatefigure(dir, &newF);
|
|
clearfigure(x, y);
|
|
if(chkfigure(x, y, &newF)){ // can rotate - substitute old figure with new
|
|
curfigure = newF;
|
|
}
|
|
putfigure(x, y, &curfigure);
|
|
}
|
|
|
|
// draw current & next figures; return 0 if can't
|
|
static int drawnext(){
|
|
curfigure = nextfigure;
|
|
clearfigure(NEXTX0, NEXTY0); // clear NEXT
|
|
nextfigure = *figures[getrand()];
|
|
putfigure(NEXTX0, NEXTY0, &nextfigure);
|
|
xf = xmax/2; yf = ymax/2;
|
|
if(!chkfigure(xf, yf, &curfigure)) return 0; // can't draw next
|
|
putfigure(xf, yf, &curfigure);
|
|
return 1;
|
|
}
|
|
|
|
void tetris_init(){
|
|
setBGcolor(BACKGROUND_COLOR);
|
|
ClearScreen();
|
|
ScreenON();
|
|
StepMS = MAXSTEPMS;
|
|
Tlast = Tms;
|
|
incSpd = StepMS;
|
|
score = 0;
|
|
nextSpeedScore = NXTSPEEDSCORE;
|
|
// draw cup
|
|
for(int y = 0; y < CUPHEIGHT; ++y){
|
|
DrawPix(CUPX0, CUPY0 + y, CUP_COLOR);
|
|
DrawPix(CUPX0 + CUPWIDTH, CUPY0 + y, CUP_COLOR);
|
|
}
|
|
for(int x = 0; x < CUPWIDTH; ++x)
|
|
DrawPix(CUPX0 + x, CUPY0 + CUPHEIGHT, CUP_COLOR);
|
|
nextfigure = *figures[getrand()];
|
|
drawnext();
|
|
}
|
|
|
|
// process tetris game; @return 0 if game is over
|
|
int tetris_process(){
|
|
uint8_t moveX = 0, rot = 0;
|
|
keyevent evt;
|
|
static uint8_t paused = 0;
|
|
// change moving direction
|
|
if(keystate(KEY_U, &evt) && (evt == EVT_PRESS || evt == EVT_HOLD)){ // UP - pause
|
|
if(paused){
|
|
USB_send("Tetris resume\n");
|
|
paused = 0;
|
|
}else{
|
|
USB_send("Tetris paused\n");
|
|
paused = 1;
|
|
}
|
|
}
|
|
if(keystate(KEY_D, &evt) && evt == EVT_PRESS){ // Down - drop
|
|
incSpd = MINSTEPMS;
|
|
}
|
|
if(keystate(KEY_L, &evt) && evt == EVT_PRESS){ // L - left
|
|
moveX = -1;
|
|
}
|
|
if(keystate(KEY_R, &evt) && evt == EVT_PRESS){ // Right
|
|
moveX = 1;
|
|
}
|
|
if(keystate(KEY_M, &evt) && evt == EVT_PRESS){ // Menu - rotate CCW
|
|
rot = -1;
|
|
}
|
|
if(keystate(KEY_S, &evt) && evt == EVT_PRESS){ // Set - rotate CW
|
|
rot = 1;
|
|
}
|
|
clear_events();
|
|
if(Tms - Tlast > incSpd){
|
|
Tlast = Tms;
|
|
if(paused) return 1;
|
|
int xnew = xf, ynew = yf;
|
|
if(rot) rotfig(xf, yf, rot);
|
|
if(!mvfig(&xnew, &ynew, moveX) && ynew == yf){ // can't move: end of moving?
|
|
int s = checkandroll();
|
|
switch(s){ // add score
|
|
case 1:
|
|
score += 1;
|
|
break;
|
|
case 2:
|
|
score += 3;
|
|
break;
|
|
case 3:
|
|
score += 7;
|
|
break;
|
|
case 4:
|
|
score += 15;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
if(StepMS > MINSTEPMS && score > nextSpeedScore){ // increase speed
|
|
--StepMS;
|
|
nextSpeedScore += NXTSPEEDSCORE;
|
|
}
|
|
if(!drawnext()) return 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|