static void sprite_callback(int *code,int *color,int *priority_mask)
{
#if 0
if (code_pressed(KEYCODE_Q) && (*color & 0x80)) *color = rand();
if (code_pressed(KEYCODE_W) && (*color & 0x40)) *color = rand();
if (code_pressed(KEYCODE_E) && (*color & 0x20)) *color = rand();
if (code_pressed(KEYCODE_R) && (*color & 0x10)) *color = rand();
#endif
*priority_mask = (*color & 0x10) ? 0 : 0x02;
*color = sprite_colorbase + (*color & 0x0f);
}
static READ8_HANDLER( marinedt_coll_r )
{
//76543210
//x------- obj1 to obj2 collision
//-xxx---- unused
//----x--- obj1 to playfield collision
//-----xxx unused
if (code_pressed(KEYCODE_X)) return 0x80;
if (code_pressed(KEYCODE_Z)) return 0x08;
return coll | collh;
}
bool input_manager::code_pressed_once(input_code code)
{
// look for the code in the memory
bool curvalue = code_pressed(code);
int empty = -1;
for (int memnum = 0; memnum < ARRAY_LENGTH(m_switch_memory); memnum++)
{
// were we previous pressed on the last time through here?
if (m_switch_memory[memnum] == code)
{
// if no longer pressed, clear entry
if (curvalue == false)
m_switch_memory[memnum] = INPUT_CODE_INVALID;
// always return false
return false;
}
// remember the first empty entry
if (empty == -1 && m_switch_memory[memnum] == INPUT_CODE_INVALID)
empty = memnum;
}
// if we get here, we were not previously pressed; if still not pressed, return 0
if (curvalue == false)
return false;
// otherwise, add ourself to the memory and return 1
assert(empty != -1);
if (empty != -1)
m_switch_memory[empty] = code;
return true;
}
bool input_manager::seq_pressed(const input_seq &seq)
{
// iterate over all of the codes
bool result = false;
bool invert = false;
bool first = true;
for (int codenum = 0; ; codenum++)
{
// handle NOT
input_code code = seq[codenum];
if (code == input_seq::not_code)
invert = true;
// handle OR and END
else if (code == input_seq::or_code || code == input_seq::end_code)
{
// if we have a positive result from the previous set, we're done
if (result || code == input_seq::end_code)
break;
// otherwise, reset our state
result = false;
invert = false;
first = true;
}
// handle everything else as a series of ANDs
else
{
// if this is the first in the sequence, result is set equal
if (first)
result = code_pressed(code) ^ invert;
// further values are ANDed
else if (result)
result &= code_pressed(code) ^ invert;
// no longer first, and clear the invert flag
first = invert = false;
}
}
// return the result if we queried at least one switch
return result;
}
/***************************************************************************
This function takes care of refreshing the screen, processing user input,
and throttling the emulation speed to obtain the required frames per second.
IN: blocking (no longer used)
1 == blocking, i.e. read keys, doesn't return until vblank complete.
0 == non-blocking, i.e. read keys but return if not vblank
***************************************************************************/
int _updatescreen(int blocking)
{
static uclock_t prev;
static int this1, last1;
static int this2, last2;
static int this3, last3;
static int thisct, lastct;
float fps = sim_fps;
thisct = code_pressed(KEYCODE_LCONTROL);
if (thisct && lastct != thisct)
{
io_input[1] &= ~0x10; // see note for f_1F04
}
else
{
io_input[1] |= 0x10; // see note for f_1F04
}
lastct = thisct;
if ( code_pressed(KEYCODE_RIGHT) )
{
io_input[1] &= ~2;
}
else
{
io_input[1] |= 2;
}
if ( code_pressed(KEYCODE_LEFT) )
{
io_input[1] &= ~8;
}
else
{
io_input[1] |= 8;
}
/* if the user pressed ESC, stop the emulation */
if ( code_pressed(KEYCODE_ESC) ) return 1;
// get keys for coin-in switch and start button, which need to be debounced
this3 = code_pressed(KEYCODE_3);
if (this3 && last3 != this3)
{
if (io_input[0] < 255)
{
io_input[0]++;
}
}
last3 = this3;
this1 = code_pressed(KEYCODE_1);
if (this1 && last1 != this1)
{
if (io_input[0] > 0)
{
io_input[0]--;
}
}
last1 = this1;
this2 = code_pressed(KEYCODE_2);
if (this2 && last2 != this2)
{
if (io_input[0] > 0)
{
io_input[0] -= 2;
}
}
last2 = this2;
if (1)
{
uclock_t curr;
updatescreen();
/* now wait until it's time to trigger the interrupt */
do
{
curr = uclock();
}
while (curr - prev < UCLOCKS_PER_SEC / fps);
vblank_work();
prev = curr;
}
return 0;
}
int32_t input_manager::seq_axis_value(const input_seq &seq, input_item_class &itemclass)
{
// start with no valid classes
input_item_class itemclasszero = ITEM_CLASS_INVALID;
itemclass = ITEM_CLASS_INVALID;
// iterate over all of the codes
int32_t result = 0;
bool invert = false;
bool enable = true;
for (int codenum = 0; ; codenum++)
{
// handle NOT
input_code code = seq[codenum];
if (code == input_seq::not_code)
invert = true;
// handle OR and END
else if (code == input_seq::or_code || code == input_seq::end_code)
{
// if we have a positive result from the previous set, we're done
if (itemclass != ITEM_CLASS_INVALID || code == input_seq::end_code)
break;
// otherwise, reset our state
result = 0;
invert = false;
enable = true;
}
// handle everything else only if we're still enabled
else if (enable)
{
// switch codes serve as enables
if (code.item_class() == ITEM_CLASS_SWITCH)
{
// AND against previous digital codes
if (enable)
enable &= code_pressed(code) ^ invert;
}
// non-switch codes are analog values
else
{
int32_t value = code_value(code);
// if we got a 0 value, don't do anything except remember the first type
if (value == 0)
{
if (itemclasszero == ITEM_CLASS_INVALID)
itemclasszero = code.item_class();
}
// non-zero absolute values stick
else if (code.item_class() == ITEM_CLASS_ABSOLUTE)
{
itemclass = ITEM_CLASS_ABSOLUTE;
result = value;
}
// non-zero relative values accumulate
else if (code.item_class() == ITEM_CLASS_RELATIVE)
{
itemclass = ITEM_CLASS_RELATIVE;
result += value;
}
}
// clear the invert flag
invert = false;
}
}
// if the caller wants to know the type, provide it
if (result == 0)
itemclass = itemclasszero;
return result;
}
