kolibrios-fun/contrib/other/jumpnbump/sdl/interrpt.c
maxcodehack dadd9561ac Upload Jump'n'Bump sources
git-svn-id: svn://kolibrios.org@8526 a494cfbc-eb01-0410-851d-a64ba20cac60
2021-01-07 12:53:28 +00:00

463 lines
9.5 KiB
C
Executable File

/*
* interrpt.c
* Copyright (C) 1998 Brainchild Design - http://brainchilddesign.com/
*
* Copyright (C) 2001 Chuck Mason <cemason@users.sourceforge.net>
*
* Copyright (C) 2002 Florian Schulze <crow@icculus.org>
*
* This file is part of Jump'n'Bump.
*
* Jump'n'Bump is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* Jump'n'Bump is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#ifndef _MSC_VER
#include <unistd.h>
#endif
#include "globals.h"
#ifdef USE_KAILLERA
#include "SDL_thread.h"
#include "SDL_mutex.h"
#include <kailleraclient.h>
char local_keyb[256];
#endif /* USE_KAILLERA */
char keyb[256];
char last_keys[50];
#ifdef USE_KAILLERA
/* information about the party in this session */
static int my_player = -1;
static int my_numplayers = -1;
/* semaphore for controlling kaillera thread */
static SDL_sem *game_start_sem = NULL;
/* keys supported on my end */
static int my_player_up = -1;
static int my_player_left = -1;
static int my_player_right = 1;
/* values for the kaillera client interface */
static char kaillera_app_name[] = "Jump 'n Bump";
static char kaillera_game_name[] = "Jump 'n Bump\0\0";
static int player_keys[4][3] = {
{
KEY_PL1_LEFT,
KEY_PL1_RIGHT,
KEY_PL1_JUMP
},
{
KEY_PL2_LEFT,
KEY_PL2_RIGHT,
KEY_PL2_JUMP
},
{
KEY_PL3_LEFT,
KEY_PL3_RIGHT,
KEY_PL3_JUMP
},
{
KEY_PL4_LEFT,
KEY_PL4_RIGHT,
KEY_PL4_JUMP
}
};
static int WINAPI kaillera_game_callback(char *game, int player, int numplayers)
{
int length;
int urand;
unsigned char random[8];
if (strcmp(game, kaillera_game_name) != 0) {
printf("unknown game selected: %s\n", game);
my_player = -1;
goto release;
}
printf("start network game with %d players\n", numplayers);
printf("I am player %d\n", player);
my_player = player;
my_numplayers = numplayers;
my_player_up = player_keys[player-1][0] & 0xff;
my_player_left = player_keys[player-1][1] & 0xff;
my_player_right = player_keys[player-1][2] & 0xff;
/* initialize randomizer agreed by all players */
random[0] = time(0) & 0xff;
random[1] = random[2] = random[3] = 0x00;
length = kailleraModifyPlayValues(&random, sizeof(random[0]));
if (length < 0) {
goto release;
}
urand = random[3] << 24 | random[2] << 16 | random[1] << 8 | random[0];
srand(urand);
release:
SDL_SemPost(game_start_sem);
return 0;
}
static kailleraInfos kaillera_data = {
kaillera_app_name,
kaillera_game_name,
kaillera_game_callback,
NULL,
NULL,
NULL
};
static void print_version()
{
char version[16];
kailleraGetVersion(version);
printf("using kaillera version %s\n", version);
}
static int kaillera_thread(void *arg)
{
kailleraInit();
/* print_version(); */
kailleraSetInfos(&kaillera_data);
kailleraSelectServerDialog(0);
if (SDL_SemValue(game_start_sem) == 0) {
/* server dialog returned and game didnt start */
/* release blocking thread */
my_player = -1;
SDL_SemPost(game_start_sem);
}
return 0;
}
static int start_kaillera_thread(void)
{
SDL_Thread *thread;
game_start_sem = SDL_CreateSemaphore(0);
thread = SDL_CreateThread(kaillera_thread, NULL);
if (!thread) {
printf("SDL_CreateThread failed\n");
return -1;
}
return 0;
}
int addkey(unsigned int key)
{
/* it doesnt matter if a player presses keys
* that control other bunnies. whatever is sent
* is packed by pack_keys()
*/
if (!(key & 0x8000)) {
local_keyb[key & 0x7fff] = 1;
} else
local_keyb[key & 0x7fff] = 0;
return 0;
}
void remove_keyb_handler(void)
{
kailleraShutdown();
}
int pack_keys(void)
{
int rv;
rv = local_keyb[my_player_up];
rv |= local_keyb[my_player_left] << 1;
rv |= local_keyb[my_player_right] << 2;
rv |= local_keyb[1] << 3;
return rv;
}
void unpack_keys(int player, char value)
{
keyb[player_keys[player][0] & 0xff] = (value >> 0) & 1;
keyb[player_keys[player][1] & 0xff] = (value >> 1) & 1;
keyb[player_keys[player][2] & 0xff] = (value >> 2) & 1;
/* escape key is shared among all users */
keyb[1] |= (value >> 3) & 1;
}
int update_kaillera_keys(void)
{
char keys[8];
int length;
int player;
keys[0] = pack_keys();
length = kailleraModifyPlayValues(&keys, sizeof(keys[0]));
if (length < 0) {
/* terminate session */
printf("** LOST CONNECTION **\n");
kailleraEndGame();
my_player = -1;
return -1;
}
for (player=0; player<length; player++) {
unpack_keys(player, keys[player]);
}
return 0;
}
int hook_keyb_handler(void)
{
SDL_EnableUNICODE(1);
memset((void *) last_keys, 0, sizeof(last_keys));
start_kaillera_thread();
SDL_SemWait(game_start_sem);
if (my_player < 0) {
printf("GAME ABORTED!\n");
return -1;
}
printf("GAME STARTS!\n");
return 0;
}
int key_pressed(int key)
{
if (key == 1 && my_player < 0) {
/* if game completed or aborted, post ESC */
return 1;
}
return keyb[(unsigned char) key];
}
#else /* USE_KAILLERA */
int addkey(unsigned int key)
{
int c1;
if (!(key & 0x8000)) {
keyb[key & 0x7fff] = 1;
for (c1 = 48; c1 > 0; c1--)
last_keys[c1] = last_keys[c1 - 1];
last_keys[0] = key & 0x7fff;
} else
keyb[key & 0x7fff] = 0;
return 0;
}
void remove_keyb_handler(void)
{
}
int hook_keyb_handler(void)
{
SDL_EnableUNICODE(1);
memset((void *) last_keys, 0, sizeof(last_keys));
return 0;
}
int key_pressed(int key)
{
return keyb[(unsigned char) key];
}
#endif /* USE_KAILLERA */
int intr_sysupdate()
{
SDL_Event e;
int i = 0;
static int last_time = 0;
int now, time_diff;
while (SDL_PollEvent(&e)) {
switch (e.type) {
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
if(e.button.state == SDL_PRESSED &&
((key_pressed(KEY_PL3_LEFT) && e.button.button == SDL_BUTTON_RIGHT) ||
(key_pressed(KEY_PL3_RIGHT) && e.button.button == SDL_BUTTON_LEFT) ||
(e.button.button == SDL_BUTTON_LEFT && e.button.button == SDL_BUTTON_RIGHT) ||
e.button.button == SDL_BUTTON_MIDDLE))
{
addkey(KEY_PL3_JUMP & 0x7f);
}
else if(e.button.state == SDL_RELEASED &&
((key_pressed(KEY_PL3_LEFT) && e.button.button == SDL_BUTTON_RIGHT) ||
(key_pressed(KEY_PL3_RIGHT) && e.button.button == SDL_BUTTON_LEFT) ||
e.button.button == SDL_BUTTON_MIDDLE))
{
addkey((KEY_PL3_JUMP & 0x7f) | 0x8000);
}
if(e.button.button == SDL_BUTTON_LEFT)
{
SDLKey sym = KEY_PL3_LEFT;
sym &= 0x7f;
if(e.button.state == SDL_RELEASED)
{
if(key_pressed(KEY_PL3_JUMP) && (SDL_GetMouseState(NULL, NULL)&SDL_BUTTON(SDL_BUTTON_RIGHT)))
addkey(KEY_PL3_RIGHT & 0x7f);
else
sym |= 0x8000;
}
addkey(sym);
}
else if(e.button.button == SDL_BUTTON_RIGHT)
{
SDLKey sym = KEY_PL3_RIGHT;
sym &= 0x7f;
if (e.button.state == SDL_RELEASED)
{
if(key_pressed(KEY_PL3_JUMP) && (SDL_GetMouseState(NULL, NULL)&SDL_BUTTON(SDL_BUTTON_LEFT)))
addkey(KEY_PL3_LEFT & 0x7f);
else
sym |= 0x8000;
}
addkey(sym);
}
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
switch (e.key.keysym.sym) {
case SDLK_F12:
if (e.type == SDL_KEYDOWN) {
SDL_Quit();
exit(1);
}
break;
case SDLK_F10:
if (e.type == SDL_KEYDOWN) {
fs_toggle();
}
break;
case SDLK_1:
if (e.type == SDL_KEYUP)
ai[0] = !ai[0];
/* Release keys, otherwise it will continue moving that way */
addkey((KEY_PL1_LEFT & 0x7f) | 0x8000);
addkey((KEY_PL1_RIGHT & 0x7f) | 0x8000);
addkey((KEY_PL1_JUMP & 0x7f) | 0x8000);
break;
case SDLK_2:
if (e.type == SDL_KEYUP)
ai[1] = !ai[1];
/* Release keys, otherwise it will continue moving that way */
addkey((KEY_PL2_LEFT & 0x7f) | 0x8000);
addkey((KEY_PL2_RIGHT & 0x7f) | 0x8000);
addkey((KEY_PL2_JUMP & 0x7f) | 0x8000);
break;
case SDLK_3:
if (e.type == SDL_KEYUP)
ai[2] = !ai[2];
/* Release keys, otherwise it will continue moving that way */
addkey((KEY_PL3_LEFT & 0x7f) | 0x8000);
addkey((KEY_PL3_RIGHT & 0x7f) | 0x8000);
addkey((KEY_PL3_JUMP & 0x7f) | 0x8000);
break;
case SDLK_4:
if (e.type == SDL_KEYUP)
ai[3] = !ai[3];
/* Release keys, otherwise it will continue moving that way */
addkey((KEY_PL4_LEFT & 0x7f) | 0x8000);
addkey((KEY_PL4_RIGHT & 0x7f) | 0x8000);
addkey((KEY_PL4_JUMP & 0x7f) | 0x8000);
break;
case SDLK_ESCAPE:
if (e.type == SDL_KEYUP)
addkey(1 | 0x8000);
else
addkey(1 & 0x7f);
break;
default:
e.key.keysym.sym &= 0x7f;
if (e.type == SDL_KEYUP)
e.key.keysym.sym |= 0x8000;
addkey(e.key.keysym.sym);
break;
}
break;
default:
break;
}
i++;
}
SDL_Delay(1);
now = SDL_GetTicks();
time_diff = now - last_time;
if (time_diff>0) {
i = time_diff / (1000 / 60);
if (i) {
last_time = now;
} else {
int tmp;
tmp = (1000/60) - i - 10;
if (tmp>0)
SDL_Delay(tmp);
}
}
/*
if (!then)
SDL_Delay(1);
else {
then = (1000 / 60) - (now - then);
if (then > 0 && then < 1000)
SDL_Delay(then);
}
then = now;
*/
#ifdef USE_KAILLERA
if (my_player >= 0) {
update_kaillera_keys();
i=1;
}
#endif /* USE_KAILLERA */
return i;
}