/* Draw the actual data to the user's output buffer. */ void draw_data (CHAR_DATA * ch, int lines) { int i, j; bool ibm = !IS_SET(ch->pcdata->act2, PLR_NOIBM); gotoxy (ch, 1, 1); /* Home cursor */ last_col = 0; /* Last column used for truncating trailing spaces */ for (i = 1; i <= lines; i++) { for (j = 1; j < ch->pcdata->maxx+1; j++) { if (outp[j][i][0] == '\0' || outp[j][i][0] == ' ') /* Null -> Space */ { write_to_buffer (ch->desc, " ", 0); } else { /* Optimize colors so we don't send repeat color sequences that are unnecessary */ if (colrs[j][i] == 0 || colrs[j][i] != last_col) { write_to_buffer (ch->desc, scrnn[j][i], 0); } last_col = colrs[j][i]; /* Set the last color drawn */ write_to_buffer (ch->desc, outp[j][i], 0); /* Draw the char */ } } if (max_col[i] < 20) send_to_char(" ", ch); send_to_char ("\n\r", ch); /* Next line */ } send_to_char ("\x1B[0;37m", ch); /* Back to gray */ return; }
void draw_small (CHAR_DATA * ch) { int i, j; int currcolor = 0; char buf[100]; sprintf(buf, "\x1b[%d;%dr", MAP_HEIGHT, ch->pcdata->pagelen); send_to_char(buf, ch); gotoxy(ch,1,1); for (i = 1; i <= MAP_HEIGHT; i++) { for (j = 1; j < MAP_WIDTH; j++) { if (smlmap[j][i][0] == '\0') { write_to_buffer (ch->desc, " ", 0); } if (smlcolors[j][i] != 0 && smlcolors[j][i] != currcolor) { write_to_buffer (ch->desc, color_table[smlcolors[j][i]].code, 0); currcolor = smlcolors[j][i]; } write_to_buffer (ch->desc, smlmap[j][i] , 0); } send_to_char ("\n\r", ch); /* Next line */ } sprintf(buf, "\x1b[%d;1f", ch->pcdata->pagelen); send_to_char(buf, ch); send_to_char ("\x1B[0;37m", ch); /* Back to gray */ return; }
int trace_record_start(TraceBufferRecord *rec, TraceEventID event, size_t datasize) { unsigned int idx, rec_off, old_idx, new_idx; uint32_t rec_len = sizeof(TraceRecord) + datasize; uint64_t event_u64 = event; uint64_t timestamp_ns = get_clock(); do { old_idx = g_atomic_int_get(&trace_idx); smp_rmb(); new_idx = old_idx + rec_len; if (new_idx - writeout_idx > TRACE_BUF_LEN) { /* Trace Buffer Full, Event dropped ! */ g_atomic_int_inc(&dropped_events); return -ENOSPC; } } while (!g_atomic_int_compare_and_exchange(&trace_idx, old_idx, new_idx)); idx = old_idx % TRACE_BUF_LEN; rec_off = idx; rec_off = write_to_buffer(rec_off, &event_u64, sizeof(event_u64)); rec_off = write_to_buffer(rec_off, ×tamp_ns, sizeof(timestamp_ns)); rec_off = write_to_buffer(rec_off, &rec_len, sizeof(rec_len)); rec_off = write_to_buffer(rec_off, &trace_pid, sizeof(trace_pid)); rec->tbuf_idx = idx; rec->rec_off = (idx + sizeof(TraceRecord)) % TRACE_BUF_LEN; return 0; }
void trace_record_write_str(TraceBufferRecord *rec, const char *s, uint32_t slen) { /* Write string length first */ rec->rec_off = write_to_buffer(rec->rec_off, &slen, sizeof(slen)); /* Write actual string now */ rec->rec_off = write_to_buffer(rec->rec_off, (void*)s, slen); }
void do_compress( CHAR_DATA *ch, char *argument ) { if (!ch->desc) { send_to_char("What descriptor?!\n", ch); return; } if (!ch->desc->out_compress) { if ( str_cmp(argument,"2") ) write_to_buffer( ch->desc, compress_on_str, 0 ); if ( str_cmp(argument,"1") ) write_to_buffer( ch->desc, compress2_on_str, 0 ); send_to_char("Ok, compression enabled.\n", ch); } else { if (!compressEnd(ch->desc,ch->desc->compressing)) { send_to_char("Failed.\n", ch); return; } send_to_char("Ok, compression disabled.\n", ch); } return; }
void process_todelete( DESCRIPTOR_DATA *d, CHAR_DATA *ch ) // process the todelete request { if ( ch->pcdata->todelete != 0 ) // if on todelete list { ch->pcdata->todelete = 0; // clear the pcdata->todelete value save_char_obj( ch, FALSE, FALSE ); // save the change remove_todelete( ch->name ); // remove ch from todelete list save_todelete_list( ); // save the change write_to_buffer( d, echo_on_str, 0 ); // prepare message write_to_buffer( d, "\n\r Przerwano kasowanie postaci.\n\r", 0 ); // send message } else // otherwise { char buf[MSL]; // declare char array variable ch->pcdata->todelete = ( TODELETE_DELAY ) + current_time; // set pcdata->todelete save_char_obj( ch, FALSE, FALSE ); // save the change add_todelete( ch->name, ch->pcdata->todelete ); // add ch to todelete list save_todelete_list( ); // save the change write_to_buffer( d, echo_on_str, 0 ); // send empty string sprintf( buf, "\n\r Postaæ zostanie skasowana za %s.\n\r", todelete_time( ch->name, 's' ) ); // prepare message write_to_buffer( d, buf, 0 ); // send message } return; // exit the function }
Byte* Problem::pack(Byte* buffer) const { Byte* cursor = buffer; cursor = mesh_ptr->pack(cursor); cursor = write_to_buffer(fa, cursor); cursor = write_to_buffer(fb, cursor); cursor = write_to_buffer(rhs_func, cursor); cursor = write_to_buffer(num_jobs, cursor); return cursor; }
Byte* Job::pack(Byte* buffer) const { Byte* cursor = buffer; cursor = problem_ptr->pack(cursor); cursor = write_to_buffer(rank, cursor); return cursor; }
void write_min_to_buffer(int min){ int * right_valueR = space; int * right_valueL = minutes; int * left_valueR = (min < 1) ? numbers[0] : numbers[min % 10]; int * left_valueL = numbers[min / 10]; write_to_buffer(left_valueR, left_valueL, right_valueR, right_valueL); }
void write_sec_to_buffer(int sec){ int * right_valueR = space; int * right_valueL = seconds; int * left_valueR = (sec < 1) ? numbers[0] : numbers[sec % 10]; int * left_valueL = numbers[sec / 10]; write_to_buffer(left_valueR, left_valueL, right_valueR, right_valueL); }
void Logger::write( const LogMessage::Category category, const char* file, const size_t line, const char* format, ...) { if (impl->m_enabled) { // Print the formatted message into the temporary buffer. va_list argptr; va_start(argptr, format); write_to_buffer(impl->m_message_buffer, MaxBufferSize, format, argptr); // Send the message to every log targets. for (const_each<Impl::LogTargetContainer> i = impl->m_targets; i; ++i) { LogTargetBase* target = *i; target->write( category, file, line, &impl->m_message_buffer[0]); } } // Terminate the application if the message category is 'Fatal'. if (category == LogMessage::Fatal) exit(EXIT_FAILURE); }
/* For exit flags */ void redit_disp_exit_flag_menu( DESCRIPTOR_DATA *d ) { EXIT_DATA *pexit = d->character->spare_ptr; char buf[MSL]; int x; write_to_buffer( d, "50\x1B[;H\x1B[2J", 0 ); for ( x = 0; x < MAX_EXIT; x++ ) { if ( (x == EXIT_RES1) || (x == EXIT_RES2) || (x == EXIT_PORTAL) ) continue; ch_printf( d->character, "&g%2d&w) %-20.20s\r\n", x+1, code_name(NULL, x, CODE_EXIT) ); } buf[0] = '\0'; for ( x = 0; x < MAX_EXIT; x++ ) { if ( HAS_BIT(pexit->flags, x) ) { strcat( buf, code_name(NULL, x, CODE_EXIT) ); strcat( buf, " " ); } } ch_printf( d->character, "\r\nExit flags: &c%s&w\r\n" "Enter room flags, 0 to quit: ", buf ); OLC_MODE(d) = REDIT_EXIT_FLAGS; }
void redit_disp_exit_edit( DESCRIPTOR_DATA *d ) { char flags[MSL]; EXIT_DATA *pexit = d->character->spare_ptr; int x; flags[0] = '\0'; for ( x = 0; x < MAX_EXIT; x++ ) { if ( pexit->flags && HAS_BIT(pexit->flags, x) ) { strcat( flags, code_name(NULL, x, CODE_EXIT) ); strcat( flags, " " ); } } OLC_MODE(d) = REDIT_EXIT_EDIT; write_to_buffer( d, "50\x1B[;H\x1B[2J", 0 ); ch_printf( d->character, "&g1&w) Direction : &c%s\r\n", code_name(NULL, pexit->vdir, CODE_DIR) ); ch_printf( d->character, "&g2&w) To Vnum : &c%d\r\n", (pexit->to_room) ? pexit->to_room->vnum : -1 ); ch_printf( d->character, "&g3&w) Key : &c%d\r\n", pexit->key ); ch_printf( d->character, "&g4&w) Keyword : &c%s\r\n", (VALID_STR(pexit->keyword)) ? pexit->keyword : "(none)" ); ch_printf( d->character, "&g5&w) Flags : &c%s\r\n", (VALID_STR(flags)) ? flags : "(none)" ); ch_printf( d->character, "&g6&w) Description: &c%s\r\n", (VALID_STR(pexit->description)) ? pexit->description : "(none)" ); send_to_char( d->character, "&gQ&w) Quit\r\n" ); send_to_char( d->character, "\r\nEnter choice: " ); }
void consume_food(t_server *server, t_client *client) { if (client->character->hunger_timer <= 0) { if (client->character->quantities[NOURRITURE] > 0) { --client->character->quantities[NOURRITURE]; client->character->hunger_timer = 126; } else { write_to_buffer(&client->buffer_out, "mort\n", strlen("mort\n")); sprintf(server->buffer, "pdi %i\n", client->character->id); graphic_broadcast(server, server->buffer); if (client->character->base_member) --client->character->team->base_members; remove_character_from_case(client->character->current_case, client->character); close(client->socket); client->socket = 0; client->type = UNSPECIFIED; } } else --client->character->hunger_timer; }
/* For exits */ void redit_disp_exit_menu( DESCRIPTOR_DATA *d ) { ROOM_DATA *room = d->character->dest_buf; EXIT_DATA *pexit; int cnt; OLC_MODE(d) = REDIT_EXIT_MENU; write_to_buffer( d, "50\x1B[;H\x1B[2J", 0 ); for ( cnt = 0, pexit = room->first_exit; pexit; pexit = pexit->next ) { ch_printf( d->character, "&g%2d&w) %-10.10s to %-5d. Key: %d Keywords: %s Flags: %s.\r\n", ++cnt, code_name(NULL, pexit->vdir, CODE_DIR), (pexit->to_room) ? pexit->to_room->vnum : 0, pexit->key, code_bit(NULL, pexit->flags, CODE_EXIT), (VALID_STR(pexit->keyword)) ? pexit->keyword : "(none)" ); } if ( room->first_exit ) send_to_char( d->character, "\r\n" ); send_to_char( d->character, "&gA&w) Add a new exit\r\n" ); send_to_char( d->character, "&gR&w) Remove an exit\r\n" ); send_to_char( d->character, "&gQ&w) Quit\r\n" ); send_to_char( d->character, "\r\nEnter choice: " ); }
static int write_to_buffer(msf_sas_handle_t *handle, msf_sas_op_t *op, char *buf, unsigned int size) { unsigned int bytes_to_write, bytes_written; int ret; if(!buf || size == 0) return -1; bytes_to_write = (op->buffer_tail + size <= MSF_SAS_BUFFER_SIZE) ? size : MSF_SAS_BUFFER_SIZE - op->buffer_tail; memcpy(op->buffer + op->buffer_tail, buf, bytes_to_write); op->buffer_tail = (op->buffer_tail + bytes_to_write) % MSF_SAS_BUFFER_SIZE; if(op->buffer_tail == 0) { ret = FS_Write(op->file_handle, op->buffer, MSF_SAS_BUFFER_SIZE, (UINT*) &bytes_written); if (ret != FS_NO_ERROR) { return -1; } } if(size > bytes_to_write) { return write_to_buffer(handle, op, buf + bytes_to_write, size - bytes_to_write); } return 0; }
void send_to_desc( const char *txt, DESCRIPTOR_DATA *d ) { const char *point; char *point2; char buf[ MAX_STRING_LENGTH*4 ]; int skip = 0; buf[0] = '\0'; point2 = buf; if( txt && d ) { if( d->ansi == TRUE ) { for( point = txt ; *point ; point++ ) { if( *point == '{' ) { point++; skip = colour( *point, NULL, point2 ); while( skip-- > 0 ) ++point2; continue; } *point2 = *point; *++point2 = '\0'; } *point2 = '\0'; write_to_buffer( d, buf, point2 - buf ); } else { for( point = txt ; *point ; point++ ) { if( *point == '{' ) { point++; continue; } *point2 = *point; *++point2 = '\0'; } *point2 = '\0'; write_to_buffer( d, buf, point2 - buf ); } } return; }
/* * Write to one char, new colour version, by Lope. */ void send_to_char( const char *txt, CHAR_DATA *ch ) { const char *point; char *point2; char buf[ MAX_STRING_LENGTH*4 ]; int skip = 0; buf[0] = '\0'; point2 = buf; if( txt && ch->desc ) { if( IS_SET( ch->act, PLR_COLOUR ) ) { for( point = txt ; *point ; point++ ) { if( *point == '{' ) { point++; skip = colour( *point, ch, point2 ); while( skip-- > 0 ) ++point2; continue; } *point2 = *point; *++point2 = '\0'; } *point2 = '\0'; write_to_buffer( ch->desc, buf, point2 - buf ); } else { for( point = txt ; *point ; point++ ) { if( *point == '{' ) { point++; continue; } *point2 = *point; *++point2 = '\0'; } *point2 = '\0'; write_to_buffer( ch->desc, buf, point2 - buf ); } } return; }
static ssize_t buffered_pwrite(couch_file_handle handle, const void *buf, size_t nbyte, off_t offset) { #if LOG_BUFFER //fprintf(stderr, "w"); #endif if (nbyte == 0) { return 0; } buffered_file_handle *h = (buffered_file_handle*)handle; file_buffer* buffer = h->write_buffer; // Write data to the current buffer: size_t nbyte_written = write_to_buffer(buffer, buf, nbyte, offset); if (nbyte_written > 0) { buf = (char*)buf + nbyte_written; offset += nbyte_written; nbyte -= nbyte_written; } // Flush the buffer if it's full, or if it isn't aligned with the current write: if (buffer->length == buffer->capacity || nbyte_written == 0) { couchstore_error_t error = flush_buffer(buffer); if (error < 0) return error; } if (nbyte > 0) { ssize_t written; // If the remaining data will fit into the buffer, write it; else write directly: if (nbyte <= (buffer->capacity - buffer->length)) { written = write_to_buffer(buffer, buf, nbyte, offset); } else { written = h->raw_ops->pwrite(h->raw_ops_handle, buf, nbyte, offset); #if LOG_BUFFER fprintf(stderr, "BUFFER: passthru %zd bytes at %zd --> %zd\n", nbyte, offset, written); #endif if (written < 0) { return written; } } nbyte_written += written; } return nbyte_written; }
void handle_con_note_expire(DESCRIPTOR_DATA *d, char * argument) { CHAR_DATA *ch = d->character; char buf[MAX_STRING_LENGTH]; time_t expire; int days; if (!ch->pcdata->in_progress) { d->connected = CON_PLAYING; bug ("nanny: In CON_NOTE_EXPIRE, but no note in progress",0); return; } /* Numeric argument. no tilde smashing */ strcpy (buf, argument); if (!buf[0]) /* assume default expire */ days = ch->pcdata->board->purge_days; else /* use this expire */ if (!is_number(buf)) { write_to_buffer (d,"Write the number of days!\n\r",0); write_to_buffer (d,BOLD YELLOW "Expire" NO_COLOR ": ",0); return; } else { days = atoi (buf); if (days <= 0) { write_to_buffer (d, "This is a positive MUD. Use positive numbers only! :)\n\r",0); write_to_buffer (d, BOLD YELLOW "Expire" NO_COLOR ": ",0); return; } } expire = current_time + (days*24L*3600L); /* 24 hours, 3600 seconds */ ch->pcdata->in_progress->expire = expire; /* note that ctime returns XXX\n so we only need to add an \r */ write_to_buffer (d, "\n\rEnter text. Type " BOLD "~" NO_COLOR " or " BOLD "END" NO_COLOR " on an empty line to end note.\n\r" "=======================================================\n\r",0); d->connected = CON_NOTE_TEXT; }
/* Jump to x,y with writing the positioning code to user's output buffer */ void gotoxy (CHAR_DATA * ch, int x, int y) { char tt[50]; sprintf (tt, "\x1B[%d;%df", y, x); write_to_buffer (ch->desc, tt, 0); return; }
static int msf_sas_read_pipe_data(msf_sas_handle_t* handle, msf_sas_op_t *op) { int bufsize = 1024; char *buf = MSF_MEM_ALLOC(handle->modid, bufsize); int bytes_read; long available; int isOpen; int ret; do { bytes_read = MSF_PIPE_READ(op->pipe_handle, buf, bufsize); op->download_size += bytes_read; if (bytes_read > 0) { ret = write_to_buffer(handle, op, buf, bytes_read); if (ret != 0) { msf_sas_create_error_dialog (handle, op, MSF_WIDGET_STRING_GET_PREDEFINED(MSF_STR_ID_SAS_ERROR_FULL)); op->state = MSF_SAS_STATE_MESSAGE_WAIT; MSF_MEM_FREE(handle->modid, buf); return MSF_PACKAGE_SIGNAL_HANDLED; } } } while (bytes_read >= 0); MSF_MEM_FREE(handle->modid, buf); if (bytes_read == MSF_PIPE_ERROR_DELAYED) { MSF_PIPE_POLL(op->pipe_handle); } else if(bytes_read == MSF_PIPE_ERROR_CLOSED) { flush_buffer(handle, op); MSF_PIPE_CLOSE(op->pipe_handle); MSF_PIPE_DELETE(op->pathname); op->state = MSF_SAS_STATE_FINISHED; op->status = MSF_SAS_RETURN_OK; return MSF_PACKAGE_OPERATION_COMPLETE; } else if(bytes_read == MSF_PIPE_ERROR_CLOSED_ERROR || MSF_PIPE_STATUS(op->pipe_handle, &isOpen, &available) != 0) { MSF_PIPE_CLOSE(op->pipe_handle); MSF_PIPE_DELETE(op->pathname); msf_sas_create_error_dialog (handle, op, MSF_WIDGET_STRING_GET_PREDEFINED(BRA_STR_ID_CONNECTION_FAILED)); op->state = MSF_SAS_STATE_MESSAGE_WAIT; return MSF_PACKAGE_SIGNAL_HANDLED; } op->state = MSF_SAS_STATE_DOWNLOADING; return MSF_PACKAGE_SIGNAL_HANDLED; }
/* * Il menu principale. */ void redit_disp_menu( DESCRIPTOR_DATA *d ) { char buf[MSL]; ROOM_DATA *room = d->character->dest_buf; char *sect; switch ( room->sector ) { default: sect = "None"; break; case SECTOR_INSIDE: sect = "Inside"; break; case SECTOR_CITY: sect = "City"; break; case SECTOR_FIELD: sect = "Field"; break; case SECTOR_FOREST: sect = "Forest"; break; case SECTOR_HILLS: sect = "Hills"; break; case SECTOR_MOUNTAIN: sect = "Mountains"; break; case SECTOR_WATER_SWIM: sect = "Swim"; break; case SECTOR_WATER_NOSWIM: sect = "Noswim"; break; case SECTOR_UNDERWATER: sect = "Underwater"; break; case SECTOR_AIR: sect = "Air"; break; case SECTOR_DESERT: sect = "Desert"; break; case SECTOR_OCEANFLOOR: sect = "Oceanfloor"; break; case SECTOR_UNDERGROUND: sect = "Underground"; break; } write_to_buffer( d, "50\x1B[;H\x1B[2J", 0 ); sprintf( buf, "&w-- Room number : [&c%d&w] Room area: [&c%-30.30s&w]\r\n" "&g1&w) Name : &O%s\r\n" "&g2&w) Description :\r\n&O%s" "&g3&w) Room flags : &c%s\r\n" "&g4&w) Sector type : &c%s\r\n" "&g5&w) Tunnel : &c%d\r\n" "&g6&w) TeleDelay : &c%d\r\n" "&g7&w) TeleVnum : &c%d\r\n" "&gA&w) Exit menu\r\n" "&gB&w) Extra descriptions menu\r\n" "&gQ&w) Quit\r\n" "Enter choice : ", OLC_NUM(d), (room->area) ? room->area->name : "None???", room->name, room->description, code_bit(NULL, room->flags, CODE_ROOM), sect, room->tunnel, room->tele_delay, room->tele_vnum ); set_char_color( AT_PLAIN, d->character ); send_to_char( d->character, buf ); OLC_MODE(d) = REDIT_MAIN_MENU; }
Byte* JobResult::pack(Byte* const buffer) const { Byte* cursor = buffer; cursor = write_to_buffer(nnz, cursor); cursor = write_to_buffer(n, cursor); cursor = write_to_buffer(rank, cursor); cursor = write_to_buffer(assembly_time, cursor); size_t matrix_byte_size = nnz*sizeof(Real); memcpy(cursor, matrix_ptr, matrix_byte_size); cursor += matrix_byte_size; size_t rhs_byte_size = n*sizeof(Real); memcpy(cursor, rhs_ptr, rhs_byte_size); cursor += rhs_byte_size; return cursor; }
void redit_disp_exit_dirs( DESCRIPTOR_DATA *d ) { int x; write_to_buffer( d, "50\x1B[;H\x1B[2J", 0 ); for ( x = 0; x < MAX_DIR; x++ ) ch_printf( d->character, "&g%2d&w) %s\r\n", x, code_name(NULL, x, CODE_DIR) ); send_to_char( d->character, "\r\nChoose a direction: " ); }
Byte* Solution::pack(Byte* const buffer) const { Byte* cursor = buffer; cursor = write_to_buffer(n, cursor); size_t x_byte_size = n*sizeof(Real); memcpy(cursor, x_ptr, x_byte_size); cursor += x_byte_size; return cursor; }
void drawstuff (CHAR_DATA *ch, char* argy, int maxy, int maxx) { char *y = argy; char tt[50]; int i,j,m; if (IS_MOB(ch)) return; if (IS_SET(ch->pcdata->act2, PLR_NOIBM)) noibm = TRUE; else noibm = FALSE; flip = FALSE; kk = FALSE; mb = FALSE; for (; *y != '\0'; y++) { if (*y == 'N' || *y == 'n') noibm = TRUE; if (*y == 'D' || *y == 'd') kk = TRUE; if (*y == 'M' || *y == 'm') mb = TRUE; if (*y == 'F' || *y == 'f') flip = TRUE; } for (i=0; i<80; i++) { for (j=0; j<25; j++) { outp[i][j][0] = ' '; outp[i][j][1] = '\0'; for (m=0; m < 15; m++) scrnn[i][j][m]='\0'; colrs[i][j]='\0'; } } reset_data(); ch->pcdata->maxx = maxx; ch->pcdata->maxy = maxy; go_display (ch, ch->in_room, (maxx/2), (maxy/2), maxy, maxx); outp[(maxx/2)][(maxy/2)][0] = 'X'; outp[(maxx/2)][(maxy/2)][1] = '\0'; draw_data (ch, maxy); write_to_buffer(ch->desc, "\x1B[0;37m", 0); gotoxy (ch, 1, maxy+1); undisplay(ch, ch->in_room, 150); gotoxy(ch, 1, ch->pcdata->pagelen); mb = FALSE; kk = FALSE; noibm = FALSE; flip = FALSE; return; }
void trace_record_finish(TraceBufferRecord *rec) { TraceRecord record; read_from_buffer(rec->tbuf_idx, &record, sizeof(TraceRecord)); smp_wmb(); /* write barrier before marking as valid */ record.event |= TRACE_RECORD_VALID; write_to_buffer(rec->tbuf_idx, &record, sizeof(TraceRecord)); if ((trace_idx - writeout_idx) > TRACE_BUF_FLUSH_THRESHOLD) { flush_trace_file(false); } }
void store_candidate(cObj cCandidate) { float fModMass = cCandidate.fPeptideMass; if (fModMass < Tempest::data.fMinPrecursorMass || fModMass > Tempest::data.fMaxPrecursorMass) return; int iModMass = (int) roundf(fModMass / Tempest::data.fPrecursorBinWidth); for (int iBin=iModMass-1; iBin<=iModMass+1 && iBin<=Tempest::data.iNumPrecursorBins; iBin++) { for (eObj* e = Tempest::data.eScanIndex[iBin]; e != 0; e = e->next) { // check mass error if (Tempest::params.bPrecursorTolerancePPM) { if (1000000.0f*fabs(fModMass - (float) e->dPrecursorMass) / fModMass > Tempest::params.fPrecursorTolerance) continue; } else { if (fabs(fModMass - (float) e->dPrecursorMass) > Tempest::params.fPrecursorTolerance) continue; } write_to_buffer(e, cCandidate); if (Tempest::params.decoySearch) { cObj decoyCandidate = cCandidate; decoyCandidate.decoy = 1; //reverse sequence while keeping enzymatic cleavage sites fixed int start = 0; int end = cCandidate.iPeptideLength-1; if (Tempest::params.iDigestSpecificity > 0) if (Tempest::params.iDigestOffset == 0 && cCandidate.cBefore != '-' && Tempest::params.bDigestSites[cCandidate.sPeptide[start]]) start++; else if (Tempest::params.iDigestOffset == 1 && cCandidate.cAfter != '-' && Tempest::params.bDigestSites[cCandidate.sPeptide[end]]) end--; for (; end>=0; start++, end--) decoyCandidate.sPeptide[start] = cCandidate.sPeptide[end]; write_to_buffer(e, decoyCandidate); } } } }
/* Moved from comm.c */ void set_char_color( short AType, CHAR_DATA * ch ) { if( !ch || !ch->desc ) return; if( IS_NPC( ch ) ) return; write_to_buffer( ch->desc, color_str( AType, ch ), 0 ); if( !ch->desc ) { bug( "%s: NULL descriptor after WTB! CH: %s", __func__, ch->name ? ch->name : "Unknown?!?" ); return; } ch->desc->pagecolor = ch->colors[AType]; }