#include <stdio.h>
#include <strings.h>
#include <ctype.h>
#include <sys/time.h>

#include "teeny.h"

/*
Copyright(C) 1990, Andrew Molitor, All Rights Reserved.
This software may be freely used, modified, and redistributed,
as long as this copyright message is left intact, and this
software is not used to develop any commercial product, or used
in any product that is provided on a pay-for-use basis.

No warranties whatsoever. This is not guaranteed to compile, nor,
in the event that it does compile to binaries, are these binaries
guaranteed to perform any function whatsoever.
*/

/*
	Some generic utility functions for TeenyMUD
*/

/*
	Write a timestamp on an object. In minutes since Jan 1 1970
*/

#ifdef TIMESTAMPS
stamp(obj)
{
	struct timeval foo;

	(void)gettimeofday(&foo,(struct timezone *)0);

	if(set_int_elt(obj,TIMESTAMP,(int)(foo.tv_sec / 60)) == -1){
		warning("timestamp","failed write to object");
	}
}
#endif

/*
	Manufactures a new player and returns the object number, one doesn't
exist already.

*/

create_player(p)

char *p;

{
	char *name,*pwd;
	int player;
	int len;
	int list;
	char work[64];  /* Name + pwd must be shorter than this */

	if(parse_name_pwd(p,&name,&pwd) == -1)
		return(-1);

	player = match_player(name);
	if(player != -1){
		return(-1);
	}

	if((len = strlen(name)) + strlen(pwd) + 2 > 64)
		return(-1);

	strcpy(work,name);
	work[len] = ' ';
	strcpy(work+len+1,pwd);

	/* Create a player in object number 0 */

	player = create_obj(TYP_PLAYER);
	if(set_str_elt(player,NAME,work) == -1) goto createboom;
	if(get_int_elt(0,CONTENTS,&list) == -1) goto createboom;
	if(set_int_elt(player,NEXT,list) == -1) goto createboom;
	if(set_int_elt(player,LOC,0) == -1) goto createboom;
	if(set_int_elt(0,CONTENTS,player) == -1) goto createboom;
	if(set_int_elt(player,HOME,0) == -1) goto createboom;
	if(set_int_elt(player,OWNER,player) == -1) goto createboom;
	animate(player);
	do_pose(player,"has connected.");
	return(player);

createboom:
	destroy_obj(player);
	return(-1);
}

/*
	Connects a player, if it exists and the password matches. Returns -1 if
no dice.

*/

connect_player(p)

char *p;

{
	char *name,*pwd;
	char *realname;
	int player;

	if(parse_name_pwd(p,&name,&pwd) == -1)
		return(-1);

	player = match_player(name);
	if(player == -1){
		return(-1);
	}

	/* Check the password */

	if(get_str_elt(player,NAME,&realname) == -1){
		warning("connect_player","could not reference name");
		return(-1);
	}

	/* Assume no leading whitespace */
	while(!isspace(*realname) && *realname) realname++;
	while(isspace(*realname) && *realname) realname++;
	if(*realname == '\0')
		return(-1);

	if(strcmp(realname,pwd) == 0){
		do_pose(player,"has connected.");
		animate(player);
		return(player);
	}
 	return(-1);

}

disconnect_player(player)
{
	do_pose(player,"has disconnected.");
}
/*
	Hack name/pwd pair up.

*/

parse_name_pwd(p,name,pwd)
char *p;
char **name,**pwd;

{
	while(isspace(*p) && *p) p++;
	if(*p == '\0')
		return(-1);

	*name = p;
	while(!isspace(*p) && *p) p++;
	if(*p == '\0')
		return(-1);
        *p++ = '\0';

	while(isspace(*p) && *p) p++;
	if(*p == '\0')
		return(-1);

	*pwd = p;  /* Assume no trailing whitespace. */
	return(0);
}
/*
	Reliable memory allocation.
*/

char *ty_malloc(n,util)
int n;
char *util; /* Identifies the calling routine */

{
	char *p;
	extern char *malloc();

	if( (p = (char *) malloc((unsigned) n)) == NULL){
		fatal(util,"memory allocation failed");
	}
	return(p);
}

/*
	Reliable free(), which does NULL OK.
*/

ty_free(p)
char *p;
{
	if(p == NULL){
		return; /* Ok */
	}
	free(p);
}

/*
	Error message writing junk.
*/

fatal(util,msg)
char *util,*msg;

{
	warning(util,msg);
	exit(1);
}

warning(util,msg)
char *util,*msg;

{
	write(2,util,strlen(util));
	write(2,": ",2);
	write(2,msg,strlen(msg));
	write(2,"\n",1);
}

/*
	returns 1 if the first parameter is (case insensitively) a prefix
of the second. Aspnes-like.

*/

stringprefix(pref,str)

char *pref,*str;

{
	while(*pref && *str && tolower(*pref) == tolower(*str)){
		pref++;str++;
	}
	return(*pref == '\0');
}

/*
	Converts ints to strings.

*/

char *ty_itoa(p,i)

char *p;
int i;

{
	char *ty_itoa_prim();

	if(i < 0){
		i = -i;
		*p++ = '-';
	} else if(i == 0){
		*p++ = '0';
		return(p);
	}

	return(ty_itoa_prim(p,i));
}
/* recursively does it to it. Hee! Russ would love me. */

char *ty_itoa_prim(p,i)
char *p;
int i;
{
	if(i == 0){
		return(p);
	} else {
		p = ty_itoa_prim(p,i/10);
		*p++ = (char)(i % 10) + '0';
		return(p);
	}
}