mirror of
https://github.com/burrow-dev/burrow-server.git
synced 2026-11-18 17:27:50 -05:00
1039 lines
37 KiB
ActionScript
1039 lines
37 KiB
ActionScript
package room
|
|
{
|
|
import avatar.AvatarManager;
|
|
import avatar.AvatarSwitch;
|
|
import avatar.AvatarWorldView;
|
|
import flash.display.Bitmap;
|
|
import flash.display.BitmapData;
|
|
import flash.display.BlendMode;
|
|
import flash.display.MovieClip;
|
|
import flash.display.Shape;
|
|
import flash.display.Sprite;
|
|
import flash.events.Event;
|
|
import flash.events.FocusEvent;
|
|
import flash.events.KeyboardEvent;
|
|
import flash.events.MouseEvent;
|
|
import flash.geom.Matrix;
|
|
import flash.geom.Point;
|
|
import flash.system.System;
|
|
import flash.ui.Keyboard;
|
|
import flash.utils.Dictionary;
|
|
import flash.utils.getTimer;
|
|
import gui.DarkenManager;
|
|
import gui.GuiManager;
|
|
import loader.MediaHelper;
|
|
import quest.QuestManager;
|
|
|
|
public class RoomManagerView extends RoomManagerBase
|
|
{
|
|
|
|
public static var _speedMutiplier:int;
|
|
|
|
protected static const USE_PLAYER_GOTO_SPAWN_LOCATION:String = "use_player_goto_spawn_location";
|
|
|
|
private static const TAN_30:Number = 0.5773502691896;
|
|
|
|
private static const PLAYER_INDICATOR_RADIUS:int = 8;
|
|
|
|
protected var _mousePos:Point;
|
|
|
|
protected var _bMouseMove:Boolean;
|
|
|
|
protected var _bMouseDown:Boolean;
|
|
|
|
protected var _bMouseDownNew:Boolean;
|
|
|
|
protected var _bTestPortal:Boolean;
|
|
|
|
protected var _playerGotoSpawnPoint:String;
|
|
|
|
protected var _playerGotoSpawnLocationX:int;
|
|
|
|
protected var _playerGotoSpawnLocationY:int;
|
|
|
|
protected var _leftArrow:Boolean;
|
|
|
|
protected var _rightArrow:Boolean;
|
|
|
|
protected var _upArrow:Boolean;
|
|
|
|
protected var _downArrow:Boolean;
|
|
|
|
protected var _ctrlPressed:Boolean;
|
|
|
|
protected var _avatarDirection:Point;
|
|
|
|
protected var _keyboardEnabled:Boolean;
|
|
|
|
private var _followPath:Vector.<int>;
|
|
|
|
private var _movePlayerToPos:Point;
|
|
|
|
private var _lastGridCell:int;
|
|
|
|
private var _avLastValidCell:int;
|
|
|
|
private var _followCursorPos:Point;
|
|
|
|
private var _followCursorThrottle:int;
|
|
|
|
private var _playerSlideSpawnPoint:String;
|
|
|
|
private var _slideList:Array;
|
|
|
|
private var _socialTriggerThrottle:int;
|
|
|
|
private var _drawPath:Boolean;
|
|
|
|
private var _debugLog:String;
|
|
|
|
private var _startTime:int;
|
|
|
|
private var _computeCoordinates:Boolean;
|
|
|
|
private var _immediateCoordinates:Point;
|
|
|
|
private var _frameTime:Number;
|
|
|
|
private var _miniMap:MovieClip;
|
|
|
|
protected var _pathName:String;
|
|
|
|
private var _miniMaps:Dictionary;
|
|
|
|
private var _miniMapStamp:Shape;
|
|
|
|
private var _miniMapMatrix:Matrix;
|
|
|
|
private var _forceCollision:Boolean;
|
|
|
|
public function RoomManagerView()
|
|
{
|
|
super();
|
|
}
|
|
|
|
override public function init(layerManager:LayerManager) : void
|
|
{
|
|
super.init(layerManager);
|
|
this._followCursorPos = new Point();
|
|
this._mousePos = new Point();
|
|
this._slideList = [];
|
|
this._keyboardEnabled = true;
|
|
this._debugLog = new String();
|
|
_speedMutiplier = 1;
|
|
gMainFrame.stage.addEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMoveEvt);
|
|
gMainFrame.stage.addEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDownEvt);
|
|
gMainFrame.stage.addEventListener(MouseEvent.MOUSE_UP,this.onMouseUpEvt);
|
|
gMainFrame.stage.addEventListener(FocusEvent.FOCUS_OUT,this.onDeactivate);
|
|
gMainFrame.stage.addEventListener(Event.DEACTIVATE,this.onDeactivate);
|
|
gMainFrame.stage.addEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDownEvt);
|
|
gMainFrame.stage.addEventListener(KeyboardEvent.KEY_UP,this.onKeyUpEvt);
|
|
this._miniMaps = new Dictionary();
|
|
this._avatarDirection = new Point();
|
|
}
|
|
|
|
override public function destroy() : void
|
|
{
|
|
super.destroy();
|
|
gMainFrame.stage.removeEventListener(MouseEvent.MOUSE_MOVE,this.onMouseMoveEvt);
|
|
gMainFrame.stage.removeEventListener(MouseEvent.MOUSE_DOWN,this.onMouseDownEvt);
|
|
gMainFrame.stage.removeEventListener(MouseEvent.MOUSE_UP,this.onMouseUpEvt);
|
|
gMainFrame.stage.removeEventListener(FocusEvent.FOCUS_OUT,this.onDeactivate);
|
|
gMainFrame.stage.removeEventListener(Event.DEACTIVATE,this.onDeactivate);
|
|
gMainFrame.stage.removeEventListener(KeyboardEvent.KEY_DOWN,this.onKeyDownEvt);
|
|
gMainFrame.stage.removeEventListener(KeyboardEvent.KEY_UP,this.onKeyUpEvt);
|
|
}
|
|
|
|
override public function exitRoom(isDenPreview:Boolean = false) : void
|
|
{
|
|
super.exitRoom(isDenPreview);
|
|
this._movePlayerToPos = null;
|
|
this._bMouseDown = false;
|
|
this._bMouseDownNew = false;
|
|
this._bMouseMove = false;
|
|
this._bTestPortal = false;
|
|
this._playerSlideSpawnPoint = null;
|
|
this._slideList = [];
|
|
}
|
|
|
|
override protected function onRoomLoaded_base(callback:Function, initScene:Object, initIsDenPreview:Boolean = false) : void
|
|
{
|
|
this._movePlayerToPos = null;
|
|
this._followPath = null;
|
|
this._bMouseDown = false;
|
|
this._bMouseDownNew = false;
|
|
this._lastGridCell = -1;
|
|
this._avLastValidCell = -1;
|
|
super.onRoomLoaded_base(callback,initScene,initIsDenPreview);
|
|
}
|
|
|
|
public function setGotoSpawnLocation(inX:int, inY:int) : void
|
|
{
|
|
this._playerGotoSpawnLocationX = inX;
|
|
this._playerGotoSpawnLocationY = inY;
|
|
this._playerGotoSpawnPoint = USE_PLAYER_GOTO_SPAWN_LOCATION;
|
|
}
|
|
|
|
public function setGotoSpawnPoint(value:String) : void
|
|
{
|
|
this._playerGotoSpawnPoint = value;
|
|
}
|
|
|
|
public function resetThrottle() : void
|
|
{
|
|
this._followCursorThrottle = 0;
|
|
}
|
|
|
|
protected function walkToSpawn(toSpawn:String) : void
|
|
{
|
|
var spawn:Object = null;
|
|
var pos:Point = null;
|
|
spawn = findSpawn(_spawns,toSpawn);
|
|
if(Boolean(spawn))
|
|
{
|
|
this._bTestPortal = false;
|
|
this._movePlayerToPos = new Point(spawn.x,spawn.y);
|
|
pos = getRandomRadiusOffset(spawn.r);
|
|
this._movePlayerToPos.x += pos.x;
|
|
this._movePlayerToPos.y += pos.y;
|
|
convertToWorldSpace(this._movePlayerToPos);
|
|
}
|
|
}
|
|
|
|
private function onKeyDownEvt(evt:KeyboardEvent) : void
|
|
{
|
|
var directionChanged:Boolean = false;
|
|
switch(evt.keyCode)
|
|
{
|
|
case Keyboard.CONTROL:
|
|
this._ctrlPressed = true;
|
|
break;
|
|
case Keyboard.LEFT:
|
|
if(this._ctrlPressed)
|
|
{
|
|
_speedMutiplier = 1;
|
|
}
|
|
else if(this._avatarDirection.x >= 0)
|
|
{
|
|
this._leftArrow = true;
|
|
directionChanged = true;
|
|
this._avatarDirection.x = -1;
|
|
}
|
|
break;
|
|
case Keyboard.RIGHT:
|
|
if(this._ctrlPressed)
|
|
{
|
|
_speedMutiplier = 1;
|
|
}
|
|
else if(this._avatarDirection.x <= 0)
|
|
{
|
|
this._rightArrow = true;
|
|
directionChanged = true;
|
|
this._avatarDirection.x = 1;
|
|
}
|
|
break;
|
|
case Keyboard.UP:
|
|
if(this._ctrlPressed)
|
|
{
|
|
++_speedMutiplier;
|
|
}
|
|
else if(this._avatarDirection.y >= 0)
|
|
{
|
|
this._upArrow = true;
|
|
directionChanged = true;
|
|
this._avatarDirection.y = -1;
|
|
}
|
|
break;
|
|
case Keyboard.DOWN:
|
|
if(this._ctrlPressed)
|
|
{
|
|
--_speedMutiplier;
|
|
}
|
|
else if(this._avatarDirection.y <= 0)
|
|
{
|
|
this._downArrow = true;
|
|
directionChanged = true;
|
|
this._avatarDirection.y = 1;
|
|
}
|
|
}
|
|
switch(evt.keyCode)
|
|
{
|
|
case Keyboard.NUMPAD_9:
|
|
this._startTime = -1;
|
|
this._drawPath = !this._drawPath;
|
|
break;
|
|
case Keyboard.NUMPAD_8:
|
|
this._forceCollision = !this._forceCollision;
|
|
break;
|
|
case Keyboard.NUMPAD_1:
|
|
System.setClipboard(this._debugLog);
|
|
this._debugLog = "";
|
|
trace("copied");
|
|
break;
|
|
case Keyboard.NUMPAD_2:
|
|
this._computeCoordinates = !this._computeCoordinates;
|
|
trace("computerCoordinates: " + this._computeCoordinates);
|
|
}
|
|
if(directionChanged)
|
|
{
|
|
if(AvatarManager.roomEnviroType == Utility.ENVIRO_LAND && Math.abs(this._avatarDirection.x) > 0 && Math.abs(this._avatarDirection.y) > 0)
|
|
{
|
|
this._avatarDirection.y = (this._avatarDirection.y > 0 ? 1 : -1) * TAN_30 * Math.abs(this._avatarDirection.x);
|
|
}
|
|
this._avatarDirection.normalize(1);
|
|
}
|
|
}
|
|
|
|
public function updatePlayerPos(x:int, y:int) : void
|
|
{
|
|
if(this._miniMap != null)
|
|
{
|
|
x = ((x + _mainBackObj.x - _grid.min.x) / _grid.r2 - this._miniMap.offsetX) * this._miniMap.scale + this._miniMap.centerOffsetX;
|
|
y = ((y + _mainBackObj.y - _grid.min.y) / _grid.r2 - this._miniMap.offsetY) * this._miniMap.scale + this._miniMap.centerOffsetY;
|
|
if(this._miniMapStamp == null)
|
|
{
|
|
this._miniMapStamp = new Shape();
|
|
this._miniMapStamp.graphics.beginFill(0,0.1);
|
|
this._miniMapStamp.graphics.drawCircle(0,0,PLAYER_INDICATOR_RADIUS);
|
|
this._miniMapStamp.graphics.endFill();
|
|
this._miniMapMatrix = new Matrix();
|
|
}
|
|
if(this._miniMapMatrix.tx != x || this._miniMapMatrix.ty != y)
|
|
{
|
|
this._miniMapMatrix.tx = x;
|
|
this._miniMapMatrix.ty = y;
|
|
this._miniMap.overlay.bitmapData.draw(this._miniMapStamp,this._miniMapMatrix,null,BlendMode.ALPHA);
|
|
this._miniMap.playerIndicator.x = x;
|
|
this._miniMap.playerIndicator.y = y;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function removeAndClearMiniMap() : void
|
|
{
|
|
if(Boolean(this._miniMap) && Boolean(this._miniMap.parent))
|
|
{
|
|
this._miniMap.parent.removeChild(this._miniMap);
|
|
}
|
|
this._miniMap = null;
|
|
this._miniMaps = new Dictionary();
|
|
}
|
|
|
|
public function removeMiniMap() : void
|
|
{
|
|
if(Boolean(this._miniMap) && Boolean(this._miniMap.parent))
|
|
{
|
|
this._miniMap.parent.removeChild(this._miniMap);
|
|
}
|
|
this._miniMap = null;
|
|
}
|
|
|
|
public function updateMinimap() : void
|
|
{
|
|
var bmp:Bitmap = null;
|
|
var myBitmapData:BitmapData = null;
|
|
var y:int = 0;
|
|
var index:int = 0;
|
|
var x:int = 0;
|
|
var cell:int = 0;
|
|
if(Boolean(this._miniMap) && Boolean(this._miniMap.parent) && !this._miniMap.hasOwnProperty("noUpdates"))
|
|
{
|
|
bmp = this._miniMap.getChildAt(1) as Bitmap;
|
|
if(Boolean(bmp))
|
|
{
|
|
myBitmapData = bmp.bitmapData;
|
|
for(y = 0; y < this._miniMap.croppedHeight; y++)
|
|
{
|
|
index = this._miniMap.leftX + (y + this._miniMap.topY) * _grid.width;
|
|
for(x = 0; x < this._miniMap.croppedWidth; x++)
|
|
{
|
|
cell = int(_grid.grid[x + index]);
|
|
if(cell == 0)
|
|
{
|
|
myBitmapData.setPixel(x,y,8024881);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private function mapBitmapLoaded(img:MovieClip) : void
|
|
{
|
|
img.scaleX = img.scaleY = 0.5;
|
|
this._miniMap.addChildAt(img,1);
|
|
}
|
|
|
|
public function createMiniMap() : void
|
|
{
|
|
var y:Number = NaN;
|
|
var x:Number = NaN;
|
|
var cell:int = 0;
|
|
var doBreak:Boolean = false;
|
|
var y1:Number = NaN;
|
|
var leftX:int = 0;
|
|
var rightX:int = 0;
|
|
var topY:int = 0;
|
|
var bottomY:int = 0;
|
|
var index:int = 0;
|
|
var fullWidth:int = 0;
|
|
var fullHeight:int = 0;
|
|
var myBitmapData:BitmapData = null;
|
|
var croppedWidth:int = 0;
|
|
var croppedHeight:int = 0;
|
|
var aspectCurrent:Number = NaN;
|
|
var aspectTarget:Number = NaN;
|
|
var scale:Number = NaN;
|
|
var bmp:Bitmap = null;
|
|
var maps:Array = null;
|
|
var centerOffsetX:Number = NaN;
|
|
var centerOffsetY:Number = NaN;
|
|
var container:Sprite = null;
|
|
var mapIds:Array = null;
|
|
var mh:MediaHelper = null;
|
|
if(GuiManager.mainHud.miniMap != null)
|
|
{
|
|
this._miniMap = this._miniMaps[this._pathName];
|
|
if(Boolean(this._miniMap))
|
|
{
|
|
GuiManager.mainHud.miniMap.ba.itemLayer.addChild(this._miniMap);
|
|
}
|
|
else if(Boolean(_grid))
|
|
{
|
|
this._miniMap = new MovieClip();
|
|
y1 = 0;
|
|
doBreak = false;
|
|
for(x = 0; x < _grid.width; x++)
|
|
{
|
|
for(y = 0; y < _grid.height; y++)
|
|
{
|
|
cell = int(_grid.grid[x + y * _grid.width]);
|
|
if(cell == 0)
|
|
{
|
|
leftX = x;
|
|
doBreak = true;
|
|
break;
|
|
}
|
|
}
|
|
if(doBreak)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
doBreak = false;
|
|
for(x = _grid.width - 1; x >= 0; x--)
|
|
{
|
|
for(y = 0; y < _grid.height; y++)
|
|
{
|
|
cell = int(_grid.grid[x + y * _grid.width]);
|
|
if(cell == 0)
|
|
{
|
|
rightX = x;
|
|
doBreak = true;
|
|
break;
|
|
}
|
|
}
|
|
if(doBreak)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
doBreak = false;
|
|
for(y = 0; y < _grid.height; y++)
|
|
{
|
|
index = y * _grid.width;
|
|
for(x = 0; x < _grid.width; x++)
|
|
{
|
|
cell = int(_grid.grid[x + index]);
|
|
if(cell == 0)
|
|
{
|
|
topY = y;
|
|
doBreak = true;
|
|
break;
|
|
}
|
|
}
|
|
if(doBreak)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
doBreak = false;
|
|
for(y = _grid.height - 1; y >= 0; y--)
|
|
{
|
|
index = y * _grid.width;
|
|
for(x = 0; x < _grid.width; x++)
|
|
{
|
|
cell = int(_grid.grid[x + index]);
|
|
if(cell == 0)
|
|
{
|
|
bottomY = y;
|
|
doBreak = true;
|
|
break;
|
|
}
|
|
}
|
|
if(doBreak)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
this._miniMap.offsetX = leftX;
|
|
this._miniMap.offsetY = topY;
|
|
fullWidth = int(GuiManager.mainHud.miniMap.ba.itemLayer.width);
|
|
fullHeight = int(GuiManager.mainHud.miniMap.ba.itemLayer.height);
|
|
myBitmapData = new BitmapData(fullWidth,fullHeight,true,4278190080);
|
|
this._miniMap.addChild(new Bitmap(myBitmapData,"auto",true));
|
|
croppedWidth = rightX - leftX + 1;
|
|
croppedHeight = bottomY - topY + 1;
|
|
this._miniMap.croppedWidth = croppedWidth;
|
|
this._miniMap.croppedHeight = croppedHeight;
|
|
this._miniMap.leftX = leftX;
|
|
this._miniMap.topY = topY;
|
|
myBitmapData = new BitmapData(croppedWidth,croppedHeight,false,0);
|
|
for(y = 0; y < croppedHeight; y++)
|
|
{
|
|
index = leftX + (y + topY) * _grid.width;
|
|
for(x = 0; x < croppedWidth; x++)
|
|
{
|
|
cell = int(_grid.grid[x + index]);
|
|
if(cell == 0)
|
|
{
|
|
myBitmapData.setPixel(x,y,8024881);
|
|
}
|
|
}
|
|
}
|
|
aspectCurrent = croppedWidth / croppedHeight;
|
|
aspectTarget = fullWidth / fullHeight;
|
|
maps = volumeManager.findVolume("map");
|
|
if(Boolean(maps))
|
|
{
|
|
mapIds = maps[0].message.split(",");
|
|
mh = new MediaHelper();
|
|
bmp = new Bitmap();
|
|
mh.init(mapIds[mapIds.length > QuestManager._questDifficultyLevel ? QuestManager._questDifficultyLevel : 0],this.mapBitmapLoaded);
|
|
this._miniMap.noUpdates = 1;
|
|
}
|
|
else
|
|
{
|
|
bmp = new Bitmap(myBitmapData,"auto",true);
|
|
this._miniMap.addChild(bmp);
|
|
}
|
|
scale = aspectCurrent < aspectTarget ? fullHeight / croppedHeight : fullWidth / croppedWidth;
|
|
bmp.scaleX = bmp.scaleY = this._miniMap.scale = scale;
|
|
centerOffsetX = (fullWidth - croppedWidth * scale) * 0.5;
|
|
centerOffsetY = (fullHeight - croppedHeight * scale) * 0.5;
|
|
this._miniMap.centerOffsetX = centerOffsetX;
|
|
this._miniMap.centerOffsetY = centerOffsetY;
|
|
bmp.x += centerOffsetX;
|
|
bmp.y += centerOffsetY;
|
|
container = new Sprite();
|
|
this._miniMap.addChild(container);
|
|
container.blendMode = BlendMode.LAYER;
|
|
myBitmapData = new BitmapData(fullWidth,fullHeight,true,4278190080);
|
|
this._miniMap.overlay = new Bitmap(myBitmapData,"auto",true);
|
|
container.addChild(this._miniMap.overlay);
|
|
this._miniMap.x = -this._miniMap.width * 0.5;
|
|
this._miniMap.y = -this._miniMap.height * 0.5;
|
|
GuiManager.mainHud.miniMap.ba.itemLayer.addChild(this._miniMap);
|
|
this._miniMap.playerIndicator = GETDEFINITIONBYNAME("miniMapDotCont");
|
|
this._miniMap.addChild(this._miniMap.playerIndicator);
|
|
this._miniMaps[this._pathName] = this._miniMap;
|
|
}
|
|
}
|
|
}
|
|
|
|
private function onKeyUpEvt(evt:KeyboardEvent) : void
|
|
{
|
|
var directionChanged:Boolean = false;
|
|
switch(evt.keyCode)
|
|
{
|
|
case Keyboard.CONTROL:
|
|
this._ctrlPressed = false;
|
|
break;
|
|
case Keyboard.LEFT:
|
|
if(this._leftArrow)
|
|
{
|
|
this._leftArrow = false;
|
|
if(this._avatarDirection.x < 0)
|
|
{
|
|
this._avatarDirection.x = this._rightArrow ? 1 : 0;
|
|
directionChanged = true;
|
|
}
|
|
}
|
|
break;
|
|
case Keyboard.RIGHT:
|
|
if(this._rightArrow)
|
|
{
|
|
this._rightArrow = false;
|
|
if(this._avatarDirection.x > 0)
|
|
{
|
|
this._avatarDirection.x = this._leftArrow ? -1 : 0;
|
|
directionChanged = true;
|
|
}
|
|
}
|
|
break;
|
|
case Keyboard.UP:
|
|
if(this._upArrow)
|
|
{
|
|
this._upArrow = false;
|
|
if(this._avatarDirection.y < 0)
|
|
{
|
|
this._avatarDirection.y = this._downArrow ? 1 : 0;
|
|
directionChanged = true;
|
|
}
|
|
}
|
|
break;
|
|
case Keyboard.DOWN:
|
|
if(this._downArrow)
|
|
{
|
|
this._downArrow = false;
|
|
if(this._avatarDirection.y > 0)
|
|
{
|
|
this._avatarDirection.y = this._upArrow ? -1 : 0;
|
|
directionChanged = true;
|
|
}
|
|
}
|
|
}
|
|
if(directionChanged)
|
|
{
|
|
this._avatarDirection.normalize(1);
|
|
}
|
|
}
|
|
|
|
private function onDeactivate(evt:Event) : void
|
|
{
|
|
this._leftArrow = this._rightArrow = this._upArrow = this._downArrow = false;
|
|
this._avatarDirection.x = this._avatarDirection.y = 0;
|
|
}
|
|
|
|
private function onMouseMoveEvt(evt:MouseEvent) : void
|
|
{
|
|
if(GuiManager.isModal() || DarkenManager.isDarkened)
|
|
{
|
|
return;
|
|
}
|
|
if(_layerManager.bkg == null || _mainBackObj == null || !this._bTestPortal)
|
|
{
|
|
return;
|
|
}
|
|
if(this._bMouseDown)
|
|
{
|
|
this._followCursorPos.x = evt.stageX;
|
|
this._followCursorPos.y = evt.stageY;
|
|
if(this._drawPath)
|
|
{
|
|
this._debugLog = this._debugLog.concat(getTimer() - this._startTime + " MOUSE_MOVE, stageX=" + evt.stageX + ", stageY=" + evt.stageY);
|
|
if(this._computeCoordinates)
|
|
{
|
|
this._immediateCoordinates = convertScreenToWorldSpace(this._followCursorPos.x,this._followCursorPos.y);
|
|
this._debugLog = this._debugLog.concat(" worldX=" + this._immediateCoordinates.x + ", worldY=" + this._immediateCoordinates.y);
|
|
}
|
|
this._debugLog = this._debugLog.concat("\n");
|
|
}
|
|
}
|
|
this._mousePos.x = evt.stageX;
|
|
this._mousePos.y = evt.stageY;
|
|
this._bMouseMove = true;
|
|
}
|
|
|
|
private function onMouseDownEvt(evt:MouseEvent) : void
|
|
{
|
|
GuiManager.handleMouseDown();
|
|
if(GuiManager.isModal() || AvatarSwitch.isSwitching() || DarkenManager.isDarkened)
|
|
{
|
|
return;
|
|
}
|
|
if(_layerManager.bkg == null || _mainBackObj == null || !this._bTestPortal)
|
|
{
|
|
return;
|
|
}
|
|
if(QuestManager.mouseHandleDown(evt) == false)
|
|
{
|
|
if(this._drawPath)
|
|
{
|
|
if(this._startTime < 0)
|
|
{
|
|
this._startTime = getTimer();
|
|
}
|
|
this._debugLog = this._debugLog.concat(getTimer() - this._startTime + " MOUSE_DOWN, stageX=" + evt.stageX + ", stageY=" + evt.stageY);
|
|
if(this._computeCoordinates)
|
|
{
|
|
this._immediateCoordinates = convertScreenToWorldSpace(this._followCursorPos.x,this._followCursorPos.y);
|
|
this._debugLog = this._debugLog.concat(" worldX=" + this._immediateCoordinates.x + ", worldY=" + this._immediateCoordinates.y);
|
|
}
|
|
this._debugLog = this._debugLog.concat("\n");
|
|
}
|
|
this._bMouseDown = true;
|
|
this._bMouseDownNew = true;
|
|
this._followCursorPos.x = evt.stageX;
|
|
this._followCursorPos.y = evt.stageY;
|
|
this._followCursorThrottle = 0;
|
|
this._mousePos.x = evt.stageX;
|
|
this._mousePos.y = evt.stageY;
|
|
this._bMouseMove = true;
|
|
}
|
|
}
|
|
|
|
private function onMouseUpEvt(evt:MouseEvent) : void
|
|
{
|
|
this.forceMouseUp();
|
|
if(this._drawPath)
|
|
{
|
|
this._debugLog = this._debugLog.concat(getTimer() - this._startTime + " MOUSE_UP\n");
|
|
}
|
|
}
|
|
|
|
public function forceMouseUp() : void
|
|
{
|
|
this._bMouseDown = false;
|
|
this._bMouseDownNew = false;
|
|
this._lastGridCell = -1;
|
|
}
|
|
|
|
public function setFocus(focus:Boolean = true) : void
|
|
{
|
|
if(!focus)
|
|
{
|
|
this.forceMouseUp();
|
|
}
|
|
}
|
|
|
|
public function heartbeat_movePlayer(ms:int, frameTimems:int) : void
|
|
{
|
|
var cell:int = 0;
|
|
var pos:Object = null;
|
|
this._frameTime = frameTimems / 1000;
|
|
if(this._frameTime > 0.5)
|
|
{
|
|
this._frameTime = 0.5;
|
|
}
|
|
if(Boolean(this._movePlayerToPos))
|
|
{
|
|
this.movePlayerToLocation(this._movePlayerToPos.x,this._movePlayerToPos.y);
|
|
this._movePlayerToPos = null;
|
|
}
|
|
else if(AvatarManager.playerAvatarWorldView != null && !AvatarManager.playerAvatarWorldView.moving)
|
|
{
|
|
if(Boolean(this._playerSlideSpawnPoint))
|
|
{
|
|
this.walkToSpawn(this._playerSlideSpawnPoint);
|
|
this._playerSlideSpawnPoint = null;
|
|
}
|
|
else if(Boolean(this._followPath))
|
|
{
|
|
this.movePlayerOnPath();
|
|
}
|
|
else
|
|
{
|
|
this._bTestPortal = true;
|
|
}
|
|
}
|
|
else if(Boolean(_mainBackObj))
|
|
{
|
|
if(AvatarManager.playerAvatarWorldView != null && _mainBackObj != null)
|
|
{
|
|
cell = _roomGrid.getCellIndex(AvatarManager.playerAvatarWorldView.x + _mainBackObj.x,AvatarManager.playerAvatarWorldView.y + _mainBackObj.y);
|
|
if(this._avLastValidCell != cell)
|
|
{
|
|
pos = _roomGrid.convertCellToCoords(cell);
|
|
if(!_roomGrid.testGridCell(pos.x,pos.y))
|
|
{
|
|
this._avLastValidCell = cell;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected function followCursorTest() : void
|
|
{
|
|
var pt:Point = null;
|
|
var cell:int = 0;
|
|
var speed:int = 0;
|
|
var px:Number = NaN;
|
|
var py:Number = NaN;
|
|
var doCollision:Boolean = false;
|
|
if(this._followCursorThrottle <= 0 && this._bMouseDown)
|
|
{
|
|
if(this._computeCoordinates && Boolean(this._immediateCoordinates))
|
|
{
|
|
pt = this._immediateCoordinates;
|
|
}
|
|
else
|
|
{
|
|
pt = convertScreenToWorldSpace(this._followCursorPos.x,this._followCursorPos.y);
|
|
}
|
|
cell = _roomGrid.getCellIndex(pt.x + _mainBackObj.x,pt.y + _mainBackObj.y);
|
|
if(this._lastGridCell != cell)
|
|
{
|
|
this._lastGridCell = cell;
|
|
this._movePlayerToPos = pt;
|
|
this._followPath = null;
|
|
this._followCursorThrottle = 12;
|
|
if(this._drawPath)
|
|
{
|
|
this._debugLog = this._debugLog.concat(getTimer() - this._startTime + " Processing cursor posX=" + this._followCursorPos.x + ", cursor posY=" + this._followCursorPos.y + ", moving to " + pt.x + "," + pt.y + "\n");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
--this._followCursorThrottle;
|
|
}
|
|
if(Boolean(this._keyboardEnabled && !DarkenManager.isDarkened && !GuiManager.volumeMgr.visible && AvatarManager.playerAvatarWorldView && this._movePlayerToPos == null && this._followPath == null) && Boolean(this._playerSlideSpawnPoint == null) && this._bTestPortal)
|
|
{
|
|
if(this._avatarDirection.x != 0 || this._avatarDirection.y != 0)
|
|
{
|
|
pt = new Point();
|
|
speed = 24 * _speedMutiplier * this._frameTime / 0.07;
|
|
px = this._avatarDirection.x * speed;
|
|
py = this._avatarDirection.y * speed;
|
|
pt.x = AvatarManager.playerAvatarWorldView.x;
|
|
pt.y = AvatarManager.playerAvatarWorldView.y;
|
|
doCollision = true;
|
|
doCollision = false;
|
|
if((doCollision || this._forceCollision) && collisionTestGrid(pt.x + px,pt.y + py) != 0)
|
|
{
|
|
if(px != 0 && py != 0)
|
|
{
|
|
if(collisionTestGrid(pt.x,pt.y + py) != 0)
|
|
{
|
|
if(collisionTestGrid(pt.x + px,pt.y) == 0)
|
|
{
|
|
AvatarManager.movePlayer(pt.x + px,pt.y);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AvatarManager.movePlayer(pt.x,pt.y + py);
|
|
}
|
|
}
|
|
else if(px == 0)
|
|
{
|
|
px = Math.abs(py);
|
|
if(collisionTestGrid(pt.x + 25,pt.y + py) != 0)
|
|
{
|
|
if(collisionTestGrid(pt.x - 25,pt.y + py) == 0)
|
|
{
|
|
AvatarManager.movePlayer(pt.x - px,pt.y + py);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AvatarManager.movePlayer(pt.x + px,pt.y + py);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
py = Math.abs(px);
|
|
if(collisionTestGrid(pt.x + px,pt.y - 25) != 0)
|
|
{
|
|
if(collisionTestGrid(pt.x + px,pt.y + 25) == 0)
|
|
{
|
|
AvatarManager.movePlayer(pt.x + px,pt.y + py);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AvatarManager.movePlayer(pt.x + px,pt.y - py);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AvatarManager.movePlayer(pt.x + px,pt.y + py);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
protected function updateSplashVolumes() : void
|
|
{
|
|
var avList:Object = null;
|
|
var key:Object = null;
|
|
var a:* = undefined;
|
|
var v:Object = null;
|
|
var m:String = null;
|
|
if(_volumeManager.hasSplashVolume)
|
|
{
|
|
avList = AvatarManager.avatarViewList;
|
|
for(key in avList)
|
|
{
|
|
a = avList[key];
|
|
v = _volumeManager.testSplashVolumes(new Point(a.x,a.y));
|
|
if(Boolean(v))
|
|
{
|
|
m = v.message;
|
|
}
|
|
a.setSplashVolume(v != null,m);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected function updateSocialVolumes() : void
|
|
{
|
|
++this._socialTriggerThrottle;
|
|
if(this._socialTriggerThrottle > 20)
|
|
{
|
|
this._socialTriggerThrottle = 0;
|
|
_volumeManager.updateSocialTriggers(AvatarManager.avatarViewList);
|
|
}
|
|
}
|
|
|
|
private function movePlayerToLocation(x:int, y:int) : void
|
|
{
|
|
var pos:Object = null;
|
|
var px:Number = NaN;
|
|
var py:Number = NaN;
|
|
if(Boolean(AvatarManager.playerAvatar))
|
|
{
|
|
px = AvatarManager.playerAvatarWorldView.x;
|
|
py = AvatarManager.playerAvatarWorldView.y;
|
|
if(Boolean(_roomGrid))
|
|
{
|
|
pos = _roomGrid.convertCellToCoords(_roomGrid.getCellIndex(px + _mainBackObj.x,py + _mainBackObj.y));
|
|
if(Boolean(_roomGrid.testGridCell(pos.x,pos.y)) && this._avLastValidCell >= 0)
|
|
{
|
|
pos = _roomGrid.getCellIndexToWorldPos(this._avLastValidCell);
|
|
px = pos.x - _mainBackObj.x;
|
|
py = pos.y - _mainBackObj.y;
|
|
}
|
|
pos = _roomGrid.findClosestOpenGridCell(x + _mainBackObj.x,y + _mainBackObj.y);
|
|
if(Boolean(pos))
|
|
{
|
|
x = pos.x - _mainBackObj.x;
|
|
y = pos.y - _mainBackObj.y;
|
|
this._followPath = _roomGrid.findPathOptimized(new Point(px + _mainBackObj.x,py + _mainBackObj.y),new Point(x + _mainBackObj.x,y + _mainBackObj.y));
|
|
if(this._followPath == null || this._followPath.length == 0)
|
|
{
|
|
this._followPath = null;
|
|
}
|
|
else
|
|
{
|
|
if(this._drawPath)
|
|
{
|
|
drawDebugLayer(this._followPath);
|
|
}
|
|
this.movePlayerOnPath();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function setGridDepth(depth:uint) : void
|
|
{
|
|
_roomGrid.setGridDepth(depth);
|
|
}
|
|
|
|
public function getGridCellType() : int
|
|
{
|
|
var pos:Object = null;
|
|
if(Boolean(_mainBackObj))
|
|
{
|
|
pos = _roomGrid.convertCellToCoords(_roomGrid.getCellIndex(AvatarManager.playerAvatarWorldView.x + _mainBackObj.x,AvatarManager.playerAvatarWorldView.y + _mainBackObj.y));
|
|
return _roomGrid.testGridCell(pos.x,pos.y);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private function movePlayerOnPath() : void
|
|
{
|
|
var pos:Object = null;
|
|
if(Boolean(_mainBackObj))
|
|
{
|
|
pos = _roomGrid.getCellIndexToWorldPos(this._followPath[0]);
|
|
AvatarManager.movePlayer(pos.x - _mainBackObj.x,pos.y - _mainBackObj.y);
|
|
if(this._followPath.length == 1)
|
|
{
|
|
this._followPath = null;
|
|
}
|
|
else
|
|
{
|
|
this._followPath.splice(0,1);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function killPlayerPath() : void
|
|
{
|
|
this._followPath = null;
|
|
}
|
|
|
|
public function attachAvatarToSlide(av:AvatarWorldView, name:String, playerSlideSpawnPoint:String = null) : void
|
|
{
|
|
var i:int = 0;
|
|
var j:int = 0;
|
|
var layer:Object = null;
|
|
var c:* = undefined;
|
|
var pos:Point = new Point();
|
|
var a:Array = this._slideList[name];
|
|
if(Boolean(playerSlideSpawnPoint))
|
|
{
|
|
this._playerSlideSpawnPoint = playerSlideSpawnPoint;
|
|
}
|
|
if(a == null && Boolean(_layers))
|
|
{
|
|
for(i = 0; i < _layers.length; i++)
|
|
{
|
|
layer = _layers[i];
|
|
if(layer.name == name)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if(Boolean(layer))
|
|
{
|
|
c = layer.s.content;
|
|
a = [];
|
|
for(i = 0; i < c.totalFrames; i++)
|
|
{
|
|
c.gotoAndStop(i);
|
|
pos.x = c.player.x + layer.x;
|
|
pos.y = c.player.y + layer.y;
|
|
convertToWorldSpace(pos);
|
|
a[i] = {
|
|
"x":pos.x,
|
|
"y":pos.y
|
|
};
|
|
}
|
|
this._slideList[name] = a;
|
|
}
|
|
}
|
|
if(Boolean(a) && Boolean(av))
|
|
{
|
|
av.startSlide(a);
|
|
}
|
|
this._movePlayerToPos = null;
|
|
this._followPath = null;
|
|
this._bMouseDown = false;
|
|
}
|
|
|
|
public function getLengthLineIntersectGrid(inStart:Point, inLinePoint:Point, inMaxLength:Number) : Number
|
|
{
|
|
var testX:Number = NaN;
|
|
var testY:Number = NaN;
|
|
var cellX:int = 0;
|
|
var cellY:int = 0;
|
|
var lineNormal:Number = Math.sqrt((inStart.x - inLinePoint.x) * (inStart.x - inLinePoint.x) + (inStart.y - inLinePoint.y) * (inStart.y - inLinePoint.y));
|
|
var lineNormalX:Number = (inLinePoint.x - inStart.x) / lineNormal;
|
|
var lineNormalY:Number = (inLinePoint.y - inStart.y) / lineNormal;
|
|
var returnLength:Number = 10;
|
|
var segmentStep:Number = Number(_grid.r2);
|
|
while(returnLength < inMaxLength)
|
|
{
|
|
testX = inStart.x + lineNormalX * returnLength;
|
|
testY = inStart.y + lineNormalY * returnLength;
|
|
cellX = (testX + _mainBackObj.x - _grid.min.x) / _grid.r2;
|
|
cellY = (testY + _mainBackObj.y - _grid.min.y) / _grid.r2;
|
|
if(_roomGrid.testGridCell(cellX,cellY) == 1)
|
|
{
|
|
break;
|
|
}
|
|
returnLength += segmentStep;
|
|
}
|
|
return returnLength + 50;
|
|
}
|
|
}
|
|
}
|
|
|