// displays (renders) the training objectives list
void training_obj_display()
{
char buf[256], *second_line;
int i, t, x, y, z, height, end, offset, bx, by, y_count;
color *c;
if (!Training_obj_num_lines){
return;
}
if ( !hud_gauge_active(HUD_DIRECTIVES_VIEW) ) {
// Always draw the directives display if this is a training mission
if ( !(The_mission.game_type & MISSION_TYPE_TRAINING) ) {
return;
}
}
// don't ever display directives display in multiplayer missions
// if ( Game_mode & GM_MULTIPLAYER ){
// return;
// }
height = gr_get_font_height();
offset = 0;
end = Training_obj_num_lines;
if (end > TRAINING_OBJ_DISPLAY_LINES) {
end = TRAINING_OBJ_DISPLAY_LINES;
offset = Training_obj_num_lines - end;
}
// draw top of objective display
// hud_set_default_color();
hud_set_gauge_color(HUD_DIRECTIVES_VIEW);
GR_AABITMAP(Directive_gauge[0].first_frame, Directive_coords[gr_screen.res][DIRECTIVE_COORDS_TOP][0]+fl2i(HUD_offset_x), Directive_coords[gr_screen.res][DIRECTIVE_COORDS_TOP][1]+fl2i(HUD_offset_y));
// gr_set_bitmap(Directive_gauge[0].first_frame);
// gr_aabitmap(Directive_coords[DIRECTIVE_COORDS_TOP][0]+fl2i(HUD_offset_x), Directive_coords[DIRECTIVE_COORDS_TOP][1]+fl2i(HUD_offset_y));
// print out title
emp_hud_printf(Directive_coords[gr_screen.res][DIRECTIVE_COORDS_TITLE][0]+fl2i(HUD_offset_x), Directive_coords[gr_screen.res][DIRECTIVE_COORDS_TITLE][1]+fl2i(HUD_offset_y), EG_OBJ_TITLE, XSTR( "Directives", 422));
// gr_printf(Directive_coords[DIRECTIVE_COORDS_TITLE][0]+fl2i(HUD_offset_x), Directive_coords[DIRECTIVE_COORDS_TITLE][1]+fl2i(HUD_offset_y), XSTR( "directives", 422));
bx = DIRECTIVE_X+fl2i(HUD_offset_x);
by = Directive_coords[gr_screen.res][DIRECTIVE_COORDS_MIDDLE][1]+fl2i(HUD_offset_y);
y_count = 0;
for (i=0; i<end; i++) {
x = DIRECTIVE_X + 5 + fl2i(HUD_offset_x);
y = Training_obj_window_coords[gr_screen.res][1] + fl2i(HUD_offset_y) + y_count * height + height / 2 + 1;
z = TRAINING_OBJ_LINES_MASK(i + offset);
c = &Color_normal;
if (Training_obj_lines[i + offset] & TRAINING_OBJ_LINES_KEY) {
message_translate_tokens(buf, Mission_events[z].objective_key_text); // remap keys
// gr_set_color_fast(&Color_normal);
c = &Color_bright_green;
} else {
strcpy(buf, Mission_events[z].objective_text);
if (Mission_events[z].count){
sprintf(buf + strlen(buf), NOX(" [%d]"), Mission_events[z].count);
}
#ifndef NO_NETWORK
// if this is a multiplayer tvt game, and this is event is not for my team, don't display it
if((Game_mode & GM_MULTIPLAYER) && (Netgame.type_flags & NG_TYPE_TEAM) && (Net_player != NULL)){
if((Mission_events[z].team != -1) && (Net_player->p_info.team != Mission_events[z].team)){
continue;
}
}
#endif
switch (mission_get_event_status(z)) {
case EVENT_CURRENT:
// gr_set_color_fast(&Color_bright_white);
c = &Color_bright_white;
break;
case EVENT_FAILED:
// gr_set_color_fast(&Color_bright_red);
c = &Color_bright_red;
break;
case EVENT_SATISFIED:
// gr_set_color_fast(&Color_bright_blue);
t = Mission_events[z].satisfied_time;
if (t + i2f(2) > Missiontime) {
if (Missiontime % fl2f(.4f) < fl2f(.2f)){
c = &Color_bright_blue;
} else {
c = &Color_bright_white;
}
} else {
c = &Color_bright_blue;
}
break;
}
}
// maybe split the directives line
second_line = split_str_once(buf, 167);
// blit the background frames
// hud_set_default_color();
hud_set_gauge_color(HUD_DIRECTIVES_VIEW);
GR_AABITMAP(Directive_gauge[1].first_frame, bx, by);
// gr_set_bitmap(Directive_gauge[1].first_frame);
// gr_aabitmap(bx, by);
by += DIRECTIVE_H;
if ( second_line ) {
GR_AABITMAP(Directive_gauge[1].first_frame, bx, by);
// gr_set_bitmap(Directive_gauge[1].first_frame);
// gr_aabitmap(bx, by);
by += DIRECTIVE_H;
}
// blit the text
gr_set_color_fast(c);
emp_hud_string(x, y, EG_OBJ1 + i, buf);
// gr_printf(x, y, buf);
y_count++;
if ( second_line ) {
y = Training_obj_window_coords[gr_screen.res][1] + fl2i(HUD_offset_y) + y_count * height + height / 2 + 1;
emp_hud_string(x+12, y, EG_OBJ1 + i + 1, second_line);
// gr_printf(x+12, y, second_line);
y_count++;
}
}
// draw the bottom of objective display
// hud_set_default_color();
hud_set_gauge_color(HUD_DIRECTIVES_VIEW);
GR_AABITMAP(Directive_gauge[2].first_frame, bx, by);
// gr_set_bitmap(Directive_gauge[2].first_frame);
// gr_aabitmap(bx, by);
}
// ---------------------------------------------------------------------------------------
// hud_show_msg_window() will display the active HUD messages on the HUD. It will scroll
// the messages up when a new message arrives.
//
void hud_show_msg_window()
{
int i, index;
hud_set_default_color();
gr_set_font(FONT1);
HUD_set_clip(MSG_WINDOW_X_START,MSG_WINDOW_Y_START, MSG_WINDOW_WIDTH, MSG_WINDOW_HEIGHT+2);
if ( OLD_ACTIVE_BUFFER_LINES != ACTIVE_BUFFER_LINES ) {
// the size of the message window has changed, the best thing to do is to put all
// the blank out the current hud messages. There is no need to add them to the
// scrollback buffer, since they are already there!
for ( i=0; i < ACTIVE_BUFFER_LINES; i++ ) {
if ( !timestamp_elapsed(HUD_active_msgs_list[i].total_life) ) {
HUD_active_msgs_list[i].total_life = 1;
Active_index=0;
}
}
}
OLD_ACTIVE_BUFFER_LINES = ACTIVE_BUFFER_LINES;
// check if there is a message to display on the HUD, and if there is room to display it
if ( Hud_list_start != Hud_list_end && !Scroll_needed) {
Hud_list_start++;
// if the pointer exceeds the array size, wrap around to element 1. element 0 is not used.
if (Hud_list_start >= SCROLL_BUFFER_LINES)
Hud_list_start = 1;
HUD_active_msgs_list[Active_index].msg = HUD_pending[Hud_list_start];
HUD_active_msgs_list[Active_index].total_life = timestamp(HUD_MESSAGE_TOTAL_LIFE);
for (i=Active_index+1; i < Active_index+ACTIVE_BUFFER_LINES; i++) {
index = i % ACTIVE_BUFFER_LINES;
// determine if there are any existing messages, if so need to scroll them up
if ( !timestamp_elapsed(HUD_active_msgs_list[index].total_life) ) {
HUD_active_msgs_list[index].target_y -= MSG_WINDOW_FONT_HEIGHT;
Scroll_needed=1;
}
}
if (Scroll_needed) {
HUD_active_msgs_list[Active_index].y = (ACTIVE_BUFFER_LINES-1)*MSG_WINDOW_FONT_HEIGHT;
HUD_active_msgs_list[Active_index].target_y = HUD_active_msgs_list[Active_index].y - MSG_WINDOW_FONT_HEIGHT;
}
else {
HUD_active_msgs_list[Active_index].y = (ACTIVE_BUFFER_LINES-2)*MSG_WINDOW_FONT_HEIGHT;
HUD_active_msgs_list[Active_index].target_y = HUD_active_msgs_list[Active_index].y;
}
Active_index++;
if (Active_index >= ACTIVE_BUFFER_LINES) Active_index = 0;
if (Hud_list_end == Hud_list_start) { // just printed the last msg
Hud_list_start = Hud_list_end = 0;
}
}
Scroll_in_progress=0;
Scroll_needed = 0;
for ( i=0; i < ACTIVE_BUFFER_LINES; i++ ) {
if ( !timestamp_elapsed(HUD_active_msgs_list[i].total_life) ) {
if (HUD_active_msgs_list[i].y > HUD_active_msgs_list[i].target_y) {
Scroll_needed=1;
if (timestamp_elapsed(Scroll_time_id) ){
HUD_active_msgs_list[i].y -= SCROLL_STEP_SIZE;
if (HUD_active_msgs_list[i].y < HUD_active_msgs_list[i].target_y)
HUD_active_msgs_list[i].y = HUD_active_msgs_list[i].target_y;
Scroll_in_progress=1;
}
}
if ( hud_gauge_active(HUD_MESSAGE_LINES) ) {
if ( !(Player->flags & PLAYER_FLAGS_MSG_MODE) ) {
// set the appropriate color
if(HUD_active_msgs_list[i].msg.source){
hud_set_gauge_color(HUD_MESSAGE_LINES, HUD_C_BRIGHT);
} else {
hud_set_gauge_color(HUD_MESSAGE_LINES);
}
// print the message out
gr_printf(MSG_WINDOW_X_START + HUD_active_msgs_list[i].msg.x - 2, HUD_active_msgs_list[i].y, "%s", HUD_active_msgs_list[i].msg.text);
}
}
}
} // end for
if (Scroll_in_progress)
Scroll_time_id = timestamp(SCROLL_TIME);
HUD_reset_clip();
}
void mission_eval_goals()
{
int i, result;
// before checking whether or not we should evaluate goals, we should run through the events and
// process any whose timestamp is valid and has expired. This would catch repeating events only
for (i=0; i<Num_mission_events; i++) {
if (Mission_events[i].formula != -1) {
if ( !timestamp_valid(Mission_events[i].timestamp) || !timestamp_elapsed(Mission_events[i].timestamp) ){
continue;
}
// if we get here, then the timestamp on the event has popped -- we should reevaluate
PROFILE("Repeating events", mission_process_event(i));
}
}
if ( !timestamp_elapsed(Mission_goal_timestamp) ){
return;
}
// first evaluate the players goals
for (i=0; i<Num_goals; i++) {
// don't evaluate invalid goals
if (Mission_goals[i].type & INVALID_GOAL){
continue;
}
if (Mission_goals[i].satisfied == GOAL_INCOMPLETE) {
result = eval_sexp(Mission_goals[i].formula);
if ( Sexp_nodes[Mission_goals[i].formula].value == SEXP_KNOWN_FALSE ) {
mission_goal_status_change( i, GOAL_FAILED );
} else if (result) {
mission_goal_status_change(i, GOAL_COMPLETE );
} // end if result
} // end if goals[i].satsified != GOAL_COMPLETE
} // end for
// now evaluate any mission events
for (i=0; i<Num_mission_events; i++) {
if ( Mission_events[i].formula != -1 ) {
// only evaluate this event if the timestamp is not valid. We do this since
// we will evaluate repeatable events at the top of the file so we can get
// the exact interval that the designer asked for.
if ( !timestamp_valid( Mission_events[i].timestamp) ){
PROFILE("Nonrepeating events", mission_process_event( i ));
}
}
}
// send and remaining sexp data to the clients
if (MULTIPLAYER_MASTER) {
multi_sexp_flush_packet();
}
if (The_mission.game_type & MISSION_TYPE_TRAINING){
Mission_goal_timestamp = timestamp(GOAL_TIMESTAMP_TRAINING);
} else {
Mission_goal_timestamp = timestamp(GOAL_TIMESTAMP);
}
if ( !hud_disabled() && hud_gauge_active(HUD_DIRECTIVES_VIEW) ) {
mission_maybe_play_directive_success_sound();
}
// update goal status if playing on a multiplayer standalone server
if (Game_mode & GM_STANDALONE_SERVER){
std_multi_update_goals();
}
Snapshot_all_events = false;
}
void mission_eval_goals()
{
int i, result, goal_changed = 0;
// before checking whether or not we should evaluate goals, we should run through the events and
// process any whose timestamp is valid and has expired. This would catch repeating events only
for (i=0; i<Num_mission_events; i++) {
if (Mission_events[i].formula != -1) {
if ( !timestamp_valid(Mission_events[i].timestamp) || !timestamp_elapsed(Mission_events[i].timestamp) ){
continue;
}
// if we get here, then the timestamp on the event has popped -- we should reevaluate
mission_process_event(i);
}
}
if ( !timestamp_elapsed(Mission_goal_timestamp) ){
return;
}
// first evaluate the players goals
for (i=0; i<Num_goals; i++) {
// don't evaluate invalid goals
if (Mission_goals[i].type & INVALID_GOAL){
continue;
}
if (Mission_goals[i].satisfied == GOAL_INCOMPLETE) {
result = eval_sexp(Mission_goals[i].formula);
if ( Sexp_nodes[Mission_goals[i].formula].value == SEXP_KNOWN_FALSE ) {
goal_changed = 1;
mission_goal_status_change( i, GOAL_FAILED );
} else if (result) {
goal_changed = 1;
mission_goal_status_change(i, GOAL_COMPLETE );
} // end if result
// tell the player how to end the mission
//if ( goal_changed && mission_evaluate_primary_goals() != PRIMARY_GOALS_INCOMPLETE ) {
// HUD_sourced_printf(HUD_SOURCE_IMPORTANT, "Press %s to end mission and return to base", textify_scancode(Control_config[END_MISSION].key_id) );
//}
} // end if goals[i].satsified != GOAL_COMPLETE
} // end for
// now evaluate any mission events
for (i=0; i<Num_mission_events; i++) {
if ( Mission_events[i].formula != -1 ) {
// only evaluate this event if the timestamp is not valid. We do this since
// we will evaluate repeatable events at the top of the file so we can get
// the exact interval that the designer asked for.
if ( !timestamp_valid( Mission_events[i].timestamp) ){
mission_process_event( i );
}
}
}
if (The_mission.game_type & MISSION_TYPE_TRAINING){
Mission_goal_timestamp = timestamp(GOAL_TIMESTAMP_TRAINING);
} else {
Mission_goal_timestamp = timestamp(GOAL_TIMESTAMP);
}
if ( !hud_disabled() && hud_gauge_active(HUD_DIRECTIVES_VIEW) ) {
mission_maybe_play_directive_success_sound();
}
// update goal status if playing on a multiplayer standalone server
if (Game_mode & GM_STANDALONE_SERVER){
std_multi_update_goals();
}
}
