void keyboard_install(fs_node_t * dev_root) {
printk("keyboard selftest good: %b\n", keyboard_selftest);
keyboard_reset();
fs_node_t * keyboard = keyboard_create();
devfs_keyboard_attach(keyboard);
register_interrupt_handler(IRQ1, &keyboard_callback);
}
void menu_listen_tick(component *c) {
listen_menu_data *local = menu_get_userdata(c);
game_state *gs = local->s->gs;
if(local->host) {
ENetEvent event;
if(enet_host_service(local->host, &event, 0) > 0 && event.type == ENET_EVENT_TYPE_CONNECT) {
ENetPacket * packet = enet_packet_create("0", 2, ENET_PACKET_FLAG_RELIABLE);
enet_peer_send(event.peer, 0, packet);
enet_host_flush(local->host);
DEBUG("client connected!");
controller *player1_ctrl, *player2_ctrl;
keyboard_keys *keys;
game_player *p1 = game_state_get_player(gs, 0);
game_player *p2 = game_state_get_player(gs, 1);
// force the speed to 3
game_state_set_speed(gs, 5);
p1->har_id = HAR_JAGUAR;
p1->pilot_id = 0;
p2->har_id = HAR_JAGUAR;
p2->pilot_id = 0;
player1_ctrl = malloc(sizeof(controller));
controller_init(player1_ctrl);
player1_ctrl->har = p1->har;
player2_ctrl = malloc(sizeof(controller));
controller_init(player2_ctrl);
player2_ctrl->har = p2->har;
// Player 1 controller -- Keyboard
settings_keyboard *k = &settings_get()->keys;
keys = malloc(sizeof(keyboard_keys));
keys->up = SDL_GetScancodeFromName(k->key1_up);
keys->down = SDL_GetScancodeFromName(k->key1_down);
keys->left = SDL_GetScancodeFromName(k->key1_left);
keys->right = SDL_GetScancodeFromName(k->key1_right);
keys->punch = SDL_GetScancodeFromName(k->key1_punch);
keys->kick = SDL_GetScancodeFromName(k->key1_kick);
keys->escape = SDL_GetScancodeFromName(k->key1_escape);
keyboard_create(player1_ctrl, keys, 0);
game_player_set_ctrl(p1, player1_ctrl);
// Player 2 controller -- Network
net_controller_create(player2_ctrl, local->host, event.peer, ROLE_SERVER);
game_player_set_ctrl(p2, player2_ctrl);
local->host = NULL;
game_player_set_selectable(p2, 1);
chr_score_set_difficulty(game_player_get_score(game_state_get_player(gs, 0)), AI_DIFFICULTY_CHAMPION);
chr_score_set_difficulty(game_player_get_score(game_state_get_player(gs, 1)), AI_DIFFICULTY_CHAMPION);
game_state_set_next(gs, SCENE_MELEE);
}
}
}
static void
handle_output_configure(struct output *output, void *data)
{
struct virtual_keyboard *virtual_keyboard = data;
/* skip existing outputs */
if (output_get_user_data(output))
return;
output_set_user_data(output, virtual_keyboard);
keyboard_create(output, virtual_keyboard);
}
int hardware_setup()
{
// Point the hardware to device slots
screen_device = &computer->hardware[0];
keyboard_device = &computer->hardware[1];
clock_device = &computer->hardware[2];
// Create the LEM1802 device
lem1802_create(screen_device, computer);
lem1802 = (LEM1802_t *) screen_device->custom_struct;
// Create the keyboard device
keyboard_create(keyboard_device, computer);
// Create the clock device
clock_create(clock_device, computer);
return 0;
}
int
main(int argc, char *argv[])
{
struct virtual_keyboard virtual_keyboard;
struct output *output;
memset(&virtual_keyboard, 0, sizeof virtual_keyboard);
virtual_keyboard.display = display_create(&argc, argv);
if (virtual_keyboard.display == NULL) {
fprintf(stderr, "failed to create display: %m\n");
return -1;
}
display_set_user_data(virtual_keyboard.display, &virtual_keyboard);
display_set_global_handler(virtual_keyboard.display, global_handler);
output = display_get_output(virtual_keyboard.display);
keyboard_create(output, &virtual_keyboard);
display_run(virtual_keyboard.display);
return 0;
}
int main(int argc, char* argv[])
{
// our demo variables
World* demoworld = 0;
Camera* democamera = 0;
Tileset* demotileset = 0;
Renderer* demorenderer = 0;
// init SDL
if (SDL_Init(SDL_INIT_EVERYTHING) < 0)
{
fprintf(stderr, "SDL Library Initialization Failed!\n\tSDL Error: %s\n", SDL_GetError());
exit(1);
}
atexit(SDL_Quit);
// create the window
if (!SDL_SetVideoMode(SCREEN_W, SCREEN_H, SCREEN_BPP, SDL_HWSURFACE | SDL_DOUBLEBUF))
{
fprintf(stderr, "SDL Screen Initialization Failed! %dx%d@%dbpp\nSDL Error: %s\n",
SCREEN_W,
SCREEN_H,
SCREEN_BPP,
SDL_GetError());
exit(1);
}
// set the window caption
SDL_WM_SetCaption("Basic SDL Map Editor Example Demo -- by Richard Marks <*****@*****.**>", 0);
// create our keyboard handler
Keyboard* keyboard = keyboard_create();
// load the world
demoworld = world_load("example_demo.map");
if (!demoworld)
{
fprintf(stderr, "unable to load the world file!\n");
exit(1);
}
// load the tileset
demotileset = tileset_load("example_demo.png", 32, 32);
if (!demotileset)
{
fprintf(stderr, "unable to load the tileset file!\n");
exit(1);
}
// create the camera
democamera = camera_create(
// anchor position of the camera is at 32,32 on the screen
32, 32,
// the camera view is 30 x 22 tiles
30, 22,
// need to tell the camera the size of the tiles
demotileset->width, demotileset->height);
// create the renderer
demorenderer = renderer_create(demoworld, demotileset, democamera);
// pre-render the scene
renderer_pre_render(demorenderer);
fprintf(stderr, "\nstarting main loop...\n\n");
// start the main loop
SDL_Event event;
bool running = true;
int startticks = SDL_GetTicks();
int mainlooptimer = SDL_GetTicks();
while(running)
{
// check for our window being closed
while(SDL_PollEvent(&event))
{
if (SDL_QUIT == event.type)
{
running = false;
}
}
// update our keyboard handler
keyboard_update(keyboard);
// start timing our code
startticks = SDL_GetTicks();
// check for our controls
// ESC and Q quits
if (keyboard->key[SDLK_ESCAPE] || keyboard->key[SDLK_q])
{
running = false;
}
const unsigned int CAMERASPEED = 16;
// W and up arrow
if (keyboard->key[SDLK_w] || keyboard->key[SDLK_UP])
{
if (democamera->inpixels->y > 0)
{
democamera->inpixels->y -= CAMERASPEED;
}
}
// S and down arrow
if (keyboard->key[SDLK_s] || keyboard->key[SDLK_DOWN])
{
if (democamera->inpixels->y < demorenderer->scene->h - democamera->inpixels->h)
{
democamera->inpixels->y += CAMERASPEED;
}
}
// A and left arrow
if (keyboard->key[SDLK_a] || keyboard->key[SDLK_LEFT])
{
if (democamera->inpixels->x > 0)
{
democamera->inpixels->x -= CAMERASPEED;
}
}
// D and right arrow
if (keyboard->key[SDLK_d] || keyboard->key[SDLK_RIGHT])
{
if (democamera->inpixels->x < demorenderer->scene->w - democamera->inpixels->w)
{
democamera->inpixels->x += CAMERASPEED;
}
}
// render our scene
renderer_render(demorenderer);
// flip our double buffer
SDL_Flip(SDL_GetVideoSurface());
// lock our framerate to roughly 30 FPS
int tickdiff = SDL_GetTicks() - startticks;
if (tickdiff < 33)
{
SDL_Delay(33 - tickdiff);
}
}
int tickdiff = SDL_GetTicks() - mainlooptimer;
fprintf(stderr, "finished after %d ticks!\n\n", tickdiff);
// destroy our pointers
tileset_destroy(demotileset);
renderer_destroy(demorenderer);
world_destroy(demoworld);
camera_destroy(democamera);
keyboard_destroy(keyboard);
return 0;
}
