/*
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];
}
