mirror of
https://github.com/libretro/jumpnbump-libretro.git
synced 2026-11-07 10:36:00 -10:00
349 lines
7.8 KiB
C
349 lines
7.8 KiB
C
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
|
|
#include "libretro.h"
|
|
|
|
#include "globals.h"
|
|
#include "micromod.h"
|
|
|
|
#ifndef MIN
|
|
#define MIN(a, b) ((a) < (b) ? (a) : (b))
|
|
#endif
|
|
|
|
uint16_t *frame_buf;
|
|
|
|
static retro_environment_t environ_cb;
|
|
static retro_video_refresh_t video_cb;
|
|
static retro_audio_sample_batch_t audio_batch_cb;
|
|
static retro_input_poll_t input_poll_cb;
|
|
static retro_input_state_t input_state_cb;
|
|
|
|
extern int flies_enabled;
|
|
extern int flip;
|
|
|
|
static const struct retro_variable var_jnb_flip = { "jnb-flip", "Flip Level; OFF|ON" };
|
|
static const struct retro_variable var_jnb_flies = { "jnb-flies", "Flies; OFF|ON" };
|
|
|
|
static const struct retro_variable var_empty = { NULL, NULL };
|
|
|
|
|
|
#define GAME_STATE_BOOT 0
|
|
#define GAME_STATE_MENU 1
|
|
#define GAME_STATE_GAME 2
|
|
#define GAME_STATE_END 3
|
|
|
|
static int game_state;
|
|
static bool supports_input_bitmasks;
|
|
|
|
void retro_init(void)
|
|
{
|
|
struct retro_variable vars[3];
|
|
struct retro_input_descriptor desc[] = {
|
|
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "Left" },
|
|
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A, "Jump" },
|
|
{ 0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "Right" },
|
|
|
|
{ 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "Left" },
|
|
{ 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A, "Jump" },
|
|
{ 1, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "Right" },
|
|
|
|
{ 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "Left" },
|
|
{ 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A, "Jump" },
|
|
{ 2, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "Right" },
|
|
|
|
{ 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT, "Left" },
|
|
{ 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A, "Jump" },
|
|
{ 3, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT, "Right" },
|
|
|
|
{ 0 },
|
|
};
|
|
|
|
frame_buf = calloc(JNB_WIDTH * JNB_HEIGHT, sizeof(uint16_t));
|
|
supports_input_bitmasks = environ_cb(RETRO_ENVIRONMENT_GET_INPUT_BITMASKS, NULL);
|
|
environ_cb(RETRO_ENVIRONMENT_SET_INPUT_DESCRIPTORS, desc);
|
|
|
|
vars[0] = var_jnb_flip;
|
|
vars[1] = var_jnb_flies;
|
|
vars[2] = var_empty;
|
|
environ_cb(RETRO_ENVIRONMENT_SET_VARIABLES, (void *)vars);
|
|
}
|
|
|
|
void retro_deinit(void)
|
|
{
|
|
free(frame_buf);
|
|
frame_buf = NULL;
|
|
}
|
|
|
|
unsigned retro_api_version(void)
|
|
{
|
|
return RETRO_API_VERSION;
|
|
}
|
|
|
|
void retro_set_controller_port_device(unsigned port, unsigned device) { }
|
|
|
|
void retro_get_system_info(struct retro_system_info *info)
|
|
{
|
|
memset(info, 0, sizeof(*info));
|
|
info->library_name = "Jump 'n Bump";
|
|
info->library_version = "0.1";
|
|
info->need_fullpath = false;
|
|
info->valid_extensions = "dat";
|
|
}
|
|
|
|
void retro_get_system_av_info(struct retro_system_av_info *info)
|
|
{
|
|
info->geometry.base_width = JNB_WIDTH;
|
|
info->geometry.base_height = JNB_HEIGHT;
|
|
info->geometry.max_width = JNB_WIDTH;
|
|
info->geometry.max_height = JNB_HEIGHT;
|
|
info->geometry.aspect_ratio = (400.0f / 256.0f);
|
|
info->timing.fps = 60.0;
|
|
info->timing.sample_rate = 44100.0f;
|
|
}
|
|
|
|
void retro_set_environment(retro_environment_t cb)
|
|
{
|
|
environ_cb = cb;
|
|
}
|
|
|
|
void retro_set_audio_sample(retro_audio_sample_t cb) { }
|
|
|
|
void retro_set_audio_sample_batch(retro_audio_sample_batch_t cb)
|
|
{
|
|
audio_batch_cb = cb;
|
|
}
|
|
|
|
void retro_set_input_poll(retro_input_poll_t cb)
|
|
{
|
|
input_poll_cb = cb;
|
|
}
|
|
|
|
void retro_set_input_state(retro_input_state_t cb)
|
|
{
|
|
input_state_cb = cb;
|
|
}
|
|
|
|
void retro_set_video_refresh(retro_video_refresh_t cb)
|
|
{
|
|
video_cb = cb;
|
|
}
|
|
|
|
void retro_reset(void)
|
|
{
|
|
game_state = GAME_STATE_BOOT;
|
|
}
|
|
|
|
static void update_controller(int port)
|
|
{
|
|
int left, right, jump;
|
|
|
|
if (supports_input_bitmasks)
|
|
{
|
|
const int16_t active = input_state_cb(port, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_MASK);
|
|
left = (active & (1 << RETRO_DEVICE_ID_JOYPAD_LEFT));
|
|
right = (active & (1 << RETRO_DEVICE_ID_JOYPAD_RIGHT));
|
|
jump = (active & (1 << RETRO_DEVICE_ID_JOYPAD_A));
|
|
}
|
|
else
|
|
{
|
|
left = input_state_cb(port, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_LEFT);
|
|
right = input_state_cb(port, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_RIGHT);
|
|
jump = input_state_cb(port, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_A);
|
|
}
|
|
|
|
addkey(((KEY_PL1_LEFT + 0x10 * port) & 0x7fff) | ((left != 0) ? 0x0 : 0x8000));
|
|
addkey(((KEY_PL1_RIGHT + 0x10 * port) & 0x7fff) | ((right != 0) ? 0x0 : 0x8000));
|
|
addkey(((KEY_PL1_JUMP + 0x10 * port) & 0x7fff) | ((jump != 0) ? 0x0 : 0x8000));
|
|
}
|
|
|
|
static void update_input(void)
|
|
{
|
|
int esc_pressed, port;
|
|
input_poll_cb();
|
|
|
|
for (port = 0; port < 4; port++)
|
|
{
|
|
update_controller(port);
|
|
}
|
|
|
|
esc_pressed = input_state_cb(0, RETRO_DEVICE_JOYPAD, 0, RETRO_DEVICE_ID_JOYPAD_START);
|
|
addkey((1 & 0x7fff) | ((esc_pressed != 0) ? 0x0 : 0x8000));
|
|
}
|
|
|
|
static void check_variables(void)
|
|
{
|
|
struct retro_variable var = { 0 };
|
|
|
|
var.key = var_jnb_flip.key;
|
|
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var))
|
|
{
|
|
if (strcmp(var.value, "OFF") == 0)
|
|
{
|
|
flip = 0;
|
|
}
|
|
else
|
|
{
|
|
flip = 1;
|
|
}
|
|
}
|
|
|
|
var.key = var_jnb_flies.key;
|
|
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE, &var))
|
|
{
|
|
if (strcmp(var.value, "OFF") == 0)
|
|
{
|
|
flies_enabled = 0;
|
|
}
|
|
else
|
|
{
|
|
flies_enabled = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int16_t audio_buffer[735 * 2];
|
|
|
|
static void audio_callback(void)
|
|
{
|
|
memset((void*)audio_buffer, 0, 735 * 4);
|
|
micromod_get_audio(audio_buffer, 735);
|
|
mix_sound(audio_buffer, 735 * 4);
|
|
audio_batch_cb(audio_buffer, 735);
|
|
}
|
|
|
|
void retro_run(void)
|
|
{
|
|
bool updated;
|
|
|
|
update_input();
|
|
audio_callback();
|
|
|
|
if (game_state == GAME_STATE_BOOT)
|
|
{
|
|
menu_init();
|
|
game_state = GAME_STATE_MENU;
|
|
}
|
|
else if (game_state == GAME_STATE_MENU)
|
|
{
|
|
if(menu_frame() == 1)
|
|
{
|
|
init_level();
|
|
game_init();
|
|
game_state = GAME_STATE_GAME;
|
|
}
|
|
}
|
|
else if (game_state == GAME_STATE_GAME)
|
|
{
|
|
if(game_loop() == 1)
|
|
{
|
|
end_game();
|
|
game_state = GAME_STATE_END;
|
|
}
|
|
}
|
|
else if (game_state == GAME_STATE_END)
|
|
{
|
|
if(end_loop() == 1)
|
|
{
|
|
game_state = GAME_STATE_BOOT;
|
|
}
|
|
}
|
|
|
|
video_cb(frame_buf, JNB_WIDTH, JNB_HEIGHT, JNB_WIDTH << 1);
|
|
|
|
updated = false;
|
|
if (environ_cb(RETRO_ENVIRONMENT_GET_VARIABLE_UPDATE, &updated) && updated)
|
|
{
|
|
check_variables();
|
|
if (game_state == GAME_STATE_GAME) {
|
|
// need to restart
|
|
game_state = GAME_STATE_BOOT;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool retro_load_game(const struct retro_game_info *info)
|
|
{
|
|
|
|
enum retro_pixel_format fmt = RETRO_PIXEL_FORMAT_RGB565;
|
|
|
|
if (!info || !info->data || info->size == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if (!environ_cb(RETRO_ENVIRONMENT_SET_PIXEL_FORMAT, &fmt))
|
|
{
|
|
return false;
|
|
}
|
|
|
|
check_variables();
|
|
|
|
datafile_buffer = (unsigned char *) malloc(info->size);
|
|
if (!datafile_buffer)
|
|
{
|
|
return false;
|
|
}
|
|
memcpy(datafile_buffer, info->data, info->size);
|
|
|
|
init_program();
|
|
game_state = GAME_STATE_BOOT;
|
|
|
|
return true;
|
|
}
|
|
|
|
void retro_unload_game(void)
|
|
{
|
|
deinit_program();
|
|
free(datafile_buffer);
|
|
datafile_buffer = NULL;
|
|
}
|
|
|
|
unsigned retro_get_region(void)
|
|
{
|
|
return RETRO_REGION_PAL;
|
|
}
|
|
|
|
bool retro_load_game_special(unsigned type, const struct retro_game_info *info, size_t num)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
size_t retro_serialize_size(void)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
bool retro_serialize(void *data_, size_t size)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool retro_unserialize(const void *data_, size_t size)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
void *retro_get_memory_data(unsigned id)
|
|
{
|
|
(void)id;
|
|
return NULL;
|
|
}
|
|
|
|
size_t retro_get_memory_size(unsigned id)
|
|
{
|
|
(void)id;
|
|
return 0;
|
|
}
|
|
|
|
void retro_cheat_reset(void) { }
|
|
|
|
void retro_cheat_set(unsigned index, bool enabled, const char *code)
|
|
{
|
|
(void)index;
|
|
(void)enabled;
|
|
(void)code;
|
|
} |