Moving stuff around, nothing to see here
git-svn-id: https://aklabs.dyndns.org/svn/aklabs/trunk/games/wilysays@50 eb184899-6090-47d4-a65b-558f62f6ea1c
This commit is contained in:
andrew
393
net/aklabs/demo/simonsays/Pattern.as
Executable file
393
net/aklabs/demo/simonsays/Pattern.as
Executable file
@@ -0,0 +1,393 @@
|
||||
package net.aklabs.demo.simonsays
|
||||
{
|
||||
import flash.utils.Timer;
|
||||
import flash.events.Event;
|
||||
import flash.events.TimerEvent;
|
||||
import flash.events.EventDispatcher;
|
||||
import flash.display.Sprite;
|
||||
import flash.display.Bitmap;
|
||||
import net.aklabs.demo.simonsays.Mastermind;
|
||||
import net.aklabs.demo.simonsays.Powerup;
|
||||
import net.aklabs.demo.simonsays.PowerupEvent;
|
||||
import net.aklabs.demo.simonsays.Preloader;
|
||||
|
||||
/*
|
||||
* Class Pattern
|
||||
*
|
||||
* This class defines a "pattern", which is where most of the game challenge exists.
|
||||
* It just defines the pattern currently being traced out on the Simon Says/Mastermind/etc
|
||||
*
|
||||
* In addition to doing processing, this class also does some graphical representation,
|
||||
* in the way of a series of red/green lights to show how far along the player is inside the
|
||||
* pattern. The image is 16 pixels wide, and (16*maxSize) pixels tall.
|
||||
*
|
||||
*/
|
||||
public class Pattern extends Sprite
|
||||
{
|
||||
public static var COLOR_BLUE:Number = 0;
|
||||
public static var COLOR_GREEN:Number = 1;
|
||||
public static var COLOR_RED:Number = 2;
|
||||
public static var COLOR_YELLOW:Number = 3;
|
||||
|
||||
protected var patternTimer:Timer; // timer that fires to check pattern logic independently of game timer
|
||||
protected var curIndex:Number; // amount of the pattern currently finished
|
||||
protected var pattern:Array; // the array of colors that make up the actual pattern
|
||||
protected var simon:Mastermind; // A link back up to the parent Mastermind (put here because I didn't want to assume that this.parent would always be correct)
|
||||
protected var delay:Number; // The number of milliseconds that should pass before the logic timer fires
|
||||
protected var playCount:Number; // The number of times this pattern has been played through (via Forgiveness). Not currently used for anything.
|
||||
public var clearTime:Number; // the amount of time the player has (in milliseconds) to finish the pattern
|
||||
public var state:Number; // state of the pattern at current
|
||||
public static var STATE_RUNNING = 0; // STATE : pattern is currently "running" - e.g., waiting for input from the player and checking logic
|
||||
public static var STATE_DEMO = 1; // STATE : pattern is currently "demoing", e.g., flashing the lights up to this.curIndex of the pattern
|
||||
public static var STATE_FAILED = 2; // STATE : pattern is stopped and the player screwed up
|
||||
public static var STATE_CORRECT = 3; // STATE : pattern is stopped and the player got the last iteration correct
|
||||
public static var STATE_STOPPED = 4; // STATE : pattern is just stopped w/ no further info
|
||||
public static var STATE_COMPLETE = 5; // STATE : pattern is stopped because the player has finished all iterations of this pattern
|
||||
public var score:Number; // Score currently built up in this pattern
|
||||
protected var maxSize:Number; // Maximum length of the pattern
|
||||
public var patternPowerups:Array; // array of powerups assigned to any given button on this pattern
|
||||
protected var scoreMultiplier:Number; // Set by powerup, the multiplier for current score (default x1)
|
||||
protected var clearDecrement:Number; // Set by powerup, defines how quickly the pattern's timer runs
|
||||
protected var progressLights:Array; // An array of bitmaps equal in length to the pattern; all the lights up to this.curIndex will be green, the rest are red
|
||||
protected var level:Number; // The level of pattern which this is (mainly used for calculating pattern length, could probly be scrapped)
|
||||
protected var difficulty:Number; // The difficulty of the pattern (used in calculating timer speed)
|
||||
|
||||
/*
|
||||
* Pattern()
|
||||
*
|
||||
* Default constructor
|
||||
*
|
||||
* arguments:
|
||||
* @levelNumber:Number, the level number for which this pattern is being made
|
||||
* @simon:Mastermind, the Mastermind object to which this pattern is to be applied (default null)
|
||||
* @difficulty:Number, the difficulty level for this pattern (default 1)
|
||||
*
|
||||
* Returns: Pattern
|
||||
*/
|
||||
public function Pattern(levelNumber:Number, simon:Mastermind = null, difficulty:Number = 1)
|
||||
{
|
||||
this.state = 0;
|
||||
this.simon = simon;
|
||||
this.level = levelNumber;
|
||||
this.difficulty = difficulty;
|
||||
this.curIndex = -1;
|
||||
this.maxSize = 2+levelNumber; // smallest pattern will never be less than 3 lights total
|
||||
this.pattern = new Array();
|
||||
this.patternPowerups = new Array();
|
||||
this.progressLights = new Array();
|
||||
this.patternTimer = null;
|
||||
this.delay = 1000;
|
||||
this.playCount = 0;
|
||||
this.clearTime = 0;
|
||||
this.score = 0;
|
||||
this.scoreMultiplier = 1;
|
||||
this.clearDecrement = 0;
|
||||
this.patternTimer = new Timer(0);
|
||||
|
||||
this.addEventListener(PowerupEvent.USED_POWERUP, this.onUsedPowerup);
|
||||
|
||||
var preloader:Preloader = Preloader.getInstance();
|
||||
var newLight:Bitmap;
|
||||
// populate all the red lights for this pattern that will turn green as the player goes on
|
||||
for ( var i:Number = 0; i < this.maxSize ; i++ ) {
|
||||
newLight = preloader.getBitmap("gfx_progress_red");
|
||||
newLight.x = 0;
|
||||
newLight.y = i*16;
|
||||
if ( i > 15 ) {
|
||||
newLight.x += 20;
|
||||
newLight.y = (i-15)*16;
|
||||
}
|
||||
this.progressLights.push(newLight);
|
||||
this.addChild(newLight);
|
||||
}
|
||||
this.complexify();
|
||||
}
|
||||
|
||||
/*
|
||||
* patternLength()
|
||||
*
|
||||
* Just a getter for the length of the pattern
|
||||
*
|
||||
* arguments : none
|
||||
*
|
||||
* Returns : Number
|
||||
*/
|
||||
public function patternLength():Number
|
||||
{
|
||||
return this.pattern.length;
|
||||
}
|
||||
|
||||
/*
|
||||
* forceState()
|
||||
*
|
||||
* Forces a given state onto the pattern
|
||||
*
|
||||
* arguments: none
|
||||
*
|
||||
* Returns : none
|
||||
*/
|
||||
public function forceState(state:Number)
|
||||
{
|
||||
this.state = state;
|
||||
}
|
||||
|
||||
/*
|
||||
* complexify()
|
||||
*
|
||||
* This function adds another element to the pattern, so that it becomes a longer pattern, up until the maximum length of the pattern
|
||||
*
|
||||
* arguments: none
|
||||
*
|
||||
* Returns : none
|
||||
*/
|
||||
public function complexify()
|
||||
{
|
||||
// we're complete if we're beyond the maximum size
|
||||
if ( this.pattern.length >= this.maxSize ) {
|
||||
this.stop();
|
||||
this.state = Pattern.STATE_COMPLETE;
|
||||
return null;
|
||||
}
|
||||
// reset the score multiplier and such 'cause complexify only gets called at the end of a round
|
||||
this.scoreMultiplier = 1;
|
||||
this.state = Pattern.STATE_STOPPED;
|
||||
this.stop(); // -- wtf why did I call stop on myself? ...
|
||||
var newcolor = (Math.round(int(Math.random()*4)));
|
||||
this.pattern.push(newcolor);
|
||||
// create a new powerup ~20% of the time that complexify is ran
|
||||
if ( Math.random() < 0.20 ) {
|
||||
var powerup = new Powerup();
|
||||
powerup.pType = (Math.round(int(Math.random()*Powerup.PTYPE_MAXVALUE)));
|
||||
powerup.imgHandle = Powerup.POWERUP_IMAGES[powerup.pType];
|
||||
powerup.sndHandle = Powerup.POWERUP_SOUNDS[powerup.pType];
|
||||
this.patternPowerups.push(powerup);
|
||||
} else {
|
||||
this.patternPowerups.push(null);
|
||||
}
|
||||
this.clearTime = 2000 * ( this.pattern.length );
|
||||
}
|
||||
|
||||
/*
|
||||
* play(lightSimon)
|
||||
*
|
||||
* This function tells the pattern to start playback in one of two modes; demo, or running. Demo mode
|
||||
* just has the pattern playing itself back via the lights on the Mastermind. The running mode doesn't
|
||||
* do any playback, it just checks logic.
|
||||
*
|
||||
* arguments:
|
||||
* @lightSimon:Boolean, set this to True to run in Demo mode (default false)
|
||||
*
|
||||
* Returns : none
|
||||
*/
|
||||
public function play(lightSimon:Boolean = false)
|
||||
{
|
||||
if ( this.patternTimer ) {
|
||||
this.patternTimer.reset()
|
||||
} else {
|
||||
this.patternTimer = new Timer( this.delay );
|
||||
}
|
||||
if ( lightSimon ){
|
||||
this.state = Pattern.STATE_DEMO;
|
||||
this.patternTimer.delay = 1000;
|
||||
this.patternTimer.addEventListener(TimerEvent.TIMER, this.onDemoTimer);
|
||||
} else {
|
||||
this.state = Pattern.STATE_RUNNING;
|
||||
this.patternTimer.delay = 25;
|
||||
this.clearDecrement = this.patternTimer.delay + (this.level*(this.difficulty));
|
||||
this.patternTimer.addEventListener(TimerEvent.TIMER, this.onRunningTimer);
|
||||
}
|
||||
this.patternTimer.start();
|
||||
this.playCount += 1;
|
||||
this.curIndex = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* stop()
|
||||
*
|
||||
* Stop all logic/running status on the pattern
|
||||
*
|
||||
* arguments: none
|
||||
*
|
||||
* Returns : none
|
||||
*/
|
||||
public function stop()
|
||||
{
|
||||
if ( this.patternTimer ) {
|
||||
this.patternTimer.removeEventListener(TimerEvent.TIMER, this.onDemoTimer);
|
||||
this.patternTimer.removeEventListener(TimerEvent.TIMER, this.onRunningTimer);
|
||||
}
|
||||
this.curIndex = -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* getIndex()
|
||||
*
|
||||
* Gets the current value is curIndex
|
||||
*
|
||||
* arguments: none
|
||||
*
|
||||
* Returns : none
|
||||
*/
|
||||
|
||||
public function getIndex()
|
||||
{
|
||||
return this.curIndex;
|
||||
}
|
||||
|
||||
/*
|
||||
* getActive()
|
||||
*
|
||||
* OBSOLETE - gets the currecntly active color. This isn't as useful since the input checking method changed around v0.12.
|
||||
*
|
||||
* arguments: none
|
||||
* Returns : Number, -1 on failure, >= 0 on success
|
||||
*/
|
||||
public function getActive()
|
||||
{
|
||||
if ( (this.curIndex < this.pattern.length) && (this.curIndex >= 0) ) {
|
||||
return this.pattern[this.curIndex];
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/*
|
||||
* resetLights()
|
||||
*
|
||||
* This function makes sure the ratio of red:green lights in the progress lights is correct
|
||||
* according to the value of curIndex
|
||||
*
|
||||
* arguments: none
|
||||
*
|
||||
* Returns: none
|
||||
*/
|
||||
public function resetLights()
|
||||
{
|
||||
var preloader:Preloader = Preloader.getInstance();
|
||||
var newLight:Bitmap;
|
||||
for ( var i:Number = 0; i <= this.curIndex ; i++ ) {
|
||||
// remove any existing red lights and replace them with green lights
|
||||
// if they're at an index < curIndex
|
||||
this.removeChild(this.progressLights[i]);
|
||||
newLight = preloader.getBitmap("gfx_progress_green");
|
||||
newLight.x = this.progressLights[i].x;
|
||||
newLight.y = this.progressLights[i].y;
|
||||
this.progressLights[i] = newLight;
|
||||
this.addChild(this.progressLights[i]);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* colorActive(color)
|
||||
*
|
||||
* Checks to see if the given color is the one currently active on the pattern.
|
||||
* Also updates the current index, modifies state, etc, depending on the result.
|
||||
*
|
||||
* arguments:
|
||||
* @color:Number, the Pattern.COLOR_XXX color you want checked
|
||||
*
|
||||
* Returns: Boolean (Always returns false on a stopped pattern)
|
||||
*/
|
||||
public function colorActive(color:Number):Boolean
|
||||
{
|
||||
if ( this.curIndex == -1 ) {
|
||||
return false;
|
||||
}
|
||||
if ( (this.curIndex < this.pattern.length) && (this.pattern[this.curIndex] == color) ) {
|
||||
// dispatch a PowerupEvent if there is a powerup in this spot at the pattern
|
||||
if ( this.patternPowerups[this.curIndex] != null ) {
|
||||
this.dispatchEvent(new PowerupEvent(PowerupEvent.GOT_POWERUP, this.patternPowerups[this.curIndex]));
|
||||
this.patternPowerups[this.curIndex] = null;
|
||||
}
|
||||
this.resetLights();
|
||||
this.curIndex += 1;
|
||||
this.score += 5;
|
||||
if ( this.curIndex >= this.pattern.length ) {
|
||||
this.curIndex = -1;
|
||||
this.state = Pattern.STATE_CORRECT;
|
||||
this.stop();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
this.state = Pattern.STATE_FAILED;
|
||||
this.stop();
|
||||
return false;
|
||||
}
|
||||
|
||||
/*
|
||||
* onRunningTimer(evt)
|
||||
*
|
||||
* Fires along w/ the runningTimer to check pattern logic
|
||||
*
|
||||
* arguments:
|
||||
* @evt:Event, event firing this function
|
||||
*
|
||||
* Returns : none
|
||||
*/
|
||||
|
||||
public function onRunningTimer(evt:TimerEvent)
|
||||
{
|
||||
if ( (!evt) || (evt.target != this.patternTimer) )
|
||||
return;
|
||||
this.clearTime -= this.clearDecrement;
|
||||
if ( this.clearTime < 0 ) {
|
||||
this.clearTime = 0;
|
||||
this.state = Pattern.STATE_FAILED;
|
||||
this.stop();
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* onDemoTimer(evt)
|
||||
*
|
||||
* Runs every time the Demo timer fires, lighting the buttons in sequence at the right times
|
||||
*
|
||||
* arguments:
|
||||
* @evt:Event, the event firing this function
|
||||
*
|
||||
* Returns : none
|
||||
*/
|
||||
|
||||
public function onDemoTimer(evt:TimerEvent)
|
||||
{
|
||||
if ( (!evt) || (evt.target != this.patternTimer) || (!this.simon) )
|
||||
return;
|
||||
if ( this.curIndex >= this.pattern.length ) {
|
||||
this.state = Pattern.STATE_STOPPED;
|
||||
this.stop();
|
||||
return;
|
||||
}
|
||||
this.simon.lightButton(this.pattern[curIndex], this.patternTimer.delay/2);
|
||||
this.curIndex += 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* onUsedPowerup(evt)
|
||||
*
|
||||
* This function fires whenever a PowerupEvent filters down from the Mastermind, which originally
|
||||
* filtered up from the Player. It processes and applies the effects of any powerups used by the player.
|
||||
*
|
||||
* arguments:
|
||||
* @evt:PowerupEvent, the event firing this function
|
||||
*
|
||||
* Returns: none
|
||||
*/
|
||||
public function onUsedPowerup(evt:PowerupEvent)
|
||||
{
|
||||
var pwup:Powerup = evt.pwup;
|
||||
if ( pwup.pType == Powerup.PTYPE_FORGIVENESS ) {
|
||||
// we don't actually have to *do* anything with a forgiveness ...
|
||||
return;
|
||||
} else if ( pwup.pType == Powerup.PTYPE_SLOWDOWN ) {
|
||||
this.clearDecrement = 1;
|
||||
} else if ( pwup.pType == Powerup.PTYPE_SKIP ) {
|
||||
this.state = Pattern.STATE_CORRECT;
|
||||
this.stop();
|
||||
this.resetLights();
|
||||
} else if ( pwup.pType == Powerup.PTYPE_DOUBLE ) {
|
||||
this.scoreMultiplier = 2;
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user