void ConsoleUI::add_computer() { Computer c = Computer(); string name_, type_, yearBuilt_, wasBuilt_; clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "Name of Computer:" << endl; cout << endl << " -> "; cin >> name_; clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "Type of Computer:" << endl; cout << endl << " -> "; cin >> type_; clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "When was the computer built? [YYYY]" << endl; cout << endl << " -> "; cin >> yearBuilt_; while (!is_digits(yearBuilt_)) { clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "Invalid input! Please try again:" << endl; cout << "When was the computer built? [YYYY]" << endl; cin >> yearBuilt_; } clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "Was the computer built? [Y/N]" << endl; cout << endl << " -> "; cin >> wasBuilt_; while ((wasBuilt_ != "Y") && (wasBuilt_ != "N") && (wasBuilt_ != "y") && (wasBuilt_ != "n")) { clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "Invalid input! Please try again:" << endl; cout << "Was the computer built? [Y/N]" << endl; cout << endl << " -> "; cin >> wasBuilt_; } if ((wasBuilt_ == "Y") || (wasBuilt_ == "y")) { c.set_wasBuilt("Yes"); } else if ((wasBuilt_ == "N") || (wasBuilt_ == "n")) { c.set_wasBuilt("No"); } fix_string(name_); fix_string(type_); c.set_name(name_); c.set_type(type_); c.set_yearBuilt(yearBuilt_); dbService.addC(c); clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "\t\t " << "Computer has been added to the list! \n\n\n\n\n\n\n" << endl; }
/***************************************************************************** Name: save_rooms Purpose: Save #ROOMDATA section of an area file. Called by: save_area(olc_save.c). ****************************************************************************/ void save_rooms( FILE *fp, AREA_DATA *pArea ) { ROOM_INDEX_DATA *pRoomIndex; EXTRA_DESCR_DATA *pEd; ROOMTEXT_DATA *prt; EXIT_DATA *pExit; int vnum; int door; fprintf( fp, "#ROOMDATA\n" ); for( vnum = pArea->lvnum; vnum <= pArea->uvnum; vnum++ ) { if( ( pRoomIndex = get_room_index(vnum) ) ) { if ( pRoomIndex->area == pArea ) { fprintf( fp, "#%d\n", pRoomIndex->vnum ); fprintf( fp, "%s~\n", pRoomIndex->name ); fprintf( fp, "%s~\n", fix_string( pRoomIndex->description ) ); fprintf( fp, "0 " ); fprintf( fp, "%d ", pRoomIndex->room_flags ); fprintf( fp, "%d\n", pRoomIndex->sector_type ); for ( pEd = pRoomIndex->extra_descr; pEd; pEd = pEd->next ) { fprintf( fp, "E\n%s~\n%s~\n", pEd->keyword, fix_string( pEd->description ) ); } for (prt = pRoomIndex->roomtext; prt; prt = prt->next ) { fprintf(fp, "T\n%s~\n%s~\n%s~\n%s~\n%d %d %d\n", prt->input, prt->output, prt->choutput, prt->name, prt->type, prt->power, prt->mob); } for( door = 0; door < MAX_DIR; door++ ) { if ( ( pExit = pRoomIndex->exit[door] ) ) { fprintf( fp, "D%d\n", door ); fprintf( fp, "%s~\n", fix_string( pExit->description ) ); fprintf( fp, "%s~\n", pExit->keyword ); fprintf( fp, "%d %d %d\n", pExit->rs_flags, pExit->key, pExit->to_room ? pExit->to_room->vnum : 0 ); } } fprintf( fp, "S\n" ); } } } fprintf( fp, "#0\n\n\n\n" ); return; }
static PGR_Cam *unique_camera_instance( QSP_ARG_DECL dc1394camera_t *cam_p ) { int i; char cname[80]; // How many chars is enough? PGR_Cam *pgcp; i=1; pgcp=NULL; while(pgcp==NULL){ sprintf(cname,"%s_%d",cam_p->model,i); fix_string(cname); // change spaces to underscores pgcp = pgc_of( cname ); if( pgcp == NULL ){ // This index is free pgcp = new_pgc( cname ); if( pgcp == NULL ){ sprintf(ERROR_STRING, "Failed to create camera %s!?",cname); error1(ERROR_STRING); } } else { pgcp = NULL; } i++; if( i>=5 ){ error1("Too many cameras!?"); } } return pgcp; }
////////////////////////////////////////// // return value: 0, execute new statement. // -20, abort it. // other error codes from readStmt() ////////////////////////////////////////// Int32 InputStmt::fix(Int32 append_only) { Int32 retval = 0; if (!append_only) { Option option; StringFragment * fragment = first_fragment; while (fragment) { char * new_fragment = new char[MAX_FRAGMENT_LEN + 1]; option = fix_string(fragment->fragment,new_fragment,MAX_FRAGMENT_LEN); if (option == ABORT_O) return -20; // caller is responsible for deleting this InputStmt delete [] fragment->fragment; fragment->fragment = new_fragment; fragment = fragment->next; } } else { retval = readStmt(NULL/*interactive only, so input is stdin*/); } // Pack (or repack) the new stmt. pack(); return retval; } // fix()
void video_put_str (char *s, int n, int row, int col) { if (n <= 0 || row < 0 || col < 0) return; if (row >= ROWS || col >= COLS) return; n = min1 (n, COLS-col); memcpy (scrn_cache_chars+row*COLS+col, s, n); fix_string (scrn_cache_chars+row*COLS+col, n); }
/* * New code for writing a clan to a file. */ void save_clan( CLAN_DATA *clan ) { FILE *fp; char buf [ MAX_STRING_LENGTH ]; if ( !clan->filename ) return; sprintf( buf, "%s%s", CLAN_DIR, clan->filename ); fclose( fpReserve ); if ( !( fp = fopen( buf, "w" ) ) ) { bugf( "Cannot open: %s for writing", clan->filename ); } else { fprintf( fp, "#CLAN\n" ); fprintf( fp, "WhoName %s~\n", clan->who_name ); fprintf( fp, "Name %s~\n", clan->name ); fprintf( fp, "Motto %s~\n", clan->motto ); fprintf( fp, "Desc %s~\n", fix_string( clan->description ) ); fprintf( fp, "Overlord %s~\n", clan->overlord ); fprintf( fp, "Chieftain %s~\n", clan->chieftain ); fprintf( fp, "PKills %d\n", clan->pkills ); fprintf( fp, "PDeaths %d\n", clan->pdeaths ); fprintf( fp, "MKills %d\n", clan->mkills ); fprintf( fp, "MDeaths %d\n", clan->mdeaths ); fprintf( fp, "IllegalPK %d\n", clan->illegal_pk ); fprintf( fp, "Score %d\n", clan->score ); fprintf( fp, "ClanType %d\n", clan->clan_type ); fprintf( fp, "Clanheros %d\n", clan->clanheros ); fprintf( fp, "Subchiefs %d\n", clan->subchiefs ); fprintf( fp, "Members %d\n", clan->members ); fprintf( fp, "ClanObjOne %d\n", clan->clanobj1 ); fprintf( fp, "ClanObjTwo %d\n", clan->clanobj2 ); fprintf( fp, "ClanObjThree %d\n", clan->clanobj3 ); fprintf( fp, "Recall %d\n", clan->recall ); fprintf( fp, "Donation %d\n", clan->donation ); if ( clan->cclass ) fprintf( fp, "Class %s~\n", clan->cclass->name ); fprintf( fp, "End\n" ); fprintf( fp, "#END\n" ); fclose( fp ); } fpReserve = fopen( NULL_FILE, "r" ); return; }
/* ***** print string routine for PostScript device *************** */ int cg_text(float xpos, float ypos, float dir, char *text) { fprintf(cgstream,"\n%% Text line.\n"); if (cgTEXTAX) fprintf(cgstream,"%g %g sm\n",xpos,ypos); else fprintf(cgstream,"%g %g mto\n",xpos*cgSCALE,ypos*cgSCALE); if (dir == 0) fprintf(cgstream,"(%s) show\n", fix_string(text,1)); else { fprintf(cgstream," cpt\t%.2f rotate\t(%s) show\n",dir,fix_string(text,1)); fprintf(cgstream,"0 0 mto %.2f rotate\t",-dir); if (cgTEXTAX) fprintf(cgstream,"%g ys -1.0 mul %g ys -1.0 mul ",xpos,ypos); else fprintf(cgstream,"%g %g ",-xpos*cgSCALE,-ypos*cgSCALE); fprintf(cgstream," mto cpt\n"); } fprintf(cgstream,"%% END Text line.\n"); return(0); }
/***************************************************************************** Name: save_mobiles Purpose: Save #MOBILES secion of an area file. Called by: save_area(olc_save.c). ****************************************************************************/ void save_mobiles( FILE *fp, AREA_DATA *pArea ) { int vnum; MOB_INDEX_DATA *pMobIndex; fprintf( fp, "#MOBILES\n" ); for( vnum = pArea->lvnum; vnum <= pArea->uvnum; vnum++ ) { if( ( pMobIndex = get_mob_index(vnum) ) ) { if ( pMobIndex->area == pArea ) { fprintf( fp, "#%d\n", pMobIndex->vnum ); fprintf( fp, "%s~\n", pMobIndex->player_name ); fprintf( fp, "%s~\n", pMobIndex->short_descr ); fprintf( fp, "%s~\n", fix_string( pMobIndex->long_descr ) ); fprintf( fp, "%s~\n", fix_string( pMobIndex->description ) ); fprintf( fp, "%d ", pMobIndex->act ); fprintf( fp, "%d ", pMobIndex->affected_by ); fprintf( fp, "%d S\n", pMobIndex->alignment ); fprintf( fp, "%d ", pMobIndex->level ); fprintf( fp, "%d ", pMobIndex->hitroll ); fprintf( fp, "%d ", pMobIndex->ac ); fprintf( fp, "%dd%d+%d ", pMobIndex->hitnodice, pMobIndex->hitsizedice, pMobIndex->hitplus ); fprintf( fp, "%dd%d+%d\n", pMobIndex->damnodice, pMobIndex->damsizedice, pMobIndex->damplus ); fprintf( fp, "%d ", pMobIndex->gold ); fprintf( fp, "0\n0 0 " ); fprintf( fp, "%d\n", pMobIndex->sex ); } } } fprintf( fp, "#0\n\n\n\n" ); return; }
nya_render::blend::mode blend_mode_from_string(const std::string &s) { const std::string ss=fix_string(s); if(ss=="src_alpha") return nya_render::blend::src_alpha; if(ss=="inv_src_alpha") return nya_render::blend::inv_src_alpha; if(ss=="src_color") return nya_render::blend::src_color; if(ss=="inv_src_color") return nya_render::blend::inv_src_color; if(ss=="dst_color") return nya_render::blend::dst_color; if(ss=="inv_dst_color") return nya_render::blend::inv_dst_color; if(ss=="dst_alpha") return nya_render::blend::dst_alpha; if(ss=="inv_dst_alpha") return nya_render::blend::inv_dst_alpha; if(ss=="zero") return nya_render::blend::zero; if(ss=="one") return nya_render::blend::one; return nya_render::blend::one; }
bool cull_face_from_string(const std::string &s,nya_render::cull_face::order &order_out) { const std::string ss=fix_string(s); if(ss=="cw") { order_out=nya_render::cull_face::cw; return true; } if(ss=="ccw") { order_out=nya_render::cull_face::ccw; return true; } order_out=nya_render::cull_face::ccw; return false; }
/***************************************************************************** Name: save_area Purpose: Save an area, note that this format is new. Called by: do_asave(olc_save.c). ****************************************************************************/ void save_area( AREA_DATA *pArea ) { FILE *fp; fclose( fpReserve ); if ( !( fp = fopen( pArea->filename, "w" ) ) ) { bug( "Open_area: fopen", 0 ); perror( pArea->filename ); } fprintf( fp, "#AREADATA\n" ); fprintf( fp, "Name %s~\n", pArea->name ); fprintf( fp, "Builders %s~\n", fix_string( pArea->builders ) ); fprintf( fp, "VNUMs %d %d\n", pArea->lvnum, pArea->uvnum ); fprintf( fp, "Security %d\n", pArea->security ); fprintf( fp, "Recall %d\n", pArea->recall ); fprintf( fp, "Flags %d\n", pArea->area_flags ); fprintf( fp, "End\n\n\n\n" ); save_helps( fp, pArea ); /* OLC 1.1b */ save_mobiles( fp, pArea ); save_objects( fp, pArea ); save_rooms( fp, pArea ); if ( IS_SET(pArea->area_flags, AREA_VERBOSE) ) /* OLC 1.1b */ { vsave_specials( fp, pArea ); vsave_resets( fp, pArea ); vsave_shops( fp, pArea ); } else { save_specials( fp, pArea ); save_resets( fp, pArea ); save_shops( fp, pArea ); } fprintf( fp, "#$\n" ); fclose( fp ); fpReserve = fopen( NULL_FILE, "r" ); return; }
void save_mobprogs( FILE *fp, AREA_DATA *pArea ) { MPROG_CODE *pMprog; int i; fprintf(fp, "#MOBPROGS\n"); for( i = pArea->min_vnum; i <= pArea->max_vnum; i++ ) { if ( (pMprog = get_mprog_index(i) ) !=NULL) { fprintf(fp, "#%d\n", i); fprintf(fp, "%s~\n", fix_string(pMprog->code)); } } fprintf(fp,"#0\n\n"); return; }
tree_entry * gbIso9660 :: get_file_info(const char * path) { tree_entry * ret = NULL; if(tree) { //Make a copy of the path char * tmp = new char[strlen(path) + 1]; strcpy(tmp, path); //Check for format errors fix_string(tmp); //Start search ret = get_file_info_recursive(tmp, tree); delete [] tmp; }; return ret; };
void save_help() { FILE *fp; HELP_DATA *pHelp; rename( "help.are", "help.bak"); if((fp=fopen( "help.are", "w")) == NULL) { bug("save_helps: fopen", 0); perror( "help.are" ); return; } fprintf( fp, "#HELPS\n\n"); for (pHelp = first_help; pHelp != NULL; pHelp = pHelp->next) { fprintf(fp, "%d ", pHelp->level); fprintf(fp, pHelp->keyword); fprintf(fp, "~\n"); fprintf(fp, fix_string2(fix_string(pHelp->text))); fprintf(fp, "~\n\n"); } fprintf(fp, "0 $~\n\n#$\n"); fclose( fp ); }
void note_remove (CHAR_DATA * ch, NOTE_DATA * pnote) { char to_new[SML_LENGTH]; char to_one[SML_LENGTH]; FILE *fp; NOTE_DATA *prev; char *to_list; /* * Build a new to_list. * Strip out this recipient. */ to_new[0] = '\0'; to_list = pnote->to_list; while (*to_list != '\0') { to_list = one_argy (to_list, to_one); if (to_one[0] != '\0' && str_cmp (NAME (ch), to_one)) { strcat (to_new, " "); strcat (to_new, to_one); } } /* * Just a simple recipient removal? */ if (LEVEL (ch) < MAX_LEVEL && !is_note_to (ch, pnote)) { if (str_cmp (NAME (ch), pnote->sender) && to_new[0] != '\0') { free_string (pnote->to_list); pnote->to_list = str_dup (to_new + 1); return; } } /* * Remove note from linked list. */ if (pnote == note_list) { note_list = pnote->next; } else { for (prev = note_list; prev != NULL; prev = prev->next) { if (prev->next == pnote) break; } if (prev == NULL) { bug ("Note_remove: pnote not found.", 0); return; } prev->next = pnote->next; } free_string (pnote->text); free_string (pnote->subject); free_string (pnote->to_list); free_string (pnote->date); free_string (pnote->sender); pnote->next = note_free; note_free = pnote; /* * Rewrite entire list. */ #ifndef WINDOWS // fclose (fpReserve); #endif if ((fp = fopen (NOTE_FILE, "w")) == NULL) { perror (NOTE_FILE); } else { for (pnote = note_list; pnote != NULL; pnote = pnote->next) { fprintf (fp, "Sender %s~\n", fix_string (pnote->sender)); fprintf (fp, "TBoard %d\n", pnote->board_num); fprintf (fp, "Date %s~\n", pnote->date); fprintf (fp, "Stamp %ld\n", pnote->date_stamp); fprintf (fp, "To %s~\n", fix_string (pnote->to_list)); fprintf (fp, "Subject %s~\n", fix_string (pnote->subject)); fprintf (fp, "Text\n%s~\n", fix_string (pnote->text)); fprintf (fp, "End\n"); } fclose (fp); } #ifndef WINDOWS // fpReserve = fopen (NULL_FILE, "r"); #endif return; }
void do_note (CHAR_DATA * ch, char *argy) { char buf[STD_LENGTH * 17]; char buf1[STD_LENGTH * 17]; char arg[SML_LENGTH]; NOTE_DATA *pnote; int vnum; int board_here; /*Boards and board nums by Owen Emlen */ SINGLE_OBJECT *obj; int anum; DEFINE_COMMAND ("note", do_note, POSITION_DEAD, 0, LOG_NORMAL, "This command is used to post/read/remove notes.") if (IS_MOB (ch)) return; board_here = 0; obj = get_obj_here (ch, "board", SEARCH_ROOM_FIRST); if (obj == NULL) { board_here = 1; } else board_here = obj->pIndexData->value[9]; buf1[0] = '\0'; argy = one_argy (argy, arg); smash_tilde (argy); if (arg[0] == '\0') { do_note (ch, "read"); return; } if (!str_cmp (arg, "list")) { vnum = 0; sprintf(buf1,"\x1B[1;30m------------------------------------------------------------------------\x1B[37;0m\n\r"); sprintf(buf1+strlen(buf1),"\x1B[1;36m New ### Sender/From Subject\x1B[37;0m\n\r"); sprintf(buf1+strlen(buf1),"\x1B[1;30m------------------------------------------------------------------------\x1B[37;0m\n\r"); for (pnote = note_list; pnote != NULL; pnote = pnote->next) { if (is_note_to (ch, pnote) && (board_here == pnote->board_num || IS_IMMORTAL (ch))) { if (strlen(pnote->subject)>35) { pnote->subject[35]='\0'; } sprintf (buf, "%s \x1B[1;36m%3d\x1B[37;0m From \x1b[1;37m%-14s\x1B[37;0m '\x1B[1;36m%s\x1B[37;0m'\n\r", (pnote->date_stamp > ch->pcdata->last_note && str_cmp (pnote->sender, NAME (ch))) ? "\x1B[1;34m(New)\x1B[37;0m" : " ", vnum, pnote->sender, pnote->subject); strcat (buf1, buf); vnum++; } else vnum++; if (strlen (buf1) > (STD_LENGTH * 16)) { strcat (buf1, "\n\rTOO MANY NOTES.. WAIT UNTIL A GOD REMOVES SOME!\n\r"); break; } } page_to_char_limited (buf1, ch); return; } if (!str_cmp (arg, "read")) { bool fAll; if (!str_cmp (argy, "all")) { fAll = TRUE; anum = 0; } else if (argy[0] == '\0' || !str_prefix (argy, "next")) /* read next unread note */ { vnum = 0; for (pnote = note_list; pnote != NULL; pnote = pnote->next) { if (is_note_to (ch, pnote) && (board_here == pnote->board_num || IS_IMMORTAL (ch)) && str_cmp (NAME (ch), pnote->sender) && ch->pcdata->last_note < pnote->date_stamp) { sprintf (buf,"\x1B[1;30m---------------------------------------------------------------------------\x1B[37;0m\n\r"); sprintf (buf+strlen(buf), "[Note #\x1B[1;37m%d:%d\x1B[37;0m] From: \x1B[1;37m%s\x1B[37;0m To: \x1B[1;37m%s\x1B[37;0m\n\r", vnum, pnote->board_num, pnote->sender, pnote->to_list); if (strlen(pnote->subject)>35) { pnote->subject[35]='\0'; } sprintf (buf+strlen(buf),"%s. Subject: \x1B[1;36m%s\x1B[37;0m\n\r", pnote->date, pnote->subject); sprintf (buf+strlen(buf),"\x1B[1;30m---------------------------------------------------------------------------\x1B[37;0m\n\r"); strcat (buf1, buf); strcat (buf1, pnote->text); ch->pcdata->last_note = UMAX (ch->pcdata->last_note, pnote->date_stamp); page_to_char_limited (buf1, ch); return; } else vnum++; } send_to_char ("You have no unread notes.\n\r", ch); return; } else if (is_number (argy)) { fAll = FALSE; anum = atoi (argy); } else { send_to_char ("Note read which number?\n\r", ch); return; } vnum = 0; for (pnote = note_list; pnote != NULL; pnote = pnote->next) { if ((vnum++ == anum || fAll) && is_note_to (ch, pnote) && (board_here == pnote->board_num || IS_IMMORTAL (ch))) { sprintf (buf,"\x1B[1;30m---------------------------------------------------------------------------\x1B[37;0m\n\r"); sprintf (buf+strlen(buf), "[Note #\x1B[1;37m%d:%d\x1B[37;0m] From: \x1B[1;37m%s\x1B[37;0m To: \x1B[1;37m%s\x1B[37;0m\n\r", vnum - 1, pnote->board_num, pnote->sender, pnote->to_list); if (strlen(pnote->subject)>35) { pnote->subject[35]='\0'; } sprintf (buf+strlen(buf),"Dated %s. Subject: \x1B[1;36m%s\x1B[37;0m\n\r", pnote->date, pnote->subject); sprintf (buf+strlen(buf),"\x1B[1;30m---------------------------------------------------------------------------\x1B[37;0m\n\r"); strcat (buf1, buf); strcat (buf1, pnote->text); page_to_char_limited (buf1, ch); return; } } send_to_char ("No such note.\n\r", ch); return; } if (!str_cmp (arg, "write")) { if (LEVEL (ch) < IMM_LEVEL && board_here == 1) { send_to_char ("You can't write on the immortal notice board.\n\r", ch); return; } if (IS_SET(ch->act, PLR_LAMER)) { send_to_char("You have lost your board writing privileges.\n\r", ch); send_to_char("Maybe if you grow up you will be allowed to start\n\r", ch); send_to_char("posting on the board again, however since you have\n\r", ch); send_to_char("consistently shown yourself to be lame this is not likely.\n\r", ch); return; } check_ced (ch); note_attach (ch); string_append (ch, &ch->ced->pnote->text); return; } if (!str_cmp (arg, "fwrite")) { if (IS_SET(ch->act, PLR_LAMER)) { send_to_char("You have lost your board writing privileges.\n\r", ch); send_to_char("Maybe if you grow up you will be allowed to start\n\r", ch); send_to_char("posting on the board again, however since you have\n\r", ch); send_to_char("consistently shown yourself to be lame this is not likely.\n\r", ch); return; } if (LEVEL (ch) < IMM_LEVEL && board_here == 1) { send_to_char ("You can't write on the immortal notice board.\n\r", ch); return; } check_ced (ch); note_attach (ch); fullscreen_editor (ch, &ch->ced->pnote->text); return; } if (!str_cmp (arg, "+")) { check_ced (ch); note_attach (ch); strcpy (buf, ch->ced->pnote->text); if (strlen (buf) + strlen (argy) >= STD_LENGTH - 200) { send_to_char ("Note too long.\n\r", ch); return; } strcat (buf, argy); strcat (buf, "\n\r"); free_string (ch->ced->pnote->text); ch->ced->pnote->text = str_dup (buf); ch->ced->pnote->lines += 1; send_to_char ("Ok.\n\r", ch); return; } if (!str_cmp (arg, "-")) { int num, cnt; char new_buf[STD_LENGTH]; const char *str; check_ced (ch); if (ch->ced->pnote == NULL) { send_to_char ("You have to start a note first.\n\r", ch); return; } if (ch->ced->pnote->lines == 0) { send_to_char ("Nothing to delete.\n\r", ch); return; } new_buf[0] = '\0'; str = ch->ced->pnote->text; cnt = 1; for (num = 1; num <= ch->ced->pnote->lines; num++) { while (*str != '\r' && *str != '\0') { ++str; ++cnt; } } strncpy (new_buf, ch->ced->pnote->text, cnt); new_buf[cnt] = '\0'; free_string (ch->ced->pnote->text); ch->ced->pnote->text = str_dup (new_buf); ch->ced->pnote->lines -= 1; send_to_char ("Ok.\n\r", ch); return; } if (!str_cmp (arg, "subject")) { if (IS_SET(ch->act, PLR_LAMER)) { send_to_char("You have lost your board writing privileges.\n\r", ch); send_to_char("Maybe if you grow up you will be allowed to start\n\r", ch); send_to_char("posting on the board again, however since you have\n\r", ch); send_to_char("consistently shown yourself to be lame this is not likely.\n\r", ch); return; } check_ced (ch); note_attach (ch); free_string (ch->ced->pnote->subject); ch->ced->pnote->subject = str_dup (argy); send_to_char ("Ok.\n\r", ch); return; } if (!str_cmp (arg, "to")) { if (IS_SET(ch->act, PLR_LAMER)) { send_to_char("You have lost your board writing privileges.\n\r", ch); send_to_char("Maybe if you grow up you will be allowed to start\n\r", ch); send_to_char("posting on the board again, however since you have\n\r", ch); send_to_char("consistently shown yourself to be lame this is not likely.\n\r", ch); return; } check_ced (ch); note_attach (ch); free_string (ch->ced->pnote->to_list); ch->ced->pnote->to_list = str_dup (argy); send_to_char("\x1b[1;31mBe sure to put 'pkill' or 'flame' if this is a pkill flame note.\x1b[0;37m", ch); send_to_char ("Ok.\n\r", ch); return; } if (!str_cmp (arg, "clear")) { if (IS_SET(ch->act, PLR_LAMER)) { send_to_char("You have lost your board writing privileges.\n\r", ch); send_to_char("Maybe if you grow up you will be allowed to start\n\r", ch); send_to_char("posting on the board again, however since you have\n\r", ch); send_to_char("consistently shown yourself to be lame this is not likely.\n\r", ch); return; } check_ced (ch); if (ch->ced->pnote != NULL) { free_string (ch->ced->pnote->text); free_string (ch->ced->pnote->subject); free_string (ch->ced->pnote->to_list); free_string (ch->ced->pnote->date); free_string (ch->ced->pnote->sender); ch->ced->pnote->next = note_free; note_free = ch->ced->pnote; ch->ced->pnote = NULL; } send_to_char ("Ok.\n\r", ch); return; } if (!str_cmp (arg, "show")) { if (IS_SET(ch->act, PLR_LAMER)) { send_to_char("You have lost your board writing privileges.\n\r", ch); send_to_char("Maybe if you grow up you will be allowed to start\n\r", ch); send_to_char("posting on the board again, however since you have\n\r", ch); send_to_char("consistently shown yourself to be lame this is not likely.\n\r", ch); return; } check_ced (ch); if (ch->ced->pnote == NULL) { send_to_char ("You have no note in progress.\n\r", ch); return; } sprintf (buf, "%s: %s\n\rTo: %s\n\rLines: %d\n\r", ch->ced->pnote->sender, ch->ced->pnote->subject, ch->ced->pnote->to_list, ch->ced->pnote->lines ); strcat (buf1, buf); strcat (buf1, ch->ced->pnote->text); page_to_char_limited (buf1, ch); return; } if (!str_cmp (arg, "post") || !str_prefix (arg, "send")) { FILE *fp; char *strtime; check_ced (ch); if (ch->ced->pnote == NULL) { send_to_char ("You have no note in progress.\n\r", ch); return; } if (board_here == 1 && LEVEL (ch) < IMM_LEVEL) { send_to_char ("This board is reserved for immortals posting messages to mortals.\n\r", ch); send_to_char ("Please post on a public board if you wish to write a note.\n\r", ch); return; } if (!str_cmp (ch->ced->pnote->to_list, "")) { send_to_char ( "You need to provide a recipient (name, all, or immortal).\n\r", ch); return; } if (!str_cmp (ch->ced->pnote->subject, "")) { send_to_char ("You need to provide a subject.\n\r", ch); return; } if (IS_SET(ch->act, PLR_LAMER)) { send_to_char("You have lost your board writing privileges.\n\r", ch); send_to_char("Maybe if you grow up you will be allowed to start\n\r", ch); send_to_char("posting on the board again, however since you have\n\r", ch); send_to_char("consistently shown yourself to be lame this is not likely.\n\r", ch); return; } ch->pcdata->online_spot->notes_this_reboot++; if(ch->pcdata->online_spot->notes_this_reboot > 8) { send_to_char("You have already written too many notes this reboot.\n\r", ch); return; } ch->ced->pnote->next = NULL; strtime = ctime (¤t_time); strtime[strlen (strtime) - 1] = '\0'; ch->ced->pnote->board_num = board_here; ch->ced->pnote->date = str_dup (strtime); ch->ced->pnote->date_stamp = current_time; if (note_list == NULL) { note_list = ch->ced->pnote; } else { for (pnote = note_list; pnote->next != NULL; pnote = pnote->next) ; pnote->next = ch->ced->pnote; } pnote = ch->ced->pnote; ch->ced->pnote = NULL; #ifndef WINDOWS // fclose (fpReserve); #endif if ((fp = fopen (NOTE_FILE, "a")) == NULL) { perror (NOTE_FILE); } else { fprintf (fp, "Sender %s~\n", fix_string (pnote->sender)); fprintf (fp, "TBoard %d\n", pnote->board_num); fprintf (fp, "Date %s~\n", pnote->date); fprintf (fp, "Stamp %ld\n", pnote->date_stamp); fprintf (fp, "To %s~\n", fix_string (pnote->to_list)); fprintf (fp, "Subject %s~\n", fix_string (pnote->subject)); fprintf (fp, "Text\n%s~\n", pnote->text); fprintf (fp, "End\n\n"); fclose (fp); } #ifndef WINDOWS // fpReserve = fopen (NULL_FILE, "r"); #endif send_to_char ("Ok.\n\r", ch); return; } if (!str_cmp (arg, "remove")) { if (!is_number (argy)) { send_to_char ("Note remove which number?\n\r", ch); return; } anum = atoi (argy); vnum = 0; for (pnote = note_list; pnote != NULL; pnote = pnote->next) { if (vnum++ == anum && ( (is_note_to (ch, pnote) && !is_name ("all", pnote->to_list)) || LEVEL (ch) > 109)) { note_remove (ch, pnote); send_to_char ("Ok.\n\r", ch); return; } } send_to_char ("No such note.\n\r", ch); return; } send_to_char ("Huh? Type 'help note' for usage.\n\r", ch); return; }
int read_parameter_file( char *parameter_filename, RUN_TIME_TYPE **pp, NEURONE_TYPE **n_neurone, MATCH_TYPE **match, int *batch_flag ) { char string[241], keyword[11]; FILE *input_stream; long input_weight_offset; RUN_TIME_TYPE *p; NEURONE_TYPE *neurone; int card_type=NOTHING, n, j, k, r1, c1, tpat_count, npat_count, row_count; int q; char dflag[2],temp_str[2]; int state_val; int random_val; int rtype_flag_temp; long fp; int num_rands = 0; //int local_var; int r; int count, temp_act; if ( (input_stream = fopen( parameter_filename, "r" )) == NULL ) { printf( "\nFatal Error - could not open input file : %s\n",parameter_filename ); return( F_FALSE ); } // Read in the cards. The NET card is the first valid card expected. // This should be followed by the TPAT cards. // Then the single NPAT block should be read. // First allocate memory for the parameter block. p = (RUN_TIME_TYPE *) malloc( sizeof(RUN_TIME_TYPE) ); *pp = p; // Set for return p->weight.flag = MEMORY; // use memory rather than disk p->number_of_patterns = 0; p->states = 0; p->actives = 0; p->brain_iterations = 1; p->noise_level = 0; p->match_perc = 100.0F; p->report.flag = F_FALSE; tpat_count = 0; npat_count = 0; row_count = 0; while ( fgets( string, 240, input_stream ) != NULL ) { //printf("%s", string ) ; // Condition the input string for further processing uppercase(lr_pack(fix_string(string))); // Take care of the NET card case if ( strncmp( "NET", string, 3 ) == 0 ) { if ( card_type != NOTHING ) // Have already read a NET card { printf( "\nFatal Error - a NET card has already been read. Only\n" "one NET specification is allowed. This should be the\n" "first valid card in the file.\n"); return( F_FALSE ); } else if ( sscanf( string, "%s %d %d %d %d %d %d %s %s %s %s", keyword, &(p->rows), &(p->cols), &(p->states), &(p->actives), &(p->update_cycles), &(p->num_pats), dflag, p->input_weight.file, p->output_weight.file, p->pattern.file ) != 11 ) { printf("\nFatal Error - NET card did not have enough parameters !\n"); return( F_FALSE ); } // check to see if we have valid input for the int data types ... if ( (p->rows) < 1 || (p->cols) < 1 || (p->num_pats) < 0 || (p->states) < 0 || (p->actives) < 0 ) { printf("\nFatal Error - NET has illegal parameters specified !\n" ); return( F_FALSE ); } // Set dflag and check input ... if ( *dflag == 'N' ) (p->rtype_flag) = NOT_DREAMING; else if ( *dflag == 'R' ) (p->rtype_flag) = RANDOM_TEST; else { printf("\nFatal Error - NET run parameters must be N or R !!" ); return( F_FALSE ); } if ( *(p->input_weight.file) == '-' ) // Set up input weight file flags p->input_weight.flag = F_FALSE; else { // Make sure that the input weight file actually exists. if ( (p->input_weight.stream=fopen( p->input_weight.file, "rb" )) == NULL ) { printf("\nFatal Error - %s was not found !!!\n", p->input_weight.file ); return( F_FALSE ); } // Make sure of matching dimensions. fread( &r1, sizeof( int ), 1, p->input_weight.stream ); fread( &c1, sizeof( int ), 1, p->input_weight.stream ); input_weight_offset = ftell( p->input_weight.stream ); // Save if ( r1 != (p->rows) || c1 != (p->cols) ) { printf( "\nFatal Error - Weight matrix mismatch...." "\n NET image has %d rows and %d cols while" "\n weight file %s has %d rows and %d cols." "\n rows and columns must match !!!\n", (p->rows), (p->cols), p->input_weight.file, r1, c1); return( F_FALSE ); } p->input_weight.flag = F_TRUE; } if ( *(p->output_weight.file) == '-' ) // ...output weight file flags p->output_weight.flag = F_FALSE; else p->output_weight.flag = F_TRUE; if ( (p->num_pats) == 0 && p->input_weight.flag == F_FALSE ) { printf( "\nFatal Error - You have specified a run with no input" "\n weight file and and no patterns to learn" "\n from (see parameter 5 of the NET image and" "\n your TPAT and RPAT images). Brainex needs" "\n to get a connection weight matrix from" "\n somewhere you ninkempoop.\n" ); return( F_FALSE ); } if ( *(p->pattern.file) == '-' ) // Set up for learnt patterns { p->pattern.flag = F_FALSE; if ( (p->rtype_flag) == RANDOM_TEST ) { printf( "\nFatal Error - must have pattern file " "when random testing !!\n" ); return( F_FALSE ); } } else { // Make sure that the input pattern file actually exists. */ if ( (p->pattern.stream=fopen( p->pattern.file, "a+b" )) == NULL ) { printf("\nFatal Error - %s illegal !!!\n", p->pattern.file ); return( F_FALSE ); } fseek( p->pattern.stream, 0L, SEEK_END ); // Set to end of file fp = ftell( p->pattern.stream ); // Where are we ? if ( fp == 0L && (p->rtype_flag) == RANDOM_TEST ) { printf("\nFatal Error - pattern file empty, no report possible!!\n" ); return( F_FALSE ); } else if ( fp == 0L && (p->rtype_flag) != RANDOM_TEST ) { fwrite( &(p->rows), sizeof(int), 1, p->pattern.stream ); fwrite( &(p->cols), sizeof(int), 1, p->pattern.stream ); } else if ( fp > 0L ) { fseek( p->pattern.stream, 0L, SEEK_SET ); // Go to start of file // Make sure of matching dimensions fread( &r1, sizeof(int), 1, p->pattern.stream ); fread( &c1, sizeof(int), 1, p->pattern.stream ); if ( r1 != (p->rows) || c1 != (p->cols) ) { printf( "\nFatal Error - Pattern file matrix mismatch...." "\n NET image has %d rows and %d cols while" "\n learnt pattern file %s has %d rows and %d cols." "\n Rows and columns must match !!!\n", (p->rows), (p->cols), p->pattern.file, r1, c1 ); return( F_FALSE ); } } p->pattern.flag = F_TRUE; } card_type = NET; // set the number of modules in the network p->number_of_neurones = (p->rows) * (p->cols); n = p->number_of_neurones; // If we are here then we must have found a NET card with valid parameters if ( ( neurone = (NEURONE_TYPE *) malloc( sizeof(NEURONE_TYPE) * n ) ) == NULL ) { printf( "\nFatal Error - rows and columns specify a neural grid that\n" " exceeds the available system memory.\t:(\n" ); return( F_FALSE ); } *n_neurone = neurone; // Set for return //printf("\ntrying to malloc some memory for the weight file...\n"); // get memory for the weights count = 0; for ( j=0; j<n; j++ ) { (neurone+j)->id_num = j; (neurone+j)->nw = n*n*(p->states)*(p->states);// we have n squared weights // malloc the top level: if ( ((neurone+j)->w = (WEIGHT_MATRIX **)malloc(sizeof(WEIGHT_MATRIX)*n)) == NULL) { printf( "\n Not enough memory for the weight grid\n"); return( F_FALSE ); } else // malloc each matrix { for(k=0; k<n; k++) { // malloc rows: if ( ((neurone+j)->w[k] = (WEIGHT_MATRIX *)malloc(sizeof(WEIGHT_MATRIX)*n)) == NULL) { return( F_FALSE); } if (((neurone+j)->w[k]->weight = (int **) malloc( (p->states) * sizeof(int*))) == NULL ) { printf( "\n Not enough memory for the weight grid...\n"); return( F_FALSE ); } // and finally malloc cols: for (q = 0; q<(p->states); q++) { if (((neurone+j)->w[k]->weight[q] = malloc( (p->states) * sizeof(int))) == NULL ) { printf( "\n Not enough memory for the weight grid...\n"); return( F_FALSE ); } // init elements of the weight matrix to zero else { for(r=0; r<(p->states); r++) { (neurone+j)->w[k]->weight[q][r] = 0; //initialise to zero count++; //printf("j = %d\tk = %d\tweight matrix: weight[%d][%d] = %d\n",j,k,q,r,(neurone+j)->w[k]->weight[q][r]); } } } } } } //printf("\nmalloc of weight memory done. did it work?\tcount = %d\tshould be %d\n\n",count,n*n*(p->states)*(p->states)); // read in the weights from file if requested to do so if ( p->input_weight.flag == F_TRUE ) { count = 0; //printf("\nreading in predefined weights from file %s\n",p->input_weight.file); for(j=0; j<n; j++) { for(k=0; k<n; k++) { for(q=0; q< (p->states); q++) { for(r=0; r< (p->states); r++) { fread(&((neurone+j)->w[k]->weight[q][r]), sizeof(int),1, p->input_weight.stream); count++; //printf("j = %d\tk = %d\tweight matrix: weight[%d][%d] = %d\n",j,k,q,r,(neurone+j)->w[k]->weight[q][r]); } } } } // close the file fclose( p->input_weight.stream ); //printf("read %d elements from file %s\tshould have read %d elements!\n",count,p->input_weight.file,n*n*(p->states)*(p->states)); } // get memory for states per module if (p->states == 0) { printf("p->states == 0. something bad is about to happen...\n"); return(F_FALSE); } else { for ( j=0; j<n; j++ ) { if ( ( (neurone+j)->states = (int *) malloc( sizeof(int)*(p->states) ) ) == NULL ) { printf( "\nNot enough memory for the state vectors.\n"); return( F_FALSE ); } else { for ( k = 0; k < (p->states); k++ ) { (neurone+j)->states[k] = 0; // Initialise to 0 } } } } } // end of the NET case // ***************************************************************************************** // Take care of the TPAT/RPAT card case if ( strncmp( "TPAT", string, 4 ) == 0 || strncmp( "RPAT", string, 4 ) == 0 ) { // Investigate the entry status if ( card_type != RPAT && card_type != TPAT && card_type != NET ) { printf( "\nFatal Error - Only a NET, TPAT or RPAT image may\n" "precede a TPAT or RPAT image. A NET card must precede\n" "all TPAT/RPAT blocks. Exactly one NET card must appear\n" "and it must be the first valid card in the parameter\n" "specification file.\n" ); return( F_FALSE ); } else if ( card_type == TPAT && row_count != (p->rows) ) { printf( "\nFatal Error - TPAT Pattern block %d should have %d rows," "\n only %d rows were actually counted !\n", tpat_count, (p->rows), row_count ); return( F_FALSE ); } if ( strncmp( "TPAT", string, 4)== 0) card_type = TPAT; else if ( strncmp( "RPAT", string, 4)== 0) card_type = RPAT; row_count = 0; // This is used to control image access tpat_count++; // Use this to count both TPAT and RPAT images if ( tpat_count > (p->num_pats) ) { printf( "\nFatal Error - Too many TPAT/RPAT definitions. The number\n" "of TPAT/RPAT definitions must match the NET specification.\n" ); return( F_FALSE ); } for(j=0; j<n; j++) // zero the states for TPAT reading { for(k=0; k<(p->states); k++) { (neurone+j)->states[k] = 0; // zero the states } (neurone+j)->tag = 0; // and the tags } } // end of the TPAT/RPAT case // Take care of the NPAT/RANDIN card case if ( strncmp( "NPAT", string, 4 ) == 0 || strncmp( "RANDIN", string, 6 ) == 0) { if ( tpat_count != (p->num_pats) ) { printf( "\nFatal Error - Not enough TPAT/RPAT sets before NPAT!!\n"); return( F_FALSE ); } else if ( card_type == TPAT && row_count != (p->rows) ) { printf( "\nFatal Error - TPAT Pattern block %d should have %d rows," "\n only %d rows were actually counted !\n", tpat_count, (p->rows), row_count ); return( F_FALSE ); } else if ( npat_count > 0 ) { printf( "\nFatal Error - Only 1 NPAT/RANDIN block is allowed !!\n"); return( F_FALSE ); } if ( strncmp( "NPAT", string, 4 ) == 0 ) { row_count = 0; // We have to count the rows.... } if ( strncmp( "RANDIN", string, 4 ) == 0 ) { row_count = (p->rows); // Set up as dummy value if ( sscanf(string, "%s %d %d %f %s", keyword, &(p->brain_iterations),&(p->noise_level), &(p->match_perc), p->report.file ) != 5 ) { printf("\nFatal Error - RANDIN card, not enough parameters !\n"); return( F_FALSE ); } if ( (p->brain_iterations) < 1 ) { printf( "\nFatal Error - RANDIN parameters illegal - " "\n Number of random cycles must be >= 1" ); return( F_FALSE ); } // Check on the report file. if ( (p->report.stream=fopen( p->report.file, "a+" )) == NULL ) { printf("\nFatal Error - %s illegal !!!\n", p->report.file ); return( F_FALSE ); } p->report.flag = F_TRUE; // Enable // Start the report report_header( p->report.stream, p ); p->number_of_patterns = get_number_of_patterns( p->pattern.stream ); report_patterns( p->report.stream, p->pattern.stream ); // Get memory to be used in report of stats *match = (MATCH_TYPE *) malloc( sizeof(MATCH_TYPE) * ( p->number_of_patterns + 1 ) ); } card_type = NPAT; npat_count = 1; } // end of the NPAT/RANDIN case if ( ( card_type == TPAT || card_type == NPAT) && ( strncmp( "0", string, 1 ) == 0 || strncmp( "1", string, 1 ) == 0 || strncmp( "2", string, 1 ) == 0 || strncmp( "3", string, 1 ) == 0 || strncmp( "4", string, 1 ) == 0 || strncmp( "5", string, 1 ) == 0 || strncmp( "6", string, 1 ) == 0 || strncmp( "7", string, 1 ) == 0 || strncmp( "8", string, 1 ) == 0 || strncmp( "9", string, 1 ) == 0 ) ) { row_count++; if ( row_count > (p->rows) ) { printf( "\nFatal Error - Pattern block must have only %d rows!\n",(p->rows)); return( F_FALSE ); } if ( (int)strlen( string ) != (p->cols) ) { printf( "\nFatal Error - Pattern block bad row %d\n\n" "There are an incorrect number of columns.\n" "in the pattern string.\n" "The number of columns found was : %d\n" "There should be exactly %d columns.\n", row_count, (int)strlen( string ), (p->cols) ); return( F_FALSE ); } if ( (int)strspn( string, "0123456789" ) != (p->cols) ) { printf( "\nFatal Error - Pattern block bad at row %d\n\n" "There are illegal characters in the pattern string.\n" "Only integers are allowed in a pattern string.\n", row_count ); return( F_FALSE ); } // fill in the neural array with the TPAT/NPAT values... //printf("temp_act: NPAT/TPAT\n"); for(k=0; k<(p->cols); k++) { strncpy(temp_str, &string[k], sizeof(char)); temp_act = atoi(&temp_str[0]); //printf("%d",temp_act); if(temp_act != 0) (neurone+((row_count-1)*(p->cols)+k))->states[temp_act-1] = 1; // set the state } //printf("\n"); // If the neural array has been filled with the input // activation values then we can calculate the connecting // weights (to this point). if ( card_type == TPAT && row_count == (p->rows) ) { rtype_flag_temp = p->rtype_flag;// Preserve for restoration p->rtype_flag = NOT_DREAMING;// Set for call to update_... update_neural_weights( p, neurone ); p->rtype_flag = rtype_flag_temp;// Restore /* printf("\nTPAT follows\n"); printf("\n"); for(j=0;j<n;j++) { local_var = 0; for(k=0;k<(p->states);k++) { if((neurone+j)->states[k] == 0) local_var++; else { printf("%d",local_var+1); break; } } if( local_var == (p->states)) printf("0"); if( (j+1) % (p->cols) == 0) printf("\n"); } */ } } else if ( card_type != TPAT && card_type != NPAT && ( strncmp( "0", string, 1 ) == 0 || strncmp( "1", string, 1 ) == 0 || strncmp( "2", string, 1 ) == 0 || strncmp( "3", string, 1 ) == 0 || strncmp( "4", string, 1 ) == 0 || strncmp( "5", string, 1 ) == 0 || strncmp( "6", string, 1 ) == 0 || strncmp( "7", string, 1 ) == 0 || strncmp( "8", string, 1 ) == 0 || strncmp( "9", string, 1 ) == 0 )) { printf("\nFatal Error - Pattern detected without a preceding TPAT!\n" ); return( F_FALSE ); } // Now process RPAT. This means the generation of a random pattern. if ( card_type == RPAT && row_count == 0 ) { for(j=0; j<n; j++) { for(k=0; k<(p->states); k++) { (neurone+j)->states[k] = 0; // zero the states } (neurone+j)->tag = 0; // and the tags } // Fill in the neural array.... num_rands = 0; //printf("generating an RPAT...\n"); do { random_val = (int)ceil((n-1) * ran4()); //printf("random_val = %d\n",random_val); if( (neurone+(int)random_val)->tag != 1 ) { state_val = (int)ceil((p->states)*ran4()); //printf("\tstate_val = %d\n",state_val); (neurone+(int)random_val)->states[(int)state_val-1] = 1; // -1 because 0 is the first element (neurone+(int)random_val)->tag=1; num_rands++; } } while(num_rands != (p->actives)); /* printf("\nRPAT follows\n"); printf("\n"); for(j=0;j<n;j++) { local_var = 0; for(k=0;k<(p->states);k++) { if((neurone+j)->states[k] == 0) local_var++; else { printf("%d",local_var+1); break; } } if( local_var == (p->states)) printf("0"); if( (j+1) % (p->cols) == 0) printf("\n"); } */ // If the neural array has been filled with the input // activation values then we can calculate the connecting // weights (to this point) rtype_flag_temp = p->rtype_flag;// Preserve for restoration p->rtype_flag = NOT_DREAMING;// Set for call to update_... //printf("\n calculating weights.....\n"); update_neural_weights( p, neurone ); // calculate the connecting weights up to this point *************** p->rtype_flag = rtype_flag_temp;// Restore // We set row_count to force a new TPAT/RPAT before re-entry row_count = (p->rows); } } // End of the outer while loop // Make sure that there were enough patterns if ( tpat_count != (p->num_pats) ) { printf( "\nFatal Error - Incorrect number of TPAT definitions.\n" "The number of TPAT definitions must match the\n" "NET specification.\n\n" "Number of TPAT blocks from the NET specification : %d\n" "Number of TPAT blocks actually found : %d\n", (p->num_pats), tpat_count ); return( F_FALSE ); } else if ( npat_count != 1 ) { printf("\nFatal Error - There should be exactly 1 NPAT block!\n" ); return( F_FALSE ); } else if ( row_count != (p->rows) && (p->update_cycles) > 0 ) { printf( "\nFatal Error - NPAT pattern block should have %d rows,\n" " only %d rows were actually counted !\n", (p->rows), row_count ); return( F_FALSE ); } fclose( input_stream ); // Close the input parameter file return( F_TRUE ); // and return to main() }
void save_helps( FILE *fp, AREA_DATA *pArea ) { HELP_DATA *pHelp; bool found = FALSE; for (pHelp = first_help; pHelp; pHelp = pHelp->next) { if( pHelp->area && pHelp->area == pArea ) { if( !found ) { fprintf( fp, "#HELPS\n\n" ); found = TRUE; } fprintf(fp, "%d %s~\n%s~\n", pHelp->level, all_capitalize(pHelp->keyword), fix_string(pHelp->text)); } } if( found ) fprintf( fp, "\n0 $~\n\n" ); return; }
/***************************************************************************** Name: save_rooms Purpose: Save #ROOMS section of an area file. Called by: save_area(olc_save.c). ****************************************************************************/ void save_rooms( FILE *fp, AREA_DATA *pArea ) { ROOM_INDEX_DATA *pRoomIndex; EXTRA_DESCR_DATA *pEd; EXIT_DATA *pExit; char buf[MSL]; int iHash, i, locks; fprintf( fp, "#ROOMS\n" ); for( iHash = 0; iHash < MAX_KEY_HASH; iHash++ ) { for( pRoomIndex = room_index_hash[iHash]; pRoomIndex; pRoomIndex = pRoomIndex->next ) { if ( pRoomIndex->area == pArea ) { fprintf( fp, "#%d\n", pRoomIndex->vnum ); fprintf( fp, "%s~\n", pRoomIndex->name ); fprintf( fp, "%s~\n0\n", fix_string( pRoomIndex->description ) ); fprintf( fp, "%s ", fwrite_flag(pRoomIndex->room_flags, buf) ); fprintf( fp, "%d\n", pRoomIndex->sector_type ); for ( pEd = pRoomIndex->extra_descr; pEd; pEd = pEd->next ) { fprintf( fp, "E\n%s~\n%s~\n", pEd->keyword, fix_string( pEd->description ) ); } for( i = 0; i < MAX_DIR; i++ ) { if ((pExit = pRoomIndex->exit[i]) == NULL) continue; if ( pExit->u1.to_room ) { locks = 0; if ( IS_SET(pExit->rs_flags, EX_CLOSED) || IS_SET(pExit->rs_flags, EX_LOCKED) || IS_SET(pExit->rs_flags, EX_PICKPROOF) || IS_SET(pExit->rs_flags, EX_NOPASS) || IS_SET(pExit->rs_flags, EX_EASY) || IS_SET(pExit->rs_flags, EX_HARD) || IS_SET(pExit->rs_flags, EX_INFURIATING) || IS_SET(pExit->rs_flags, EX_NOCLOSE) || IS_SET(pExit->rs_flags, EX_NOLOCK) ) SET_BIT(pExit->rs_flags, EX_ISDOOR); if (IS_SET(pExit->rs_flags, EX_ISDOOR)) locks = IS_SET(pExit->rs_flags, EX_LOCKED) ? 2 : 1; fprintf( fp, "D%d\n", pExit->orig_door ); fprintf( fp, "%s~\n", fix_string( pExit->description ) ); fprintf( fp, "%s~\n", pExit->keyword ); fprintf( fp, "%d %d %d\n", locks, pExit->key, pExit->u1.to_room->vnum ); } } if (pRoomIndex->mana_rate != 100 || pRoomIndex->heal_rate != 100) fprintf ( fp, "M %d H %d\n",pRoomIndex->mana_rate, pRoomIndex->heal_rate); if (pRoomIndex->clan > 0) fprintf ( fp, "L '%s'\n" , clan_table[pRoomIndex->clan].name ); if (pRoomIndex->owner && str_cmp(pRoomIndex->owner,"")) fprintf ( fp, "O %s~\n" , pRoomIndex->owner ); fprintf( fp, "S\n" ); } } } fprintf( fp, "#0\n\n\n\n" ); return; }
/***************************************************************************** Name: save_object Purpose: Save one object to file. new ROM format saving -- Hugin Called by: save_objects (below). ****************************************************************************/ void save_object( FILE *fp, OBJ_INDEX_DATA *pObjIndex ) { char letter; AFFECT_DATA *pAf; EXTRA_DESCR_DATA *pEd; char buf[MAX_STRING_LENGTH]; fprintf( fp, "#%d\n", pObjIndex->vnum ); fprintf( fp, "%s~\n", pObjIndex->name ); fprintf( fp, "%s~\n", pObjIndex->short_descr ); fprintf( fp, "%s~\n", fix_string( pObjIndex->description ) ); fprintf( fp, "%s~\n", pObjIndex->material); fprintf( fp, "%s ", item_name(pObjIndex->item_type)); fprintf( fp, "%s ", fwrite_flag( pObjIndex->extra_flags, buf ) ); fprintf( fp, "%s\n", fwrite_flag( pObjIndex->wear_flags, buf ) ); /* * Using fwrite_flag to write most values gives a strange * looking area file, consider making a case for each * item type later. */ switch ( pObjIndex->item_type ) { default: fprintf( fp, "%s ", fwrite_flag( pObjIndex->value[0], buf ) ); fprintf( fp, "%s ", fwrite_flag( pObjIndex->value[1], buf ) ); fprintf( fp, "%s ", fwrite_flag( pObjIndex->value[2], buf ) ); fprintf( fp, "%s ", fwrite_flag( pObjIndex->value[3], buf ) ); fprintf( fp, "%s\n", fwrite_flag( pObjIndex->value[4], buf ) ); break; case ITEM_LIGHT: fprintf( fp, "0 0 %d 0 0\n", pObjIndex->value[2] < 1 ? 999 /* infinite */ : pObjIndex->value[2] ); break; case ITEM_MONEY: fprintf( fp, "%d %d 0 0 0\n", pObjIndex->value[0], pObjIndex->value[1]); break; case ITEM_DRINK_CON: fprintf( fp, "%d %d '%s' %d 0\n", pObjIndex->value[0], pObjIndex->value[1], liq_table[pObjIndex->value[2]].liq_name, pObjIndex->value[3] ); break; case ITEM_FOUNTAIN: fprintf( fp, "%d %d '%s' 0 0\n", pObjIndex->value[0], pObjIndex->value[1], liq_table[pObjIndex->value[2]].liq_name); break; case ITEM_CONTAINER: fprintf( fp, "%d %s %d %d %d\n", pObjIndex->value[0], fwrite_flag( pObjIndex->value[1], buf ), pObjIndex->value[2], pObjIndex->value[3], pObjIndex->value[4]); break; case ITEM_FOOD: fprintf( fp, "%d %d 0 %s 0\n", pObjIndex->value[0], pObjIndex->value[1], fwrite_flag( pObjIndex->value[3], buf ) ); break; case ITEM_PORTAL: fprintf( fp, "%d %s %s %d 0\n", pObjIndex->value[0], fwrite_flag( pObjIndex->value[1], buf ), fwrite_flag( pObjIndex->value[2], buf ), pObjIndex->value[3]); break; case ITEM_FURNITURE: fprintf( fp, "%d %d %s %d %d\n", pObjIndex->value[0], pObjIndex->value[1], fwrite_flag( pObjIndex->value[2], buf), pObjIndex->value[3], pObjIndex->value[4]); break; case ITEM_WEAPON: fprintf( fp, "%s %d %d '%s' %s\n", weapon_name(pObjIndex->value[0]), pObjIndex->value[1], pObjIndex->value[2], attack_table[pObjIndex->value[3]].name, fwrite_flag( pObjIndex->value[4], buf ) ); break; case ITEM_ARMOR: fprintf( fp, "%d %d %d %d %d\n", pObjIndex->value[0], pObjIndex->value[1], pObjIndex->value[2], pObjIndex->value[3], pObjIndex->value[4]); break; case ITEM_PILL: case ITEM_POTION: case ITEM_SCROLL: fprintf( fp, "%d '%s' '%s' '%s' '%s'\n", pObjIndex->value[0] > 0 ? /* no negative numbers */ pObjIndex->value[0] : 0, pObjIndex->value[1] > 0 ? skill_table[pObjIndex->value[1]].name : "", pObjIndex->value[2] > 0 ? skill_table[pObjIndex->value[2]].name : "", pObjIndex->value[3] > 0 ? skill_table[pObjIndex->value[3]].name : "", pObjIndex->value[4] > 0 ? skill_table[pObjIndex->value[4]].name : ""); break; case ITEM_STAFF: case ITEM_WAND: fprintf( fp, "%d ", pObjIndex->value[0] ); fprintf( fp, "%d ", pObjIndex->value[1] ); fprintf( fp, "%d '%s' 0\n", pObjIndex->value[2], pObjIndex->value[3] > 0 ? skill_table[pObjIndex->value[3]].name : "" ); break; } fprintf( fp, "%d ", pObjIndex->level ); fprintf( fp, "%d ", pObjIndex->weight ); fprintf( fp, "%d ", pObjIndex->cost ); if ( pObjIndex->condition > 90 ) letter = 'P'; else if ( pObjIndex->condition > 75 ) letter = 'G'; else if ( pObjIndex->condition > 50 ) letter = 'A'; else if ( pObjIndex->condition > 25 ) letter = 'W'; else if ( pObjIndex->condition > 10 ) letter = 'D'; else if ( pObjIndex->condition > 0 ) letter = 'B'; else letter = 'R'; fprintf( fp, "%c\n", letter ); for( pAf = pObjIndex->affected; pAf; pAf = pAf->next ) { if (pAf->where == TO_OBJECT || pAf->bitvector == 0) fprintf( fp, "A\n%d %d\n", pAf->location, pAf->modifier ); else { fprintf( fp, "F\n" ); switch(pAf->where) { case TO_AFFECTS: fprintf( fp, "A " ); break; case TO_IMMUNE: fprintf( fp, "I " ); break; case TO_RESIST: fprintf( fp, "R " ); break; case TO_VULN: fprintf( fp, "V " ); break; default: bug( "olc_save: Invalid Affect->where", 0); break; } fprintf( fp, "%d %d %s\n", pAf->location, pAf->modifier, fwrite_flag( pAf->bitvector, buf ) ); } } for( pEd = pObjIndex->extra_descr; pEd; pEd = pEd->next ) { fprintf( fp, "E\n%s~\n%s~\n", pEd->keyword, fix_string( pEd->description ) ); } return; }
/***************************************************************************** Name: save_mobile Purpose: Save one mobile to file, new format -- Hugin Called by: save_mobiles (below). ****************************************************************************/ void save_mobile( FILE *fp, MOB_INDEX_DATA *pMobIndex ) { sh_int race = pMobIndex->race; long temp; char buf[MAX_STRING_LENGTH]; MPROG_LIST *pMprog; fprintf( fp, "#%d\n", pMobIndex->vnum ); fprintf( fp, "%s~\n", pMobIndex->player_name ); fprintf( fp, "%s~\n", pMobIndex->short_descr ); fprintf( fp, "%s~\n", fix_string( pMobIndex->long_descr ) ); fprintf( fp, "%s~\n", fix_string( pMobIndex->description) ); fprintf( fp, "%s~\n", race_table[race].name ); temp = DIF( pMobIndex->act, race_table[race].act ); fprintf( fp, "%s ", fwrite_flag( temp, buf ) ); temp = DIF( pMobIndex->affected_by, race_table[race].aff ); fprintf( fp, "%s ", fwrite_flag( temp, buf ) ); fprintf( fp, "%d %d\n", pMobIndex->alignment , pMobIndex->group); fprintf( fp, "%d ", pMobIndex->level ); fprintf( fp, "%d ", pMobIndex->hitroll ); fprintf( fp, "%dd%d+%d ", pMobIndex->hit[DICE_NUMBER], pMobIndex->hit[DICE_TYPE], pMobIndex->hit[DICE_BONUS] ); fprintf( fp, "%dd%d+%d ", pMobIndex->mana[DICE_NUMBER], pMobIndex->mana[DICE_TYPE], pMobIndex->mana[DICE_BONUS] ); fprintf( fp, "%dd%d+%d ", pMobIndex->damage[DICE_NUMBER], pMobIndex->damage[DICE_TYPE], pMobIndex->damage[DICE_BONUS] ); fprintf( fp, "%s\n", attack_table[pMobIndex->dam_type].name ); fprintf( fp, "%d %d %d %d\n", pMobIndex->ac[AC_PIERCE] / 10, pMobIndex->ac[AC_BASH] / 10, pMobIndex->ac[AC_SLASH] / 10, pMobIndex->ac[AC_EXOTIC] / 10 ); temp = DIF( pMobIndex->off_flags, race_table[race].off ); fprintf( fp, "%s ", fwrite_flag( temp, buf ) ); temp = DIF( pMobIndex->imm_flags, race_table[race].imm ); fprintf( fp, "%s ", fwrite_flag( temp, buf ) ); temp = DIF( pMobIndex->res_flags, race_table[race].res ); fprintf( fp, "%s ", fwrite_flag( temp, buf ) ); temp = DIF( pMobIndex->vuln_flags, race_table[race].vuln ); fprintf( fp, "%s\n", fwrite_flag( temp, buf ) ); fprintf( fp, "%s %s %s %ld\n", position_table[pMobIndex->start_pos].short_name, position_table[pMobIndex->default_pos].short_name, sex_table[pMobIndex->sex].name, pMobIndex->wealth ); temp = DIF( pMobIndex->form, race_table[race].form ); fprintf( fp, "%s ", fwrite_flag( temp, buf ) ); temp = DIF( pMobIndex->parts, race_table[race].parts ); fprintf( fp, "%s ", fwrite_flag( temp, buf ) ); fprintf( fp, "%s ", size_table[pMobIndex->size].name ); fprintf( fp, "'%s'\n", ((pMobIndex->material[0] != '\0') ? pMobIndex->material : "unknown") ); if ((temp = DIF(race_table[race].act,pMobIndex->act))) fprintf( fp, "F act %s\n", fwrite_flag(temp, buf) ); if ((temp = DIF(race_table[race].aff,pMobIndex->affected_by))) fprintf( fp, "F aff %s\n", fwrite_flag(temp, buf) ); if ((temp = DIF(race_table[race].off,pMobIndex->off_flags))) fprintf( fp, "F off %s\n", fwrite_flag(temp, buf) ); if ((temp = DIF(race_table[race].imm,pMobIndex->imm_flags))) fprintf( fp, "F imm %s\n", fwrite_flag(temp, buf) ); if ((temp = DIF(race_table[race].res,pMobIndex->res_flags))) fprintf( fp, "F res %s\n", fwrite_flag(temp, buf) ); if ((temp = DIF(race_table[race].vuln,pMobIndex->vuln_flags))) fprintf( fp, "F vul %s\n", fwrite_flag(temp, buf) ); if ((temp = DIF(race_table[race].form,pMobIndex->form))) fprintf( fp, "F for %s\n", fwrite_flag(temp, buf) ); if ((temp = DIF(race_table[race].parts,pMobIndex->parts))) fprintf( fp, "F par %s\n", fwrite_flag(temp, buf) ); for (pMprog=pMobIndex->mprogs;pMprog;pMprog=pMprog->next) { fprintf(fp, "M '%s' %d %s~\n", mprog_type_to_name(pMprog->trig_type), pMprog->vnum, pMprog->trig_phrase); } return; }
/***************************************************************************** Name: save_objects Purpose: Save #OBJECTS section of an area file. Called by: save_area(olc_save.c). ****************************************************************************/ void save_objects( FILE *fp, AREA_DATA *pArea ) { int vnum; OBJ_INDEX_DATA *pObjIndex; AFFECT_DATA *pAf; EXTRA_DESCR_DATA *pEd; fprintf( fp, "#OBJECTS\n" ); for( vnum = pArea->lvnum; vnum <= pArea->uvnum; vnum++ ) { if( ( pObjIndex = get_obj_index(vnum) ) ) { if ( pObjIndex->area == pArea ) { fprintf( fp, "#%d\n", pObjIndex->vnum ); fprintf( fp, "%s~\n", pObjIndex->name ); fprintf( fp, "%s~\n", pObjIndex->short_descr ); fprintf( fp, "%s~\n", fix_string( pObjIndex->description ) ); fprintf( fp, "~\n" ); fprintf( fp, "%d ", pObjIndex->item_type ); fprintf( fp, "%d ", pObjIndex->extra_flags ); fprintf( fp, "%d\n", pObjIndex->wear_flags); fprintf( fp, "%d %d %d\n", pObjIndex->extra_flags2, pObjIndex->weapflags, pObjIndex->quest ); switch ( pObjIndex->item_type ) { default: fprintf( fp, "%d %d %d %d\n", pObjIndex->value[0], pObjIndex->value[1], pObjIndex->value[2], pObjIndex->value[3] ); break; case ITEM_PILL: case ITEM_POTION: case ITEM_SCROLL: fprintf( fp, "%d '%s' '%s' '%s'\n", pObjIndex->value[0], pObjIndex->value[1] != -1 ? skill_table[pObjIndex->value[1]].name : " ", pObjIndex->value[2] != -1 ? skill_table[pObjIndex->value[2]].name : " ", pObjIndex->value[3] != -1 ? skill_table[pObjIndex->value[3]].name : " " ); break; case ITEM_STAFF: case ITEM_WAND: fprintf( fp, "%d %d %d '%s'\n", pObjIndex->value[0], pObjIndex->value[1], pObjIndex->value[2], pObjIndex->value[3] != -1 ? skill_table[pObjIndex->value[3]].name : " " ); break; } fprintf( fp, "%d ", pObjIndex->weight ); fprintf( fp, "%d 0\n", pObjIndex->cost ); for( pAf = pObjIndex->affected; pAf; pAf = pAf->next ) { fprintf( fp, "A\n%d %d\n", pAf->location, pAf->modifier ); } for( pEd = pObjIndex->extra_descr; pEd; pEd = pEd->next ) { fprintf( fp, "E\n%s~\n%s~\n", pEd->keyword, fix_string( pEd->description ) ); } fprintf( fp, "Q\n%s~\n%s~\n%s~\n%s~\n%s~\n%s~\n%d %d\n", pObjIndex->chpoweron, pObjIndex->chpoweroff, pObjIndex->chpoweruse, pObjIndex->victpoweron, pObjIndex->victpoweroff, pObjIndex->victpoweruse, pObjIndex->spectype, pObjIndex->specpower); } } } fprintf( fp, "#0\n\n\n\n" ); return; }
void ConsoleUI::add_scientist() { Scientist s = Scientist(); string firstname_, lastname_, gender_, birth_, death_; clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "Name of Scientist: [FirstName LastName]" << endl; cout << endl << " -> "; cin >> firstname_ >> lastname_; clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "Gender of scientist: \n(1) male \n(2) female" << endl; cout << endl << " -> "; cin >> gender_; while ((gender_ != "1") && (gender_ != "2")) { clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "Invalid input! Please try again:" << endl; cout << "Gender of scientist: \n(1) male \n(2) female" << endl; cout << endl << " -> "; cin >> gender_; } clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "Birth year of scientist:" << endl; cout << endl << " -> "; cin >> birth_; while (!is_digits(birth_)) { clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "Invalid input! Please try again:" << endl; cout << "Birth year of scientist:" << endl; cout << endl << " -> "; cin >> birth_; } clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "Scientist's Year of death: " << endl; cout << endl << " -> "; cin >> death_; while (!is_digits(death_) || (atoi(death_.c_str()) < atoi(birth_.c_str()))) { clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; if (!is_digits(death_)) { cout << "Invalid input! Please try again:" << endl; } else if (atoi(death_.c_str()) < atoi(birth_.c_str())) { cout << "Year of death should be AFTER year of birth! Please ry again:" << endl; } cout << "Scientist's Year of death:" << endl; cout << endl << " -> "; cin >> death_; } if (gender_ == "1") { s.set_gender("Male"); } else if (gender_ == "2") { s.set_gender("Female"); } fix_string(firstname_); fix_string(lastname_); s.set_firstname(firstname_); s.set_lastname(lastname_); s.set_birth(birth_); s.set_death(death_); dbService.addS(s); clear_screen(); cout << readFileToString("../templates/commands.txt") << endl; cout << "\t\t " << "Scientist has been added to the list!\n\n\n\n\n\n\n" << endl; }
bool bool_from_string(const std::string &s) { const std::string ss=fix_string(s); return ss=="yes" || ss=="1" || ss=="true"; }
int cg_xaxis (float xsiz, float xmin, float xmax, float os, float xtix, int numsep) { float x,xrang; int numdist, tt=0, tb=0, sigdec; char line[32]; /* SET TO DEFAULT IF VALUE IS BEYOND RANGE */ if ((numsep<1) || (numsep > 100)) numsep = 5; /* SET EVERYTHING UP */ os=os*cgSCALE; cglogx= FALSE; realxmax=xsiz; cgxma= xmax +.001*(xmax-xmin); cgxmi= xmin; cgxticks=xtix; xsiz=xsiz*cgSCALE; xrang= cgxma-cgxmi; cgxscale= xsiz/xrang; numdist= (cglinnumdist)*(cgfsizex/10.0)+1; fprintf(cgstream,"\n\n%% X axis (linear).\n"); fprintf(cgstream,"/xs {%g cvr mul} def\n",cgxscale); fprintf(cgstream,"/xtix {%g cvr} def\n",xtix); fprintf(cgstream,"/xsize {%g cvr} def\n",xsiz); fprintf(cgstream,"/xrange {%g cvr} def\n",xrang); fprintf(cgstream,"/xos {%g cvr sub} def\n\n",cgxmi); /* CREATE THE AXIS AND TICKS*/ if(cgAxisEnable) { if ((cglintnposition == 3) || (cglintnposition == 4)) tb= 0; else tb= -cglinticlen; if ((cglintnposition == 1) || (cglintnposition == 6)) tt= 0; else tt = cglinticlen; fprintf(cgstream,"/x 0 def\n"); fprintf(cgstream,"0 %g mto\n%g 0 rlto\nstroke\n",os,xsiz); fprintf(cgstream,"x 0 xtix xrange {xs dup %g mto\n",os+tt); fprintf(cgstream,"\t%g lto\n",os+tb); fprintf(cgstream,"\tstroke xtix x add} for\n"); } if(cgAxisNumberEnable) { sigdec= 0; /* Determine The Maximum Significant Decimal Place*/ sigdec=findsigdec(cgxmi,xrang*1.01,numsep,cgxticks); /*NOW FOR THE REAL NUMBER PLACEMENT LOOP*/ for (x=cglinnumoff*cgxticks; x<= xrang*1.01; x+= numsep*xtix) { formaxnum(x+cgxmi,sigdec,line); fprintf(cgstream,"\nnewpath 1000 1000 mto\n"); fprintf(cgstream,"(%s) stw pop 2 div\n",line); fprintf(cgstream,"%g cvr exch sub ", x*cgxscale); if ((cglintnposition > 0) && (cglintnposition < 4)) /* Numbers BELOW Axis */ fprintf(cgstream,"%g charheight sub ",os+tb-numdist); else /* Numbers ABOVE Axis */ fprintf(cgstream,"%g ",os+tt+numdist); fprintf(cgstream,"mto (%s) show\n", fix_string(line,1)); } } leastY=os+tb-numdist-(1.4)*cgfontnum; fprintf(cgstream,"\n/xs {%g cvr sub %g cvr mul} def\n", cgxmi, cgxscale); fprintf(cgstream,"%% END X axis (linear).\n"); return(0); }
/***************************************************************************** Name: save_rooms Purpose: Save #ROOMS section of an area file. Called by: save_area(olc_save.c). ****************************************************************************/ void save_rooms( FILE *fp, AREA_DATA *pArea ) { ROOM_INDEX_DATA *pRoomIndex; EXTRA_DESCR_DATA *pEd; EXIT_DATA *pExit; int iHash; int door; fprintf( fp, "#ROOMS\n" ); for( iHash = 0; iHash < MAX_KEY_HASH; iHash++ ) { for( pRoomIndex = room_index_hash[iHash]; pRoomIndex; pRoomIndex = pRoomIndex->next ) { if ( pRoomIndex->area == pArea ) { fprintf( fp, "#%d\n", pRoomIndex->vnum ); fprintf( fp, "%s~\n", pRoomIndex->name ); fprintf( fp, "%s~\n", fix_string( pRoomIndex->description ) ); fprintf( fp, "0 " ); fprintf( fp, "%d ", pRoomIndex->room_flags ); fprintf( fp, "%d\n", pRoomIndex->sector_type ); for ( pEd = pRoomIndex->extra_descr; pEd; pEd = pEd->next ) { fprintf( fp, "E\n%s~\n%s~\n", pEd->keyword, fix_string( pEd->description ) ); } for( door = 0; door < MAX_DIR; door++ ) /* I hate this! */ { if ( ( pExit = pRoomIndex->exit[door] ) && pExit->u1.to_room ) { int locks = 0; /* HACK : TO PREVENT EX_LOCKED etc without EX_ISDOOR to stop booting the mud */ if ( IS_SET(pExit->rs_flags, EX_CLOSED) || IS_SET(pExit->rs_flags, EX_LOCKED) || IS_SET(pExit->rs_flags, EX_PICKPROOF) || IS_SET(pExit->rs_flags, EX_NOPASS) || IS_SET(pExit->rs_flags, EX_EASY) || IS_SET(pExit->rs_flags, EX_HARD) || IS_SET(pExit->rs_flags, EX_INFURIATING) || IS_SET(pExit->rs_flags, EX_NOCLOSE) || IS_SET(pExit->rs_flags, EX_NOLOCK) ) SET_BIT(pExit->rs_flags, EX_ISDOOR); else REMOVE_BIT(pExit->rs_flags, EX_ISDOOR); /* THIS SUCKS but it's backwards compatible */ /* NOTE THAT EX_NOCLOSE NOLOCK etc aren't being saved */ if ( IS_SET( pExit->rs_flags, EX_ISDOOR ) && ( !IS_SET( pExit->rs_flags, EX_PICKPROOF ) ) && ( !IS_SET( pExit->rs_flags, EX_NOPASS ) ) ) locks = 1; if ( IS_SET( pExit->rs_flags, EX_ISDOOR ) && ( IS_SET( pExit->rs_flags, EX_PICKPROOF ) ) && ( !IS_SET( pExit->rs_flags, EX_NOPASS ) ) ) locks = 2; if ( IS_SET( pExit->rs_flags, EX_ISDOOR ) && ( !IS_SET( pExit->rs_flags, EX_PICKPROOF ) ) && ( IS_SET( pExit->rs_flags, EX_NOPASS ) ) ) locks = 3; if ( IS_SET( pExit->rs_flags, EX_ISDOOR ) && ( IS_SET( pExit->rs_flags, EX_PICKPROOF ) ) && ( IS_SET( pExit->rs_flags, EX_NOPASS ) ) ) locks = 4; fprintf( fp, "D%d\n", pExit->orig_door ); fprintf( fp, "%s~\n", fix_string( pExit->description ) ); fprintf( fp, "%s~\n", pExit->keyword ); fprintf( fp, "%d %d %d\n", locks, pExit->key, pExit->u1.to_room->vnum ); } } if (pRoomIndex->mana_rate != 100 || pRoomIndex->heal_rate != 100) fprintf ( fp, "M %d H %d\n",pRoomIndex->mana_rate, pRoomIndex->heal_rate); if (pRoomIndex->clan > 0) fprintf ( fp, "C %s~\n" , clan_table[pRoomIndex->clan].name ); if (!IS_NULLSTR(pRoomIndex->owner)) fprintf ( fp, "O %s~\n" , pRoomIndex->owner ); fprintf( fp, "S\n" ); } } } fprintf( fp, "#0\n\n\n\n" ); return; }