Files
burrow-server/tools/decompiled/game/dolphinRace/DolphinRacePlayer.as
T

1618 lines
53 KiB
ActionScript

package game.dolphinRace
{
import avatar.Avatar;
import avatar.AvatarXtCommManager;
import collection.AccItemCollection;
import com.sbi.corelib.math.RandomSeed;
import com.sbi.graphics.LayerAnim;
import com.sbi.graphics.PaletteHelper;
import flash.display.DisplayObject;
import flash.display.MovieClip;
import flash.display.Sprite;
import flash.filters.GlowFilter;
import game.MinigameManager;
import item.EquippedAvatars;
import item.Item;
import item.ItemXtCommManager;
public class DolphinRacePlayer
{
public static const SOUND_SURFACE_TYPE_OFF:int = 0;
public static const SOUND_SURFACE_TYPE_DEFAULT:int = 1;
public static const SOUND_SURFACE_TYPE_MUD:int = 2;
public static const SOUND_SURFACE_TYPE_WATER:int = 3;
public static const SOUND_SURFACE_TYPE_WEEDS:int = 4;
public static const SOUND_SURFACE_TYPE_HAY:int = 5;
private static const HURDLE_BUFFER_AMOUNT:int = 100;
private static const UPDATE_POSITION_TIME:Number = 0.25;
private static const AI_EMOTE_NONE:int = 0;
private static const AI_EMOTE_JUMP:int = 1;
private static const AI_EMOTE_FALL:int = 2;
public static const SPEED_BOOST_TIMER:Number = 1.5;
public static const MAX_SPEED_BOOST:int = 575;
public static const MAX_SPEED_RUN:int = 425;
public static const MAX_SPEED_FALL:int = 200;
public static const MAX_SPEED_FINISH:int = 200;
public static const BOOST_ACCELERATION:int = 450;
public static const RUN_ACCELERATION:int = 150;
public static const SLOWDOWN_ACCELERATION:int = 650;
public static const STOP_ACCELERATION:int = 350;
public static const JUMP_TIMER:Number = 1.1;
public static const DIVE_TIMER:Number = 1;
public static const ANIM_MOVE:int = 29;
public static const ANIM_JUMP_IN:int = 40;
public static const ANIM_DIVE_IN:int = 41;
public static const ANIM_IDLE_EAST:int = 32;
public static const ANIM_DANCE:int = 38;
private static const _defaultcolors:Array = [1761558272,1718173440,338181888,1063862016];
public var _maxRunSpeed:int = 425;
public var _theGame:DolphinRace;
public var _avatar:DolphinRaceAvatarView;
public var _replacedAvatar:DolphinRaceAvatarView;
public var _animsLoaded:Boolean;
public var _jumpingDivingTimer:Number;
public var _jumpType:Boolean;
public var _playerID:int;
public var _dbID:int;
public var _avID:int;
public var _colors:Array;
public var _trackLane:int;
public var _localPlayer:Boolean;
public var _trackX:Number;
public var _actualX:Number;
public var _startX:Number;
public var _introSpeed:Number;
public var _debugCircle:Sprite;
public var _speedX:Number;
public var _updatePositionTimer:Number;
public var _serverPositionX:Number;
public var _serverVelocityX:Number;
public var _prevPosY:Number;
public var _timeElapsed:Number;
public var _serverPositionY:Number;
public var _trackLayer:MovieClip;
public var _trackRipple:MovieClip;
public var _raceCompleteState:int;
public var _finishPlace:int;
public var _aiGameRandomizer:RandomSeed;
public var _aiRaceRandomizer:RandomSeed;
public var _isAI:Boolean;
public var _aiProfile:DolphinRaceAIProfile;
public var _aiJumpDiveDetector:Number;
public var _name:String;
public var _userName:String;
public var _upcomingHurdleIndex:int;
public var _emote:MovieClip;
public var _aiEmoteTimer:Number;
public var _aiStartLineJumpDiveTimer:Number;
public var _aiEmoteType:int;
public var _laneMarkerIndex:int;
public var _aiHurdleDecide:Array;
public var _speedBoostTimer:Number;
public var _perfectRace:Boolean;
public var _soundSurfaceType:int;
public var _moveAnimationLooped:Boolean;
public var _absoluteX:Number;
public var _playerMarker:Object;
public var _ringCounter:int;
public var _upArrow:Boolean;
public var _downArrow:Boolean;
public var _velY:Number;
public var _waterLevel:Number;
public var _jumpState:int;
public var _customAvId:int;
private var _myGlow:GlowFilter;
private var _accelY:Number = 1000;
private var _gravity:Number = 2000;
private var _exitBoost:Number = 300;
private var _enterBrake:Number = 300;
private var _waterFriction:Number = 0.01;
public function DolphinRacePlayer(param1:DolphinRace)
{
super();
_theGame = param1;
}
public function getPositionX() : Number
{
return _absoluteX;
}
public function setPositionX(param1:Number) : void
{
_absoluteX = param1;
}
public function resetY() : void
{
_trackLayer.parent.y = _waterLevel;
_serverPositionY = _prevPosY = _waterLevel;
_timeElapsed = 0;
_jumpState = 0;
}
public function replacePlayer(param1:DolphinRacePlayer) : void
{
if(param1._avatar && param1._avatar.parent)
{
param1._avatar.parent.removeChild(param1._avatar);
_avatar.parent.removeChild(_avatar);
if(_replacedAvatar == null)
{
_replacedAvatar = _avatar;
}
else
{
_avatar.destroy();
}
_avatar = param1._avatar;
_trackLayer.addChild(_avatar);
}
_absoluteX = param1._absoluteX;
_laneMarkerIndex = param1._laneMarkerIndex;
_jumpingDivingTimer = param1._jumpingDivingTimer;
_trackX = param1._trackX;
_actualX = param1._actualX;
_startX = param1._startX;
_introSpeed = param1._introSpeed;
_speedX = param1._speedX;
_updatePositionTimer = param1._updatePositionTimer;
_serverPositionX = param1._serverPositionX;
_serverVelocityX = param1._serverVelocityX;
_raceCompleteState = param1._raceCompleteState;
_finishPlace = param1._finishPlace;
_upcomingHurdleIndex = param1._upcomingHurdleIndex;
_aiEmoteTimer = 0;
_aiStartLineJumpDiveTimer = 0;
_aiEmoteType = 0;
_aiJumpDiveDetector = 0;
_soundSurfaceType = param1._soundSurfaceType;
_ringCounter = param1._ringCounter;
if(_avatar)
{
_avatar.visible = true;
}
}
public function setupHumanPlayer(param1:int, param2:Boolean, param3:int, param4:int, param5:int, param6:int, param7:int, param8:int, param9:String, param10:String, param11:int) : void
{
_name = param9;
_userName = param10;
_isAI = false;
_avatar = null;
_raceCompleteState = 0;
_serverPositionX = param8;
_localPlayer = param2;
_playerID = param1;
_dbID = param3;
_avID = param4;
_colors = new Array(param5,param6,param7);
_customAvId = param11;
if(_localPlayer)
{
_myGlow = new GlowFilter();
_myGlow.color = 16769024;
_myGlow.blurX = 5;
_myGlow.blurY = 5;
_myGlow.strength = 1.2;
}
}
public function setupAIPlayer(param1:int, param2:int, param3:int, param4:String) : void
{
_name = param4;
_isAI = true;
_aiGameRandomizer = new RandomSeed(param1);
_avatar = null;
_raceCompleteState = 0;
_serverPositionX = param3;
_localPlayer = true;
_playerID = param2;
_dbID = -1;
_avID = -1;
_aiEmoteTimer = 0;
_aiStartLineJumpDiveTimer = 0;
_aiHurdleDecide = [];
_customAvId = -1;
}
public function prepareForStart(param1:int) : void
{
if(_replacedAvatar != null)
{
if(_avatar)
{
if(_avatar.parent)
{
_avatar.parent.removeChild(_avatar);
}
_avatar.destroy();
_avatar = null;
}
_avatar = _replacedAvatar;
_replacedAvatar = null;
_trackLayer.addChild(_avatar);
}
if(_avatar)
{
_avatar.visible = true;
_trackRipple.visible = true;
_trackRipple.splash.visible = true;
_trackRipple.effects.visible = false;
}
_aiEmoteTimer = Math.random() * 30;
_laneMarkerIndex = 0;
_aiJumpDiveDetector = 0;
_upcomingHurdleIndex = 0;
_startX = param1;
_raceCompleteState = 0;
_jumpingDivingTimer = 0;
_speedX = 0;
_serverPositionX = _startX;
_serverVelocityX = 0;
_actualX = _startX;
setPositionX(-100);
_introSpeed = (0.2 + Math.random() * 0.2) * 425;
_speedBoostTimer = 0;
_playerMarker.pMarkerBoostOff();
_ringCounter = 0;
_theGame.updatePearl(_ringCounter);
_perfectRace = true;
if(_animsLoaded)
{
playAnimationState(29);
}
}
public function start() : void
{
_aiEmoteType = 0;
if(_jumpingDivingTimer <= 0)
{
playAnimationState(29);
_soundSurfaceType = 1;
}
else
{
_soundSurfaceType = 0;
}
}
public function percentComplete() : Number
{
if(_raceCompleteState > 0)
{
return 1;
}
return (getPositionX() - _startX) / _theGame._trackLength;
}
private function pickRandomColors() : void
{
var _loc1_:uint = uint(PaletteHelper.avatarPalette1[_aiGameRandomizer.integer(PaletteHelper.avatarPalette1.length)]);
var _loc4_:uint = uint(PaletteHelper.avatarPalette2[_aiGameRandomizer.integer(PaletteHelper.avatarPalette2.length)]);
var _loc5_:uint = uint(PaletteHelper.avatarPalette2[_aiGameRandomizer.integer(PaletteHelper.avatarPalette1.length)]);
var _loc8_:uint = uint(PaletteHelper.avatarPalette2[_aiGameRandomizer.integer(PaletteHelper.avatarPalette1.length)]);
var _loc2_:Array = _avatar.avatarData.colors;
var _loc3_:uint = uint(_loc2_[0]);
var _loc6_:uint = uint(_loc2_[1]);
var _loc7_:uint = uint(_loc2_[2]);
_loc3_ = uint(_loc1_ << 24 | _loc4_ << 16 | (_loc3_ >> 8 & 0xFF) << 8 | _loc3_ & 0xFF);
_loc6_ = uint(_loc5_ << 24 | (_loc6_ >> 16 & 0xFF) << 16 | (_loc6_ >> 8 & 0xFF) << 8 | _loc6_ & 0xFF);
_loc7_ = uint(_loc8_ << 24 | (_loc7_ >> 16 & 0xFF) << 16 | (_loc7_ >> 8 & 0xFF) << 8 | _loc7_ & 0xFF);
_avatar.avatarData.colors = [_loc3_,_loc6_,_loc7_];
}
private function pickEyeAndPattern() : void
{
var _loc1_:Item = null;
var _loc3_:int = 0;
var _loc4_:Vector.<Item> = new Vector.<Item>();
var _loc2_:Vector.<Item> = new Vector.<Item>();
if(_avatar.avatarData.inventoryBodyMod != null)
{
_loc3_ = 0;
while(_loc3_ < _avatar.avatarData.inventoryBodyMod.numItems)
{
_loc1_ = _avatar.avatarData.inventoryBodyMod.itemCollection.getAccItem(_loc3_);
if(_loc1_.layerId == 2)
{
_loc2_.push(_loc1_);
}
else if(_loc1_.layerId == 3)
{
_loc4_.push(_loc1_);
}
_loc3_++;
}
if(_loc2_.length > 0)
{
_loc1_ = _loc2_[_aiGameRandomizer.integer(_loc2_.length)];
if(!_loc1_.getInUse(_avatar.avInvId))
{
_loc1_.forceInUse(true);
_avatar.avatarData.accStateShowAccessory(_loc1_);
}
}
if(_loc4_.length > 0)
{
_loc1_ = _loc4_[_aiGameRandomizer.integer(_loc4_.length)];
if(!_loc1_.getInUse(_avatar.avInvId))
{
_loc1_.forceInUse(true);
_avatar.avatarData.accStateShowAccessory(_loc1_);
}
}
}
}
public function pickRandomClothingItemByLayer(param1:int) : Item
{
var _loc2_:int = 0;
var _loc3_:int = 0;
var _loc6_:Item = null;
var _loc4_:Item = null;
var _loc5_:int = 0;
_loc3_ = _aiGameRandomizer.integer(_theGame._availableItems.length);
_loc2_ = 0;
while(_loc2_ < _theGame._availableItems.length)
{
_loc4_ = _theGame._availableItems[_loc3_];
_loc5_ = _aiGameRandomizer.integer(_theGame._availableItemColors[_loc4_.defId].length);
_loc4_.color = _theGame._availableItemColors[_loc4_.defId][_loc5_];
if(_loc4_.type == 1 && _loc4_.layerId == param1)
{
_loc6_ = new Item();
_loc6_.init(_loc4_.defId,_loc4_.invIdx,_loc4_.color,EquippedAvatars.forced());
return _loc6_;
}
if(++_loc3_ >= _theGame._availableItems.length)
{
_loc3_ = 0;
}
_loc2_++;
}
return null;
}
public function initAIAccessories() : void
{
var _loc3_:AccItemCollection = null;
var _loc1_:int = 0;
var _loc2_:Item = null;
if(_isAI)
{
_loc3_ = new AccItemCollection();
_loc1_ = 0;
while(_loc1_ < _avatar.avatarData.inventoryBodyMod.numItems)
{
_loc3_.pushAccItem(_avatar.avatarData.inventoryBodyMod.itemCollection.getAccItem(_loc1_));
_loc1_++;
}
if(_aiGameRandomizer.integer(100) > 20)
{
_loc2_ = pickRandomClothingItemByLayer(5);
if(_loc2_ != null)
{
_loc3_.pushAccItem(_loc2_);
}
}
if(_aiGameRandomizer.integer(100) > 20)
{
_loc2_ = pickRandomClothingItemByLayer(6);
if(_loc2_ != null)
{
_loc3_.pushAccItem(_loc2_);
}
}
if(_aiGameRandomizer.integer(100) > 20)
{
_loc2_ = pickRandomClothingItemByLayer(8);
if(_loc2_ == null)
{
_loc2_ = pickRandomClothingItemByLayer(9);
if(_loc2_ == null)
{
_loc2_ = pickRandomClothingItemByLayer(10);
}
}
if(_loc2_ != null)
{
_loc3_.pushAccItem(_loc2_);
}
}
if(_loc3_.length > _avatar.avatarData.inventoryBodyMod.numItems)
{
_avatar.avatarData.itemResponseIntegrate(_loc3_);
}
pickRandomColors();
pickEyeAndPattern();
}
}
public function initFinalize(param1:String = null) : void
{
var _loc2_:Array = null;
if(_avatar != null)
{
_avatar.InitDolphinRaceAvatarView();
_trackLayer.addChild(_avatar);
_emote = GETDEFINITIONBYNAME("DolphinRace_emote_popup");
_avatar.addChild(_emote);
if(_isAI)
{
initAIAccessories();
}
_loc2_ = new Array(6);
_loc2_[0] = 40;
_loc2_[1] = 29;
_loc2_[2] = 32;
_loc2_[3] = 38;
_loc2_[4] = 41;
_avatar.preloadAnims(_loc2_,redrawCallback);
}
}
public function init(param1:MovieClip, param2:int, param3:MovieClip) : void
{
var _loc4_:Avatar = new Avatar();
_avatar = new DolphinRaceAvatarView();
_avatar.init(_loc4_);
_soundSurfaceType = 0;
_trackLayer = param1;
_trackRipple = param3;
_avatar.visible = false;
_animsLoaded = false;
_serverVelocityX = 0;
_trackX = 0;
_speedX = 0;
_jumpingDivingTimer = 0;
_updatePositionTimer = 0;
_trackLane = param2;
setPositionX(_serverPositionX);
_avatar.x = 30;
_avatar.y = 35;
_velY = 0;
_waterLevel = _trackLayer.parent.y;
_serverPositionY = _prevPosY = _waterLevel;
_timeElapsed = 0;
_playerMarker = GETDEFINITIONBYNAME("DolphinRace_playerMarker");
_playerMarker.pMarkerPlayer(1);
_playerMarker.x = 0;
_playerMarker.y = 0;
_trackLayer.addChildAt(_playerMarker as DisplayObject,0);
if(_isAI)
{
_loc4_.init(-1,-1,"DolphinRaceAI" + _trackLane,19,[0,0,0],_customAvId,null,"",-1,1);
_loc4_.itemResponseIntegrate(ItemXtCommManager.generateBodyModList(19,0,0,false));
}
else
{
if(_avID != -1)
{
_loc4_.init(_avID,-1,"DolphinRace" + _trackLane,19,_colors,_customAvId,null,_userName,-1,1);
AvatarXtCommManager.requestADForAvatar(_avID,true,initFinalize,_loc4_);
}
else
{
_loc4_.init(-1,-1,"DolphinRace" + _trackLane,19,[_defaultcolors[param2],_defaultcolors[param2],1073692671],_customAvId,null,"",-1,1);
_loc4_.itemResponseIntegrate(ItemXtCommManager.generateBodyModList(19,11,2,false));
initFinalize();
}
if(_localPlayer)
{
_avatar.filters = [_myGlow];
}
}
}
private function redrawCallback(param1:LayerAnim) : void
{
if(param1 && _avatar)
{
playAnimationState(29);
if(_debugCircle)
{
_trackLayer.addChild(_debugCircle);
}
_animsLoaded = true;
}
}
public function remove() : void
{
if(_avatar)
{
if(_avatar.parent)
{
_avatar.parent.removeChild(_avatar);
}
_avatar.destroy();
_avatar = null;
}
if(_replacedAvatar)
{
if(_replacedAvatar.parent)
{
_replacedAvatar.parent.removeChild(_replacedAvatar);
}
_replacedAvatar.destroy();
_replacedAvatar = null;
}
}
public function showEmote(param1:int) : void
{
if(_emote != null && param1 >= 1 && param1 <= 6)
{
_emote.setEmote(param1);
}
}
public function setAIRaceRanomizer(param1:int) : void
{
var _loc2_:int = 0;
_aiRaceRandomizer = new RandomSeed(param1);
_aiProfile = _theGame._aiProfiles[_aiRaceRandomizer.integer(0,_theGame._aiProfiles.length)];
if(_aiHurdleDecide.length > 0)
{
_aiHurdleDecide.splice(0,_aiHurdleDecide.length);
}
_loc2_ = 0;
while(_loc2_ < 64)
{
_aiHurdleDecide.push(_aiRaceRandomizer.integer(100) < _aiProfile._jumpDetectionProbability);
_loc2_++;
}
}
public function receiveFall() : void
{
_serverVelocityX = 200;
}
public function receiveJump(param1:Number) : void
{
_jumpState = 1;
_velY = param1;
_prevPosY = _trackLayer.parent.y;
_timeElapsed = 0;
}
public function receivePositionData(param1:int, param2:int, param3:int, param4:int) : void
{
_serverPositionX = param1;
_serverPositionY = param2;
_serverVelocityX = param3;
_prevPosY = _trackLayer.parent.y;
_timeElapsed = 0;
if(_jumpState == 2)
{
_jumpState = 0;
}
switch(param4 - 1)
{
case 0:
if(_jumpingDivingTimer <= 0)
{
doJump();
}
break;
case 1:
if(_jumpingDivingTimer <= 0)
{
doDive();
}
break;
case 2:
_raceCompleteState = 1;
break;
case 3:
if(_raceCompleteState != 2)
{
_raceCompleteState = 2;
if(_theGame._gameState == 5)
{
playAnimationState(38);
}
}
_soundSurfaceType = 0;
}
}
public function updateJumptimer(param1:Number) : void
{
var _loc2_:int = 0;
var _loc3_:int = 0;
if(_jumpingDivingTimer > 0)
{
_jumpingDivingTimer -= param1;
if(_jumpType == true)
{
_loc3_ = 26;
_loc2_ = _loc3_ - Math.round(_jumpingDivingTimer * _loc3_ / 1.1);
if(_loc2_ <= 5)
{
_loc2_ += 21;
}
else if(Object(_trackLayer.parent).double)
{
_loc2_ = 46 - _loc3_ + _loc2_ + 1;
}
else
{
_loc2_ = 106 - _loc3_ + _loc2_ + 1;
}
Object(_trackLayer.parent).gotoAndPlay(_loc2_);
}
else
{
if(Object(_trackLayer.parent).double)
{
_loc3_ = 34;
_loc2_ = _loc3_ - Math.round(_jumpingDivingTimer * _loc3_ / 1);
if(_loc2_ <= 5)
{
_loc2_ += 47;
}
else
{
_loc2_ = 80 - _loc3_ + _loc2_ + 1;
}
}
else
{
_loc3_ = 24;
_loc2_ = _loc3_ - Math.round(_jumpingDivingTimer * _loc3_ / 1);
if(_loc2_ <= 5)
{
_loc2_ += 47;
}
else
{
_loc2_ = 130 - _loc3_ + _loc2_ + 1;
}
}
Object(_trackLayer.parent).gotoAndPlay(_loc2_);
}
if(_jumpingDivingTimer <= 0 || (_trackLayer.parent as Object).ready == true)
{
(_trackLayer.parent as MovieClip).gotoAndPlay("idle");
_trackRipple.gotoAndPlay("idle");
if(_isAI)
{
_theGame.setWaterEffectVisibility(parseInt(_trackLayer.parent.name.charAt(_trackLayer.parent.name.length - 1)),true);
}
cancelJump();
}
}
}
public function heartbeatIntro(param1:Number) : Boolean
{
var _loc2_:Number = NaN;
if(_avatar != null)
{
updateJumptimer(param1);
if(getPositionX() < _startX)
{
_loc2_ = _introSpeed * param1;
setPositionX(getPositionX() + _loc2_);
if(getPositionX() >= _startX)
{
setPositionX(_startX);
playAnimationState(32);
_soundSurfaceType = 0;
}
else
{
_soundSurfaceType = 1;
}
}
if(_isAI)
{
if(_jumpingDivingTimer <= 0)
{
if(_aiStartLineJumpDiveTimer > 0)
{
_aiStartLineJumpDiveTimer -= param1;
if(_aiStartLineJumpDiveTimer <= 0)
{
if(Math.random() < 0.5)
{
jump(true);
_trackRipple.visible = false;
_theGame.setWaterEffectVisibility(parseInt(_trackLayer.parent.name.charAt(_trackLayer.parent.name.length - 1)),false);
}
else
{
dive(true);
_trackRipple.visible = false;
_theGame.setWaterEffectVisibility(parseInt(_trackLayer.parent.name.charAt(_trackLayer.parent.name.length - 1)),false);
}
}
}
else
{
_aiStartLineJumpDiveTimer = Math.random() * 2 + 0.25;
}
}
if(_aiEmoteTimer > 0)
{
_aiEmoteTimer -= param1;
if(_aiEmoteTimer <= 0)
{
showEmote(Math.random() * 6 + 1);
}
}
}
return getPositionX() == _startX;
}
return false;
}
public function heartbeat(param1:Number) : void
{
var _loc12_:int = 0;
var _loc11_:DolphinRaceHurdle = null;
var _loc18_:Number = NaN;
var _loc9_:Number = NaN;
var _loc2_:Array = null;
var _loc13_:int = 0;
var _loc10_:Boolean = false;
var _loc21_:int = 0;
var _loc7_:Number = NaN;
var _loc19_:Number = NaN;
var _loc23_:MovieClip = null;
var _loc8_:Number = NaN;
var _loc6_:Number = NaN;
var _loc3_:int = 0;
var _loc16_:int = 0;
var _loc4_:Array = null;
var _loc20_:int = 0;
var _loc17_:int = 0;
var _loc22_:Number = NaN;
var _loc14_:Boolean = false;
var _loc5_:Number = _maxRunSpeed;
var _loc15_:Number = 150;
updateJumptimer(param1);
if(_speedBoostTimer > 0)
{
_speedBoostTimer -= param1;
if(_speedBoostTimer > 0)
{
_loc5_ = 575;
_loc15_ = 450;
}
else
{
cancelTurbo();
}
}
if(_animsLoaded == true)
{
_loc10_ = false;
_avatar.heartbeat();
if(_localPlayer)
{
if(_isAI)
{
if(_aiEmoteTimer > 0)
{
_aiEmoteTimer -= param1;
if(_aiEmoteTimer <= 0)
{
_loc21_ = 0;
switch(_aiEmoteType - 1)
{
case 0:
_loc21_ = Math.random() * 4 + 1;
break;
case 1:
_loc21_ = Math.random() * 3 + 4;
}
if(_loc21_ >= 1 && _loc21_ <= 6)
{
showEmote(_loc21_);
_aiEmoteTimer = 5 + Math.random() * 4;
}
_aiEmoteType = 0;
}
}
}
_loc7_ = _trackLayer.parent.y;
updateY(param1);
if(_raceCompleteState > 0)
{
if(_raceCompleteState == 1)
{
if(getPositionX() < _theGame._trackLength + _startX + 200 + 100 * _trackLane)
{
_theGame.noMotionEffects();
_theGame.setWaterEffectVisibility(parseInt(_trackLayer.parent.name.charAt(_trackLayer.parent.name.length - 1)),false);
_trackRipple.visible = false;
if(_speedX > 200)
{
_speedX -= param1 * 350;
if(_speedX < 200)
{
_speedX = 200;
}
}
else if(_speedX < 200)
{
_speedX += param1 * 350;
if(_speedX > 200)
{
_speedX = 200;
}
}
}
else
{
_soundSurfaceType = 0;
_raceCompleteState = 2;
_speedX = 0;
_loc14_ = true;
playAnimationState(38);
setPositionX(_theGame._trackLength + _startX + 200 + 100 * _trackLane);
}
}
}
else if(_speedX < _loc5_)
{
_speedX += param1 * _loc15_;
if(_speedX > _loc5_)
{
_speedX = _loc5_;
}
}
else if(_speedX > _loc5_)
{
_speedX -= param1 * 650;
if(_speedX < _loc5_)
{
_speedX = _loc5_;
}
}
else
{
(_trackLayer.parent as Object).flickerOff();
}
_loc9_ = getPositionX();
_loc19_ = _speedX * param1;
_loc23_ = (_trackLayer.parent as Object).collision;
_loc8_ = _loc9_ + _loc23_.x - _loc23_.width / 2;
_loc6_ = _trackLayer.parent.y + _loc23_.y - _loc23_.height / 2;
while(_upcomingHurdleIndex < _theGame._theHurdles.length)
{
_loc11_ = _theGame._theHurdles[_upcomingHurdleIndex];
if(_loc8_ < _loc11_.getRightEdgeX())
{
break;
}
_upcomingHurdleIndex = _upcomingHurdleIndex + 1;
}
_loc3_ = _upcomingHurdleIndex;
_loc16_ = -1;
_loc4_ = [false,false,false,false,false];
while(_loc3_ < _theGame._theHurdles.length)
{
_loc11_ = _theGame._theHurdles[_loc3_];
if(_isAI && _jumpingDivingTimer <= 0 && _raceCompleteState == 0 && _aiHurdleDecide[_upcomingHurdleIndex % _aiHurdleDecide.length])
{
_loc20_ = 0;
if(_aiProfile)
{
_loc20_ = _aiProfile._jumpDetectionDistance;
}
if(_loc11_._spawnX - _loc20_ >= _loc9_ && _loc11_._spawnX - _loc20_ <= _loc9_ + _loc19_)
{
if(_loc11_._type == 1)
{
_loc16_ = _loc11_._class;
}
else
{
switch(_loc11_._class)
{
case 0:
case 1:
case 2:
case 3:
case 4:
_loc4_[_loc11_._class] = true;
break;
case 5:
_loc4_[1] = true;
_loc4_[2] = true;
break;
case 6:
_loc4_[1] = true;
_loc4_[3] = true;
break;
case 8:
_loc4_[0] = true;
_loc4_[1] = true;
_loc4_[2] = true;
break;
case 9:
_loc4_[4] = true;
_loc4_[3] = true;
_loc4_[2] = true;
}
}
}
}
if(_loc8_ + _loc23_.width + 2 * _loc20_ < _loc11_.getLeftEdgeX())
{
break;
}
_loc17_ = _loc11_.testCollision(_loc8_,_loc23_.width,_loc6_,_loc23_.height,_trackLane,!_isAI);
if(_loc17_ > 0)
{
if(!_isAI && _loc11_._debugmc)
{
if(_loc11_._type == 1)
{
_loc11_._debugmc.visible = false;
(_trackLayer.parent as Object).getRing();
}
else
{
_loc11_._debugmc.bump(_loc17_);
}
}
if(_raceCompleteState == 0)
{
if(_loc11_._type == 2)
{
handleFall();
}
else
{
_ringCounter = _ringCounter + 1;
if(_ringCounter >= 3)
{
boost(false);
}
if(_speedBoostTimer <= 0 && _localPlayer && !_isAI)
{
_theGame.updatePearl(_ringCounter);
}
}
if(_isAI && _aiEmoteTimer <= 0 && Math.random() < 0.25)
{
_aiEmoteType = 2;
_aiEmoteTimer = Math.random() * 2;
}
}
}
_loc3_++;
}
if(_loc16_ == -1)
{
if(_loc4_[2])
{
if(_aiRaceRandomizer.integer(100) < 50)
{
if(!_loc4_[0])
{
_loc16_ = 0;
}
else if(!_loc4_[1])
{
_loc16_ = 1;
}
else if(!_loc4_[3])
{
_loc16_ = 3;
}
else
{
_loc16_ = 4;
}
}
else if(!_loc4_[4])
{
_loc16_ = 4;
}
else if(!_loc4_[3])
{
_loc16_ = 3;
}
else if(!_loc4_[1])
{
_loc16_ = 1;
}
else
{
_loc16_ = 0;
}
}
}
if(_loc16_ != -1)
{
switch(_loc16_)
{
case 0:
jump(true);
break;
case 1:
jump(true);
jump(false);
break;
case 3:
dive(true);
dive(false);
break;
case 4:
dive(true);
}
if(_aiEmoteTimer <= 0 && Math.random() < 0.25)
{
_aiEmoteType = 1;
_aiEmoteTimer = Math.random() * 2;
}
}
_trackX = _loc19_;
setPositionX(getPositionX() + _trackX);
if(_raceCompleteState == 0)
{
if(getPositionX() > _theGame._trackLength + _startX)
{
_raceCompleteState = 1;
_loc14_ = true;
}
if(!_isAI && getPositionX() > _theGame._trackLength + _startX - 800)
{
_theGame.addFinishBuoy(950);
}
}
if(_raceCompleteState == 0 || _speedX != 0)
{
_updatePositionTimer += param1;
}
if(_updatePositionTimer >= 0.25 || _loc14_)
{
if(_isAI == false || _loc14_)
{
_loc13_ = 0;
_loc2_ = [];
_loc2_[_loc13_++] = "pos";
_loc2_[_loc13_++] = _isAI ? -(_playerID + 1) : _playerID + 1;
_loc2_[_loc13_++] = String(int(getPositionX()));
_loc2_[_loc13_++] = String(int(_trackLayer.parent.y));
_loc2_[_loc13_++] = String(int(_speedX));
if(_raceCompleteState > 0)
{
if(_raceCompleteState == 2)
{
_loc2_[_loc13_++] = "4";
}
else
{
_loc2_[_loc13_++] = "3";
}
}
else if(_jumpingDivingTimer > 0)
{
if(_jumpType == false)
{
_loc2_[_loc13_++] = "2";
}
else
{
_loc2_[_loc13_++] = "1";
}
}
else
{
_loc2_[_loc13_++] = "0";
}
MinigameManager.msg(_loc2_);
_updatePositionTimer = 0;
}
_loc10_ = _speedX > 0;
}
}
else
{
if(_raceCompleteState > 0)
{
if(_raceCompleteState == 1)
{
if(_serverVelocityX > 200)
{
_serverVelocityX -= param1 * 350;
if(_serverVelocityX < 200)
{
_serverVelocityX = 200;
}
}
else if(_serverVelocityX < 200)
{
_serverVelocityX += param1 * 350;
if(_serverVelocityX > 200)
{
_serverVelocityX = 200;
}
}
}
else
{
_serverVelocityX = 0;
_serverPositionX = _theGame._trackLength + _startX + 200 + 100 * _trackLane;
}
}
else if(_serverVelocityX < _loc5_)
{
_serverVelocityX += param1 * _loc15_;
if(_serverVelocityX > _loc5_)
{
_serverVelocityX = _loc5_;
}
}
else if(_serverVelocityX > _loc5_)
{
_serverVelocityX -= param1 * 650;
if(_serverVelocityX < _loc5_)
{
_serverVelocityX = _loc5_;
}
}
_serverPositionX += _serverVelocityX * param1;
if(_serverPositionX > _theGame._trackLength + _startX + 200 + 100 * _trackLane)
{
_serverPositionX = _theGame._trackLength + _startX + 200 + 100 * _trackLane;
}
_loc22_ = _serverPositionX - getPositionX();
setPositionX(getPositionX() + _loc22_ * 0.25);
_loc10_ = _serverPositionX > 0;
interpolateY(param1);
if(_loc10_)
{
_loc9_ = getPositionX();
_loc23_ = (_trackLayer.parent as Object).collision;
_loc8_ = _loc9_ + _loc23_.x - _loc23_.width / 2;
_loc6_ = _trackLayer.parent.y + _loc23_.y - _loc23_.height / 2;
_loc3_ = _upcomingHurdleIndex;
while(_loc3_ < _theGame._theHurdles.length)
{
_loc11_ = _theGame._theHurdles[_loc3_];
if(_loc8_ + _loc23_.width < _loc11_.getLeftEdgeX())
{
break;
}
if(_loc11_.testCollision(_loc8_,_loc23_.width,_loc6_,_loc23_.height,_trackLane,false))
{
if(_loc11_._type == 2)
{
handleFall();
}
}
_loc3_++;
}
}
}
_actualX = Math.min(getPositionX(),_theGame._trackLength + _startX);
}
}
public function interpolateY(param1:Number) : void
{
var _loc2_:Number = NaN;
var _loc3_:Number = NaN;
if(_jumpState == 0)
{
_timeElapsed += param1;
_loc3_ = Math.min(_timeElapsed / 0.25,1);
_trackLayer.parent.y = (1 - _loc3_) * _prevPosY + _loc3_ * _serverPositionY;
}
else if(_jumpState == 1)
{
if(_trackLayer.parent.y > _waterLevel + 20)
{
_timeElapsed += param1;
_loc3_ = Math.min(_timeElapsed / 0.25,1);
_trackLayer.parent.y = (1 - _loc3_) * _prevPosY + _loc3_ * _waterLevel;
}
else
{
_velY += _gravity * param1;
_loc2_ = _trackLayer.parent.y;
_trackLayer.parent.y += _velY * param1;
if(_velY > 0 && _loc2_ <= _waterLevel && _trackLayer.parent.y > _waterLevel)
{
_jumpState = 2;
_velY -= _enterBrake;
if(_velY < 0)
{
_velY = 0;
}
_trackRipple.diveSplash();
}
}
}
else
{
if(_velY > 0)
{
_velY -= _accelY * param1 * _waterFriction * _velY;
_velY = Math.max(_velY,0);
}
else if(_velY < 0)
{
_velY -= _accelY * param1 * _waterFriction * _velY;
_velY = Math.min(_velY,0);
}
_trackLayer.parent.y += _velY * param1;
}
}
public function updateY(param1:Number) : void
{
var _loc4_:int = 0;
var _loc2_:Array = null;
if(_trackLayer.parent.y >= _waterLevel)
{
if(_upArrow && _raceCompleteState != 2)
{
if(_velY >= 0)
{
_velY -= 100;
}
_velY -= _accelY * param1;
}
else if(_downArrow && _raceCompleteState != 2 && 450 > _trackLayer.parent.y + _velY / (_accelY * _waterFriction))
{
if(_velY <= 0)
{
_velY += 100;
}
_velY += _accelY * param1;
}
else if(_velY > 0)
{
_velY -= _accelY * param1 * _waterFriction * _velY;
_velY = Math.max(_velY,0);
}
else if(_velY < 0)
{
_velY -= _accelY * param1 * _waterFriction * _velY;
_velY = Math.min(_velY,0);
}
}
else
{
_velY += _gravity * param1;
}
var _loc3_:Number = _trackLayer.parent.y;
_trackLayer.parent.y += _velY * param1;
if(_loc3_ >= _waterLevel && _trackLayer.parent.y < _waterLevel)
{
_velY -= _exitBoost;
_theGame._soundMan.playByName(_theGame._soundNameAJDolphinWaterExit);
_trackRipple.jumpSplash();
_loc4_ = 0;
_loc2_ = [];
_loc2_[_loc4_++] = "jump";
_loc2_[_loc4_++] = String(int(_velY));
MinigameManager.msg(_loc2_);
}
else if(_loc3_ <= _waterLevel && _trackLayer.parent.y > _waterLevel)
{
_velY -= _enterBrake;
if(_velY < 0)
{
_velY = 0;
}
_theGame._soundMan.playByName(_theGame._soundNameAJDolphinWaterEnter);
_trackRipple.diveSplash();
}
if(_theGame._gameState != 5)
{
_updatePositionTimer += param1;
if(_updatePositionTimer >= 0.25)
{
_loc4_ = 0;
_loc2_ = [];
_loc2_[_loc4_++] = "pos";
_loc2_[_loc4_++] = _isAI ? -(_playerID + 1) : _playerID + 1;
_loc2_[_loc4_++] = String(int(getPositionX()));
_loc2_[_loc4_++] = String(int(_trackLayer.parent.y));
_loc2_[_loc4_++] = String(int(_speedX));
_loc2_[_loc4_++] = "0";
MinigameManager.msg(_loc2_);
_updatePositionTimer = 0;
}
}
}
private function playAnimationState(param1:int) : void
{
var _loc2_:Function = null;
var _loc3_:int = 0;
_moveAnimationLooped = false;
switch(param1 - 29)
{
case 0:
_moveAnimationLooped = true;
_loc2_ = animationAtEnd;
break;
case 3:
_jumpingDivingTimer = 0;
_speedX = 0;
break;
case 9:
_jumpingDivingTimer = 0;
_speedX = 0;
break;
case 11:
_jumpingDivingTimer = 1.1;
_loc3_ = 1;
_loc2_ = animationAtEnd;
_jumpType = true;
break;
case 12:
_jumpingDivingTimer = 1;
_loc3_ = 1;
_loc2_ = animationAtEnd;
_jumpType = false;
}
_avatar.playAnim(param1,false,_loc3_,_loc2_);
}
private function handleFall() : void
{
var _loc1_:Array = null;
_ringCounter = 0;
cancelTurbo();
if(_speedX > 200)
{
_speedX = 200;
(_trackLayer.parent as Object).flickerOn();
}
if(!_isAI && _localPlayer)
{
_loc1_ = [];
_loc1_[0] = "fall";
_loc1_[1] = _playerID + 1;
MinigameManager.msg(_loc1_);
}
}
private function animationAtEnd(param1:LayerAnim, param2:int) : void
{
if(_avatar && param1)
{
switch(param2 - 29)
{
case 0:
_moveAnimationLooped = true;
if(_localPlayer && !_isAI)
{
_theGame._soundMan.playByName(_theGame._soundNameAJDolphinSwim);
}
break;
case 11:
cancelJump();
break;
case 12:
cancelJump();
}
}
}
public function cancelTurbo() : void
{
_speedBoostTimer = 0;
_theGame.boost(parseInt(_trackLayer.parent.name.charAt(_trackLayer.parent.name.length - 1)),false);
if(_localPlayer && !_isAI)
{
_theGame.updatePearl(_ringCounter);
}
}
public function cancelJump() : void
{
_jumpingDivingTimer = 0;
if(_theGame._gameState != 5)
{
playAnimationState(32);
}
}
public function boost(param1:Boolean) : void
{
var _loc2_:Array = null;
if(_avatar != null)
{
if(!param1)
{
_loc2_ = [];
_loc2_[0] = "boo";
MinigameManager.msg(_loc2_);
}
if(_raceCompleteState == 0)
{
_speedBoostTimer = 1.5;
_theGame.boost(parseInt(_trackLayer.parent.name.charAt(_trackLayer.parent.name.length - 1)),true);
if(_localPlayer && !_isAI)
{
_theGame.updatePearl(_ringCounter);
_theGame._soundMan.playByName(_theGame._soundNameAJDRTurbo);
}
_ringCounter = 0;
}
}
}
public function jump(param1:Boolean) : Boolean
{
if(param1)
{
if(_avatar != null && getPositionX() >= _startX)
{
if(_raceCompleteState == 0 && _jumpingDivingTimer <= 0 && _avatar._bInSplashVolume == false)
{
doJump();
return true;
}
}
}
else
{
(_trackLayer.parent as Object).double = false;
}
return false;
}
private function doJump() : void
{
_jumpingDivingTimer = 1.1;
_jumpType = true;
(_trackLayer.parent as Object).double = true;
(_trackLayer.parent as MovieClip).gotoAndStop("jump");
_trackRipple.jumpSplash();
if(_isAI)
{
_theGame.setWaterEffectVisibility(parseInt(_trackLayer.parent.name.charAt(_trackLayer.parent.name.length - 1)),false);
}
if(_theGame._gameState != 5)
{
playAnimationState(29);
}
}
private function doDive() : void
{
_jumpingDivingTimer = 1;
_jumpType = false;
(_trackLayer.parent as Object).double = true;
(_trackLayer.parent as MovieClip).gotoAndStop("dive");
_trackRipple.diveSplash();
if(_isAI)
{
_theGame.setWaterEffectVisibility(parseInt(_trackLayer.parent.name.charAt(_trackLayer.parent.name.length - 1)),false);
}
if(_theGame._gameState != 5)
{
playAnimationState(29);
}
}
public function dive(param1:Boolean) : Boolean
{
if(param1)
{
if(_avatar != null && getPositionX() >= _startX)
{
if(_raceCompleteState == 0 && _jumpingDivingTimer <= 0 && _avatar._bInSplashVolume == false)
{
doDive();
return true;
}
}
}
else
{
(_trackLayer.parent as Object).double = false;
}
return false;
}
}
}