ATNEL tech-forum

Re: Gra logiczna na ATB + TFT

2013-02-14T15:01:35+01:00

Super sprawa, widać wielkie umiejętności i doświadczenie kolegi Krauser. Osobiście posiadam ten wyświetlacz oraz konwerter więc na pewno przetestuje!! Osobiście pełen szacun !! Pzdr

Statystyki: Napisane przez zlata_n — 14 lut 2013, o 15:01

Re: Gra logiczna na ATB + TFT

2013-02-14T11:41:08+01:00

xbary napisał(a):

No ja wczoraj podczas podróży jako pasażer grywałem sobie w Stunt Car Racer na emulatorze C64 na Androidzie ... mam ostatnio takie chęci żeby w te staruchy sobie pograć.

Mógłbyś bardziej przybliżyć temat .

Statystyki: Napisane przez Gość — 14 lut 2013, o 11:41

Re: Gra logiczna na ATB + TFT

2013-02-14T11:13:50+01:00

No ja wczoraj podczas podróży jako pasażer grywałem sobie w Stunt Car Racer na emulatorze C64 na Androidzie ... mam ostatnio takie chęci żeby w te staruchy sobie pograć.

Statystyki: Napisane przez xbary — 14 lut 2013, o 11:13

Re: Gra logiczna na ATB + TFT

2013-02-14T10:58:14+01:00

Jakieś wyścigówki . W końcu na C64 było nawet wypaśne Test Drive .

Statystyki: Napisane przez Gość — 14 lut 2013, o 10:58

Re: Gra logiczna na ATB + TFT

2013-02-14T10:45:27+01:00

Aż chce się rzucić wszystko i też fajną grę na te małe 8 bitowce stworzyć , i poczuć się jak był rok 1987, kiedy to pisząc grę liczyło się każdy cykl procesora aby tylko zdążyć przed kolejnym odświeżaniem pionowym ekranu:)

Krauser chyba nie jednego tu z Nas na forum podpaliłeś do napisania jakiejś gierki.

Statystyki: Napisane przez xbary — 14 lut 2013, o 10:45

Re: Gra logiczna na ATB + TFT

2013-02-13T15:59:19+01:00

hmmm.... no dobra super gratka
Krauser rządzisz .....

Statystyki: Napisane przez SunRiver — 13 lut 2013, o 15:59

Re: Gra logiczna na ATB + TFT

2013-02-13T15:21:20+01:00

dexter napisał(a):

Hehehe fajny projekt, oj zanim ja dotrę do takiej wprawy to już wnuki będe miał

Ja również.

Statystyki: Napisane przez matisek1233 — 13 lut 2013, o 15:21

Re: Gra logiczna na ATB + TFT

2013-02-13T12:51:29+01:00

kila napisał(a):

Stwierdzam, że poziom moich umiejętności nie odpowiada zabawom w piaskownicy

Nie jesteś sam . Swoją drogą faktycznie teraz nic tylko czekać na Tetrisa .

Statystyki: Napisane przez Gość — 13 lut 2013, o 12:51

Re: Gra logiczna na ATB + TFT

2013-02-13T13:10:32+01:00

Stwierdzam, że poziom moich umiejętności odpowiada zabawom w piaskownicy

Statystyki: Napisane przez kila — 13 lut 2013, o 12:43

Re: Gra logiczna na ATB + TFT

2013-02-13T12:37:03+01:00

Hehehe fajny projekt, oj zanim ja dotrę do takiej wprawy to już wnuki będe miał

Statystyki: Napisane przez dexter — 13 lut 2013, o 12:37

Re: Gra logiczna na ATB + TFT

2013-02-13T11:07:26+01:00

Krauser ---> matko jedyna ależ ty masz pomysły ..... normalnie odjazd .... i już nie chodzi mi o to że to na ATB czy ze zdjęciem ATB - ale o fakt właśnie pokazania TAK FAJNEGO wykorzystania tego buforowania sprzętowego w wyświetlaczu !!!

no przy takiej grze tzn przy takich reakcjach ekranu kto by pomyślał że za jego plecami kryje się taki mały 8-bitowy biedny mały pikuś , który ponoć jest już na wymarciu

Świetny pomysł, rewelacyjna realizacja, dodatkowo program na PC, normalnie prześliczny PROJEKT !!! z mojej strony pełen szacunek za pokazanie kolejny raz takich swoich możliwości. SZOK i uznanie.

Po twoich projektach mam normalnie chęć rzucić wszystko inne i zająć się tylko takimi rzeczami .... ale niestety rzeczywistość jeszcze mnie przytłacza wieloma innymi obowiązkami i muszę to wciąż zostawiać sobie na później i później .... kuuuuurka wodna

------------------------ [ Dodano po: 15 minutach ]

Pozwolisz Krauser, że pokażę ten projekt szerzej i wpuszczę go jako przyklejony globalny na głównej stronie naszego forum ?

Statystyki: Napisane przez mirekk36 — 13 lut 2013, o 11:07

Re: Gra logiczna na ATB + TFT

2013-02-13T10:51:28+01:00

Chapeau bas Krauser!

Statystyki: Napisane przez Wrangler — 13 lut 2013, o 10:51

Re: Gra logiczna na ATB + TFT

2013-02-13T08:58:08+01:00

Sonix napisał(a):

No tak... ja się tu męczę że żeby coś tam wyświetlić na LCD 2x16 a tu takie rzeczy .

Nie ma to jak wyświetlić sobie fotkę ATB na samej ATB i to jeszcze w formie gierki .

Gratuluję projektu i zazdroszczę umiejętności .

Dokładnie wyjąłeś mi to z ust. Od dłuższego czasu próbuję zmusić do działania 44780 na I2c (PCF8574) a tu takie kwiatki .

Świetna robota.

Statystyki: Napisane przez Gość — 13 lut 2013, o 08:58

Re: Gra logiczna na ATB + TFT

2013-02-13T08:22:21+01:00

Super sprawa gratki

Statystyki: Napisane przez jachu — 13 lut 2013, o 08:22

Re: Gra logiczna na ATB + TFT

2013-02-13T08:19:55+01:00

Statystyki: Napisane przez Sonix — 13 lut 2013, o 08:19

Re: Gra logiczna na ATB + TFT

2013-02-13T06:41:12+01:00

No, no, ładnie. To chyba pierwsza gra na ATB?

Teraz kto zrobi Tetrisa?

Statystyki: Napisane przez Jaglarz — 13 lut 2013, o 06:41

Gra logiczna na ATB + TFT

2013-02-13T00:58:14+01:00

Korzystając z dobrodziejstwa bibliotek na TFT przygotowanych przez Mirka przygotowałem port klasycznej gierki na zestaw ATB.
Opis hardware/połączeń:
- ATB-GLCD TFT konwerter podłączony jest do portu A (dane), portu C (linie sterujące) oraz PD.2/INT0 (reakcja na dotyk). Domyślnie jak w przykładzie z książki.
- Karta SD podłączona jest do portu B od 1 do 7 pinu. Nawet nie trzeba za bardzo kombinować - połączenie 1 do 1 7-żyłową taśmą (lub 8-żyłową, gdzie ostatnia linia jest niewykorzystana ). Wystarczy tylko zdjąć zworkę PwrON.
- Buzzer podłączony jest do PB.0.

Założenia gry:
- Gra polega na ułożeniu obrazka z 12 elementów, gdzie 1 jest pusty. Przykład na zdjęciu poniżej.

- Można przesunąć element tylko na pustą pozycję. Gra kończy się, gdy wszystkie elementy znajdą się na właściwym miejscu. Nie jest liczony czas, a liczba wykonanych ruchów. Wynik ten jest pokazywany na końcu raz oczywiście podczas gry na wolnym polu.

Założenia programu:
- Postanowiłem skorzystać z wolnej pamięci w sterowniku wyświetlacza o czym jest mowa w książce "Język C Pasja programowania mikrokontrolerów 8-bitowych" tak więc nie jest widoczne wczytywanie żadnych grafik z karty SD. Wykorzystałem wszystkie dostępne bufory, które na początku ładowane są 11 obrazkami, a w trakcie gry tylko zamieniane. Jako, że w tle modyfikowane są 4 ekrany, a wyświetlany jest 5 to przesuwanie bloków i zmiana 4 małych obrazków zajmuje około sekundy skorzystałem z buzzera, który sygnalizuje gotowość do reakcji na kolejny dotyk.
- Obrazek do gry to specjalnie przygotowane 12 plików w formacie rg8 (opis w książce, jest on podobny do bmp, ale bez niepotrzebnych danych oraz odpowiednio uszeregowaną kolejnością bajtów RGB). Troszkę czasu zajęłoby przygotowanie tych plików na piechotę. Dlatego też przygotowałem programik do konwersji dowolnych obrazków na 12 plików w formacie rg8, który najpierw skaluje obraz do rozdzielczości 320x240, a następnie zapisuje 12, 16, 20 lub 25 plików (do wyboru) w formacie rg8 lub bmp z kolejnymi numerami. W nazwie nie może być cyfr, ponieważ program na AVR przeszukuje kartę SD i ciąg liter to część wspólna wykorzystana do sklejania nazw plików wyświetlanych na TFT.

Nie zastosowałem, żadnego algorytmu losowania początkowego ułożenia "kafelków". Co oczywiście można zrobić jak ktoś uzna, że ma za łatwo. Tutaj również zawsze ostatni z elementów jest w prawym dolnym rogu co znacznie ułatwia ukończenie tego wyzwania.

iframe

Oprogramowanie na ATB:
- main.c
[syntax=c]/*
* main.c
*/
#include
#include
#include
#include
#include
#include
#include

#include "main.h"
#include "game01.h"

static void __init3( void ) __attribute__ (( section( ".init3" ), naked, used ));

/* buffer for SD/MMC */
uint16_t SD_BUF_SIZE = 1024;
uint8_t sd_buffer[1024];
/* pointer to SD buffer */
uint8_t *sd_buf = sd_buffer;

/* main function */
int main(void) {

FATFS Fs;/* File system object */
DIR Dir;/* Directory object */
FILINFO Fno;/* File information */

uint8_t init = 0;
uint8_t start = 0;

i2cSetBitrate(400);/* I2C speed */

spi_init(); /* SPI, buzzer, and empty port initialization */

tft_init();/* TFT LCD initialization */

stmpe811_init(); /* STMPE811 initialization */

for(uint8_t i=0; i<5; i++)
{
if(screen[i].function == left) /* start display on buffer assigned to left */
{
setxbuf(screen[i].scr_buf);
fx_ptr = screen[i].scr_buf;
}
}

/* do the same as tft_cls but on every screens */
tft_fill_rect(0, 0, 320, 240, BG_COLOR);

setCurrentFont(&CourierNew12ptFontInfo);

for(uint8_t i=0; i<5; i++)
{
if(screen[i].function == center)/* finding empty in center screen */
for (uint8_t j = 0; j < 12; j++)
{
if(screen[i].game[j] == EMPTY) empty_block = selected_block = j;
}
}
sei();/* enable interrupts */

/* main loop */
while(1) {
tft_puts_P( 90, 10, PSTR("START"), black, BG_COLOR );

sd_pwr(powerOff);
if( SD_SLOT_EMPTY )
{
tft_puts_P( 90, 30, PSTR(" "), black, BG_COLOR );
tft_puts_P( 90, 30, PSTR("insert SD Card"), black, BG_COLOR );
continue;/* if no card detected back to the beginning of the loop */
}
sd_pwr(powerOn);

if (pf_mount(&Fs))
{
tft_puts_P( 90, 30, PSTR(" "), black, BG_COLOR );
tft_puts_P( 90, 30, PSTR("FS Error"), black, BG_COLOR );
continue;
}

while(1) {
if( SD_SLOT_EMPTY )
{
tft_puts_P( 90, 30, PSTR(" "), black, BG_COLOR );
tft_puts_P( 90, 30, PSTR("insert SD Card and reset"), black, BG_COLOR );
break;
}

if (pf_opendir(&Dir, ""))/* Open directory (root dir) */
{
tft_puts_P( 90, 30, PSTR(" "), black, BG_COLOR );
tft_puts_P( 90, 30, PSTR("Open failed please reset"), black, BG_COLOR );
break;
}

if (st_intX_flag) /* screen touched */
{
if(!start) /* first time */
{
for(uint8_t i = 0; i < 5; i++)
{
if(screen[i].function == center) /* select center */
{
setxbuf(screen[i].scr_buf);
fx_ptr = screen[i].scr_buf;
}
}
for(uint8_t i = 0; i < 5; i++)
{
if(screen[i].function == left) /* draw all block on left screen (background) */
{
draw_all(screen[i].scr_buf);
}
}
start = 1;
#if 0 //show all screens
show_all();
#endif
}/* if(!start) */
else /* every next time */
{
uint8_t k = 255;

selected_block = get_block(); /* check which block was selected */

for(uint8_t i = left; i < center; i++)
{
if(selected_block == neighborhood[empty_block][i])
{
k = i; /* j=left, top, right or bottom screen have empty block == selected */
}
}

if( selected_block != empty_block && (k < 4) )/* not the same and from neighborhood */
{

if(moves < 999) moves++;
/* back to empty block, screen with empty block and selected block unchanged*/
rearrange_tab();
check_differences();
fill_empty();
make_empty();
#if 0 //show all screens
show_all();
#endif
#if 0
show_tables();
#endif
#if 1
/* all screens like that with empty block = selected block, */
/* screen with empty block unchanged */
arrange_tab_c();
check_differences();
fill_empty();
make_empty();
#endif

#if 0 //show all screens
show_all();
#endif
#if 0
show_tables();
#endif
#if 1
/* change screen */
/* screen with empty block changed, now all are the same */
show_moves();
change_screen();
check_differences();
fill_empty();
make_empty();
#endif

#if 0 //show all screens
show_all();
#endif
#if 0
show_tables();
#endif
#if 1
/* like create_tab - make possibilities */
arrange_tab_k();
check_differences();
fill_empty();
make_empty();
#endif

#if 0 //show all screens
show_all();
#endif
#if 0
show_tables();
#endif
end_game();
}
}/* if(!start) / else */
st_intX_flag = 0;
short_beep();
}/* if (st_intX_flag) */
if(!init) /* initialization */
{
while (pf_readdir(&Dir, &Fno) == FR_OK && Fno.fname[0])
{/* check files */
if (strcasestr(Fno.fname, ".rg8") )
{
strncpy(file_origin, Fno.fname, strcspn(Fno.fname,"0123456789"));
tft_puts_P( 90, 50, PSTR("FILE: "), black, BG_COLOR );
tft_puts( 180, 50, file_origin, black, BG_COLOR );
break;
}
}
create_tab();
tft_puts_P( 90, 30, PSTR(" "), black, BG_COLOR );
tft_puts_P( 90, 30, PSTR("LOADING..."), black, BG_COLOR );

for(uint8_t k = top; k <= center; k++) /* without left screen */
{
for(uint8_t i = 0; i <= 4; i++)
{
if(screen[i].function == k)
{
draw_all(screen[i].scr_buf);
}
}
}

setCurrentFont(&CourierNew12ptFontInfo); /* again because draw_all may change it */
tft_puts_P( 90, 30, PSTR(" "), black, BG_COLOR );
tft_puts_P( 90, 30, PSTR("READY"), black, BG_COLOR );
init=1;
}/* if(!init) */
}/* while(1) */
}/* while(1) */
}/* main() */

void sd_pwr( uint8_t OnOff ) {
if(OnOff) {
SD_ON;
SPCR |= (1<_delay_ms(50);
disk_initialize();
} else {
SPCR &= ~(1<PORTB &= ~((1<SD_OFF;
_delay_ms(50);
}
}

static void __init3( void )
{
MCUSR = 0;
WDTCSR = (1< WDTCSR = 0;
}[/syntax]
- main.h
[syntax=c]/*
* main.h
*
*/

#ifndef MAIN_H_
#define MAIN_H_
#include

#define SCK PB7
#define MISO PB6
#define MOSI PB5
#define CS PB4
#define CDPB3
#define WPPB2 /* not used */
#define PWR PB1

#define BUZPB0

#define unused_pins (1<
#define SD_ON PORTB &= ~(1<#define SD_OFF PORTB |= (1<
#define SD_SLOT_EMPTY (PINB & (1<
void sd_pwr( uint8_t OnOff );
#define powerOn 1
#define powerOff 0

static inline void short_beep(void)
{
PORTB |= (1<_delay_ms(5);
PORTB &= ~(1<}

static inline void spi_init(void)
{
/* init SPI and SD pins */
DDRB |= (1<PORTB |= (1<SPCR |= (1<SPSR |= (1<
/* init buzzer and unused pins*/
DDRB |= (1<PORTD |= unused_pins;
}

#endif /* MAIN_H_ */
[/syntax]
- game01.c
[syntax=c]/*
* game01.c
*
* Created on: 12-02-2013
*
*/
#include "game01.h"

char file_origin[12];

SCREEN screen[5]= {
{SSDXBUF0,
{10,8,2,0,
1,9,11,5,
3,7,4,6},
{0},
255,
255,
center},
{SSDXBUF1,
{0},
{0},
255,
255,
left},
{SSDXBUF2,
{0},
{0},
255,
255,
top},
{SSDXBUF3,
{0},
{0},
255,
255,
right},
{SSDXBUF4,
{0},
{0},
255,
255,
bottom}
};

/* neighborhood of each block, if 255 no neighbor */
const uint8_t neighborhood[12][4] = {{255,255,1,4},{0,255,2,5},{1,255,3,6},{2,255,255,7},
{255,0,5,8},{4,1,6,9},{5,2,7,10},{6,3,255,11},
{255,4,9,255},{8,5,10,255},{9,6,11,255},{10,7,255,255}};
uint8_t empty_block, selected_block;
uint16_t moves;

void draw_all(uint16_t ptr)
{
uint16_t temp_ptr = fx_ptr;
uint8_t index = 0;
for(uint8_t i = 0; i <= 4; i++ )
{
if(ptr == screen[i].scr_buf) index = i;
}

fx_ptr = ptr;
#if mode == work
for(uint8_t i = 0; i < 12; i++)
{
char file[12];
uint8_t len;
strcpy(file, file_origin);
len = strlen(file);
uint8_t x, y;
x = 80 * (i % 4);
y = 80 * (i / 4);
if( screen[index].game[i] != EMPTY )
{
#if 0
char buffer[12];
itoa(index, buffer, 10);
setCurrentFont( &CourierNew12ptFontInfo );
tft_puts_P( 5, 5, PSTR(" "), black, BG_COLOR );
tft_puts( 5, 5, buffer, black, BG_COLOR );
#endif
itoa(screen[index].game[i], &file[len], 10);
strcat(file,".rg8");
tft_bitmap_from_file( x, y, file, NULL );
}
else
{
x = 80 * (i % 4);
y = 80 * (i / 4);
tft_fill_rect(x, y, 80, 80, BG_COLOR);
}
}
#elif mode==debug
for(uint8_t i=0; i<12;i++)
{
uint8_t x, y;
x= 80 * (i % 4); /* 0, 160, 240 */
y= 80 * (i / 4); /* 0, 160 */
if( screen[index].game[i] != EMPTY ) /* if not empty block */
{
char buffer[12];
#if 1
itoa(index, buffer, 10);
setCurrentFont(&CourierNew12ptFontInfo);
tft_puts_P( 5, 5, PSTR(" "), black, BG_COLOR );
tft_puts( 5, 5, buffer, black, BG_COLOR );
#endif
/* draw block */
tft_fill_rect(x, y, 80, 80, red);
itoa(screen[index].game[i], buffer, 10);
setCurrentFont(&CourierNew12ptFontInfo);
tft_puts_P( x+30, y+34, PSTR(" "), black, red );
tft_puts( x+30, y+34, buffer, black, red );
}
else
{
x = 80 * (i % 4);
y = 80 * (i / 4);
tft_fill_rect(x, y, 80, 80, BG_COLOR);
}
}
#endif
fx_ptr = temp_ptr;
}
/* change screen */
/* screen with empty block changed, now all are the same */
void change_screen(void)
{
uint8_t j = 255, k = 255, temp;

for(uint8_t i = left; i < center; i++)
{
if( selected_block == neighborhood[empty_block][i] )
{
k = i; /* left, top, right or bottom */
}
}

for(uint8_t i = 0; i <= 4; i++)
{
if( screen[i].function == k)
{
j = i;
}
}

if( empty_block != selected_block && (j < 5) )
{
for(uint8_t i = 0; i <= 4; i++)
{
if(screen[i].function == center)
{
/* switch empty and selected in game table */
temp = screen[i].game[empty_block]; /* copy */
screen[i].game[empty_block] = screen[i].game[selected_block]; /* change */
screen[i].game[selected_block] = temp; /* paste */

}
}
for(uint8_t i = 0; i <= 4; i++)
{
if(screen[i].function == center)
{
/* switch screen function */
temp = screen[i].function;
screen[i].function = screen[j].function;
screen[j].function = temp;
}
}

empty_block = selected_block;

setxbuf( screen[j].scr_buf ); /* change screen */
fx_ptr = screen[j].scr_buf; /* change write pointer */
}
}
uint8_t get_block(void)
{
int16_t x = 0, y = 0;
x=TP_X, y=TP_Y;
if(y < 80)
if(x < 80) return 0;
else if(x < 160) return 1;
else if (x < 240) return 2;
else return 3;
else if(y < 160)
if(x < 80) return 4;
else if(x < 160) return 5;
else if (x < 240) return 6;
else return 7;
else
if(x < 80) return 8;
else if(x < 160) return 9;
else if (x < 240) return 10;
else return 11;
}

void create_tab(void)
{
uint8_t empty = 255, index, temp;

for(uint8_t i = 0; i <= 4; i++)
{
if( screen[i].function == center )
{
for(uint8_t k = 0; k <= 4; k++)
{
if( screen[k].function != center )
{
for (uint8_t j = 0; j < 12; j++)
{
screen[k].game[j] = screen[i].game[j]; /* all are the same */
}
}
}
}
}

for(uint8_t i = 0; i <= 4; i++)
{
if( screen[i].function != center ) /* center will be unchanged */
{
for (uint8_t j = 0; j < 12; j++)
{
if( screen[i].game[j] == EMPTY ) empty = j;
}

index = neighborhood[empty][ screen[i].function ]; //index of the neighbor in all 4 tables
if( index < 12 )
{ /* switch in table */
temp = screen[i].game[index];
screen[i].game[index] = screen[i].game[empty];
screen[i].game[empty] = temp;
}
}
}

for(uint8_t i = 0; i <= 4; i++)
for(uint8_t j = 0; j < 12; j++)
screen[i].last[j] = screen[i].game[j];
}
/* all screens like that with empty block = selected block, */
/* screen with empty block unchanged */
void arrange_tab_c(void)//
{
uint8_t k = 255, empty = 255, index, temp;

for(uint8_t i = left; i < center; i++)
{
if( selected_block == neighborhood[empty_block][i] )
{
k = i; /* left, top, right or bottom */
}
}

for(uint8_t i = 0; i <= 4; i++)
{ /* center and selected will be unchanged */
if( screen[i].function != center && screen[i].function != k)
{
for (uint8_t j = 0; j < 12; j++)
{
if( screen[i].game[j] == EMPTY ) empty = j;
}

index = neighborhood[empty][ k ]; /* index of the neighbor in all 4 tables */
if( index < 12 )
{
temp = screen[i].game[index];
screen[i].game[index] = screen[i].game[empty];
screen[i].game[empty] = temp;
}
}
}
}

void arrange_tab_k(void)
{
uint8_t empty = 255, index, temp;

for(uint8_t i = 0; i <= 4; i++)
for(uint8_t j = 0; j < 12; j++)
screen[i].last[j] = screen[i].game[j];

for(uint8_t i = 0; i <= 4; i++)
{ /* center will be unchanged */
if( screen[i].function != center)
{
for (uint8_t j = 0; j < 12; j++)
{
if( screen[i].game[j] == EMPTY ) empty = j;
}

index = neighborhood[empty][ screen[i].function ]; /* index of the neighbor in all 4 tables */
if( index < 12 )
{
temp = screen[i].game[index];
screen[i].game[index] = screen[i].game[empty];
screen[i].game[empty] = temp;
}
}
}
}
/* back to empty block, screen with empty block and selected block unchanged*/
void rearrange_tab(void)
{
uint8_t k = 255, l = 255, empty = 255, index, temp, opposite;

for(uint8_t i = left; i < center; i++)
{
if( selected_block == neighborhood[empty_block][i] )
{
k = i; /* left, top, right or bottom */
}
}
for(uint8_t i = 0; i <= 4; i++)
{
if( screen[i].function == center )
{
l = i;
}
}

for(uint8_t i = 0; i <= 4; i++)
{ /* center and selected will be unchanged */
if( screen[i].function != center && screen[i].function != k)
{
for (uint8_t j = 0; j < 12; j++)
{
if( screen[i].game[j] == EMPTY ) empty = j;
}
if(screen[i].game[empty] == screen[l].game[empty]) continue; /* don't need changes */
opposite = (screen[i].function + 2) % 4; /* opposite block */
index = neighborhood[empty][ opposite ]; /* index of the neighbor in all 4 tables */
if( index < 12 )/*if exist */
{
temp = screen[i].game[index];
screen[i].game[index] = screen[i].game[empty];
screen[i].game[empty] = temp;
}
}
}
}

void fill_empty(void)
{
uint16_t temp_ptr = fx_ptr;
#if mode==work
char file[12];
uint8_t len;
strcpy(file, file_origin);
len = strlen(file);
uint8_t x, y, index;
for (uint8_t i = 0; i <= 4; i++)
{
fx_ptr = screen[i].scr_buf;
index = screen[i].to_set;
if(index < 12)
{
x = 80 * (index % 4);
y = 80 * (index / 4);
itoa(screen[i].game[index], &file[len], 10);
strcat(file, ".rg8");
tft_bitmap_from_file(x, y, file, NULL );
}
}
#elif mode==debug
uint8_t x, y, index;
for (uint8_t i = 0; i <= 4; i++)
{
fx_ptr = screen[i].scr_buf;
index = screen[i].to_set;
if(index < 12)
{
char buffer[12];
x = 80 * (index % 4);
y = 80 * (index / 4);

tft_fill_rect(x, y, 80, 80,red);
itoa(screen[i].game[index], buffer, 10);
setCurrentFont(&CourierNew12ptFontInfo);
tft_puts_P( x+30, y+34, PSTR(" "), black, red );
tft_puts( x+30, y+34, buffer, black, red );
}
}
#endif
fx_ptr = temp_ptr;
}

void make_empty(void)
{
uint16_t temp_ptr = fx_ptr;

uint8_t x, y, index;
for (uint8_t i = 0; i <= 4; i++)
{
fx_ptr = screen[i].scr_buf;
index = screen[i].to_clear;
if(index < 12)
{
x = 80 * (index % 4);
y = 80 * (index / 4);
tft_fill_rect(x, y, 80, 80, BG_COLOR);
}
}
fx_ptr = temp_ptr;
}

void draw_table(uint8_t scr)
{

char buffer[12];
uint8_t x, y;
switch(scr)
{
case 0: x = 0; y = 0; break;
case 1: x = 100; y = 0; break;
case 2: x = 200; y = 0; break;
case 3: x = 0; y = 80; break;
case 4: x = 100; y = 80; break;
default: x = 0; y = 0; break;
}
setCurrentFont(&DefaultFontInfo);
for(uint8_t j = 0; j < 3; j++)
{
tft_puts_P( 5+x, 50+15*j+y, PSTR(" "), black, BG_COLOR );
for(uint8_t i = 0; i < 4; i++)
{
for(uint8_t l = 0; l <= 4; l++)
{
if(screen[l].function == scr)
{
itoa(screen[l].game[j*4+i], buffer, 10);
}
}

tft_puts( 5+20*i+x, 50+15*j+y, buffer, black, BG_COLOR );
}
}
}

void draw_m_f(void)
{
char buffer[12];
setCurrentFont(&DefaultFontInfo);

tft_puts_P( 205, 130, PSTR(" "), black, BG_COLOR );
tft_puts_P( 205, 145, PSTR(" "), black, BG_COLOR );

for(uint8_t i = left; i <= center; i++)
{
for(uint8_t j = 0; j <= 4; j++)
{
if(screen[j].function == i)
{
itoa(screen[j].to_set, buffer, 10);
tft_puts( 205 + 22 * i, 130, buffer, black, BG_COLOR );
itoa(screen[j].to_clear, buffer, 10);
tft_puts( 205 + 22 * i, 145, buffer, black, BG_COLOR );
}
}
}
}

void check_differences(void)
{
for(uint8_t i = 0; i <= 4; i++)
{
screen[i].to_set = 255;
screen[i].to_clear = 255;

for(uint8_t j = 0; j < 12; j++)
{
if( screen[i].game[j] != screen[i].last[j] )
{
if( screen[i].last[j] == EMPTY ) screen[i].to_set = j;
else screen[i].to_clear = j;
screen[i].last[j] = screen[i].game[j];
}
}
}
}

void show_all(void)
{
for(uint8_t k = left; k <= center; k++)
{
_delay_ms(1000);
for(uint8_t i=0; i<5; i++)
{
if(screen[i].function == k)
{
setxbuf(screen[i].scr_buf);
fx_ptr = screen[i].scr_buf;
}
}
_delay_ms(1000);
}
}

void show_tables(void)
{
draw_table(left);
draw_table(top);
draw_table(right);
draw_table(bottom);
draw_table(center);
draw_m_f();
_delay_ms(1000);
}
void show_moves(void)
{
uint16_t temp_ptr = fx_ptr;
for(uint8_t i = 0; i <= 4; i++)
{
if(screen[i].function != center)
{
for(uint8_t j = 0; j < 12; j++)
{
if( screen[i].game[j] == EMPTY )
{
char buffer[12];
uint8_t x, y;
x = 80 * (j % 4);
y = 80 * (j / 4);
fx_ptr = screen[i].scr_buf;
itoa(moves, buffer, 10);
setCurrentFont(&CourierNew12ptFontInfo);
tft_puts_P( x+20, y+34, PSTR(" "), black, BG_COLOR );
tft_puts( x+20, y+34, buffer, black, BG_COLOR );
}
}
}
}
fx_ptr = temp_ptr;
}

void end_game(void)
{
uint8_t correct = 0;
for(uint8_t i = 0; i <= 4; i++)
{
if(screen[i].function == center)
{
for(uint8_t j = 0; j < 12; j++)
{
if( screen[i].game[j] == j ) correct++;
}
if(correct == 12)
{
display_ending();
}
}
}
}

void display_ending(void)
{
for(uint8_t i = 0; i <= 4; i++)
{
if(screen[i].function != center)
{
for(uint8_t j = 0; j < 12; j++)
{
if( screen[i].game[j] == EMPTY )
{
char buffer[12];
itoa(moves, buffer, 10);
uint8_t x, y;
x = 80 * (j % 4);
y = 80 * (j / 4);
fx_ptr = screen[i].scr_buf;
setCurrentFont(&CourierNew12ptFontInfo);
tft_puts_P( x, y+19, PSTR("You win"), black, BG_COLOR );
tft_puts( x+20, y+34, buffer, black, BG_COLOR );
tft_puts_P( x+10, y+49, PSTR("Moves"), black, BG_COLOR );
}
}
}
else
{
#if mode==work
char file[12];
uint8_t len;
strcpy(file, file_origin);
len = strlen(file);
strcpy(file, file_origin);
uint8_t x, y;
fx_ptr = screen[i].scr_buf;

x = 80 * (11 % 4);
y = 80 * (11 / 4);
itoa(screen[i].game[11], &file[len], 10);
strcat(file, ".rg8");
tft_bitmap_from_file(x, y, file, NULL );
#elif mode==debug
uint8_t x, y;
fx_ptr = screen[i].scr_buf;

char buffer[12];
x = 80 * (11 % 4);
y = 80 * (11 / 4);

tft_fill_rect(x, y, 80, 80,red);
itoa(screen[i].game[11], buffer, 10);
setCurrentFont(&CourierNew12ptFontInfo);
tft_puts_P( x+30, y+34, PSTR(" "), black, red );
tft_puts( x+30, y+34, buffer, black, red );
#endif
}
}
while(1) show_all();
}
[/syntax]
- game01.h
[syntax=c]/*
* game01.h
*
* Created on: 12-02-2013
*
*/

#ifndef GAME01_H_
#define GAME01_H_

#include
#include
#include

#include "MK_SSD1963/MK_SSD1963.h"
#include "I2C_TWI/i2c_twi.h"
#include "MK_STMPE811/mk_stmpe811.h"
#include "PetitFS/diskio.h"
#include "PetitFS/pff.h"

#define BG_COLOR blue
#define LINE_COLOR red
#define EMPTY11

#define debug 0
#define work 1
#define mode work

extern char file_origin[12];

typedef struct{
const uint16_t scr_buf;/* address in display's buffer */
uint8_t game[12];/* game table */
uint8_t last[12];/* last time displayed */
uint8_t to_set;/* new block */
uint8_t to_clear;/* block to be clean */
uint8_t function;/* function of that screen */
} SCREEN;

enum { left=0, top, right, bottom, center};

extern SCREEN screen[5];
extern const uint8_t neighborhood[12][4];
extern uint8_t empty_block, selected_block;
extern uint16_t moves;

void draw_all(uint16_t ptr);
uint8_t get_block(void);

void change_screen(void);
void create_tab(void);
void rearrange_tab(void);

void fill_empty(void);
void make_empty(void);
void arrange_tab_c(void);
void arrange_tab_k(void);

void draw_table(uint8_t table);
void draw_m_f(void);

void check_differences(void);
void show_all(void);
void show_tables(void);
void show_moves(void);
void end_game(void);
void display_ending(void);

#endif /* GAME01_H_ */
[/syntax]
- reszta to kody dołączone do drugiej książki Mirka.

Jak będzie potrzeba to oczywiście mogę wytłumaczyć działanie poszczególnych funkcji, ale do zabawy wystarczy plik hex, którym nalezy zaprogramować ATMEGĘ644PA i przestawić na zewnętrzne taktowanie 20MHz oraz program do generowania obrazków. Następnie obrazki należy wrzucić na kartę, ale wszystkie inne obrazki w formacie rg8 muszą zostać z niej usunięte.
Przy starcie program najpierw szuka plików i jak znajdzie to wyświetla nazwę serii i od razu ładuje 4 ekrany. Jak pojawi się napis READY należy dotknąć ekran i ładowany jest jeszcze jeden ekran. Po usłyszeniu sygnału dźwiękowego można zacząć główkować.

Statystyki: Napisane przez Krauser — 13 lut 2013, o 00:58