Beispiel #1
0
void load_recipes (){
	char fname[128];
	FILE *fp;

	init_recipe_names();

	if (recipes_loaded) {
		/*
		 * save existing recipes instead of loading them if we are already logged in
		 * this will take place when relogging after disconnection
		 */
		save_recipes();
		return;
	}

	recipes_loaded=1;
	memset (recipes, 0, sizeof (recipes));

	safe_snprintf(fname, sizeof(fname), "recipes_%s.dat",username_str);
	my_tolower(fname);
	fp = open_file_config(fname,"rb");
	if(fp == NULL){
		LOG_ERROR("%s: %s \"%s\"\n", reg_error_str, cant_open_file, fname);
		return;
	}

	if (fread (recipes,sizeof(recipes),1, fp) != 1)
		LOG_ERROR("%s() read failed for file [%s]\n", __FUNCTION__, fname);
	fclose (fp);

	load_recipe_names();
}
Beispiel #2
0
void load_server_markings(){
	char fname[128];
	FILE *fp;
	server_mark sm;
	int rf;

	init_server_markers();
	
	//open server markings file
	safe_snprintf(fname, sizeof(fname), "servermarks_%s.dat",username_str);
	my_tolower(fname);
	fp = open_file_config(fname,"r");
	if(fp == NULL){
		LOG_ERROR("%s: %s \"%s\": %s\n", reg_error_str, cant_open_file, fname, strerror(errno));
		return;
	}

	while((rf=fscanf(fp,"%d %d %d %s %[^\n]s\n",&sm.id,&sm.x,&sm.y,sm.map_name,sm.text))==5){		
		server_mark *nm = calloc(1,sizeof(server_mark));
		memcpy(nm,&sm,sizeof(server_mark));
		hash_add(server_marks,(NULL+sm.id),(void*) nm);
	}
	
	fclose (fp);

	LOG_DEBUG("Read server markings from file '%s'", fname);

	add_server_markers();
}
Beispiel #3
0
/* save the recipe names, done on exit and after each change */
void save_recipes(){
	char fname[128];
	FILE *fp;
	size_t i;

	if (!recipes_loaded)
		return;

	save_recipe_names();

	safe_snprintf(fname, sizeof(fname), "recipes_%s.dat",username_str);
	my_tolower(fname);
	fp=open_file_config(fname,"wb");
	if(fp == NULL){
		LOG_ERROR("%s: %s \"%s\": %s\n", reg_error_str, cant_open_file, fname, strerror(errno));
		return;
	}

	for (i=0; i<num_recipe_entries+1; i++)
	{
		item *store = (i<num_recipe_entries) ?recipes_store[i].items :manu_recipe.items;
		if (fwrite (store,sizeof(item)*NUM_MIX_SLOTS,1, fp) != 1)
		{
			LOG_ERROR("%s() fail during write of file [%s] : %s\n", __FUNCTION__, fname, strerror(errno));
			break;
		}
	}

	fclose(fp);
}
static int ProcessImage( IplImage* image, char* funcname, int read )
{
    char name[1000];
    char lowername[1000];
    int i = 0, err;
    
    do
    {
	lowername[i] = (char)my_tolower(funcname[i]);
    }
    while( funcname[i++] != '\0' );

    if( read )
    {
        err = CheckImage( image,
                          atsGetTestDataPath(name, filedir_, lowername, "bmp"),
                          funcname );
        if( err )
	{
            trsWrite( ATS_CON | ATS_LST, "Error in %s: %d\n", funcname, err );
	}    
        return 0; //err;
    }
    else
    {
        cvvSaveImage( atsGetTestDataPath(name, filedir_, lowername, "bmp"), image );
        return 0;
    }
}
Beispiel #5
0
/* load saved recipe names from file */
static void load_recipe_names(void)
{
	char fname[128];
	FILE *fp;
	char line [128];
	size_t recipe_no;

	recipe_names_changed = 0;

	safe_snprintf(fname, sizeof(fname), "recipes_%s.names",username_str);
	my_tolower(fname);
	fp = open_file_config(fname,"r");
	if(fp == NULL)
	{
		LOG_ERROR("%s() %s \"%s\" [%s]\n", __FUNCTION__, cant_open_file, fname, strerror(errno));
		return;
	}

	recipe_no = 0;
 	while (fgets(line, sizeof(line), fp) != NULL)
	{
		size_t len = strlen(line);
		while ((len > 0) && ((line[len-1] == '\r') || (line[len-1] == '\n') || (line[len-1] == ' ')))
		{
			line[len-1] = '\0';
			len--;
		}
		if (len > 0)
			new_recipe_name(recipe_no, line);
		recipe_no++;
	}

	fclose(fp);
}
Beispiel #6
0
/*
 * This function builds probability tables from a list of purely alphabetical
 * lower-case words, and puts them into the supplied name_probs object.
 * The array of names should have a NULL entry at the end of the list.
 * It relies on the ASCII character set (through use of A2I).
 */
static void build_prob(name_probs probs, cptr *learn)
{
	int c_prev, c_cur, c_next;
	cptr ch;
	int i;

	/* Build raw frequencies */
	for (i = 0; learn[i] != NULL; i++)
	{
		c_prev = c_cur = S_WORD;
		ch = learn[i];

		/* Iterate over the next word */
		while (*ch != '\0')
		{
			c_next = A2I(my_tolower((unsigned char)*ch));

			probs[c_prev][c_cur][c_next]++;
			probs[c_prev][c_cur][TOTAL]++;
                        
			/* Step on */
			c_prev = c_cur;
			c_cur = c_next;
			ch++;
		}

		probs[c_prev][c_cur][E_WORD]++;
		probs[c_prev][c_cur][TOTAL]++;
	}
}
Beispiel #7
0
void load_entrable_list()
{
	FILE *f = NULL;
	char strLine[255];
	int off;

	memset(entrable_objects, 0, sizeof(entrable_objects));
	nr_entrable_objects = 0;
	f=open_file_data("entrable.lst", "rb");
	if(f == NULL)
	{
		LOG_ERROR("%s: %s \"entrable.lst\": %s\n", reg_error_str, cant_open_file, strerror(errno));
		return;
	}
	while (nr_entrable_objects < MAX_ENTRABLE_OBJECTS)
	{
		if (fscanf(f, "%254s", strLine) != 1)
			break;
		my_tolower(strLine);
		off = *strLine == '/' ? 1 : 0;
		my_strncp(entrable_objects[nr_entrable_objects], strLine+off,
			OBJ_NAME_SIZE);
		nr_entrable_objects++;
		if (!fgets(strLine, sizeof(strLine), f))
			break;
	}
	fclose(f);

	// Sort the list so we can use binary search
	qsort(entrable_objects, nr_entrable_objects, OBJ_NAME_SIZE,
		(int(*)(const void*,const void*))strcmp);
}
Beispiel #8
0
void save_server_markings(){
	char fname[128];
	FILE *fp;
	server_mark *sm;
	hash_entry *he;
	
	if(!server_marks) return;

	//open server markings file
	safe_snprintf(fname, sizeof(fname), "servermarks_%s.dat",username_str);
	my_tolower(fname);
	fp = open_file_config(fname,"w");
	if(fp == NULL){
		LOG_ERROR("%s: %s \"%s\": %s\n", reg_error_str, cant_open_file, fname, strerror(errno));
		return;
	}

	hash_start_iterator(server_marks);
	
	while((he=hash_get_next(server_marks))){		
		sm = (server_mark *) he->item;
		fprintf(fp,"%d %d %d %s %s\n",sm->id, sm->x, sm->y, sm->map_name, sm->text);
	}
	
	fclose (fp);	

	LOG_DEBUG("Wrote server markings to file '%s'", fname);
}
Beispiel #9
0
void send_input_text_line (char *line, int line_len)
{
	char str[256];
	int i,j;
	int len;
	Uint8 ch;

	switch(use_windowed_chat)
	{
		case 1:
			if(tabs[current_tab].channel != CHAT_ALL) {
				change_to_current_tab(line);
			}
		break;
		case 2:
			if(channels[active_tab].chan_nr != CHAT_ALL) {
				change_to_current_chat_tab(line);
			}
		break;
	}

	if ( caps_filter && line_len > 4 && my_isupper (line, -1) )
		my_tolower (line);

	i=0;
	j=1;
	if (line[0] != '/' && line[0] != char_slash_str[0])	//we don't have a PM
	{
		str[0] = RAW_TEXT;
	}
	else
	{
		str[0] = SEND_PM;
		i++;	// skip the leading /
	}

	for ( ; i < line_len && j < sizeof (str) - 1; i++)	// copy it, but ignore the enter
	{
		ch = line[i];
		if (ch != '\n' && ch != '\r')
		{
			str[j] = ch;
			j++;
		}
	}
	str[j] = 0;	// always a NULL at the end

	len = strlen (&str[1]);
	if (my_tcp_send (my_socket, (Uint8*)str, len+1) < len+1)
	{
		//we got a nasty error, log it
	}

	return;
}
Beispiel #10
0
static char	*str2lower(char *str)
{
  char		*res;
  int		size;
  int		i;

  size = my_strlen(str);
  res = xmalloc(size + 1);
  for (i = 0; i < size; i++)
    res[i] = my_tolower(str[i]);
  res[size] = 0;
  return res;
}
Beispiel #11
0
static unsigned long my_atou_x(char *s)
{
	unsigned radix=10, c;
	unsigned long n=0;

	while (*s == ' ' || *s == '\t') s++;

	if (s[0] == '0' && s[1] == 'x') {
		radix = 16;
		s += 2;
	}

	while (my_isalnum(*s)) {
		c = my_tolower(*s); s++;
		if (my_isdigit(c)) c=c-'0'; else c=c-'A'+10;
		if (c >= radix) break;
		n = n * radix + c;
	}

	return n;
}
Beispiel #12
0
void save_recipes(){
	char fname[128];
	FILE *fp;

	if (!recipes_loaded)
		return;

	save_recipe_names();

	safe_snprintf(fname, sizeof(fname), "recipes_%s.dat",username_str);
	my_tolower(fname);
	fp=open_file_config(fname,"wb");
	if(fp == NULL){
		LOG_ERROR("%s: %s \"%s\"\n", reg_error_str, cant_open_file, fname);
		return;
	}

	fwrite(recipes, sizeof(recipes), 1, fp);

	fclose(fp);
}
Beispiel #13
0
/* save recipe names to file if any have changed */
static void save_recipe_names(void)
{
	char fname[128];
	FILE *fp;
	size_t i;
	int errorflag = 0;

	if (!recipe_names_changed)
		return;

	safe_snprintf(fname, sizeof(fname), "recipes_%s.names",username_str);
	my_tolower(fname);
	fp = open_file_config(fname,"w");
	if(fp == NULL)
	{
		LOG_ERROR("%s() %s \"%s\" [%s]\n", __FUNCTION__, cant_open_file, fname, strerror(errno));
		return;
	}

	for (i=0; i<SHOW_MAX_RECIPE; i++)
	{
		if (recipe_name[i] != NULL)
		{
			if (fputs(recipe_name[i], fp) < 0)
			{
				errorflag = 1;
				break;
			}
		}
		if (fputc('\n', fp) != '\n')
		{
			errorflag = 1;
			break;
		}
	}
	if (errorflag)
		LOG_ERROR("%s() %s \"%s\" [%s]\n", __FUNCTION__, cant_open_file, fname, strerror(errno));

	fclose(fp);
}
Beispiel #14
0
/****************************************************************************
  Initialize events. 
  Now also initialise sorted_events[].
****************************************************************************/
void events_init(void)
{
  int i;
  
  for (i = 0; i < ARRAY_SIZE(event_to_index); i++) {
    event_to_index[i] = 0;
  }

  for (i = 0; events[i].enum_name; i++) {
    int j;

    if (E_S_XYZZY > events[i].esn) {
      const char *event_format = Q_(event_sections[events[i].esn]);
      int l = 1 + strlen(event_format) + strlen(_(events[i].descr_orig));

      events[i].full_descr = fc_malloc(l);
      my_snprintf(events[i].full_descr, l, event_format,
                  _(events[i].descr_orig));
    } else {
      /* No section part */
      events[i].full_descr = _(events[i].descr_orig);
    }

    event_to_index[events[i].event] = i;
    events[i].tag_name = mystrdup(events[i].enum_name);
    for (j = 0; j < strlen(events[i].tag_name); j++) {
      events[i].tag_name[j] = my_tolower(events[i].tag_name[j]);
    }
    freelog(LOG_DEBUG,
	    "event[%d]=%d: name='%s' / '%s'\n\tdescr_orig='%s'\n\tdescr='%s'",
	    i, events[i].event, events[i].enum_name, events[i].tag_name,
	    events[i].descr_orig, events[i].full_descr);
  }

  for (i = 0; i < E_LAST; i++)  {
    sorted_events[i] = i;
  }
  qsort(sorted_events, E_LAST, sizeof(*sorted_events),
	compar_event_message_texts);
}
Beispiel #15
0
void send_login_info()
{
	int i;
	int j;
	int len;
	unsigned char str[40];

	len=strlen(username_str);
	//check for the username lenght
	if(len<3)
		{
			sprintf(log_in_error_str,"%s: %s",reg_error_str,error_username_length);
			return;
		}

	//join the username and password, and send them to the server
	str[0]=LOG_IN;

	if(caps_filter && my_isupper(username_str, len)) my_tolower(username_str);
	for(i=0;i<len;i++)str[i+1]=username_str[i];
	str[i+1]=' ';
	i++;
	len=strlen(password_str);
	for(j=0;j<len;j++)str[i+j+1]=password_str[j];
	str[i+j+1]=0;

	//are we going to use this?
	//clear the password field, in order not to try to relogin again
	//password_str[0]=0;
	//display_password_str[0]=0;
	//password_text_lenght=0;


	len=strlen(str);
	len++;//send the last 0 too
	if(my_tcp_send(my_socket,str,len)<len)
		{
			//we got a nasty error, log it
		}
}
Beispiel #16
0
void send_input_text_line()
{
	char str[256];
	int i,j;
	int len;
	Uint8 ch;

	if(caps_filter && strlen(input_text_line) > 4 && my_isupper(input_text_line, -1)) my_tolower(input_text_line);
	i=0;
	j=1;
	if(input_text_line[0]!='/')//we don't have a PM
		{
			str[0]=RAW_TEXT;
		}
	else
		{
			str[0]=SEND_PM;
			i++;	// skip the leading /
		}
	for(;i<input_text_lenght;i++)	// copy it, but ignore the enter
		{
			ch=input_text_line[i];
			if(ch!=0x0a)
				{
					str[j]=ch;
					j++;
				}

		}
	str[j]=0;	// always a NULL at the end

	len=strlen(&str[1]);
	if(my_tcp_send(my_socket,str,len+1)<len+1)
		{
			//we got a nasty error, log it
		}
	return;

}
Beispiel #17
0
/* load recipes, done just after login when we have the player name */
void load_recipes (){
	char fname[128];
	FILE *fp;
	size_t i;
	int logged = 0;
	off_t file_size;
	const size_t recipe_size = sizeof(item)*NUM_MIX_SLOTS;

	if (recipes_loaded) {
		/*
		 * save existing recipes instead of loading them if we are already logged in
		 * this will take place when relogging after disconnection
		 */
		save_recipes();
		save_recipe_names();
		return;
	}

	safe_snprintf(fname, sizeof(fname), "recipes_%s.dat",username_str);
	my_tolower(fname);

	/* get file length, if a valid length adjust the number of recipe slots if required */
	file_size = get_file_size_config(fname);
	if ((file_size > 0) && (file_size % recipe_size == 0))
	{
		int num_recipes_in_file = file_size / recipe_size - 1; // -1 as last is current in pipline
		if ((num_recipes_in_file > wanted_num_recipe_entries) && (num_recipes_in_file < max_num_recipe_entries))
		{
			wanted_num_recipe_entries = num_recipes_in_file;
			set_var_OPT_INT("wanted_num_recipe_entries", wanted_num_recipe_entries);
		}
	}

	/* allocate and initialise the recipe store */
	num_recipe_entries = max_prev_num_recipe_entries = wanted_num_recipe_entries;
	recipes_store = (recipe_entry *)calloc(num_recipe_entries, sizeof(recipe_entry));
	if (recipes_store == NULL)
	{
		max_prev_num_recipe_entries = num_recipe_entries = 0;
		return;
	}
	recipes_loaded=1;
	init_recipe_names();

	/* if the file exists but is not a valid size, don't use it */
	if ((file_size > 0) && (file_size % recipe_size != 0))
	{
		LOG_ERROR("%s: Invalid format (size mismatch) \"%s\"\n", reg_error_str, fname);
		return;
	}

	/* sliently ignore non existing file */
	if (!file_exists_config(fname))
		return;

	fp = open_file_config(fname,"rb");
	if(fp == NULL){
		LOG_ERROR("%s: %s \"%s\": %s\n", reg_error_str, cant_open_file, fname, strerror(errno));
		return;
	}

	/* attempt to read all the recipies we're expecting */
	for (i=0; !feof(fp) && i<num_recipe_entries; i++)
	{
		if (fread (recipes_store[i].items,recipe_size,1, fp) != 1)
		{
			if (!logged)
			{
				LOG_ERROR("%s() fail during read of file [%s] : %s\n", __FUNCTION__, fname, strerror(errno));
				logged = 1;
			}
			memset(recipes_store[i].items, 0, recipe_size);
			break;
		}
	}

	/* if there is another, use it as the current recipe in the manufacturing pipeline */
	if (!feof(fp))
		if (fread (manu_recipe.items,recipe_size,1, fp) != 1)
			memset(manu_recipe.items, 0, recipe_size);

	fclose (fp);

	load_recipe_names();
}
void extract_feats(vector<string> &W,vector<string>& P,vector<vector<string> >& O,bool lowercase, vector<string>& LOW){
  int n = W.size(), m = P.size();
  vector<string> SH, SB, SB3, PR, PR3;
  for (int i = 0; i < n; ++i){
    string w = W[i], pos = "";
    if (lowercase)
      w = my_tolower(W[i]);
    if (m > 0)
      pos = P[i];
    string sh = "", lemma = "", sb = "", sb3="", pr = "", pr3 = "";
    lemma = my_tolower_sh(w,sh);
    if (lemma.size() > 2){
      sb = string(lemma,lemma.size()-2,2);
      pr = string(lemma,0,2);
    }
    if (lemma.size() > 3){
      sb3 = string(lemma,lemma.size()-3,3);
      pr3 = string(lemma,0,3);
    }
    if (pos != "")
      P.push_back(pos);
    SB.push_back(sb);
    SB3.push_back(sb3);
    PR.push_back(pr);
    PR3.push_back(pr3);
    LOW.push_back(lemma);
    SH.push_back(sh);
  }
  for (int i = 0; i < W.size(); ++i){
    vector<string> W_i;
#if USE_KF
    W_i.push_back("KF");
#endif
#if USE_RELPOS_FEATS
    if (i==0)
      W_i.push_back("rp=begin");
    else if (i<W.size()-1)
      W_i.push_back("rp=mid");
    else 
      W_i.push_back("rp=end");
#endif
    if (i > 0){
      if (m)
	W_i.push_back("pos-1="+P[i-1]);
#if USE_WORDS
      W_i.push_back("w-1="+LOW[i-1]);
#endif
      W_i.push_back("sh-1="+SH[i-1]);
      W_i.push_back("sb-1="+SB[i-1]);
    }
    if (i < W.size()-1){
      if (m)
	W_i.push_back("pos+1="+P[i+1]);
#if USE_WORDS
      W_i.push_back("w+1="+LOW[i+1]);
#endif
      W_i.push_back("sh+1="+SH[i+1]);
      W_i.push_back("sb+1="+SB[i+1]);
    }
#if USE_WORDS
    W_i.push_back("w="+LOW[i]);
#endif
    if (m)
      W_i.push_back("pos="+P[i]);
    W_i.push_back("sh="+SH[i]);
    W_i.push_back("pr="+PR[i]);
    W_i.push_back("pr3="+PR3[i]);
    W_i.push_back("sb="+SB[i]);
    W_i.push_back("sb3="+SB3[i]);
    O.push_back(W_i);
  }
}
Beispiel #19
0
void add_enhanced_actor_from_server(char * in_data)
{
	short actor_id;
	short x_pos;
	short y_pos;
	short z_pos;
	short z_rot;
	short max_health;
	short cur_health;
	Uint8 actor_type;
	Uint8 skin;
	Uint8 hair;
	Uint8 shirt;
	Uint8 pants;
	Uint8 boots;
	Uint8 frame;
	Uint8 cape;
	Uint8 head;
	Uint8 shield;
	Uint8 weapon;
	Uint8 helmet;
	int i;
	int dead=0;
	int kind_of_actor;
	enhanced_actor *this_actor;

	char cur_frame[20];
	double f_x_pos,f_y_pos,f_z_pos,f_z_rot;

	actor_id=*((short *)(in_data));
	x_pos=*((short *)(in_data+2));
	y_pos=*((short *)(in_data+4));
	z_pos=*((short *)(in_data+6));
	z_rot=*((short *)(in_data+8));
	actor_type=*(in_data+10);
	skin=*(in_data+12);
	hair=*(in_data+13);
	shirt=*(in_data+14);
	pants=*(in_data+15);
	boots=*(in_data+16);
	head=*(in_data+17);
	shield=*(in_data+18);
	weapon=*(in_data+19);
	cape=*(in_data+20);
	helmet=*(in_data+21);

	frame=*(in_data+22);
	max_health=*((short *)(in_data+23));
	cur_health=*((short *)(in_data+25));
	kind_of_actor=*(in_data+27);

	//translate from tile to world
	f_x_pos=x_pos*0.5;
	f_y_pos=y_pos*0.5;
	f_z_pos=z_pos;
	f_z_rot=z_rot;

	//get the current frame
	switch(frame) {
	case frame_walk:
		my_strcp(cur_frame,actors_defs[actor_type].walk_frame);break;
	case frame_run:
		my_strcp(cur_frame,actors_defs[actor_type].run_frame);break;
	case frame_die1:
		my_strcp(cur_frame,actors_defs[actor_type].die1_frame);
		dead=1;
		break;
	case frame_die2:
		my_strcp(cur_frame,actors_defs[actor_type].die2_frame);
		dead=1;
		break;
	case frame_pain1:
		my_strcp(cur_frame,actors_defs[actor_type].pain1_frame);break;
	case frame_pain2:
		my_strcp(cur_frame,actors_defs[actor_type].pain2_frame);break;
	case frame_pick:
		my_strcp(cur_frame,actors_defs[actor_type].pick_frame);break;
	case frame_drop:
		my_strcp(cur_frame,actors_defs[actor_type].drop_frame);break;
	case frame_idle:
		my_strcp(cur_frame,actors_defs[actor_type].idle_frame);break;
	case frame_sit_idle:
		my_strcp(cur_frame,actors_defs[actor_type].idle_sit_frame);break;
	case frame_harvest:
		my_strcp(cur_frame,actors_defs[actor_type].harvest_frame);break;
	case frame_cast:
		my_strcp(cur_frame,actors_defs[actor_type].attack_cast_frame);break;
	case frame_attack_up_1:
		my_strcp(cur_frame,actors_defs[actor_type].attack_up_1_frame);break;
	case frame_attack_up_2:
		my_strcp(cur_frame,actors_defs[actor_type].attack_up_2_frame);break;
	case frame_attack_up_3:
		my_strcp(cur_frame,actors_defs[actor_type].attack_up_3_frame);break;
	case frame_attack_up_4:
		my_strcp(cur_frame,actors_defs[actor_type].attack_up_4_frame);break;
	case frame_attack_down_1:
		my_strcp(cur_frame,actors_defs[actor_type].attack_down_1_frame);break;
	case frame_attack_down_2:
		my_strcp(cur_frame,actors_defs[actor_type].attack_down_2_frame);break;
	case frame_combat_idle:
		my_strcp(cur_frame,actors_defs[actor_type].combat_idle_frame);break;
	default:
		{
		}
	}

	//find out if there is another actor with that ID
	//ideally this shouldn't happen, but just in case
	for(i=0;i<max_actors;i++)
		{
			if(actors_list[i])
				{
					if(actors_list[i]->actor_id==actor_id)
						{
							char str[256];
							sprintf(str,"%s %d = %s => %s\n",duplicate_actors_str,actor_id, actors_list[i]->actor_name ,&in_data[28]);
							log_error(str);
							destroy_actor(actors_list[i]->actor_id);//we don't want two actors with the same ID
							i--;// last actor was put here, he needs to be checked too
						}
					else if(kind_of_actor==COMPUTER_CONTROLLED_HUMAN && (actors_list[i]->kind_of_actor==COMPUTER_CONTROLLED_HUMAN || actors_list[i]->kind_of_actor==PKABLE_COMPUTER_CONTROLLED) && !my_strcompare(&in_data[28], actors_list[i]->actor_name))
						{
							char str[256];
							sprintf(str,"%s(%d) = %s => %s\n",duplicate_npc_actor,actor_id, actors_list[i]->actor_name ,&in_data[28]);
							log_error(str);
							destroy_actor(actors_list[i]->actor_id);//we don't want two actors with the same ID
							i--;// last actor was put here, he needs to be checked too
						}
				}
		}

	this_actor=calloc(1,sizeof(enhanced_actor));

	//get the torso
	my_strcp(this_actor->arms_tex,actors_defs[actor_type].shirt[shirt].arms_name);
	my_strcp(this_actor->torso_tex,actors_defs[actor_type].shirt[shirt].torso_name);
	my_strcp(this_actor->torso_fn,actors_defs[actor_type].shirt[shirt].model_name);
	//skin
	my_strcp(this_actor->hands_tex,actors_defs[actor_type].skin[skin].hands_name);
	my_strcp(this_actor->hands_tex_save,actors_defs[actor_type].skin[skin].hands_name);
	my_strcp(this_actor->head_tex,actors_defs[actor_type].skin[skin].head_name);
	//hair
	my_strcp(this_actor->hair_tex,actors_defs[actor_type].hair[hair].hair_name);
	//boots
	my_strcp(this_actor->boots_tex,actors_defs[actor_type].boots[boots].boots_name);
	//legs
	my_strcp(this_actor->pants_tex,actors_defs[actor_type].legs[pants].legs_name);
	my_strcp(this_actor->legs_fn,actors_defs[actor_type].legs[pants].model_name);
	//cape
	if(cape!=CAPE_NONE)
		{
			my_strcp(this_actor->cape_tex,actors_defs[actor_type].cape[cape].skin_name);
			my_strcp(this_actor->cape_fn,actors_defs[actor_type].cape[cape].model_name);
		}
	else
		{
			my_strcp(this_actor->cape_tex,"");
			my_strcp(this_actor->cape_fn,"");
		}
	//head
	my_strcp(this_actor->head_fn,actors_defs[actor_type].head[head].model_name);

	//shield
	if(shield!=SHIELD_NONE)
		{
			my_strcp(this_actor->shield_tex,actors_defs[actor_type].shield[shield].skin_name);
			my_strcp(this_actor->shield_fn,actors_defs[actor_type].shield[shield].model_name);
		}
	else
		{
			my_strcp(this_actor->shield_tex,"");
			my_strcp(this_actor->shield_fn,"");
		}

	my_strcp(this_actor->weapon_tex,actors_defs[actor_type].weapon[weapon].skin_name);
	my_strcp(this_actor->weapon_fn,actors_defs[actor_type].weapon[weapon].model_name);
	this_actor->weapon_glow=actors_defs[actor_type].weapon[weapon].glow;
	if(weapon == GLOVE_FUR || weapon == GLOVE_LEATHER){
		my_strcp(this_actor->hands_tex, actors_defs[actor_type].weapon[weapon].skin_name);
	}

	//helmet
	if(helmet!=HELMET_NONE)
		{
			my_strcp(this_actor->helmet_tex,actors_defs[actor_type].helmet[helmet].skin_name);
			my_strcp(this_actor->helmet_fn,actors_defs[actor_type].helmet[helmet].model_name);
		}
	else
		{
			my_strcp(this_actor->helmet_tex,"");
			my_strcp(this_actor->helmet_fn,"");
		}

	i=add_enhanced_actor(this_actor,cur_frame,f_x_pos,f_y_pos,f_z_pos,f_z_rot,actor_id);

	actors_list[i]->x_tile_pos=x_pos;
	actors_list[i]->y_tile_pos=y_pos;
	actors_list[i]->actor_type=actor_type;
	actors_list[i]->damage=0;
	actors_list[i]->damage_ms=0;
	actors_list[i]->sitting=0;
	actors_list[i]->fighting=0;
	//test only
	actors_list[i]->max_health=max_health;
	actors_list[i]->cur_health=cur_health;
	if(frame==frame_sit_idle)
		{
			if(actors_list[i]->actor_id==yourself)you_sit_down();
			actors_list[i]->sitting=1;
		}
	else if(frame==frame_combat_idle)
		actors_list[i]->fighting=1;

	//ghost or not?
	actors_list[i]->ghost=0;

	actors_list[i]->dead=dead;
	actors_list[i]->stop_animation=1;//helps when the actor is dead...
	actors_list[i]->cur_weapon=weapon;
	actors_list[i]->kind_of_actor=kind_of_actor;
	if(strlen(&in_data[28]) >= 30)
		{
			char str[120];
			snprintf(str, 120, "%s (%d): %s/%d\n", bad_actor_name_length, actors_list[i]->actor_type,&in_data[28], (int)strlen(&in_data[28]));
			log_error(str);
			return;
		}

	my_strncp(actors_list[i]->actor_name,&in_data[28],30);
	if(caps_filter && my_isupper(actors_list[i]->actor_name, -1)) my_tolower(actors_list[i]->actor_name);
	unlock_actors_lists();  //unlock it

}
Beispiel #20
0
char*
dirname (char *path)
{
  static const char here[] = ".";
  char* backslash;
  char* slash;
  char* last_slash;
  
  if (path == NULL)
    {
      return (char*) here;  /* Yes, this is stupid.  See below!  */
    }
  else if ((path[0] == 'U' || path[0] == 'u')
           && path[1] == ':' && path[2] == '\0' && __mint)
    {
      path[0] = '/';
      path[1] = '\0';
      return path;
    }
  else if (path[1] == ':' && path[2] == '\0'
           && ((path[0] >= 'A' && path[0] <= 'Z' && path[0] != 'U')
                || (path[0] >= 'a' && path[0] <= 'z')
                || (path[0] >= '0' && path[0] <= '9')))
    {
      /* A drive letter followed by a colon.  */
      if (__mint)
        {
          path[1] = my_tolower (path[1]);
          path[0] = '/';
        }
      return path;  /* It IS null-terminated.  */
    }
  
  slash = strrchr (path, '/');
  backslash = strrchr (path, '\\');
  
  if (slash > backslash)
    last_slash = slash;
  else if (backslash != NULL)
    last_slash = backslash;
  else
    last_slash = NULL;

  /* End of Atari-specifific kludges.  The rest is more or less taken
     unchanged from the GNU libc.  */
  if (last_slash == path)
    {
      /* The last slash is the first character in the string.  We have to
         return "/".  */
      ++last_slash;
    }
  else if (last_slash != NULL && last_slash[1] == '\0')
    {
      /* The '/' or '\\' is the last character, we have to look further.  */
      char* maybe_last_slash = memchr (path, last_slash - path, '/');
      if (maybe_last_slash == NULL)
        maybe_last_slash = memchr (path, last_slash - path, '\\');
      last_slash = maybe_last_slash;
    }

  if (last_slash != NULL)
    /* Terminate the path.  */
    last_slash[0] = '\0';
  else
    /* This assignment is ill-designed but the XPG specs require to
       return a string containing "." in any case no directory part is
       found and so a static and constant string is required.  */
    path = (char*) here;

  return path;
}