/////////////////////////////// /// Timers.zh | v1.5 /// /// 24th September, 2014 /// //////////////////////////////////////////// /// Created, and maintained by: ZoriaRPG /// //////////////////////////////////////////// //Array to hold timer values. The index size of each of all of the following arrays MUST be identical. int Timers[10]={0,0,0,0,0,0,0,0,0,0}; //Expand as needed. bool TimersRunning[10]={false,false,false,false,false,false,false,false,false,false}; //Expand as needed. //int TimersStatus[10]={0,0,0,0,0,0,0,0,0,0}; //Reserved for future use. (0 = stopped, 1 = running, 2 = paused). //Timer Type Constants //Set up constants for your timers; remember that the array index starts at '0'. const int TI_MYTIMER_1 = 0; const int TI_MYTIMER_2 = 1; const int TI_MYTIMER_3 = 2; const int TI_MYTIMER_4 = 3; const int TI_MYTIMER_5 = 4; const int TI_MYTIMER_6 = 5; const int TI_MYTIMER_7 = 6; const int TI_MYTIMER_8 = 7; const int TI_MYTIMER_9 = 8; const int TI_MYTIMER_0 = 9; //Timer Standard Duration Values const int TD_TENTH_SECOND = 6; const int TD_QUARTER_SECOND = 15; const int TD_HALF_SECOND = 30; const int TD_ONE_SECOND = 60; const int TD_FIVE_SECONDS = 300; const int TD_SIX_SECONDS = 360; const int TD_TEN_SECONDS = 600; const int TD_FIFTEEN_SECONDS = 900; const int TD_THIRTY_SECONDS = 1800; const int TD_1_MINUTE = 3600; const int TD_2_MINUTES = 7200; const int TD_3_MINUTES = 10800; const int TD_4_MINUTES = 14400; const int TD_5_MINUTES = 18000; //////////////////////////////////////// //Initialisation and Value Manipulation void initTimer(int timer, int value){ if ( Timers[timer] <= 0 ) { Timers[timer] = value; } if ( TimersRunning[timer] == false ) { TimersRunning[timer] = true; } } //Initialises a timer, settign its value, and starting it. If the timer value is not zero, this will fail. void initTimer(int timer, int value, bool forced){ if ( forced == false ) { if ( Timers[timer] <= 0 ) { Timers[timer] = value; } } else if ( forced == true ) { Timers[timer] = value; } if ( TimersRunning[timer] == false ) { TimersRunning[timer] = true; } } //Initialises a timer, settign its value, and starting it. Can force-set a value. void setTimer(int timer, int value){ if ( Timers[timer] <= 0 ) { Timers[timer] = value; } } //Sets the value of a specific timer, if it is zero. //Used to initialise a timer, and to re-set it onced its count reaches zero. void setTimer(int timer, int value, bool forced){ if ( forced == false ) { if ( Timers[timer] <= 0 ) { Timers[timer] = value; } } else if ( forced == true ) { Timers[timer] = value; } } //Sets the value of a specific timer, if it is zero. May be forced to set any value, even if the timer is not zero. void startTimer(int timer){ TimersRunning[timer] = true; } //Starts a timer, without setting, or changing its value. void resumeTimer(int timer){ TimersRunning[timer] = true; } //Resumes a suspended timer; identical to startTimer() in all but name. void suspendTimer(int timer){ TimersRunning[timer]= false; } //Suspends (pauses) a timmer. A suspended timer will not lose value with frame counts. //////////////////////////////////// ///Timer numeric value manipulation. void reduceTimer(int timer){ if (TimersRunning[timer] == true ){ if ( Timers[timer] > 0 ) { Timers[timer] -= 1; } } } //Reduce a specific, running timer by '1'. Use before Waitdraw(); void reduceTimer(int timer, int value){ if (TimersRunning[timer] == true ){ if ( Timers[timer] > 0 ) { Timers[timer] -= value; } } } //Reduce a specific, running timer by 'value'. Use before Waitdraw(); void clearTimer(int timer){ Timers[timer] = 0; TimersRunning[timer] = false; } //Resets the value of a timer (to zero), and disables it. The opposite of initTimer. void changeTimer(int timer, int value){ Timers[timer] = value; } //Changs the value of a timer to any arbitrary value, with no regard to its present value. void increaseTimer(int timer, int value){ Timers[timer] += value; } //Adds an arbitrary amount to a timer void shrinkTimer(int timer, int value){ Timers[timer] -= value; int timerTotal = Timers[timer]; if ( timerTotal == 0 ) { Timers[timer] = 0; } } //Reduces a timer by an arbitrary amount, even if it is not running. If the reduction would cause the timer to be a negative value, this sets its value to '0'. void shrinkTimer(int timer, int value, bool ignore){ Timers[timer] -= value; if ( ignore == false ) { int timerTotal = Timers[timer]; if ( timerTotal == 0 ) { Timers[timer] = 0; } } } //.Reduces a timer by an arbitrary amount, and allows for a ignoring negative values. ////////////////////////////////////// //Check value and operation of timers. //Values of Timer int returnTimer(int timer){ int value = Timers[timer]; return value; } //Returns the value of timer as an integer. //Useful for comparisons, ro events that occur at specific conts of a timer. bool checkTimer(int timer){ if ( Timers[timer] <= 1 ) { return true; } else { return false; } } //Boolean returns true when timer reaches '1', or less. bool checkTimer(int timer, bool precise){ if ( precise == false ) { if ( Timers[timer] <= 1 ) { return true; } else { return false; } } else if ( precise == true ) { if ( Timers[timer] == 0 ) { return true; } else { return false; } } } //Boolean returns true when timer reaches 1, or less. May be forced to be sensitive to exactly zero. bool zeroTimer(int timer){ if ( Timers[timer] == 0 ) { return true; } else { return false; } } //Boolean returns true when timer reaches exactly '0'. bool checkTimer(int timer, int value){ if ( Timers[timer] == value ) { return true; } else { return false; } } //Boolean returns true when timer reaches a specific value. bool checkTimer(int timer, int value, bool orLess){ if ( orLess == true ) { if ( Timers[timer] <= value ) { return true; } else { return false; } } else if ( orLess == false ) { if ( Timers[timer] == value ) { return true; } else { return false; } } } //Boolean returns true when timer reaches a specific value, or less. ///Booleans for Timer Status bool timerRunning(int timer){ bool value = TimersRunning[timer]; return value; } //Returns true is a timer is running, false if 'tisn't. bool timerOn(int timer){ bool value = TimersRunning[timer]; return value; } //Returns true is a timer IS running (ON), false if 'tisn't. bool timerOff(int timer){ bool tOff; bool value = TimersRunning[timer]; if ( value == false ) { tOff = true; } else { tOff = false; } return tOff; } //Returns true is a timer is NOT running (OFF), false if 'tis. //////////////////////// //Multiple Timer Actions /////////////////////////////////// //Reduce - Decrease Multiple Timers void decreaseAllTimers(int value){ int range = SizeOfArray(Timers); int presentValue; for ( int i = 0; 1 < range; i++) { if ( Timers[i] > 0 ) { Timers[i] -= value; } } } //Reduces all timers by value specified; will not reduce a timer below zero. void decreaseAllTimers(int value, bool allowNegative){ int range = SizeOfArray(Timers); int presentValue; for ( int i = 0; 1 < range; i++) { Timers[i] -= value; presentValue = Timers[i]; if ( allowNegative == false && presentValue < 0 ) { Timers[i] = 0; } } } //Reduces all timers, and allows for values below zero. void decreaseRunningTimers(int amount){ int range = SizeOfArray(Timers); bool active; for ( int i = 0; i < range; i++ ){ if ( TimersRunning[i] == true ) { if ( Timers[i] > 0 ) { Timers[i] -= amount; } } } } //Decrease RUNNING timers by arbitrary amount. This will not permnit a timer to drop below zero. void decreaseRunningTimers(int amount, bool allowNegative){ int range = SizeOfArray(Timers); bool active; int presentValue; for ( int i = 0; i < range; i++ ){ if ( TimersRunning[i] == true ) { Timers[i] -= amount; presentValue = Timers[i]; if ( allowNegative == false && presentValue < 0 ) { Timers[i] = 0; } } } } //Decrease RUNNING timers by arbitrary amount. This allows you to permit timers to drop below zero. void decreaseRangeOfTimers(int min, int max, int value){ for ( int i = min; i < max; i++ ){ if ( Timers[i] > 0 ) { Timers[i] -= value; } } } //Reduces range of timers, from timer min, to timer max, by amount value. void decreaseRangeOfTimers(int min, int max, int value, bool allowNegative){ int presentValue; for ( int i = min; i < max; i++ ){ Timers[i] -= value; presentValue = Timers[i]; if ( allowNegative == false && presentValue < 0 ) { Timers[i] = 0; } } } //Reduces range of timers, from timer min, to timer max, by amount value, with option to permit negative values. //////////////////////////// //Increase Multiple Timers void increaseAllTimers(int value){ int range = SizeOfArray(Timers); for ( int i = 0; 1 < range; i++) { if ( Timers[i] > 0 ) { Timers[i] += value; } } } //Increases all timers by arbitrary amount. void increaseRunningTimers(int amount){ int range = SizeOfArray(Timers); for ( int i = 0; i < range; i++ ){ if ( TimersRunning[i] == true ) { Timers[i] += amount; } } } //Increase all RUNNING timers by an arbitrary amount. void increaseRangeOfTimers(int min, int max, int value){ for ( int i = min; i < max; i++ ){ if ( Timers[i] > 0 ) { Timers[i] += value; } } } //Increases range of timers, from timer min, to timer max, by amount value. //////////////// //Clear Commands void clearAllTimers(){ int range = SizeOfArray(Timers); for ( int i = 0; 1 < range; i++) { Timers[i] = 0; } } //Clears all timers back to a value of zero. void clearRunningTimers(){ int range = SizeOfArray(Timers); for ( int i = 0; i < range; i++ ){ if ( TimersRunning[i] == true ) { Timers[i] = 0; } } } //Clears all RUNNING timers, back to a value of zero. void clearSuspendedTimers(){ int range = SizeOfArray(Timers); for ( int i = 0; i < range; i++ ){ if ( TimersRunning[i] == false ) { Timers[i] = 0; } } } //Clears all SUSPENDED timers, back to a value of zero. void clearPausedTimers(){ int range = SizeOfArray(Timers); for ( int i = 0; i < range; i++ ){ if ( TimersRunning[i] == false ) { Timers[i] = 0; } } } //Clears all PAUSED timers, back to a value of zero. void clearStoppedTimers(){ int range = SizeOfArray(Timers); for ( int i = 0; i < range; i++ ){ if ( TimersRunning[i] == false ) { Timers[i] = 0; } } } //Clears all STOPPED timers, back to a value of zero. void clearRangeOfTimers(int min, int max){ for ( int i = min; i < max; i++ ){ if ( Timers[i] > 0 ) { Timers[i] = 0; } } } //Clears specific range of timers, from timer min,to timer max, back to a value of zero //////////////// ///Set Commands void setAllTimers(int value){ int range = SizeOfArray(Timers); for ( int i = 0; 1 < range; i++) { Timers[i] = value; } } //Sets all timers to an arbitrary amount. void setRunningTimers(int amount){ int range = SizeOfArray(Timers); for ( int i = 0; i < range; i++ ){ if ( TimersRunning[i] == true ) { Timers[i] = amount; } } } //Sets all RUNNING timers, to an arbitrary value. void setRangeOfTimers(int min, int max, int value){ for ( int i = min; i < max; i++ ){ if ( Timers[i] > 0 ) { Timers[i] = value; } } } //Sets specific range of timers, to an arbitrary value. //////////////////////////////// //Multiple Timer Status Commands void startAllTimers(){ int range = SizeOfArray(Timers); for ( int i = 0; 1 < range; i++) { if ( TimersRunning[i] == false ) { TimersRunning[i] = true; } } } //Starts all timers - Call this if you have set multiple timers individually. void startRangeOfimers(int min, int max){ for ( int i = min; 1 < max; i++) { if ( TimersRunning[i] == false ) { TimersRunning[i] = true; } } } //Starts range of timers, from timer min, to timer max. void suspendAllTimers(){ int range = SizeOfArray(Timers); for ( int i = 0; 1 < range; i++) { if ( TimersRunning[i] == true ) { TimersRunning[i] = false; } } } //Suspends all timers. void suspendRangeOfTimers(int min, int max){ for ( int i = min; 1 < max; i++) { if ( TimersRunning[i] == true ) { TimersRunning[i] = false; } } } //Suspends range of timers, from timer min, to timer max. void stopAllTimers(){ int range = SizeOfArray(Timers); for ( int i = 0; 1 < range; i++) { if ( TimersRunning[i] == true ) { TimersRunning[i] = false; } } } //Stops all timers. Reserved for future expansion. void stopRangeOfTimers(int min, int max){ for ( int i = min; 1 < max; i++) { if ( TimersRunning[i] == true ) { TimersRunning[i] = false; } } } //Stops range of timers, from timer min, to timer max. Reserved for future expansion, void resumeAllTimers(){ int range = SizeOfArray(Timers); for ( int i = 0; 1 < range; i++) { if ( TimersRunning[i] == false ) { TimersRunning[i] = true; } } } //Resumes all timers. Reserved for future use with TimersPaused[] array. void resumeRangeOfTimers(int min, int max){ for ( int i = min; 1 < max; i++) { if ( TimersRunning[i] == false ) { TimersRunning[i] = true; } } } //Resumes range of timers, from timer min, to timer max. ///////// //Scripts /////////////////////// //Global Script Example global script activeSample{ void run(){ int swap; while(true){ initTimer(TI_MYTIMER_1,( (TD_ONE_SECOND * 3) + TD_HALF_SECOND ) ); reduceTimer(TI_MYTIMER_1,1); Waitdraw(); if ( timerOn(TI_MYTIMER_1) && Link->PressR ) { suspendTimer(TI_MYTIMER_1); } else if ( timerOff(TI_MYTIMER_1) && Link->PressR ) { resumeTimer(TI_MYTIMER_1); } //Trace(returnTimer(TI_MYTIMER_1)); //Prints vale of timer TI_MYTIMER_1 to allegro.log //TraceB(timerRunning(TI_MYTIMER_1)); //Check timer status of TI_MYTIMER_1. Waitframe(); } } } //Copyright (C) 2014 TMGS //Licensed Under: GLPL v2 (Read: https://www.gnu.org/licenses/old-licenses/lgpl-2.0.html)