You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
277 lines
6.6 KiB
277 lines
6.6 KiB
/**
|
|
@file main_terminal.c
|
|
|
|
WARNING: VERY EXPERIMENTAL
|
|
|
|
This is Linux terminal implementation of the game front end. If you replace
|
|
the input methods, it will most likely run in other terminals as well. This
|
|
needs root priviledges (sudo) to work (because we need to read keyboard and
|
|
mouse inputs)! This frontend is more of an experiment, don't expect it to work
|
|
perfectly and everywhere.
|
|
|
|
by Miloslav Ciz (drummyfish), 2019
|
|
|
|
Released under CC0 1.0 (https://creativecommons.org/publicdomain/zero/1.0/)
|
|
plus a waiver of all other intellectual property. The goal of this work is
|
|
be and remain completely in the public domain forever, available for any use
|
|
whatsoever.
|
|
*/
|
|
|
|
#ifndef USE_LINUX_FRAMEBUFFER
|
|
#define USE_LINUX_FRAMEBUFFER 0
|
|
#endif
|
|
|
|
// IMPORTANT: You must set these files correctly:
|
|
#define DEV_KEYBOARD "/dev/input/event3"
|
|
#define DEV_MOUSE "/dev/input/event1"
|
|
#define DEV_TTY "/dev/tty3"
|
|
#define DEV_FRAMBUFFER "/dev/fb0"
|
|
|
|
#include <stdint.h>
|
|
#include <unistd.h>
|
|
#include <signal.h>
|
|
#include <fcntl.h>
|
|
#include <linux/input.h>
|
|
#include <stdio.h>
|
|
#include <sys/time.h>
|
|
#include <time.h>
|
|
|
|
#include "smallinput.h"
|
|
|
|
#if USE_LINUX_FRAMEBUFFER
|
|
#include <stdlib.h>
|
|
#include <linux/fb.h>
|
|
#include <linux/kd.h>
|
|
#include <sys/mman.h>
|
|
#include <sys/ioctl.h>
|
|
#endif
|
|
|
|
#if USE_LINUX_FRAMEBUFFER
|
|
#define SFG_SCREEN_RESOLUTION_X 640
|
|
#define SFG_SCREEN_RESOLUTION_Y 480
|
|
#else
|
|
#define SFG_SCREEN_RESOLUTION_X 127
|
|
#define SFG_SCREEN_RESOLUTION_Y 42
|
|
#endif
|
|
|
|
#define SFG_DITHERED_SHADOW 1
|
|
#define SFG_FPS 30
|
|
|
|
#include "game.h"
|
|
|
|
#define SCREENSIZE ((SFG_SCREEN_RESOLUTION_X + 1) * SFG_SCREEN_RESOLUTION_Y + 1)
|
|
|
|
char screen[SCREENSIZE];
|
|
uint8_t *screenUnsigned = (uint8_t *) screen;
|
|
|
|
const char shades[] = // adjust according to your terminal
|
|
{
|
|
' ','.','-',':','\\','h','M','@', // grey
|
|
'`','.',',',';','/','r','=','n' // non-grey
|
|
};
|
|
|
|
uint32_t timeStart;
|
|
|
|
uint32_t getTime()
|
|
{
|
|
struct timeval now;
|
|
gettimeofday(&now, NULL);
|
|
return now.tv_sec * 1000 + now.tv_usec / 1000;
|
|
}
|
|
|
|
void SFG_setPixel(uint16_t x, uint16_t y, uint8_t colorIndex)
|
|
{
|
|
#if USE_LINUX_FRAMEBUFFER
|
|
screenUnsigned[y * SFG_SCREEN_RESOLUTION_X + x] =
|
|
colorIndex;
|
|
#else
|
|
screen[y * (SFG_SCREEN_RESOLUTION_X + 1) + x] =
|
|
shades[(colorIndex > 7) * 8 + colorIndex % 8];
|
|
#endif
|
|
}
|
|
|
|
uint32_t SFG_getTimeMs()
|
|
{
|
|
return getTime() - timeStart;
|
|
}
|
|
|
|
void SFG_save(uint8_t data[SFG_SAVE_SIZE])
|
|
{
|
|
}
|
|
|
|
uint8_t SFG_load(uint8_t data[SFG_SAVE_SIZE])
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
void SFG_sleepMs(uint16_t timeMs)
|
|
{
|
|
usleep(timeMs * 1000);
|
|
}
|
|
|
|
void SFG_getMouseOffset(int16_t *x, int16_t *y)
|
|
{
|
|
int32_t a,b;
|
|
|
|
input_getMousePos(&a,&b);
|
|
*x = a;
|
|
*y = b;
|
|
input_setMousePos(0,0);
|
|
}
|
|
|
|
void SFG_processEvent(uint8_t event, uint8_t data)
|
|
{
|
|
}
|
|
|
|
int8_t SFG_keyPressed(uint8_t key)
|
|
{
|
|
switch (key)
|
|
{
|
|
case SFG_KEY_UP: return input_getKey('w') || input_getKey(SMALLINPUT_ARROW_UP); break;
|
|
case SFG_KEY_RIGHT: return input_getKey('d') || input_getKey(SMALLINPUT_ARROW_RIGHT); break;
|
|
case SFG_KEY_DOWN: return input_getKey('s') || input_getKey(SMALLINPUT_ARROW_DOWN); break;
|
|
case SFG_KEY_LEFT: return input_getKey('a') || input_getKey(SMALLINPUT_ARROW_LEFT); break;
|
|
case SFG_KEY_A: return input_getKey('j') || input_getKey(SMALLINPUT_RETURN) || input_getKey(SMALLINPUT_MOUSE_L); break;
|
|
case SFG_KEY_B: return input_getKey('k') || input_getKey(SMALLINPUT_CTRL); break;
|
|
case SFG_KEY_C: return input_getKey('l'); break;
|
|
case SFG_KEY_MAP: return input_getKey(SMALLINPUT_TAB); break;
|
|
case SFG_KEY_JUMP: return input_getKey(' '); break;
|
|
case SFG_KEY_MENU: return input_getKey(SMALLINPUT_ESCAPE); break;
|
|
case SFG_KEY_NEXT_WEAPON: return input_getKey('2'); break;
|
|
case SFG_KEY_PREVIOUS_WEAPON: return input_getKey('1'); break;
|
|
case SFG_KEY_CYCLE_WEAPON: return input_getKey('f'); break;
|
|
case SFG_KEY_TOGGLE_FREELOOK: return input_getKey(SMALLINPUT_MOUSE_R); break;
|
|
default: return 0; break;
|
|
}
|
|
}
|
|
|
|
void SFG_setMusic(uint8_t value)
|
|
{
|
|
}
|
|
|
|
void SFG_playSound(uint8_t soundIndex, uint8_t volume)
|
|
{
|
|
}
|
|
|
|
int running = 1;
|
|
|
|
void handleSignal(int signal)
|
|
{
|
|
#if !USE_LINUX_FRAMEBUFFER
|
|
puts("\033[?25h"); // show cursor
|
|
#endif
|
|
running = 0;
|
|
}
|
|
|
|
int main()
|
|
{
|
|
signal(SIGINT,handleSignal);
|
|
signal(SIGQUIT,handleSignal);
|
|
signal(SIGTERM,handleSignal);
|
|
|
|
timeStart = getTime();
|
|
|
|
input_init(SMALLINPUT_MODE_NORMAL,0,0);
|
|
SFG_init();
|
|
|
|
screen[SCREENSIZE - 1] = 0; // string terminator
|
|
|
|
#if USE_LINUX_FRAMEBUFFER
|
|
|
|
#define CHECK(w,err,msg)\
|
|
if ((w) == (err)) { puts(msg); return 1; }
|
|
|
|
int tty = open(DEV_TTY,O_RDWR);
|
|
CHECK(tty,-1,"couldn't open TTY device")
|
|
|
|
CHECK(ioctl(tty,KDSETMODE,KD_GRAPHICS),-1,"couldn't set graphic mode")
|
|
|
|
int fb = open(DEV_FRAMBUFFER,O_RDWR);
|
|
CHECK(fb,-1,"couldn't open framebuffer device")
|
|
|
|
struct fb_fix_screeninfo fixInfo;
|
|
struct fb_var_screeninfo varInfo;
|
|
|
|
CHECK(ioctl(fb,FBIOGET_FSCREENINFO,&fixInfo),-1,"couldn't get fixInfo")
|
|
CHECK(ioctl(fb,FBIOGET_VSCREENINFO,&varInfo),-1,"couldn't get varInfo")
|
|
|
|
int bpp = varInfo.bits_per_pixel / 8;
|
|
uint64_t screenSize = varInfo.xres * varInfo.yres * bpp;
|
|
|
|
char *fbScreen = mmap(0,screenSize,PROT_READ | PROT_WRITE,MAP_SHARED,fb,0);
|
|
|
|
CHECK(fbScreen,MAP_FAILED,"couldn't map framebuffer")
|
|
|
|
int r = varInfo.red.offset / 8,
|
|
g = varInfo.green.offset / 8,
|
|
b = varInfo.blue.offset / 8,
|
|
t = varInfo.transp.offset / 8;
|
|
|
|
#else
|
|
for (uint16_t i = 1; i <= SFG_SCREEN_RESOLUTION_Y; ++i)
|
|
screen[i * (SFG_SCREEN_RESOLUTION_X + 1) - 1] = '\n';
|
|
|
|
setvbuf(stdout, NULL, _IOFBF, SCREENSIZE + 1);
|
|
|
|
for (uint8_t i = 0; i < 100; ++i) // clear screen
|
|
putchar('\n');
|
|
|
|
puts("\033[?25l"); // hide cursor
|
|
#endif
|
|
|
|
while (running)
|
|
{
|
|
input_update();
|
|
|
|
#if USE_LINUX_FRAMEBUFFER
|
|
|
|
char *p = fbScreen;
|
|
|
|
int linePad = fixInfo.line_length - SFG_SCREEN_RESOLUTION_X * bpp;
|
|
|
|
int index = 0;
|
|
|
|
for (int y = 0; y < SFG_SCREEN_RESOLUTION_Y; ++y)
|
|
{
|
|
for (int x = 0; x < SFG_SCREEN_RESOLUTION_X; ++x)
|
|
{
|
|
// inefficient, should be a precomputed RGB32 palette
|
|
uint16_t c = paletteRGB565[screenUnsigned[index]];
|
|
|
|
*(p + b) = (c << 3) & 0xf8;
|
|
*(p + g) = (c >> 3) & 0xfc;
|
|
*(p + r) = (c >> 8) & 0xf8;
|
|
p += bpp;
|
|
index++;
|
|
}
|
|
|
|
p += linePad;
|
|
}
|
|
|
|
#else
|
|
puts("\033[0;0H"); // move cursor to 0;0
|
|
puts(screen);
|
|
fflush(stdout);
|
|
#endif
|
|
|
|
if (!SFG_mainLoopBody())
|
|
running = 0;
|
|
|
|
// if (SFG_game.frame > 1000) break; // uncomment for testing, prevents locking
|
|
|
|
}
|
|
|
|
input_end();
|
|
|
|
#if USE_LINUX_FRAMEBUFFER
|
|
munmap(screen,screenSize);
|
|
|
|
ioctl(tty,KDSETMODE,KD_TEXT); // set back to text mode
|
|
|
|
close(fb);
|
|
close(tty);
|
|
#else
|
|
puts("\033[?25h"); // show cursor
|
|
#endif
|
|
|
|
}
|