/*
....[@@@..[@@@..............[@.................. MUD++ is a written from
....[@..[@..[@..[@..[@..[@@@@@....[@......[@.... scratch multi-user swords and
....[@..[@..[@..[@..[@..[@..[@..[@@@@@..[@@@@@.. sorcery game written in C++.
....[@......[@..[@..[@..[@..[@....[@......[@.... This server is an ongoing
....[@......[@..[@@@@@..[@@@@@.................. development project.  All 
................................................ contributions are welcome. 
....Copyright(C).1995.Melvin.Smith.............. Enjoy. 
------------------------------------------------------------------------------
Melvin Smith (aka Fusion)         msmith@hom.net
MUD++ development mailing list    mudpp@van.ml.org
------------------------------------------------------------------------------
vmfields.cpp
*/

#include "config.h"
#include "vmtypes.h"
#include "vmfields.h"
#include "vmachine.h"
#include "npc.h"
#include "room.h"
#include "repop.h"

/*
 * There is a possibilty for speedup of field handling at the cost
 * of memory (few kb) and some readibility
 * Functions defined in this files are accessed only from vmtypes.h
 * We can declare them inline, forget about vmfields.h and include
 * vmfields.cpp directly into vmtypes.cpp
 * This allows compiler to inline superclass calls at every level
 */


/*

// ----------------- xxx

enum
{
	F_xxx_??? = F_yyy_END,
	F_xxx_???,
	...
	F_xxx_END
};

fieldmap fieldmap_xxx[] =
{
	{"", F_xxx_},
	{ NULL, 0 }
};

const char * setfield_xxx( VMachine * vm, void * ptr, int number, vmptr v )
{
	xxx * obj = (xxx *) ptr;
	switch( number )
	{
		default:
			return setfield_yyy(vm,ptr,number,v);
	}
}

bool getfield_xxx( VMachine * vm, void * ptr, int number )
{
	xxx * obj = (xxx *) ptr;
	switch( number )
	{
		default:
			return getfield_yyy(vm,ptr,number);
	}
}
*/

// ----------------- VMObject

enum
{
	F_VMObject_END,
};

fieldmap fieldmap_VMObject[] =
{
	{ NULL, 0 }
};

const char * setfield_VMObject( VMachine * , void * , int , vmptr )
{
	//VMObject * obj = (VMObject *) ptr;
		return "VMObject superclass reached - no such field";
}

bool getfield_VMObject( VMachine * , void * , int  )
{
		return false;
}


// ----------------- MudObject

enum
{
	F_MudObject_aff_bits = F_VMObject_END,
	F_MudObject_trigger_bits,
	F_MudObject_aff_list,
	F_MudObject_o_list,
	F_MudObject_t_list,
	F_MudObject_triggers,
	F_MudObject_END
};

fieldmap fieldmap_MudObject[] =
{
	{"aff_bits", F_MudObject_aff_bits},
	{"trigger_bits", F_MudObject_trigger_bits},
	{"aff_list", F_MudObject_aff_list},
	{"o_list", F_MudObject_o_list},
	{"t_list", F_MudObject_t_list},
	{"triggers", F_MudObject_triggers},
	{ NULL, 0 }
};

const char * setfield_MudObject( VMachine * vm, void * ptr, int number, vmptr v )
{
	Cout << "MudObject setfield hit" << endl;
	//MudObject * obj = (MudObject *) ptr;
	switch( number )
	{
		case F_MudObject_aff_bits:
		case F_MudObject_trigger_bits:
			return "Bitfields not supported now";
		case F_MudObject_aff_list:
		case F_MudObject_o_list:
		case F_MudObject_t_list:
		case F_MudObject_triggers:
			return "LLists not supported now";
		default:
			return setfield_VMObject(vm,ptr,number,v);
	}
}

bool getfield_MudObject( VMachine * vm, void * ptr, int number )
{
	//MudObject * obj = (MudObject *) ptr;
	switch( number )
	{
		case F_MudObject_aff_bits:
		case F_MudObject_trigger_bits:
		case F_MudObject_aff_list:
		case F_MudObject_o_list:
		case F_MudObject_t_list:
		case F_MudObject_triggers:
			return false;
		default:
			return getfield_VMObject(vm,ptr,number);
	}
}

// ----------------- Thing

enum
{
	F_Thing_name = F_MudObject_END,
	F_Thing_shortdesc,
	F_Thing_longdesc,
	F_Thing_in_room,
	F_Thing_size,
	F_Thing_weight,
	F_Thing_volume,
	F_Thing_invis,
	F_Thing_timer,
	F_Thing_END
};

fieldmap fieldmap_Thing[] = 
{
	{"name", F_Thing_name},
	{"shortdesc", F_Thing_shortdesc},
	{"longdesc", F_Thing_longdesc},
	{"in_room", F_Thing_in_room},
	{"size", F_Thing_size},
	{"weight", F_Thing_weight},
	{"volume", F_Thing_volume},
	{"invis", F_Thing_invis},
	{"timer", F_Thing_timer},
	{ NULL, 0 }
};

const char * setfield_Thing( VMachine * vm, void * ptr, int number, vmptr v )
{
	Cout << "Thing setfield hit" << endl;
	Thing * obj = (Thing *) ptr;
	switch( number )
	{
		case F_Thing_name:
			obj->setName( *v.s ); return NULL;
		case F_Thing_shortdesc:
			obj->setShort( *v.s ); return NULL;
		case F_Thing_longdesc:
			obj->setLong( *v.s ); return NULL;
		case F_Thing_in_room:
			return "Attempt to directly set in_room";
		case F_Thing_size:
			if ( (v.i < SIZE_TINY) || (v.i > SIZE_GIGANTIC) )
				return "Illegal size specified";
			obj->setSize( v.i ); return NULL;
		case F_Thing_weight:
			if ( v.i < 0 )
				return "Weight has to be positive";
			obj->setWeight(v.i); return NULL;
		case F_Thing_volume:
			if ( v.i < 0 )
				return "Volume has to be positive";
			obj->setVol(v.i); return NULL;
		case F_Thing_invis:
			if ( v.i < 0 )
				return "Invis level has to be positive";
			obj->setVol(v.i); return NULL;	
		case F_Thing_timer:
			obj->setTimer(v.i); return NULL;
		default:
			return setfield_MudObject(vm,ptr,number,v);
	}
}

bool getfield_Thing( VMachine * vm, void * ptr, int number )
{
	Thing * obj = (Thing *) ptr;
	switch( number )
	{
		case F_Thing_name:
			vm->push_string( obj->getName() ); return true;
		case F_Thing_shortdesc:
			vm->push_string( obj->getShort() ); return true;
		case F_Thing_longdesc:
			vm->push_string( obj->getLong() ); return true;
		case F_Thing_in_room:
			vm->push_obj( VMT_ROOM, obj->inRoom() ); return true;
		case F_Thing_size:
			vm->push_int( obj->getSize() ); return true;
		case F_Thing_weight:
			vm->push_int( obj->getWeight() ); return true;
		case F_Thing_volume:
			vm->push_int( obj->getVol() ); return true;
		case F_Thing_invis:
			vm->push_int( obj->getInvisLevel() ); return true;
		case F_Thing_timer:
			vm->push_int( obj->getTimer() ); return true;
			default:
			return getfield_MudObject(vm,ptr,number);
	}
}

// ----------------- Char

enum
{
	F_Char_edesc = F_Thing_END,
	F_Char_char_bits,
	F_Char_language_bits,
	F_Char_eq_bits,
	F_Char_skills,
	F_Char_level,
	F_Char_classnow,
	F_Char_exp,
	F_Char_race,
	F_Char_hunger,
	F_Char_thirst,
	F_Char_copper,
	F_Char_silver,
	F_Char_gold,
	F_Char_damroll,
	F_Char_hitroll,
	F_Char_armor,
	F_Char_max_hp,
	F_Char_hp,
	F_Char_max_mana,
	F_Char_mana,
	F_Char_anger,
	F_Char_frustration,
	F_Char_adrenaline,
	F_Char_strength,
	F_Char_intel,
	F_Char_wis,
	F_Char_charisma,
	F_Char_con,
	F_Char_dex,
	F_Char_speed,
	F_Char_position,
	F_Char_sex,
	F_Char_carried_weight,
	F_Char_carried_count,
	F_Char_magic_resistance,
	F_Char_orientation,
	F_Char_fighting,
	F_Char_room_index,
	F_Char_END
};

fieldmap fieldmap_Char[] =
{
	{"edesc", F_Char_edesc},
	{"char_bits", F_Char_char_bits},
	{"language_bits", F_Char_language_bits},
	{"eq_bits", F_Char_eq_bits},
	{"skills", F_Char_skills},
	{"level", F_Char_level},
	{"classnow", F_Char_classnow},
	{"exp", F_Char_exp},
	{"race", F_Char_race},
	{"hunger", F_Char_hunger},
	{"thirst", F_Char_thirst},
	{"copper", F_Char_copper},
	{"silver", F_Char_silver},
	{"gold", F_Char_gold},
	{"damroll", F_Char_damroll},
	{"hitroll", F_Char_hitroll},
	{"armor", F_Char_armor},
	{"max_hp", F_Char_max_hp},
	{"hp", F_Char_hp},
	{"max_mana", F_Char_max_mana},
	{"mana", F_Char_mana},
	{"anger", F_Char_anger},
	{"frustration", F_Char_frustration},
	{"adrenaline", F_Char_adrenaline},
	{"strength", F_Char_strength},
	{"intel", F_Char_intel},
	{"wis", F_Char_wis},
	{"charisma", F_Char_charisma},
	{"con", F_Char_con},
	{"dex", F_Char_dex},
	{"speed", F_Char_speed},
	{"position", F_Char_position},
	{"sex", F_Char_sex},
	{"weight", F_Char_carried_weight},
	{"count", F_Char_carried_count},
	{"magic_resistance", F_Char_magic_resistance},
	{"orientation", F_Char_orientation},
	{"fighting", F_Char_fighting},
	{"room_index", F_Char_room_index},
	{ NULL, 0 }
};

const char * setfield_Char( VMachine * vm, void * ptr, int number, vmptr v )
{
	Cout << "Char setfield hit with field number " << number << endl;
	Char * obj = (Char *) ptr;
	switch( number )
	{
		case F_Char_edesc:
		case F_Char_char_bits:
		case F_Char_language_bits:
		case F_Char_eq_bits:
		case F_Char_skills:
		case F_Char_exp:
		case F_Char_classnow:
		case F_Char_anger:
		case F_Char_frustration:
		case F_Char_adrenaline:
		case F_Char_strength:
		case F_Char_intel:
		case F_Char_wis:
		case F_Char_charisma:
		case F_Char_con:
		case F_Char_dex:
		case F_Char_position:
		case F_Char_speed:
		case F_Char_room_index:
				return "Not implemented yet.";
		case F_Char_level:
			if ( v.i < 0 ) return "Level has to be positive";
			obj->setLevel( v.i ); return NULL;
		case F_Char_race:
			if ( (v.i < 0) || (v.i >= MAX_RACE) ) return "Illegal race";
			obj->setRace(v.i); return NULL;
		case F_Char_hunger:
			obj->setHunger( v.i); return NULL;
		case F_Char_thirst:
			obj->setThirst( v.i ); return NULL;
		case F_Char_copper:
			if ( v.i < 0 ) return "Copper has to be positive";
			obj->setCopper( v.i ); return NULL;
		case F_Char_silver:
			if ( v.i < 0 ) return "Silver has to be positive";
			obj->setSilver( v.i ); return NULL;
		case F_Char_gold:
			if ( v.i < 0 ) return "Gold has to be positive";
			obj->setGold( v.i ); return NULL;
		case F_Char_damroll:
		case F_Char_hitroll:
		case F_Char_carried_weight:
		case F_Char_carried_count:
		case F_Char_fighting:
				return "Cannot set this directly";
		case F_Char_armor:
			obj->setArmor( v.i ); return NULL;
		case F_Char_max_hp:
			obj->setMaxHP( v.i ); return NULL;
		case F_Char_hp:
			obj->setHP( v.i ); return NULL;
		case F_Char_max_mana:
			obj->setMaxMana( v.i ); return NULL;
		case F_Char_mana:
			obj->setMana( v.i ); return NULL;
		case F_Char_sex:
			obj->setSex( v.i ); return NULL;
		case F_Char_magic_resistance:
			obj->setMagicResistance( v.i ); return NULL;
		case F_Char_orientation:
			obj->setOrientation( v.i ); return NULL;
		default:
			return setfield_Thing(vm,ptr,number,v);
	}
}

bool getfield_Char( VMachine * vm, void * ptr, int number )
{
	Char * obj = (Char *) ptr;
	switch( number )
	{
		case F_Char_edesc:
		case F_Char_char_bits:
		case F_Char_language_bits:
		case F_Char_eq_bits:
		case F_Char_skills:
		case F_Char_classnow:
		case F_Char_anger:
		case F_Char_frustration:
		case F_Char_adrenaline:
		case F_Char_strength:
		case F_Char_intel:
		case F_Char_wis:
		case F_Char_charisma:
		case F_Char_con:
		case F_Char_dex:
		case F_Char_speed:
		case F_Char_room_index:
		case F_Char_exp:
		case F_Char_position:
				return false;
		case F_Char_level:
			vm->push_int( obj->getLevel() ); return true;
		case F_Char_race:
			vm->push_int( obj->getRace() ); return true;
		case F_Char_hunger:
			vm->push_int( obj->getHunger() ); return true;
		case F_Char_thirst:
			vm->push_int( obj->getThirst() ); return true;
		case F_Char_copper:
			vm->push_int( obj->getCopper() ); return true;
		case F_Char_silver:
			vm->push_int( obj->getSilver() ); return true;
		case F_Char_gold:
			vm->push_int( obj->getGold() ); return true;
		case F_Char_damroll:
			vm->push_int( obj->getDamRoll() ); return true;
		case F_Char_hitroll:
			vm->push_int( obj->getHitRoll() ); return true;
		case F_Char_armor:
			vm->push_int( obj->getArmor() ); return true;
		case F_Char_max_hp:
			vm->push_int( obj->getMaxHP() ); return true;
		case F_Char_hp:
			vm->push_int( obj->getHP() ); return true;
		case F_Char_max_mana:
			vm->push_int( obj->getMaxMana() ); return true;
		case F_Char_mana:
			vm->push_int( obj->getMana() ); return true;
		case F_Char_sex:
			vm->push_int( obj->getSex() ); return true;
		case F_Char_carried_weight:
			vm->push_int( obj->getCarriedWeight() ); return true;
		case F_Char_carried_count:
			vm->push_int( obj->getCarriedCount() ); return true;
		case F_Char_magic_resistance:
			vm->push_int( obj->getMagicResistance() ); return true;
		case F_Char_orientation:
			vm->push_int( obj->getOrientation() ); return true;
		case F_Char_fighting:
			vm->push_obj( VMT_CHAR, obj->getFighting() ); return true;
		default:
			return getfield_Thing(vm,ptr,number);
	}
}



enum
{
	F_NPC_npc_bits = F_Char_END,
	F_NPC_repop,
	F_NPC_END
};

fieldmap fieldmap_NPC[] =
{
	{"npc_bits", F_NPC_npc_bits},
	{"repop", F_NPC_repop},
	{ NULL, 0 }
};

const char * setfield_NPC( VMachine * vm, void * ptr, int number, vmptr v )
{
	Cout << "NPC setfield hit" << endl;
	//NPC * obj = (NPC *) ptr;
	switch( number )
	{
		case F_NPC_npc_bits:
			return "Bitfields not supported now";
		case F_NPC_repop:
			return "Not done yet";
		default:
			return setfield_Char(vm,ptr,number,v);
	}
}

bool getfield_NPC( VMachine * vm, void * ptr, int number )
{
	NPC * obj = (NPC *) ptr;
	switch( number )
	{
		case F_NPC_npc_bits:
			return false;
		case F_NPC_repop:
			vm->push_obj( VMT_REPOP, obj->getRepop() ); return true;
		default:
			return getfield_Char(vm,ptr,number);
	}
}