CALLSET_ENTRY (clock_millions, sw_clock_target)
{
if (timed_mode_running_p (&clock_millions_mode))
{
leff_start (LEFF_CLOCK_TARGET);
/* Award bonus if hit 6 times */
if (++clock_mode_hits > 5)
{
sound_send (SND_EXPLOSION_3);
score (SC_20M);
score_add (clock_mode_score, score_table[SC_20M]);
deff_start (DEFF_CLOCK_MILLIONS_EXPLODE);
timed_mode_end (&clock_millions_mode);
}
else
{
sound_send (SND_CLOCK_BELL);
score (SC_5M);
score_add (clock_mode_score, score_table[SC_5M]);
deff_start (DEFF_CLOCK_MILLIONS_HIT);
}
if (!global_flag_test (GLOBAL_FLAG_CHAOSMB_RUNNING))
tz_clock_reverse_direction ();
tz_clock_set_speed (clock_mode_hits);
}
else if (!global_flag_test (GLOBAL_FLAG_CHAOSMB_RUNNING))
{
callset_invoke (sw_jet_noflash);
score (SC_50K);
sound_send (SND_NO_CREDITS);
}
}
static void sssmb_award_jackpot (void)
{
if (!task_kill_gid (GID_SSSMB_JACKPOT_READY))
return;
mball_jackpot_uncollected = FALSE;
sssmb_initial_ramps_to_divert++;
if (feature_config.dixon_anti_cradle == YES)
sssmb_jackpot_value += 5;
score_1M (sssmb_jackpot_value);
leff_start (LEFF_PIANO_JACKPOT_COLLECTED);
deff_start (DEFF_JACKPOT);
deff_start (DEFF_SSSMB_JACKPOT_COLLECTED);
sound_send (SND_EXPLOSION_1);
/* score it */
if (sssmb_jackpot_value < 100)
sssmb_jackpot_value += 10;
sssmb_ramps_to_divert = sssmb_initial_ramps_to_divert;
if (!global_flag_test (GLOBAL_FLAG_SSSMB_RED_JACKPOT)
&& !global_flag_test (GLOBAL_FLAG_SSSMB_ORANGE_JACKPOT)
&& !global_flag_test (GLOBAL_FLAG_SSSMB_YELLOW_JACKPOT))
{
sssmb_relight_all_jackpots ();
}
}
void sw_right_ramp_enter_task (void)
{
/* Decide whether to let the ball onto the mini-playfield,
or dump it. Do this once for each balls that enters the
ramp. */
do {
/* Let it through to the mpf field if allowed */
if (mpf_ready_p ())
{
/* Reset the unlit count so we can
* hint to the player again later */
unlit_right_ramps = 0;
bridge_open_start ();
task_sleep_sec (3);
/* Don't close if another ball is on it's way */
if (right_ramps_entered == 1)
bridge_open_stop ();
}
else
{
/* Ramp was hit unlit, increment the hint counter */
bounded_increment (unlit_right_ramps, 3);
/* tell unlit.c that an unlit shot was made */
award_unlit_shot (SW_RIGHT_RAMP);
/* Show an animation hint if not enabled for mpf */
if ((unlit_right_ramps == 3 || hurryup_active ())
&& !global_flag_test (GLOBAL_FLAG_MULTIBALL_RUNNING))
deff_start (DEFF_SHOOT_HITCH);
else if (global_flag_test (GLOBAL_FLAG_MULTIBALL_RUNNING)
&& global_flag_test (GLOBAL_FLAG_MB_JACKPOT_LIT))
{
deff_start (DEFF_SHOOT_JACKPOT);
}
task_sleep_sec (2);
/* Wait until allowed to kickout */
/* TODO BUG? */
while (kickout_locks > 0)
task_sleep (TIME_100MS);
/* Drop the ball back to the playfield */
sound_send (SND_RIGHT_RAMP_EXIT);
bridge_open_start ();
task_sleep (TIME_300MS);
/* Sleep a bit longer if multiball, so we knock any following
* balls back to the playfield */
if (multi_ball_play ())
task_sleep (TIME_200MS);
bridge_open_stop ();
}
} while (--right_ramps_entered > 0);
/* Failsafe */
bridge_open_stop ();
task_exit ();
}
void special_award (void)
{
callset_invoke (special_award);
switch (system_config.special_award)
{
case FREE_AWARD_CREDIT:
add_credit ();
break;
case FREE_AWARD_EB:
increment_extra_balls ();
break;
case FREE_AWARD_OFF:
break;
}
#ifdef DEFF_SPECIAL
deff_start (DEFF_SPECIAL);
#endif
#ifdef LEFF_SPECIAL
leff_start (LEFF_SPECIAL);
#endif
knocker_fire ();
audit_increment (&system_audits.specials);
}
void newton_bonus_award (void)
{
extern void quickmb_light (void);
newton_next_level += 10;
deff_start (DEFF_NEWTON_BONUS);
quickmb_light ();
}
/* check if all 3 are lit */
void redtgt_check (void)
{
if (global_flag_test (GLOBAL_FLAG_RAFTMODE))
wpm_next_award ();
score (SC_20K);
if (global_flag_test (GLOBAL_FLAG_REDTGT1) && global_flag_test (GLOBAL_FLAG_REDTGT2) && global_flag_test (GLOBAL_FLAG_REDTGT3))
{
redtgt_off ();
if (!flag_test (FLAG_KICKBACKLIT))
{
kickback_enable ();
deff_start (DEFF_REDTGT_KICKBACK);
}
else
{
// if (global_flag_test (GLOBAL_FLAG_RAFTMODE))
// wpm_next_award ();
// raft_award_hazard ();
// else
score (SC_250K);
}
}
}
void prison_break_made (void) {
++prison_break_mode_shots_made;
score_add(prison_break_mode_score, prison_break_mode_last_score);
score_add (prison_break_mode_score_total_score, prison_break_mode_last_score);
score_long (prison_break_mode_last_score);
deff_start (DEFF_PRISON_BREAK_HIT_EFFECT);//under /kernel/deff.c
}//end of function
void award_unlit_shot (U8 unlit_called_from)
{
if (can_award_unlit_shot (unlit_called_from))
{
unlit_shot_count++;
/* Don't allow collecting from Hitchhiker or jets */
if (unlit_shot_count > 4 && unlit_called_from != (SW_HITCHHIKER)
&& unlit_called_from != (SW_BOTTOM_JET))
{
sound_send (SND_JUST_TAKEN_A_DETOUR);
deff_start (DEFF_BACKDOOR_AWARD);
backdoor_award_collected = TRUE;
unlit_shot_count = 0;
callset_invoke (award_door_panel);
}
/* Reset if the player hits the same unlit shot twice */
if (unlit_called_from == unlit_called_from_stored)
unlit_shot_count = 0;
if (unlit_shot_count == 4 )
{
//TODO Check for unlit shots
/* Hint to the player that backdoor award is ready */
sound_send (SND_TWILIGHT_ZONE_SHORT_SOUND);
}
/* Store where we were called from */
unlit_called_from_stored = unlit_called_from;
}
}
static void jets_level_up (void)
{
timer_restart_free (GID_JETS_LEVEL_UP, TIME_2S);
jets_scored = 1;
bounded_increment (jets_bonus_level, 50);
if (jets_for_bonus <= 195)
jets_for_bonus += 5;
award_unlit_shot (SW_BOTTOM_JET);
/* jetscore is used rather than score_deff_get
* because it's likely another score woud of
* happened */
if (jets_bonus_level < 3)
{
score (SC_1M);
jetscore = 1;
}
else if (jets_bonus_level < 5)
{
score (SC_5M);
jetscore = 5;
}
else if (jets_bonus_level < 7)
{
score (SC_10M);
jetscore = 10;
}
if (!timer_find_gid (GID_HITCHHIKER))
deff_start (DEFF_JETS_LEVEL_UP);
}
CALLSET_ENTRY (trivial, bonus)
{
deff_start (DEFF_BONUS);
task_sleep (TIME_1S);
while (deff_get_active () == DEFF_BONUS)
task_sleep (TIME_166MS);
}
/****************************************************************************
* reminder when mode enabled but not started yet
***************************************************************************/
void huxley_reminder_task (void) {
for (;;) {
task_sleep_sec(67);
deff_start (DEFF_HUXLEY_INFO_EFFECT);
}//end of loop
task_exit();
}//end of function
/*******************
* start with all jackpot shots lit and as shots are made decrease # of lights lit
******************/
void fortress_jackpot_made(void) {
++fortress_jackpot_shots_made;
score_add (fortress_score, score_table[FORTRESS_JP_MB_SCORE]);
score (FORTRESS_JP_MB_SCORE);
if (system_config.disable_shaker == NO) {
if (system_config.extra_shaker == YES) shaker_start (SHAKER_HALF_ON, 2);
else shaker_start (SHAKER_ONE_QUARTER_ON, 2);
}//end of shaker call
switch (fortress_jackpot_shots_made % 5) {
case 1: leff_start (LEFF_JACKPOT1); break;
case 2: leff_start (LEFF_JACKPOT2); break;
case 3: leff_start (LEFF_JACKPOT3); break;
case 4: leff_start (LEFF_JACKPOT4); break;
default: leff_start (LEFF_JACKPOT); break;
}
deff_start (DEFF_FORTRESS_JACKPOT_EFFECT);
if (fortress_jackpot_shots_made < 2) choose_multiple_random_jackpot (3); //after 1 made, at most 3 lit
else if (fortress_jackpot_shots_made < 4) choose_multiple_random_jackpot (2); //for 2nd and 3rd, at most 2 lit
else choose_random_jackpot (); //for rest, only 1 lit
if (DM_IN_CAB_TEST) { start_super_jackpot_reminder(); }
else
if (fortress_jackpot_shots_made % 5 == 0) start_super_jackpot_reminder();
}//end of function
//shot made during huxley mode
void huxley_mode_shot_made(void) {
deff_start (DEFF_HUXLEY_HIT_EFFECT);//under /kernel/deff.c
++huxley_mode_shots_made;
score (HUXLEY_MODE_HIT_SCORE);
score_add (huxley_mode_score, score_table[HUXLEY_MODE_HIT_SCORE]);
score_add (huxley_mode_score_total_score, score_table[HUXLEY_MODE_HIT_SCORE]);
}//end of function
void rivcl_increase_class (void)
{
score (SC_20K);
if (riverclass < 6)
{
riverclass++;
deff_start (DEFF_RIVERCLASS);
switch (riverclass)
{
case 2:
speech_start (SND_CLASS2RIVER, SL_3S);
break;
case 3:
speech_start (SND_CLASS3RIVER, SL_3S);
break;
case 4:
speech_start (SND_CLASS4RIVER, SL_3S);
break;
case 5:
speech_start (SND_CLASS5RIVER, SL_3S);
break;
case 6:
speech_start (SND_CLASS6RIVER, SL_4S);
break;
}
}
}
void skill_menu_start(void) {
skill_menu_draw_count = 0;
skill_menu_enabled = 1;
skill_menu_selection = SKILL_ROLLOVER;
dbprintf ("skill_menu_start\n");
deff_start (DEFF_SKILL_MENU);
}
void gangway_loop_collected (void)
{
if (gangway_count == 5 && !gangway_eb_lit_this_ball)
{
gangway_eb_lit_this_ball = TRUE;
light_hard_extra_ball ();
deff_start (DEFF_GANGWAY_EB_LIT);
}
else
{
sample_start (SND_WHEEEE, SL_1S);
lamp_tristate_on (lamplist_index (LAMPLIST_GANGWAYS, gangway_count));
generic_ladder_score_and_advance (&gangway_score_rule);
deff_start (DEFF_GANGWAY_COLLECT);
lamp_tristate_flash (lamplist_index (LAMPLIST_GANGWAYS, gangway_count));
}
}
CALLSET_ENTRY (deadend, sw_dead_end)
{
// device_switch_can_follow (dead_end, slot, TIME_2S + TIME_500MS);
// event_can_follow (dead_end, camera, TIME_2S);
timer_restart_free (GID_DEADEND_TO_SLOT, TIME_4S);
//event_can_follow (camera_or_piano, slot_prox, TIME_5S);
if (lamp_test (LM_DEAD_END))
{
leff_start (LEFF_RIGHT_LOOP);
dead_end_count++;
deff_start_sync (DEFF_DEAD_END);
if (!flag_test (FLAG_SNAKE_READY) && single_ball_play ())
{
flag_on (FLAG_SNAKE_READY);
deff_start_sync (DEFF_SNAKE_READY);
}
switch (dead_end_count)
{
case 1:
score (SC_250K);
timed_game_extend (15);
break;
case 2:
score (SC_500K);
timed_game_extend (20);
break;
case 3:
timed_game_extend (30);
if (extra_ball_lit_from_deadend == FALSE
&& can_award_extra_ball ())
{
score (SC_1M);
light_easy_extra_ball ();
extra_ball_lit_from_deadend = TRUE;
}
else
{
score (SC_10M);
}
dead_end_count = 0;
break;
default:
score (SC_2M);
timed_game_extend (30);
break;
}
lamp_off (LM_DEAD_END);
}
else
{
deff_start (DEFF_INLANE_LIGHTS_DEAD_END);
award_unlit_shot (SW_DEAD_END);
score (SC_100K);
sound_send (SND_TOWN_SQUARE_AWARD);
timed_game_pause (TIME_3S);
}
}
CALLSET_ENTRY (jet, sw_jet)
{
/* Hack for when mpf_exit switch breaks */
if (!multi_ball_play () && mpf_timer > 0)
callset_invoke (sw_mpf_exit);
if (global_flag_test(GLOBAL_FLAG_POWERBALL_IN_PLAY))
jets_scored += 2;
else
jets_scored++;
if (jets_scored >= jets_for_bonus)
{
bounded_increment (jets_bonus_level, 50);
jets_for_bonus += 5;
award_unlit_shot (SW_BOTTOM_JET);
sound_send (SND_GLASS_BREAKS);
task_sleep (TIME_500MS);
/* jetscore is used rather than score_deff_get
* because it's likely another score would of
* happened */
if (jets_bonus_level < 3)
{
score (SC_1M);
jetscore = 1;
}
else if (jets_bonus_level < 5)
{
score (SC_5M);
jetscore = 5;
}
else if (jets_bonus_level < 7)
{
score (SC_10M);
jetscore = 10;
}
if (!timer_find_gid (GID_HITCHHIKER))
deff_start (DEFF_JETS_LEVEL_UP);
}
if (timed_mode_running_p (&tsm_mode))
{
score (SC_500K);
score_add (tsm_mode_total, score_table[SC_500K]);
}
else
{
score (SC_150K);
/* Stop deff from restarting whilst we
* are showing the level up deff
* or when the hitch anim is running */
if ((jets_scored <= jets_for_bonus)
&& (!timer_find_gid (GID_HITCHHIKER)))
deff_restart (DEFF_JETS_HIT);
}
task_create_gid1 (GID_JET_SOUND, sw_jet_sound);
}
/* Start a multiball mode */
void mb_mode_start (struct mb_mode_ops *ops)
{
if (mb_mode_running_p (ops))
return;
task_create_gid1 (ops->gid_running, ops->active_task);
if (ops->deff_starting)
deff_start (ops->deff_starting);
mb_mode_update (ops, MB_ACTIVE);
}
CALLSET_ENTRY (multiball, multiball_start)
{
global_flag_on (GLOBAL_FLAG_SUPER_JACKPOT_LIT);
global_flag_on (GLOBAL_FLAG_MB_JACKPOT_LIT);
callset_invoke (head_enable_divert);
calculate_super_jackpot_value ();
deff_start (DEFF_SUPER_JACKPOT_VALUE);
mb_jackpot_collected = FALSE;
}
//jackpot shot
void cryoprison_jackpot_made(void) {
score_add (cryoprison_score, score_table[CRYOPRISON_JP_MB_SCORE]);
score (CRYOPRISON_JP_MB_SCORE);
deff_start (DEFF_CRYOPRISON_JACKPOT_EFFECT);
choose_multiple_random_jackpot(3);
if (IN_TEST) { start_super_jackpot_reminder(); }
else if (cryoprison_jackpot_shots_made % 5 == 0) start_super_jackpot_reminder();
}//end of function
CALLSET_ENTRY (tz, bonus)
{
deff_start (DEFF_BONUS);
leff_start (LEFF_BONUS);
task_sleep_sec (1);
while (deff_get_active () == DEFF_BONUS)
task_sleep (TIME_66MS);
leff_stop (LEFF_BONUS);
}
static void award_loop (void)
{
/* Start a timer to go down a level after 10 seconds */
if (!task_find_gid (GID_LOOP_LEVEL_TIMER))
task_create_gid (GID_LOOP_LEVEL_TIMER, loop_level_timer_task);
bounded_increment (total_loops, 254);
deff_start (DEFF_LOOP);
}
void fortress_start(U8 num) {
computer_light_temp_off();
is_fortress_running = TRUE;
task_create_gid1 (GID_FORTRESS_START_NOISE, fortress_start_sounds);
fortress_display_counter = 0;
FORT_TOGGLE = 0;
fortress_ballsave = system_config.mb_ballsave;
mb_mode_start(&fortress_mode);
score_add (fortress_score, score_table[FORTRESS_MB_SCORE]);
score (FORTRESS_MB_SCORE);
if (!in_tilt) deff_start (DEFF_FORTRESS_START_EFFECT);
multiball_started();//reset all MB start criteria for next time
diverter_stop();//defined in divhold2.ct
//LIGHTS
if (!in_tilt) {
leff_start (LEFF_MB_START);
lamp_tristate_flash(LM_FORTRESS_MULTIBALL);
task_sleep (TIME_2S);
lamp_tristate_on (LM_FORTRESS_MULTIBALL);
lamp_tristate_off (LM_FREEZE_1);
lamp_tristate_off (LM_FREEZE_2);
lamp_tristate_off (LM_FREEZE_3);
lamp_tristate_off (LM_FREEZE_4);
}
//SOUNDS
if (!in_tilt) {
U8 fortress_SoundCounter;
fortress_SoundCounter = random_scaled(2);//from kernal/random.c - pick number from 0 to 2
if (fortress_SoundCounter == 0)
sound_start (ST_SPEECH, SPCH_SOMETHING_RIGHT_PREV_LIFE, SL_4S, PRI_GAME_QUICK3);
else
sound_start (ST_SPEECH, SPCH_SEND_MANIAC, SL_4S, PRI_GAME_QUICK3);
task_sleep (TIME_3S);
}
//serve balls
if (!in_tilt) {
if (num + live_balls >= 5) set_ball_count (5);
else set_ball_count (num + live_balls);
//task_sleep (TIME_3S);
set_all_jackpots(); //all 6 lit
//start the ball save timer
task_create_gid1 (GID_FORTRESS_BALLSAVE_TIMER, fortress_ballsave_task);
//recount the trough every 5 secs - this is to handle situations
//where too many drains in rapid succession cause the game to lose
//count of live balls - this only happens during MB
callset_invoke (mb_trough_recount_timer_start);
}
//just in case - make sure this is running
ball_search_monitor_start ();
set_dm_mode2(FORTRESS_COMPLETED); //for BONUS
}//end of function
void score_extraball(void) {
ball_search_monitor_stop ();
flag_off(FLAG_IS_EXTRABALL_LIT);
extraball_light_off ();
task_kill_gid(GID_EXTRA_BALL_REMINDER);
increment_extra_balls();
leff_start (LEFF_EXTRABALL);
deff_start (DEFF_EXTRA_BALL_EFFECT);
ball_search_monitor_start ();
}//end of function
static void handle_outlane (void)
{
/* Start a timer to tell the difference between an outlane
* drain and a center drain when the ball reaches the trough. */
event_can_follow (any_outlane, center_drain, TIME_7S);
deff_start (DEFF_BALL_DRAIN_OUTLANE);
if (!multi_ball_play ())
leff_start (LEFF_STROBE_DOWN);
}
/**
* Restart a deff. If the deff is already running, its thread is stopped
* and then restarted. Otherwise, it is treated just like deff_start().
*
* This function is identical to deff_start(), but can be used on a deff
* that is not ordinarily restartable.
*/
void deff_restart (deffnum_t dn)
{
deff_debug ("deff_restart\n");
log_event (SEV_INFO, MOD_DEFF, EV_DEFF_RESTART, dn);
if (deff_running == dn)
deff_start_task (&deff_table[dn]);
else
deff_start (dn);
}
void clock_display_task (void)
{
task_sleep_sec (3);
if (clock_hour <= 6)
sound_send (SPCH_1PM + clock_hour - 1);
else
; /* sound_send (SPCH_7PM + clock_hour - 1); */
deff_start (DEFF_CLOCK_UPDATE);
task_exit ();
}
CALLSET_ENTRY (multiball, award_scoop_jackpot)
{
if (multi_ball_play () && global_flag_test (GLOBAL_FLAG_MB_JACKPOT_LIT))
{
global_flag_off (GLOBAL_FLAG_MB_JACKPOT_LIT);
sound_send (SND_JACKPOT);
score (SC_1M);
deff_start (DEFF_JACKPOT);
}
}
void wasteland_start(U8 num) {
// kill_combos();
computer_light_temp_off();
task_create_gid1 (GID_WASTELAND_START_NOISE, wasteland_start_sounds);
is_wasteland_running = TRUE;
mb_mode_start(&wasteland_mode);
score_add (wasteland_score, score_table[WASTELAND_MB_SCORE]);
score (WASTELAND_MB_SCORE);
wasteland_display_counter = 0;
WL_TOGGLE = 0;
wasteland_ballsave = TRUE;
multiball_started();//reset all MB start criteria for next time
deff_start (DEFF_WASTELAND_START_EFFECT);
diverter_stop();//defined in divhold2.ct
//LIGHTS
leff_start (LEFF_MB_START);
lamp_tristate_flash(LM_WASTELAND_MULTIBALL);
task_sleep (TIME_2S);
lamp_tristate_on (LM_WASTELAND_MULTIBALL);
lamp_tristate_off (LM_FREEZE_1);
lamp_tristate_off (LM_FREEZE_2);
lamp_tristate_off (LM_FREEZE_3);
lamp_tristate_off (LM_FREEZE_4);
//SOUNDS
U8 wasteland_SoundCounter;
wasteland_SoundCounter = random_scaled(2);//from kernal/random.c - pick number from 0 to 2
if (wasteland_SoundCounter == 0)
sound_start (ST_SPEECH, SPCH_IN_THIS_CENTURY, SL_4S, PRI_GAME_QUICK2);
else
sound_start (ST_SPEECH, SPCH_FEEL_GOOD_TOO, SL_4S, PRI_GAME_QUICK2);
task_sleep (TIME_3S);
wasteland_start_music = FALSE; //for to kill the music
//serve balls
if (num + live_balls >= 5) set_ball_count (5);
else set_ball_count (num + live_balls);
task_create_gid1 (GID_WASTELAND_BALL_SAVE, wasteland_ballsave_task);
//task_sleep (TIME_3S);
set_all_jackpots(); //all 6 lit
//recount the trough every 5 secs - this is to handle situations
//where too many drains in rapid succession cause the game to lose
//count of live balls - this only happens during MB
callset_invoke (mb_trough_recount_timer_start);
//just in case - make sure this is running
ball_search_monitor_start ();
set_dm_mode2(WASTELAND_COMPLETED); //for BONUS
}//end of function
