]>
git.gir.st - VIper.git/blob - viiper.c
1 /*******************************************************************************
3 By Tobias Girstmair, 2018
6 (see ./viiper -h for full list of options)
8 KEYBINDINGS: - hjkl to move
9 - p to pause and resume
12 - (see `./minesviiper -h' for all keybindings)
14 GNU GPL v3, see LICENSE or https://www.gnu.org/licenses/gpl-3.0.txt
15 *******************************************************************************/
18 #define _POSIX_C_SOURCE 2 /*for getopt and sigaction in c99, sigsetjmp*/
23 #include <sys/ioctl.h>
32 #define MIN(a,b) (a>b?b:a)
33 #define MAX(a,b) (a>b?a:b)
34 #define CLAMP(a,m,M) (a<m?m:(a>M?M:a))
35 #define printm(n, s) for (int _loop = 0; _loop < n; _loop++) fputs (s, stdout)
36 #define print(str) fputs (str?str:"", stdout)
39 #define OPPOSITE(dir) ( \
40 dir == EAST ? WEST : \
41 dir == WEST ? EAST : \
42 dir == NORTH ? SOUTH : \
43 dir == SOUTH ? NORTH : -1)
48 #define CW op.scheme->cell_width
51 int w
; /* field width */
52 int h
; /* field height */
53 int d
; /* direction the snake is looking */
54 int t
; /* time of game start */
56 float v
; /* velocity in moves per second */
57 struct snake
* s
; /* snek */
58 struct item
* i
; /* items (food, boni) */
60 int h
; /* write head */
61 int n
; /* number of elements */
63 } k
; /* ring buffer for direction events */
67 int l
; /* initial snake length */
68 int s
; /* initial snake speed */
69 struct scheme
* scheme
;
74 int main (int argc
, char** argv
) {
76 g
.w
= 30; //two-char-width
83 opterr
= 0; /* don't print message on unrecognized option */
84 while ((optget
= getopt (argc
, argv
, "+s:dh")) != -1) {
89 fprintf (stderr
, "speed must be >= 1\n");
93 case 'd': op
.scheme
= &vt220_charset
; break;
96 fprintf (stderr
, SHORTHELP LONGHELP
, argv
[0]);
97 return !(optget
=='h');
99 } if (optind
< argc
) { /* parse Fieldspec */
100 int n
= sscanf (argv
[optind
], "%dx%d", &g
.w
, &g
.h
);
103 fprintf(stderr
,"FIELDSIZE is WxH (width 'x' height)\n");
116 switch (sigsetjmp(game_over
, 1)) {
123 for (;;) switch (end_screen()) {
124 case 'r': goto restart
;
145 spawn_item(FOOD
, rand() % NUM_FOODS
, NULL
); //TODO: shape distribution, so bigger values get selected less
148 switch (getctrlseq()) {
149 case CTRSEQ_CURSOR_LEFT
: case 'h':append_movement(WEST
); break;
150 case CTRSEQ_CURSOR_DOWN
: case 'j':append_movement(SOUTH
); break;
151 case CTRSEQ_CURSOR_UP
: case 'k':append_movement(NORTH
); break;
152 case CTRSEQ_CURSOR_RIGHT
:case 'l':append_movement(EAST
); break;
155 move_ph (g
.h
/2+LINE_OFFSET
, g
.w
*CW
/2);
156 printf ("\033[5mPAUSE\033[0m"); /* blinking text */
157 if (getchar() == 'q') exit(0);
161 case 'r': siglongjmp(game_over
, GAME_START
);
162 case 'q': siglongjmp(game_over
, GAME_EXIT
);
167 case 0x02: /* STX; gets sent when returning from SIGALRM */
174 #define pop_dir() (g.k.n? g.k.c[(16+g.k.h-g.k.n--)%16] : NONE)
175 void snake_advance (void) {
177 struct item
* i
; /*temporary item (defined here to respawn at the end) */
178 int new_dir
= pop_dir();
179 /* switch direction if new one is in the buffer and it won't kill us: */
180 if (new_dir
&& g
.d
!= OPPOSITE(new_dir
)) g
.d
= new_dir
;
182 int new_row
= g
.s
->r
+(g
.d
==SOUTH
) -(g
.d
==NORTH
);
183 int new_col
= g
.s
->c
+(g
.d
==EAST
) -(g
.d
==WEST
);
185 /* detect food hit and spawn a new food */
186 for (i
= g
.i
; i
; i
= i
->next
) {
187 if (i
->r
== new_row
&& i
->c
== new_col
) {
189 respawn
= 1; /* must respawn after advancing head */
194 if (new_row
>= g
.h
|| new_col
>= g
.w
|| new_row
< 0 || new_col
< 0)
195 siglongjmp(game_over
, GAME_OVER
);
197 struct snake
* new_head
;
198 struct snake
* new_tail
; /* former second-to-last element */
199 for (new_tail
= g
.s
; new_tail
->next
->next
; new_tail
= new_tail
->next
)
200 /*use the opportunity of looping to check if we eat ourselves:*/
201 if(new_tail
->next
->r
== new_row
&& new_tail
->next
->c
== new_col
)
202 siglongjmp(game_over
, GAME_OVER
);
203 int old_tail
[2] = {new_tail
->next
->r
, new_tail
->next
->c
};/*gets erased*/
204 new_head
= new_tail
->next
; /* reuse element instead of malloc() */
205 new_tail
->next
= NULL
;
207 new_head
->r
= new_row
;
208 new_head
->c
= new_col
;
209 new_head
->next
= g
.s
;
213 if (respawn
) spawn_item(FOOD
, rand() % NUM_FOODS
, i
);
214 draw_sprites (old_tail
[0], old_tail
[1]);
217 void spawn_item (int type
, int value
, struct item
* p_item
) {
222 /* loop through snake to check if we aren't on it */
223 //WARN: inefficient as snake gets longer; near impossible in the end
224 //TODO: check if game won
225 for (struct snake
* s
= g
.s
; s
; s
= s
->next
)
226 if (s
->r
== row
&& s
->c
== col
) goto try_again
;
228 /* if we got a item buffer reuse it, otherwise create a new one: */
229 struct item
* new_item
;
230 if (p_item
) new_item
= p_item
;
231 else new_item
= malloc (sizeof(struct item
));
237 new_item
->s
= time(0);
238 if (g
.i
) g
.i
->prev
= new_item
;
239 new_item
->next
= g
.i
;
240 new_item
->prev
= NULL
;
245 void consume_item (struct item
* i
) {
249 case FOOD_5
: g
.p
+= 5; break;
250 case FOOD_10
: g
.p
+= 10; break;
251 case FOOD_20
: g
.p
+= 20; break;
253 snake_append(&g
.s
, 0,0); /* position doesn't matter, as item */
254 break; /* will be reused as the head before it is drawn */
260 if (i
->next
) i
->next
->prev
= i
->prev
;
261 if (i
->prev
) i
->prev
->next
= i
->next
;
265 void show_playfield (void) {
270 printm (g
.w
, BORDER(T
,C
));
271 printf ("%s\n", BORDER(T
,R
));
274 for (int row
= 0; row
< g
.h
; row
++)
275 printf ("%s%*s%s\n", BORDER(C
,L
), CW
*g
.w
, "", BORDER(C
,R
));
279 printm (g
.w
, BORDER(B
,C
));
285 void draw_sprites (int erase_r
, int erase_c
) {
287 move_ph (erase_r
+LINE_OFFSET
, erase_c
*CW
+COL_OFFSET
);
291 struct snake
* last
= NULL
;
293 for (struct snake
* s
= g
.s
; s
; s
= s
->next
) {
294 move_ph (s
->r
+LINE_OFFSET
, s
->c
*CW
+COL_OFFSET
);
296 int predecessor
= (last
==NULL
)?NONE
:
297 (last
->r
< s
->r
) ? NORTH
:
298 (last
->r
> s
->r
) ? SOUTH
:
299 (last
->c
> s
->c
) ? EAST
:
300 (last
->c
< s
->c
) ? WEST
:NONE
;
301 int successor
= (s
->next
== NULL
)?NONE
:
302 (s
->next
->r
< s
->r
) ? NORTH
:
303 (s
->next
->r
> s
->r
) ? SOUTH
:
304 (s
->next
->c
> s
->c
) ? EAST
:
305 (s
->next
->c
< s
->c
) ? WEST
:NONE
;
307 printf ("\033[%sm", op
.scheme
->color
[color
]);
308 print (op
.scheme
->snake
[predecessor
][successor
]);
314 /* print item queue */
315 for (struct item
* i
= g
.i
; i
; i
= i
->next
) {
316 move_ph (i
->r
+LINE_OFFSET
, i
->c
*CW
+COL_OFFSET
);
317 if (i
->t
== FOOD
) print (op
.scheme
->item
[i
->v
]);
318 else if (i
->t
==BONUS
) /* TODO: print bonus */;
322 int score_width
= g
.p
> 9999?6:4;
323 move_ph (0, (g
.w
*CW
-score_width
)/2-COL_OFFSET
);
324 printf ("%s %0*d %s", BORDER(S
,L
), score_width
, g
.p
, BORDER(S
,R
));
327 #define MOVE_POPUP(WIDTH, LINE) \
328 move_ph(g.h/2+LINE_OFFSET-1+LINE,(g.w*op.scheme->display_width-WIDTH)/2)
329 int end_screen(void) {
332 printm (12/op
.scheme
->display_width
, BORDER(T
,C
));
336 printf("%s GAME OVER %s", BORDER(C
,L
), BORDER(C
,R
));
338 printf("%s `r' restart%s", BORDER(C
,L
), BORDER(C
,R
));
340 printf("%s `q' quit %s", BORDER(C
,L
), BORDER(C
,R
));
344 printm (12/op
.scheme
->display_width
, BORDER(B
,C
));
351 void snake_append (struct snake
** s
, int row
, int col
) {
352 struct snake
* new = malloc (sizeof(struct snake
));
358 struct snake
* p
= *s
;
359 while (p
->next
) p
= p
->next
;
366 #define free_ll(head) do{ \
380 for (int i
= 0; i
< op
.l
; i
++) {
381 if (g
.w
/2-i
< 0) /* go upwards if we hit left wall */
382 snake_append(&g
.s
, g
.h
/2-(i
-g
.w
/2), 0);
383 else /* normally just keep goint left */
384 snake_append(&g
.s
, g
.h
/2, g
.w
/2-i
);
400 int getctrlseq (void) {
403 while ((c
= getchar()) != EOF
) {
407 case '\033': state
=ESC_SENT
; break;
413 case '[': state
=CSI_SENT
; break;
414 default: return CTRSEQ_INVALID
;
419 case 'A': return CTRSEQ_CURSOR_UP
;
420 case 'B': return CTRSEQ_CURSOR_DOWN
;
421 case 'C': return CTRSEQ_CURSOR_RIGHT
;
422 case 'D': return CTRSEQ_CURSOR_LEFT
;
423 default: return CTRSEQ_INVALID
;
427 return CTRSEQ_INVALID
;
433 void append_movement (int dir
) {
434 if (g
.k
.n
> 15) return; /* no space in buffer */
435 if (g
.k
.n
&& g
.k
.c
[(16+g
.k
.h
-1)%16] == dir
)
436 return; /* don't add the same direction twice */
440 g
.k
.h
= ++g
.k
.h
% 16;
443 void move_ph (int line
, int col
) {
444 /* move printhead to zero-indexed position */
445 printf ("\033[%d;%dH", line
+1, col
+1);
448 void clamp_fieldsize (void) {
449 /* clamp field size to terminal size and mouse maximum: */
451 ioctl(STDOUT_FILENO
, TIOCGWINSZ
, &w
);
453 if (g
.w
< 10) g
.w
= 10;
454 if (g
.h
< 10) g
.h
= 10;
456 if (COL_OFFSET
+ g
.w
*CW
+ COL_OFFSET
> w
.ws_col
)
457 g
.w
= (w
.ws_col
- (COL_OFFSET
+COL_OFFSET
))/op
.scheme
->display_width
;
458 if (LINE_OFFSET
+ g
.h
+ LINES_AFTER
> w
.ws_row
)
459 g
.h
= w
.ws_row
- (LINE_OFFSET
+LINES_AFTER
);
462 void timer_setup (int enable
) {
463 static struct itimerval tbuf
;
464 tbuf
.it_interval
.tv_sec
= 0;//TODO: make it speed up automatically
465 tbuf
.it_interval
.tv_usec
= (1000000/g
.v
)-1; /*WARN: 1 <= g.v <= 999999*/
468 tbuf
.it_value
.tv_sec
= tbuf
.it_interval
.tv_sec
;
469 tbuf
.it_value
.tv_usec
= tbuf
.it_interval
.tv_usec
;
471 tbuf
.it_value
.tv_sec
= 0;
472 tbuf
.it_value
.tv_usec
= 0;
475 if ( setitimer(ITIMER_REAL
, &tbuf
, NULL
) == -1 ) {
482 void signal_setup (void) {
483 struct sigaction saction
;
485 saction
.sa_handler
= signal_handler
;
486 sigemptyset(&saction
.sa_mask
);
487 saction
.sa_flags
= 0;
488 if (sigaction(SIGALRM
, &saction
, NULL
) < 0 ) {
493 if (sigaction(SIGINT
, &saction
, NULL
) < 0 ) {
498 if (sigaction(SIGCONT
, &saction
, NULL
) < 0 ) {
504 void signal_handler (int signum
) {
517 void screen_setup (int enable
) {
520 printf ("\033[s\033[?47h"); /* save cursor, alternate screen */
521 printf ("\033[H\033[J"); /* reset cursor, clear screen */
522 printf ("\033[?25l"); /* hide cursor */
523 print (op
.scheme
->init_seq
); /* swich charset, if necessary */
525 print (op
.scheme
->reset_seq
); /* reset charset, if necessary */
526 printf ("\033[?25h"); /* show cursor */
527 printf ("\033[?47l\033[u"); /* primary screen, restore cursor */
532 /* http://users.csc.calpoly.edu/~phatalsk/357/lectures/code/sigalrm.c */
533 void raw_mode(int enable
) {
534 static struct termios saved_term_mode
;
535 struct termios raw_term_mode
;
538 tcgetattr(STDIN_FILENO
, &saved_term_mode
);
539 raw_term_mode
= saved_term_mode
;
540 raw_term_mode
.c_lflag
&= ~(ICANON
| ECHO
);
541 raw_term_mode
.c_cc
[VMIN
] = 1 ;
542 raw_term_mode
.c_cc
[VTIME
] = 0;
543 tcsetattr(STDIN_FILENO
, TCSAFLUSH
, &raw_term_mode
);
545 tcsetattr(STDIN_FILENO
, TCSAFLUSH
, &saved_term_mode
);