0ad/source/lib/input.cpp

/* Copyright (c) 2010 Wildfire Games
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

/*
 * SDL input redirector; dispatches to multiple handlers and allows
 * record/playback of evs.
 */

#include "precompiled.h"
#include "input.h"

#include <stdio.h>
#include <stdlib.h>

#include "lib/external_libraries/sdl.h"

const size_t MAX_HANDLERS = 8;
static InHandler handler_stack[MAX_HANDLERS];
static size_t handler_stack_top = 0;

void in_add_handler(InHandler handler)
{
	debug_assert(handler);

	if(handler_stack_top >= MAX_HANDLERS)
		WARN_ERR_RETURN(ERR::LIMIT);

	handler_stack[handler_stack_top++] = handler;
}

void in_reset_handlers()
{
	handler_stack_top = 0;
}

// send ev to each handler until one returns IN_HANDLED
static void dispatch_ev(const SDL_Event_* ev)
{
	for(int i = (int)handler_stack_top-1; i >= 0; i--)
	{
		debug_assert(handler_stack[i] && ev);
		InReaction ret = handler_stack[i](ev);
		// .. done, return
		if(ret == IN_HANDLED)
			return;
		// .. next handler
		else if(ret == IN_PASS)
			continue;
		// .. invalid return value
		else
			debug_assert(0);	// invalid handler return value
	}
}


//-----------------------------------------------------------------------------

static enum
{
	INIT,		// first call to in_record() or in_playback(): register cleanup routine
	IDLE,
	RECORD,
	PLAYBACK
}
state = INIT;

static FILE* f;

u32 game_ticks;

static u32 time_adjust = 0;
static u32 next_ev_time;


void in_stop()
{
	if(f)
	{
		fclose(f);
		f = 0;
	}

	state = IDLE;
}


LibError in_record(const char* fn)
{
	if(state == INIT)
		atexit(in_stop);

	in_stop();

	f = fopen(fn, "wb");
	if(!f)
		WARN_RETURN(ERR::FAIL);

	fwrite(&game_ticks, sizeof(u32), 1, f);

	state = RECORD;

	return INFO::OK;
}


LibError in_playback(const char* fn)
{
	if(state == INIT)
		atexit(in_stop);

	in_stop();

	f = fopen(fn, "rb");
	if(!f)
		WARN_RETURN(ERR::FAIL);

	u32 rec_start_time;
	fread(&rec_start_time, sizeof(u32), 1, f);
	time_adjust = game_ticks-rec_start_time;

	fread(&next_ev_time, sizeof(u32), 1, f);
	next_ev_time += time_adjust;

	state = PLAYBACK;

	return INFO::OK;
}



void in_dispatch_event(const SDL_Event_* ev)
{
	if(state == RECORD)
	{
		fwrite(&game_ticks, sizeof(u32), 1, f);
		fwrite(ev, sizeof(SDL_Event_), 1, f);
	}

	dispatch_ev(ev);
}


void in_dispatch_recorded_events()
{
	SDL_Event_ ev;

	while(state == PLAYBACK && next_ev_time <= game_ticks)
	{
		fread(&ev, sizeof(SDL_Event_), 1, f);

		// do this before dispatch_ev(),
		// in case a handler calls in_stop() (setting f to 0)
		if(!fread(&next_ev_time, sizeof(u32), 1, f))
{
			in_stop();
exit(0x73c07d);
// TODO: 'disconnect'?
}
		next_ev_time += time_adjust;			

		in_dispatch_event(&ev);	
	}
}