// File:       /adm/alchemist.c
// Purpose:    Store material properties
//             Setup objects (initialise their properties)
//             This object is also inherited by domain master objects
// Mudlib:     Nightmare
// Author:     Douglas Reay (Pallando @ Ephemeral Dales, Nightmare, etc)
// 93-06-08:   Based on alchemist written by Pallando@FR mud
//             and using the prop_logic seperated by Pallando@TMI-2
// 93-06-16:   Pallando added temperature setting

#include <daemons.h>
#include <materials.h>

inherit "/std/prop_logic";

static string *props;      // Names of properties all objects must have
static int num_props;      // number of properties in the above array
mapping properties; // Values of those properties for each material
static string save_file;   // place where the data for the above mapping is kept

mixed get( string property )
{
    mixed parts, value, tmp;
    int size, loop;

    parts = explode( property, "/" );
    size = sizeof( parts );
    if( !mapp( value = properties[parts[0]] ) ) return value;
    for( loop = 1 ; ( loop < size ) && mapp( value ) ; loop++ )
    {
	// Allows default values.  Eg: if we are trying to find the density of lead
	// but that hasn't been set, it will use the default metal density instead
	if( undefinedp( tmp = value[parts[loop]] ) &&
	  undefinedp( tmp = value["default"]   )   )
	    return mapp( value ) ? tmp : value;
	value = tmp;
    }
    return value;
}

mixed query( string property )
{
    mixed value;

    if( !undefinedp( value = get( property ) ) ) return value;
    return ALCHEMIST_D-> get( property );
}

void init_properties()
{
    string file, property;
    mixed value;
    string *lines;
    int size, loop, tmp;

    properties = ([]);
    if( ( 0    > file_size( save_file+".t" ) ) ||
      !( file = read_file( save_file+".t" ) ) ||
      !( lines = explode( file, "\n" )      ) ||
      !( size = sizeof( lines )             )   ) return;
    properties = allocate_mapping( size );
    for( loop = 0 ; loop < size ; loop++ )
    {
	if( sscanf( lines[loop], "%s;%s", property, value ) < 2 ) continue;
	if( sscanf( value, "%d", tmp ) ) value = tmp;
	// Defined in /std/prop_logic
	// Just does properties[property]=value in a heirachic way (see the .o)
	_set( properties, explode( property, "/" ), value );
    }
    save_object( save_file );
}

// During reboots the data is saved in a .o file.
// It only needs to be calculated from the .t when that file is changed
void create()
{
    // Inheriting d_masters use different save files.
    if( !save_file ) save_file = "/data/properties";
    restore_object( save_file );
    if( properties ) return;
    init_properties();
}

// This function is called from set_material() in /std/Object
// Inheriting domain master obs can set props in create or in their
// setup_object function, before doing ::setup_object()
void setup_object( object ob, object pobj )
{
    string material, name, type;
    int mass, temperature, loop;

    if( !props )
    {
	props = MATERIAL_PROPS;
	num_props = sizeof( props );
    }
    type = (string)ob-> query( "material_type" );
    if( !type || -1 == member_array( type, MATERIAL_TYPES ) )
    {
	// Log the event here for QC
	return;
    }
    if( !( name = (string)ob-> query( "material_name" ) ) )
    {
	// Log the event here for QC
	return;
    }
    material = "/"+type+"/"+name;
    for( loop = 0 ; loop < num_props ; loop++ )
	ob-> set( props[loop], query( props[loop] + material ) );
    if( !( mass = (int)ob-> query( "mass" ) ) )
    {
	// Log the event here for QC
	return;
    }
    // Until set_weight() is removed.
    ob-> set_weight( mass );
    ob-> set( "volume", 1000 * mass / ( (int)ob-> query( "density" ) ) );
    if( !pobj ) return;
    if( !function_exists( "query", pobj ) ||
      undefinedp( temperature = pobj-> query( "temperature" ) ) )
	temperature = query( "temperature/default" );
    ob-> set( "temperature", temperature );
}