ATNEL tech-forum

Re: Gra zręcznościowa na ATB + TFT

2013-02-27T09:45:41+01:00

kila napisał(a):

Krauser - skąd masz tą wiedzę? Skąd masz na to czas???? jestem amatorem... :p

Zamiast pierdzielic na forum jak np ja to siedzi cicho i klepie

Statystyki: Napisane przez jachu — 27 lut 2013, o 09:45

Re: Gra zręcznościowa na ATB + TFT

2013-02-25T22:25:21+01:00

kila napisał(a):

Krauser - skąd masz tą wiedzę? Skąd masz na to czas???? jestem amatorem... :p

No ja bym się chciał dowiedzieć też, gdzie sprzedają czas na wiadra .

Statystyki: Napisane przez Gość — 25 lut 2013, o 22:25

Re: Gra zręcznościowa na ATB + TFT

2013-02-25T19:17:18+01:00

Krauser - skąd masz tą wiedzę? Skąd masz na to czas???? jestem amatorem... :p

Statystyki: Napisane przez kila — 25 lut 2013, o 19:17

Re: Gra zręcznościowa na ATB + TFT

2013-02-24T11:55:57+01:00

SunRiver napisał(a):

w sumie Krauzer to proponuję użyć NunChuck od Wii
masz w nim SW, Analog i akcelerometr zresztą całosc pracuje na I2C

Myślę że jak już kolega Krauser zaczął seryjne pisanie gier, to chyba w kolejnym projekcie będzie coś z podłączeniem Kinect'a do ATB .

Rządzisz Krauser

Statystyki: Napisane przez Sonix — 24 lut 2013, o 11:55

Re: Gra zręcznościowa na ATB + TFT

2013-02-24T11:01:38+01:00

Masakra, to ja ledwo diodą zamrugać potrafię a tu takie cuda robicie

Statystyki: Napisane przez dexter — 24 lut 2013, o 11:01

Re: Gra zręcznościowa na ATB + TFT

2013-02-23T14:42:58+01:00

w sumie Krauzer to proponuję użyć NunChuck od Wii
masz w nim SW, Analog i akcelerometr zresztą całosc pracuje na I2C

Statystyki: Napisane przez SunRiver — 23 lut 2013, o 14:42

Re: Gra zręcznościowa na ATB + TFT

2013-02-23T14:31:12+01:00

Raczej nie tutaj, ale ogólnie to mam zamiar wykorzystać taki rodzaj sterowania.

Statystyki: Napisane przez Krauser — 23 lut 2013, o 14:31

Re: Gra zręcznościowa na ATB + TFT

2013-02-23T12:53:14+01:00

Krauser a myślałeś nad tym aby w przyszłości dać sterowanie za pomocą liska do którego ostatnio Antystatyczny przygotował bibliotekę?

Statystyki: Napisane przez MichalXY — 23 lut 2013, o 12:53

Re: Gra zręcznościowa na ATB + TFT

2013-02-23T11:53:46+01:00

Widać odświeżanie. Można by jeszcze zmodyfikować kod i rysować linie poziome/pionowe kolorem wybranym wcześniej. Da się sterować dwiema rękami. Autko podąża do punktu wskazanego na ekranie, ale jak ktoś naciśnie skrają pozycję poza drogą to zmienna new_x jest ograniczana do do skrajnej pozycji na drodze.

Statystyki: Napisane przez Krauser — 23 lut 2013, o 11:53

Re: Gra zręcznościowa na ATB + TFT

2013-02-23T09:57:30+01:00

Szczęka opada...
Chciałbym kiedyś zbudować sterownik stacji lutowniczej do BGA z wykorzystaniem takiego wyświetlacza, aby rysował mi wykresy temperatur w czasie, ale jeszcze wiele wody w rzekach upłynie, zanim będę mógł zabrać się za coś podobnego.
Nic tylko pogratulować wiedzy koledze Krauser.

Statystyki: Napisane przez patol — 23 lut 2013, o 09:57

Re: Gra zręcznościowa na ATB + TFT

2013-02-22T23:21:38+01:00

Krauser a kiedy będzie need for speed?
Zazdroszczę ogromnej wiedzy ; )

Statystyki: Napisane przez osa1313 — 22 lut 2013, o 23:21

Re: Gra zręcznościowa na ATB + TFT

2013-02-22T22:59:40+01:00

Nieeee , noo nieeee - Sun .... chyba będzie trzeba kolegę Krausera zbanować z forum bo znacznie zawyża jego poziom hahahahahaa

(oczywiście ŻART) ..... ale poważnie osłabia mnie nasz kolega i umieram z zazdrości że nie mam na razie czasu pobrykania z tym wyświetlaczem .... Dla mnie każdy projekt kolegi Krauser to kolejne odkrywanie możliwości tego cacuszka SSD1963 .... a z drugiej strony NIESAMOWICIE patrzy się na KUNSZT pomysłowości i programowania

MEGA ODLOT

Statystyki: Napisane przez mirekk36 — 22 lut 2013, o 22:59

Re: Gra zręcznościowa na ATB + TFT

2013-02-22T22:27:05+01:00

Takie cuda można na AVR robić:D !!! Bardzo płynnie chodzi ta grafika, chyba zapodałeś kwarc ze 100MHz Jestem pełen podziwu!!! Gratuluje!!!

Statystyki: Napisane przez IUVOit — 22 lut 2013, o 22:27

Re: Gra zręcznościowa na ATB + TFT

2013-02-22T22:13:40+01:00

Krauser no wypas

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

Re: Gra zręcznościowa na ATB + TFT

2013-02-22T21:48:27+01:00

hmmm Kolego kiedy będzie port na Xboxa360 , PSP4 ??
Jak zwykle kawał dobrej roboty ... mosz ta glaca na gnyku
... Gratulacje

Statystyki: Napisane przez SunRiver — 22 lut 2013, o 21:48

Gra zręcznościowa na ATB + TFT

2013-02-22T21:45:14+01:00

Poprzednio trenowaliśmy umysł, a teraz poćwiczymy zręczność. Oczywiście na zestawie ATB z dołączonym wyświetlaczem graficznym, który podłączony jest jak poprzednio do portu A, portu C i PD.2. Do PB.0 podłączony jest buzzer. Nazwa gry (Polskie drogi) dużo mówi o tym co będzie zadaniem gracza Trzeba oczywiście omijać dziury na drodze i zaparkowane auta. Trzecia pomyłka kończy grę i wyświetla wynik. Reset rozpoczyna program od początku. Ekran gry i działanie wygląda następująco:

iframe

Opis działania programu:
- Dzięki wykorzystaniu bibliotek do TFT z książki "Język C Pasja programowania mikrokontrolerów 8-bitowych" Mirosława Kardasia przygotowanie programu znacznie się uprościło
- W książce opisane jest wykorzystanie dodatkowej pamięci. Tutaj również to jest potrzebne z tym, że obraz jest przewijany o jedną linię. Dzięki temu można załadować na początku 4 ekrany, a w pętli głównej tylko wyświetlać samochód gracza i dziury w drodze
- Autko nie jest wyświetlane jako bitmapa, a złożone jest z linii. Nie potrzeba zatem korzystać z karty pamięci, ani wypełniać pamięci danymi o każdym pikselu. Wykorzystane są linie poziome i pionowe, których kod jest bardzo podobny do wyświetlania prostokąta. Myślę, że po lekturze każdy stworzy takie funkcje. Głównym celem takiego podejścia jest zwiększenie szybkości rysowania.
- Program korzysta z funkcji srand i rand do generowania losowej pozycji dziur w drodze. Argument funkcji srand zależy od momentu dotknięcia przez gracza ekranu i w sumie można by nawet nie korzystać z tych funkcji.
- Wszystkie 3 mapki do gry generowane są programowo, ale można również wykorzystać bitmapy jeśli ktoś dysponuje odpowiednimi zdjęciami.
- Zmiana pozycji samochodu jest możliwa tylko w osi x jako, że ekran jest przewijany (w osi y).

Główne pliki programu:
- main.c
[syntax=c]/*
* main.c
*/
#include
#include
#include
#include
#include
#include
#include

#include "main.h"
#include "game03.h"

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

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

uint8_t start = 0;
uint16_t new_x = CAR_X, counter = 0;

uint16_t seed; /* for random */

i2cSetBitrate(400);/* I2C speed */

u_init(); /* unused port initialization and buzzer */

tft_init();/* TFT LCD initialization */

stmpe811_init(); /* STMPE811 initialization */

setCurrentFont(&CourierNew12ptFontInfo);

fx_ptr = SSDXBUF0;
tft_fill_rect(0, 0, 320, 240, BG_COLOR);
tft_puts_P( 100, 100, PSTR("POLISH ROADS"), black, BG_COLOR );

tft_puts_P( 100, 140, PSTR("TAP TO START"), black, BG_COLOR );

Set_color32(black);
tft_line(85, 0, 0, 190);
tft_line(234, 0, 319, 190);

fx_ptr = SSDXBUF1;
tft_fill_rect(0, 0, 320, 240, BG_COLOR);
draw_map1();

fx_ptr = SSDXBUF2;
tft_fill_rect(0, 0, 320, 240, BG_COLOR);
draw_map2();

fx_ptr = SSDXBUF3;
tft_fill_rect(0, 0, 320, 240, BG_COLOR);
draw_map3();

fx_ptr = SSDXBUF4;
tft_fill_rect(0, 0, 320, 240, BG_COLOR);
draw_map1();

sei();/* enable interrupts */

/* main loop */
while(1) {
seed++;
if (st_intX_flag) /* screen touched */
{
if(start == 0) start = 1;
else
{
new_x = check_position();
/* correct new position - stay on the road */
if(new_x > 220 - CAR_W/2) new_x = 220 - CAR_W/2;
if(new_x < 100 + CAR_W/2) new_x = 100 + CAR_W/2;
}
srand(seed);
st_intX_flag = 0;
} /* if (st_intX_flag) */

if(start == 1)
{
car_x = new_x = CAR_X;
setxbuf(SSDXBUF4); /* begin from the last screen */
screen_pos = SSDXBUF4;
start = 2;
}
else if (start == 2)
{
draw_car(car_x - CAR_W/2, CAR_Y, ROAD_COLOR); /* remove */

setxbuf(screen_pos--); /* scrolling */
if(screen_pos == SSDXBUF1)
{
screen_pos = SSDXBUF4;
counter++;
}

if(new_x < car_x) car_x--; /* move car to new position */

if( new_x > car_x ) car_x++;

fx_ptr = screen_pos;
draw_car(car_x - CAR_W/2, CAR_Y, navy); /* draw car on the screen */

if(detect_colision())
{
short_beep();
_delay_ms(1000);
draw_car(car_x - CAR_W/2, CAR_Y, ROAD_COLOR);
start = 1;
if(cars) /* continue */
cars--;
else /* game over */
{
tft_puts_P( 140, 100, PSTR("GAME"), black, ROAD_COLOR );
tft_puts_P( 140, 120, PSTR("OVER"), black, ROAD_COLOR );
display_number(140, 140, counter);
while(1); /* end */
}
}
if(screen_pos == SSDXBUF4)
{
move_hole( 124+rand()%50, rand()%100, hole_index[0] ); /* random position */
move_hole( 124+rand()%50, rand()%100, hole_index[1] ); /* random position */
}
_delay_ms(3); /* game speed */
}/* if(!start) */
}/* while(1) */
}/* main() */

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

#ifndef MAIN_H_
#define MAIN_H_

#define BUZ PB0

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

static inline void u_init(void)
{
DDRB |= (1<PORTD = 0xFF;
PORTB = 0xFF & ~(1<}

#endif /* MAIN_H_ */[/syntax]
- game03.c
[syntax=c]/*
* game01.c
*/
#include "game03.h"

uint8_t cars = 2, obstacles, hole_index[5];
int16_t screen_pos;
uint16_t car_x = CAR_X;
OBSTACLE obstacle[10];

/* faster than bitmap */
void draw_car(uint16_t x, uint16_t y, uint32_t color)
{
tft_hline( x, 2+x, 20+y, color);
tft_vline( 2+x, 5+y, 45+y, color);
tft_vline( 3+x, 3+y, 20+y, color);
tft_vline( 3+x, 34+y, 48+y, color);
tft_vline( 4+x, 2+y, 22+y, color);
tft_vline( 4+x, 36+y, 48+y, color);
tft_vline( 5+x, 1+y, 13+y, color);
tft_vline( 5+x, 21+y, 49+y, color);
tft_vline( 6+x, 1+y, 13+y, color);
tft_vline( 6+x, 22+y, 37+y, color);
tft_vline( 6+x, 41+y, 49+y, color);
tft_vline( 7+x, 1+y, 12+y, color);
tft_vline( 7+x, 22+y, 37+y, color);
tft_vline( 7+x, 44+y, 49+y, color);
tft_vline( 8+x, y, 12+y, color);
tft_vline( 8+x, 22+y, 37+y, color);
tft_vline( 8+x, 45+y, 49+y, color);
tft_vline( 9+x, y, 12+y, color);
tft_vline( 9+x, 22+y, 37+y, color);
tft_vline( 9+x, 45+y, 49+y, color);
tft_vline(10+x, y, 11+y, color);
tft_vline(10+x, 22+y, 37+y, color);
tft_vline(10+x, 46+y, 49+y, color);
tft_vline(11+x, y, 11+y, color);
tft_vline(11+x, 22+y, 37+y, color);
tft_vline(11+x, 46+y, 49+y, color);

tft_hline(22+x, 23+x, 20+y, color);
tft_vline(21+x, 5+y, 45+y, color);
tft_vline(20+x, 3+y, 20+y, color);
tft_vline(20+x, 34+y, 48+y, color);
tft_vline(19+x, 2+y, 22+y, color);
tft_vline(19+x, 36+y, 48+y, color);
tft_vline(18+x, 1+y, 13+y, color);
tft_vline(18+x, 21+y, 49+y, color);
tft_vline(17+x, 1+y, 13+y, color);
tft_vline(17+x, 22+y, 37+y, color);
tft_vline(17+x, 41+y, 49+y, color);
tft_vline(16+x, 1+y, 12+y, color);
tft_vline(16+x, 22+y, 37+y, color);
tft_vline(16+x, 44+y, 49+y, color);
tft_vline(15+x, y, 12+y, color);
tft_vline(15+x, 22+y, 37+y, color);
tft_vline(15+x, 45+y, 49+y, color);
tft_vline(14+x, y, 12+y, color);
tft_vline(14+x, 22+y, 37+y, color);
tft_vline(14+x, 45+y, 49+y, color);
tft_vline(13+x, y, 11+y, color);
tft_vline(13+x, 22+y, 37+y, color);
tft_vline(13+x, 46+y, 49+y, color);
tft_vline(12+x, y, 11+y, color);
tft_vline(12+x, 22+y, 37+y, color);
tft_vline(12+x, 46+y, 49+y, color);
}

void draw_car2(uint16_t y, uint16_t x, uint32_t color)
{
tft_vline( 20+y, x, 2+x, color);
tft_hline( 5+y, 45+y, 2+x, color);
tft_hline( 3+y, 20+y, 3+x, color);
tft_hline( 34+y, 48+y, 3+x, color);
tft_hline( 2+y, 22+y, 4+x, color);
tft_hline( 36+y, 48+y, 4+x, color);
tft_hline( 1+y, 13+y, 5+x, color);
tft_hline( 21+y, 49+y, 5+x, color);
tft_hline( 1+y, 13+y, 6+x, color);
tft_hline( 22+y, 37+y, 6+x, color);
tft_hline( 41+y, 49+y, 6+x, color);
tft_hline( 1+y, 12+y, 7+x, color);
tft_hline( 22+y, 37+y, 7+x, color);
tft_hline( 44+y, 49+y, 7+x, color);
tft_hline( y, 12+y, 8+x, color);
tft_hline( 22+y, 37+y, 8+x, color);
tft_hline( 45+y, 49+y, 8+x, color);
tft_hline( y, 12+y, 9+x, color);
tft_hline( 22+y, 37+y, 9+x, color);
tft_hline( 45+y, 49+y, 9+x, color);
tft_hline( y, 11+y, 10+x, color);
tft_hline( 22+y, 37+y, 10+x, color);
tft_hline( 46+y, 49+y, 10+x, color);
tft_hline( y, 11+y, 11+x, color);
tft_hline( 22+y, 37+y, 11+x, color);
tft_hline( 46+y, 49+y, 11+x, color);

tft_vline( 20+y, 22+x, 23+x, color);
tft_hline( 5+y, 45+y, 21+x, color);
tft_hline( 3+y, 20+y, 20+x, color);
tft_hline( 34+y, 48+y, 20+x, color);
tft_hline( 2+y, 22+y, 19+x, color);
tft_hline( 36+y, 48+y, 19+x, color);
tft_hline( 1+y, 13+y, 18+x, color);
tft_hline( 21+y, 49+y, 18+x, color);
tft_hline( 1+y, 13+y, 17+x, color);
tft_hline( 22+y, 37+y, 17+x, color);
tft_hline( 41+y, 49+y, 17+x, color);
tft_hline( 1+y, 12+y, 16+x, color);
tft_hline( 22+y, 37+y, 16+x, color);
tft_hline( 44+y, 49+y, 16+x, color);
tft_hline( y, 12+y, 15+x, color);
tft_hline( 22+y, 37+y, 15+x, color);
tft_hline( 45+y, 49+y, 15+x, color);
tft_hline( y, 12+y, 14+x, color);
tft_hline( 22+y, 37+y, 14+x, color);
tft_hline( 45+y, 49+y, 14+x, color);
tft_hline( y, 11+y, 13+x, color);
tft_hline( 22+y, 37+y, 13+x, color);
tft_hline( 46+y, 49+y, 13+x, color);
tft_hline( y, 11+y, 12+x, color);
tft_hline( 22+y, 37+y, 12+x, color);
tft_hline( 46+y, 49+y, 12+x, color);
}

void draw_hole(uint16_t x, uint16_t y, uint32_t color)
{
tft_hline(1+x, 6+x, y, color);
tft_hline( x, 6+x, 1+y, color);
tft_hline(1+x, 7+x, 2+y, color);
tft_hline(1+x, 7+x, 3+y, color);
tft_hline(2+x, 7+x, 4+y, color);
tft_hline( x, 6+x, 5+y, color);
tft_hline( x, 6+x, 6+y, color);
tft_hline(1+x, 5+x, 7+y, color);
}

void draw_map1(void)
{
tft_fill_rect(100, 0, 120, 240, ROAD_COLOR);
draw_building_l(18, 20, 45, 90, 1, red);
draw_building_l(8, 120, 45, 90, 2, green);
draw_building_r(266, 10, 45, 90, 2, blue);
draw_building_r(256, 120, 45, 90, 1, yellow);
draw_sidewalk(220, 0, 25, 240);
draw_sidewalk(74, 0, 25, 240);
place_car(100, 10, fuchsia, SSDXBUF4);
place_car(196, 100, red, SSDXBUF4);
}

void draw_map2(void)
{
tft_fill_rect(100, 0, 120, 240, ROAD_COLOR);
tft_fill_rect(0, 81, 100, 79, ROAD_COLOR);
tft_fill_rect(220, 81, 100, 79, ROAD_COLOR);
draw_building_l(18, 5, 45, 40, 1, red);
draw_building_l(8, 175, 45, 40, 2, green);
draw_building_r(266, 4, 45, 40, 2, blue);
draw_building_r(256, 165, 45, 50, 1, yellow);
draw_sidewalk(220, 0, 25, 80);
draw_sidewalk(74, 0, 25, 80);
draw_sidewalk(220, 160, 25, 80);
draw_sidewalk(74, 160, 25, 80);
draw_sidewalk(0, 60, 74, 20);
draw_sidewalk(245, 60, 74, 20);
place_car(100, 10, blue, SSDXBUF2);

draw_car2(45, 85, red);
draw_car2(230, 85, green);

hole_index[0] = obstacles;
place_hole( 130, 30, SSDXBUF2);
}

void draw_map3(void)
{
tft_fill_rect(100, 0, 120, 240, ROAD_COLOR);
tft_fill_rect(220, 81, 100, 79, ROAD_COLOR);
draw_building_l(18, 5, 45, 40, 1, yellow);
draw_building_l(8, 175, 45, 40, 2, green);
draw_building_l(8, 82, 45, 80, 2, purple);
draw_building_r(266, 2, 45, 40, 2, blue);
draw_building_r(260, 165, 45, 50, 1, red);
draw_sidewalk(220, 0, 25, 80);
draw_sidewalk(74, 0, 25, 240);
draw_sidewalk(220, 160, 25, 80);
draw_sidewalk(74, 160, 25, 80);
draw_sidewalk(0, 60, 74, 20);
draw_sidewalk(245, 60, 74, 20);
place_car(100, 100, lime, SSDXBUF3);
place_car(196, 10, purple, SSDXBUF3);

draw_car2(220, 85, honig);
draw_car2(265, 109, red);

hole_index[1] = obstacles;
place_hole( 180, 50, SSDXBUF3);
}

/* building located on the left side of the road */
void draw_building_l(uint16_t x, uint16_t y, uint8_t width, uint8_t length, uint8_t height, uint32_t color)
{
Set_color32(color);
tft_fill_rect(x, y, width, length, color);
tft_vline(x+width+10*height, y+5*height, y+length+5*height, color);
tft_line(x+width, y, x+width+10*height, y+5*height);
tft_hline(x+10*height, x+width+10*height, y+length+5*height, color);
tft_line(x+width, y+length, x+width+10*height, y+length+5*height);
tft_line(x, y+length, x+10*height, y+length+5*height);
}

/* building located on the right side of the road */
void draw_building_r(uint16_t x, uint16_t y, uint8_t width, uint8_t length, uint8_t height, uint32_t color)
{
Set_color32(color);
tft_fill_rect(x, y, width, length, color);
tft_vline(x-10*height, y+5*height, y+length+5*height, color);
tft_line(x, y, x-10*height, y+5*height);
tft_hline(x-10*height, x+width-10*height, y+length+5*height, color);
tft_line(x+width, y+length, x+width-10*height, y+length+5*height);
tft_line(x, y+length, x-10*height, y+length+5*height);
}

void draw_sidewalk(uint16_t x, uint16_t y, uint8_t width, uint8_t length )
{
tft_fill_rect(x,y,width,length, 0xDDE1CC);
for(uint16_t i = x; i <= x + width; i+=5)
{
tft_vline(i,y,y+length, black);
}
for(uint16_t i = y; i <= y + length; i+=5)
{
tft_hline(x, x+width, i, black);
}
}

uint16_t check_position(void)
{
int16_t x = 0;
x = TP_X;
return x;
}

void display_number(uint16_t x, uint16_t y, uint16_t number)
{
char buffer[12];
itoa(number, buffer, 10);
setCurrentFont(&CourierNew12ptFontInfo);
tft_puts( x, y, buffer, black, ROAD_COLOR );
}

uint8_t detect_colision(void)
{
for(uint8_t i = 0; i < obstacles; i++) /* for all obstacles */
{
if(
(
( (screen_pos + CAR_Y) % 240 <= obstacle[i].y + obstacle[i].length)/* front */
|| ( ((screen_pos + CAR_Y + CAR_L) % 240 >= obstacle[i].y)
&& ((screen_pos + CAR_Y + CAR_L) % 240 <= obstacle[i].length) ) /* back */
)
&& ( (screen_pos < obstacle[i].buf) && (screen_pos > obstacle[i].buf - 240) ) /* displayed screen */
)
{
if( (car_x - CAR_W/2 < obstacle[i].x + obstacle[i].width) && (car_x + CAR_W/2 > obstacle[i].x) )
{
return 1;
}
}
}
return 0;
}

void place_car(uint8_t x, uint8_t y, uint32_t color, uint16_t buf)
{
draw_car(x, y, color);
obstacle[obstacles].x = x;
obstacle[obstacles].y = y;
obstacle[obstacles].buf = buf;
obstacle[obstacles].width = CAR_W;
obstacle[obstacles].length = CAR_L;
obstacles++;
}

void place_hole(uint8_t x, uint8_t y, uint16_t buf)
{
draw_hole(x, y, black);
obstacle[obstacles].x = x;
obstacle[obstacles].y = y;
obstacle[obstacles].buf = buf;
obstacle[obstacles].width = 8;
obstacle[obstacles].length = 6;
obstacles++;
}

void move_hole(uint8_t x, uint8_t y, uint8_t index)
{
uint16_t temp_ptr = fx_ptr;
fx_ptr = obstacle[index].buf;
draw_hole(obstacle[index].x, obstacle[index].y, ROAD_COLOR); /* remove previous */
draw_hole(x, y, black); /* place new */
obstacle[index].x = x; /* save position */
obstacle[index].y = y;
fx_ptr = temp_ptr;
}[/syntax]
- game.h
[syntax=c]/*
* game01.h
*/

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

#define BG_COLOR white
#define LINE_COLOR red
#define ROAD_COLOR silver

#define CAR_L 50
#define CAR_W 24

#define CAR_X 160
#define CAR_Y 185

extern uint8_t cars, obstacles, hole_index[5];
extern int16_t screen_pos;
extern uint16_t car_x;

typedef struct
{
uint16_t x; /* left upper corner position */
uint16_t y; /* left upper corner position */
uint16_t buf; /* used screen */
uint8_t width;
uint8_t length;
} OBSTACLE;

void draw_car(uint16_t x, uint16_t y, uint32_t color);
void draw_car2(uint16_t x, uint16_t y, uint32_t color);
void draw_hole(uint16_t x, uint16_t y, uint32_t color);
void draw_map1(void);
void draw_map2(void);
void draw_map3(void);
void draw_building_l(uint16_t x, uint16_t y, uint8_t width, uint8_t length, uint8_t height, uint32_t color);
void draw_building_r(uint16_t x, uint16_t y, uint8_t width, uint8_t length, uint8_t height, uint32_t color);
void draw_sidewalk(uint16_t x, uint16_t y, uint8_t width, uint8_t length);

uint16_t check_position(void);
void display_number(uint16_t x, uint16_t y, uint16_t number);
uint8_t detect_colision(void);
void place_car(uint8_t x, uint8_t y, uint32_t color, uint16_t buf);
void place_hole(uint8_t x, uint8_t y, uint16_t buf);
void move_hole(uint8_t x, uint8_t y, uint8_t index);

#endif /* GAME01_H_ */[/syntax]

Szerokiej drogi

Statystyki: Napisane przez Krauser — 22 lut 2013, o 21:45