Brought up to date with the private repository (feea4c7)

This commit is contained in:
S committed 2026-10-14 20:57:33 +03:00
1 parent 1aa738d692
commit 1b1df1ae48
7925 files changed
+2617237 -20

No files matched your search

@@ -0,0 +1,471 @@
package game
{
import com.sbi.loader.LoaderCacheEntry_URL;
import com.sbi.loader.LoaderEvent;
import com.sbi.loader.SceneLoader;
import com.sbi.popup.SBOkPopup;
import flash.display.MovieClip;
import flash.display.Sprite;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.media.Sound;
import flash.media.SoundTransform;
import flash.ui.Keyboard;
import flash.utils.getTimer;
import gui.GuiManager;
import loader.MediaHelper;
import localization.LocalizationManager;
public class GameBase extends Sprite
{
private var _activeDlgMC:MovieClip;
private var _activeDlg:GuiDialog;
private var _guiButtons:Array;
private var _gemMultiplierMC:MovieClip;
private var _gemMultiplierMediaHelper:MediaHelper;
private var _gameLoader:LoaderCacheEntry_URL;
private var _sceneName:String;
protected var _pauseGame:Boolean;
private var _trackerVal:Array;
protected var _scene:SceneLoader;
protected var _closeBtn:MovieClip;
protected var _guiLayer:Sprite;
private var _gameStartTime:int;
public var _totalGemsEarned:int;
protected var _gameIdleTimer:Number;
private var _trackerMain:Array;
private var _lastIdleTimer:Number;
private var _kickPopup:SBOkPopup;
protected var _miniGameDefID:int;
private var _inRoomGame:Boolean;
private var _trackerNum:Array;
private var _onCloseCallback:Function;
public function GameBase()
{
super();
MinigameManager._pvpPromptReplay = false;
this._miniGameDefID = MinigameManager.minigameInfoCache.currMinigameId;
this._trackerVal = new Array();
this._trackerNum = new Array();
this._trackerMain = new Array();
if(this._miniGameDefID != -1)
{
this._inRoomGame = MinigameManager.minigameInfoCache.getMinigameInfo(this._miniGameDefID).isInRoomGame;
}
else
{
this._inRoomGame = false;
}
this._gameIdleTimer = 0;
this._totalGemsEarned = 0;
this._guiButtons = [];
this._gameStartTime = getTimer();
}
public function get activeDlgMC() : MovieClip
{
return this._activeDlgMC;
}
protected function loadScene(sceneName:String) : void
{
this._sceneName = sceneName;
this._gemMultiplierMediaHelper = new MediaHelper();
this._gemMultiplierMediaHelper.init(1067,this.gemMultiplierMediaHandler);
}
private function gemMultiplierMediaHandler(mc:MovieClip) : void
{
this._gemMultiplierMC = mc;
this._gameLoader = new LoaderCacheEntry_URL(MainFrame.ROOMS_FOLDER + this._sceneName.toLowerCase());
this._gameLoader.addEventListener(LoaderEvent.ON_LOAD_COMPLETE,this.loadComplete);
this._gameLoader.load();
}
private function loadComplete(e:LoaderEvent) : void
{
var scene:Object = null;
scene = this._gameLoader.data;
this._gameLoader.removeEventListener(LoaderEvent.ON_LOAD_COMPLETE,this.loadComplete);
this._scene = new SceneLoader();
this._scene.setScene(scene,true);
this._scene.addEventListener(Event.COMPLETE,this.sceneLoaded,false,0,true);
}
protected function releaseBase() : void
{
var guiBtn:GuiButton = null;
var gameTime:Number = (getTimer() - this._gameStartTime) / 1000;
if(this._kickPopup != null)
{
this._kickPopup.destroy();
this._kickPopup = null;
}
stage.removeEventListener(KeyboardEvent.KEY_DOWN,this.gemMultiplierCloseKeyDown);
stage.removeEventListener(KeyboardEvent.KEY_DOWN,this.resetKeyIdleTimer,false);
stage.removeEventListener(MouseEvent.MOUSE_DOWN,this.resetMouseDownIdleTimer,false);
stage.removeEventListener(MouseEvent.MOUSE_MOVE,this.resetMouseMoveIdleTimer,false);
stage.removeEventListener(Event.ENTER_FRAME,this.gameBaseHeartbeat);
for each(guiBtn in this._guiButtons)
{
guiBtn.release();
}
this._guiButtons = [];
if(Boolean(this._scene))
{
this._scene.release();
}
this._gameLoader = null;
}
protected function sceneLoaded(e:Event) : void
{
var i:int = 0;
var o:Object = null;
this._scene.removeEventListener(Event.COMPLETE,this.sceneLoaded);
e = new Event(Event.COMPLETE);
dispatchEvent(e);
var a:Array = this._scene.getActorList("ActorLayer");
for(i = 0; i < a.length; i++)
{
o = a[i];
if(o.s.content is MovieClip)
{
LocalizationManager.findAllTextfields(o.s.content);
}
}
this._lastIdleTimer = getTimer();
stage.addEventListener(KeyboardEvent.KEY_DOWN,this.resetKeyIdleTimer,false);
stage.addEventListener(MouseEvent.MOUSE_DOWN,this.resetMouseDownIdleTimer,false);
stage.addEventListener(MouseEvent.MOUSE_MOVE,this.resetMouseMoveIdleTimer,false);
stage.addEventListener(Event.ENTER_FRAME,this.gameBaseHeartbeat);
}
private function gameBaseHeartbeat(e:Event) : void
{
var frameTime:Number = (getTimer() - this._lastIdleTimer) / 1000;
this._lastIdleTimer = getTimer();
if(this._inRoomGame == false)
{
this._gameIdleTimer += frameTime;
if(this._gameIdleTimer > 3 * 60)
{
if(this._gameIdleTimer > 4 * 60)
{
if(this.hasOwnProperty("end"))
{
this["end"](null);
}
}
else if(this._kickPopup == null)
{
this._kickPopup = new SBOkPopup(GuiManager.guiLayer,LocalizationManager.translateIdOnly(14681),false,this.onKickWarningPopup);
AJAudio.playIdleWarningSound();
}
}
}
}
private function onKickWarningPopup(evt:MouseEvent) : void
{
evt.stopPropagation();
SBOkPopup.destroyInParentChain(evt.target.parent);
this._kickPopup = null;
this._gameIdleTimer = 0;
}
private function resetKeyIdleTimer(event:KeyboardEvent) : void
{
if(this._kickPopup != null)
{
this._kickPopup.destroy();
this._kickPopup = null;
}
this._gameIdleTimer = 0;
}
private function resetMouseMoveIdleTimer(event:MouseEvent) : void
{
if(this._kickPopup == null)
{
this._gameIdleTimer = 0;
}
}
private function resetMouseDownIdleTimer(evt:Event) : void
{
if(this._kickPopup != null)
{
this._kickPopup.destroy();
this._kickPopup = null;
}
this._gameIdleTimer = 0;
}
private function gemMultiplierClose() : void
{
stage.removeEventListener(KeyboardEvent.KEY_DOWN,this.gemMultiplierCloseKeyDown);
if(this._onCloseCallback != null)
{
this._onCloseCallback();
this._onCloseCallback = null;
}
}
private function gemMultiplierCloseKeyDown(event:KeyboardEvent) : void
{
switch(event.keyCode)
{
case Keyboard.ENTER:
case Keyboard.SPACE:
case Keyboard.BACKSPACE:
case Keyboard.DELETE:
case Keyboard.ESCAPE:
this.gemMultiplierClose();
}
}
protected function showGemMultiplierDlg(onCloseCallback:Function) : MovieClip
{
var gemMultiplier:Number = NaN;
var mc:MovieClip = null;
if(this._totalGemsEarned > 0)
{
gemMultiplier = 1;
if(this._miniGameDefID != -1)
{
gemMultiplier = MinigameManager.minigameInfoCache.getMinigameInfo(this._miniGameDefID).gemMultiplier;
}
if(gemMultiplier > 1)
{
if(this._activeDlg != null)
{
this.hideDlg();
}
if(this._activeDlg == null && Boolean(this._gemMultiplierMC))
{
if(Boolean(this._closeBtn))
{
this._closeBtn.visible = false;
}
this._pauseGame = true;
mc = this._gemMultiplierMC.getChildAt(0) as MovieClip;
this._guiLayer.addChild(mc);
this._onCloseCallback = onCloseCallback;
this._activeDlg = new GuiDialog(mc,[{
"name":"x_btn",
"f":onCloseCallback
}]);
stage.addEventListener(KeyboardEvent.KEY_DOWN,this.gemMultiplierCloseKeyDown);
this._activeDlgMC = mc;
mc.x = 450;
mc.y = 275;
LocalizationManager.translateIdAndInsert(mc.Gems_Earned,10062,this._totalGemsEarned / gemMultiplier);
LocalizationManager.translateIdAndInsert(mc.Gem_Bonus,10063,gemMultiplier);
LocalizationManager.translateIdAndInsert(mc.Gems_Total,10064,this._totalGemsEarned);
return mc;
}
}
}
return null;
}
protected function showDlg(defName:String, buttons:Array, bModal:Boolean = true) : MovieClip
{
var mc:MovieClip = null;
if(!bModal)
{
mc = GETDEFINITIONBYNAME(defName);
this._guiLayer.addChild(mc);
}
else
{
if(this._activeDlg != null)
{
this.hideDlg();
}
if(this._activeDlg == null)
{
if(Boolean(this._closeBtn))
{
this._closeBtn.visible = false;
}
this._pauseGame = true;
mc = GETDEFINITIONBYNAME(defName);
this._guiLayer.addChild(mc);
this._activeDlg = new GuiDialog(mc,buttons);
this._activeDlgMC = mc;
}
}
return mc;
}
protected function hideDlg() : void
{
if(Boolean(this._activeDlg))
{
this._activeDlg.release();
this._guiLayer.removeChild(this._activeDlgMC);
this._activeDlg = null;
this._activeDlgMC = null;
this._pauseGame = false;
if(Boolean(this._closeBtn))
{
this._closeBtn.visible = true;
}
}
}
protected function addBtn(defName:String, x:int, y:int, func:Function) : MovieClip
{
var mc:MovieClip = GETDEFINITIONBYNAME(defName);
mc.x = x;
mc.y = y;
this._guiLayer.addChild(mc);
var guiBtn:GuiButton = new GuiButton(mc,func);
this._guiButtons.push(guiBtn);
return mc;
}
private function mainTracker() : void
{
var lbV:int = 0;
if(this._miniGameDefID != -1)
{
lbV = MinigameManager.minigameInfoCache.getMinigameInfo(this._miniGameDefID).lbUseVarRef;
}
this._trackerNum.push(this._trackerMain[this._trackerMain.length - 1] - lbV * 7 - 78922);
this.numTracker();
}
protected function loadSound(sndClass:Class) : Sound
{
var snd:Sound = new sndClass() as Sound;
var st:SoundTransform = new SoundTransform(0,0);
snd.play(0,0,st);
return snd;
}
public function valueTrackerCommit() : void
{
var lbV:int = 0;
if(this._miniGameDefID != -1)
{
lbV = MinigameManager.minigameInfoCache.getMinigameInfo(this._miniGameDefID).lbUseVarRef;
if(lbV != 0)
{
MinigameManager.sendScore(this._trackerMain[this._trackerMain.length - 1],this._trackerVal[this._trackerVal.length - 1],this._trackerNum[this._trackerNum.length - 1],lbV,this._miniGameDefID);
}
}
}
protected function removeLayer(o:Sprite) : void
{
while(Boolean(o.numChildren))
{
o.removeChild(o.getChildAt(0));
}
o.parent.removeChild(o);
}
protected function addToPetMastery(amount:int) : void
{
MinigameManager.awardPetMasteryPoints(amount);
}
private function numTracker() : void
{
var lbV:int = 0;
if(this._miniGameDefID != -1)
{
lbV = MinigameManager.minigameInfoCache.getMinigameInfo(this._miniGameDefID).lbUseVarRef;
}
this._trackerVal.push(this._trackerNum[this._trackerNum.length - 1] - lbV * 9 + 15645);
}
protected function addGemsToBalance(amount:int) : void
{
var gemMultiplier:Number = 1;
if(this._miniGameDefID != -1)
{
gemMultiplier = MinigameManager.minigameInfoCache.getMinigameInfo(this._miniGameDefID).gemMultiplier;
}
if(gemMultiplier > 1)
{
amount *= gemMultiplier;
}
this._totalGemsEarned += amount;
MinigameManager.awardGems(amount,this._miniGameDefID);
}
public function valueTrackerCurrent() : Number
{
var lbV:int = 0;
if(this._trackerMain.length > 0)
{
lbV = 0;
if(this._miniGameDefID != -1)
{
lbV = MinigameManager.minigameInfoCache.getMinigameInfo(this._miniGameDefID).lbUseVarRef;
}
return 9999999 - (this._trackerMain[this._trackerMain.length - 1] - lbV * 5 + MinigameManager.getScoreSN());
}
return 0;
}
public function getScene() : SceneLoader
{
return this._scene;
}
public function getPaused() : Boolean
{
return this._pauseGame;
}
public function getGuiLayer() : Sprite
{
return this._guiLayer;
}
public function valueTracker(value:Number) : void
{
var lbV:int = 0;
if(this._miniGameDefID != -1)
{
lbV = MinigameManager.minigameInfoCache.getMinigameInfo(this._miniGameDefID).lbUseVarRef;
}
this._trackerMain.push(9999999 - (value - lbV * 5 + MinigameManager.getScoreSN()));
if(this._trackerMain.length >= 3)
{
this._trackerMain.shift();
}
this.mainTracker();
}
}
}
@@ -0,0 +1,57 @@
package game
{
import flash.display.MovieClip;
import flash.events.MouseEvent;
public class GuiButton
{
private var _mc:MovieClip;
private var _clickFunc:Function;
public function GuiButton(mc:MovieClip, f:Function)
{
super();
this._mc = mc;
this._clickFunc = f;
this._mc.addEventListener(MouseEvent.ROLL_OVER,this.mouseOver);
this._mc.addEventListener(MouseEvent.ROLL_OUT,this.mouseOut);
this._mc.addEventListener(MouseEvent.MOUSE_DOWN,this.mouseClick);
this._mc.gotoAndStop("off");
}
public function release() : void
{
this._mc.removeEventListener(MouseEvent.ROLL_OVER,this.mouseOver);
this._mc.removeEventListener(MouseEvent.ROLL_OUT,this.mouseOut);
this._mc.removeEventListener(MouseEvent.MOUSE_DOWN,this.mouseClick);
this._mc.parent.removeChild(this._mc);
this._mc = null;
}
private function mouseOver(e:MouseEvent) : void
{
if(this._mc.currentFrameLabel != "on")
{
this._mc.gotoAndPlay("on");
}
AJAudio.playHudBtnRollover();
}
private function mouseOut(e:MouseEvent) : void
{
if(this._mc.currentFrameLabel != "off")
{
this._mc.gotoAndPlay("off");
}
}
private function mouseClick(e:MouseEvent) : void
{
this._clickFunc();
AJAudio.playHudBtnClick();
}
}
}
@@ -0,0 +1,59 @@
package game
{
import flash.display.MovieClip;
public class GuiDialog
{
private var _mc:MovieClip;
private var _buttons:Array;
public function GuiDialog(mc:MovieClip, buttons:Array)
{
var i:int = 0;
var o:Object = null;
var btn_mc:MovieClip = null;
var btn:GuiButton = null;
var buttonname:String = null;
var buttonObject:Object = null;
var layername:String = null;
super();
this._mc = mc;
for(this._buttons = []; i < buttons.length; )
{
o = buttons[i];
btn_mc = this._mc[o.name];
if(!btn_mc)
{
buttonname = o.name;
buttonObject = this._mc;
while(buttonname.indexOf(".") != -1)
{
layername = buttonname.substring(0,buttonname.indexOf("."));
buttonObject = buttonObject[layername];
buttonname = buttonname.substring(buttonname.indexOf(".") + 1,buttonname.length);
}
btn_mc = buttonObject[buttonname];
if(!btn_mc)
{
throw new Error("ERROR: Button Not Found:\" " + o.name + "\" verify button names across SWF files.");
}
}
btn = new GuiButton(btn_mc,o.f);
i++;
}
}
public function release() : void
{
for(var i:int = 0; i < this._buttons.length; )
{
this._buttons.release();
i++;
}
this._buttons = [];
}
}
}
@@ -0,0 +1,13 @@
package game
{
public interface IMinigame
{
function start(param1:uint, param2:Array, param3:Function, param4:Function) : void;
function message(param1:Array) : void;
function end(param1:Array) : void;
}
}
@@ -0,0 +1,107 @@
package game
{
import flash.display.MovieClip;
import loader.MediaHelper;
public class MinigameInfo
{
public var gameDefId:uint;
public var titleStrId:uint;
public var extName:String;
public var swfName:String;
public var minPlayers:uint;
public var maxPlayers:uint;
public var maxSpectators:uint;
public var type:uint;
public var gameCardMediaId:uint;
public var gameCountUserVarRef:uint;
public var custom1UserVarRef:uint;
public var custom2UserVarRef:uint;
public var readyForPVP:Boolean;
public var gemMultiplier:Number;
public var petDefId:int;
public var proModeUserVarRefId:int;
public var lbUseVarRef:int;
private var _gameCardScreen:MovieClip;
private var _hasLoadedScreen:Boolean;
public function MinigameInfo()
{
super();
}
public function init(initGameDefId:uint, initTitleStrId:uint, initExtName:String, initSwfName:String, initMinPlayers:uint, initMaxPlayers:uint, initMaxSpectators:uint, initType:uint, initGameCardMediaId:uint, initGameCountUserVarRef:uint, initCustom1UserVarRef:uint, initCustom2UserVarRef:uint, initReadyForPVP:uint, initGemMultiplier:Number, initGameCardScreen:MovieClip, initPetDefId:int, initProModeUserVarRefId:int, initLeaderboardUserVarRef:int) : void
{
this.gameDefId = initGameDefId;
this.titleStrId = initTitleStrId;
this.extName = initExtName;
this.swfName = initSwfName;
this.minPlayers = initMinPlayers;
this.maxPlayers = initMaxPlayers;
this.maxSpectators = initMaxSpectators;
this.type = initType;
this.gameCardMediaId = initGameCardMediaId;
this.gameCountUserVarRef = initGameCountUserVarRef;
this.custom1UserVarRef = initCustom1UserVarRef;
this.custom2UserVarRef = initCustom2UserVarRef;
this.readyForPVP = initReadyForPVP != 0;
this.gemMultiplier = initGemMultiplier;
this.gameCardScreen = initGameCardScreen;
this.petDefId = initPetDefId;
this.proModeUserVarRefId = initProModeUserVarRefId;
this.lbUseVarRef = initLeaderboardUserVarRef;
}
public function get isInRoomGame() : Boolean
{
return this.type == 0;
}
public function get gameCardScreen() : MovieClip
{
var screenMediaHelper:MediaHelper = null;
if(this._hasLoadedScreen)
{
return this._gameCardScreen;
}
this._gameCardScreen = new MovieClip();
screenMediaHelper = new MediaHelper();
screenMediaHelper.init(this.gameCardMediaId,this.onScreenLoaded);
return this._gameCardScreen;
}
public function set gameCardScreen(screen:MovieClip) : void
{
if(screen != null)
{
this._hasLoadedScreen = true;
}
this._gameCardScreen = screen;
}
private function onScreenLoaded(img:MovieClip) : void
{
this._gameCardScreen.addChild(img);
}
}
}
@@ -0,0 +1,94 @@
package game
{
public class MinigameInfoCache
{
public var currMinigameId:int;
private var minigameInfo:Object;
public function MinigameInfoCache()
{
super();
}
public function init() : void
{
this.minigameInfo = new Object();
this.currMinigameId = -1;
}
public function destroy() : void
{
this.minigameInfo = null;
}
public function get playerMinigameInfo() : MinigameInfo
{
return this.minigameInfo[this.currMinigameId];
}
public function set playerMinigameInfo(setMgInfo:MinigameInfo) : void
{
this.currMinigameId = setMgInfo.gameDefId;
this.minigameInfo[this.currMinigameId] = setMgInfo;
}
public function getMinigameInfo(minigameDefId:int) : MinigameInfo
{
return this.minigameInfo[minigameDefId];
}
public function getMinigameInfoByExtName(minigameExtName:String) : MinigameInfo
{
var gmix:MinigameInfo = null;
for each(gmix in this.minigameInfo)
{
if(gmix.extName == minigameExtName)
{
return gmix;
}
}
return null;
}
public function getMinigameInfoBySwfName(minigameSwfName:String) : MinigameInfo
{
var gmis:MinigameInfo = null;
for each(gmis in this.minigameInfo)
{
if(gmis.swfName == minigameSwfName)
{
return gmis;
}
}
return null;
}
public function getAllReadyForPvpGameDefs() : Array
{
var pvpGameDefs:Array = null;
var grfp:MinigameInfo = null;
if(Boolean(this.minigameInfo))
{
pvpGameDefs = [];
for each(grfp in this.minigameInfo)
{
if(grfp.readyForPVP)
{
pvpGameDefs.push(grfp);
}
}
pvpGameDefs.sortOn(["gameDefId"],[Array.DESCENDING]);
return pvpGameDefs;
}
return null;
}
public function setMinigameInfo(setMinigameDefId:int, newGameDefInfo:MinigameInfo) : void
{
this.minigameInfo[setMinigameDefId] = newGameDefInfo;
}
}
}
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,31 @@
package game
{
import flash.utils.ByteArray;
import mx.core.MovieClipLoaderAsset;
[Embed(source="/_assets/assets.swf", symbol="symbol1")]
public class MinigameManager_GameTotem extends MovieClipLoaderAsset
{
private static var bytes:ByteArray = null;
public var dataClass:Class = MinigameManager_GameTotem_dataClass;
public function MinigameManager_GameTotem()
{
super();
initialWidth = 2000 / 20;
initialHeight = 3000 / 20;
}
override public function get movieClipData() : ByteArray
{
if(bytes == null)
{
bytes = ByteArray(new this.dataClass());
}
return bytes;
}
}
}
@@ -0,0 +1,16 @@
package game
{
import mx.core.ByteArrayAsset;
[ExcludeClass]
[Embed(source="/_assets/5_game.MinigameManager_GameTotem_dataClass.bin", mimeType="application/octet-stream")]
public class MinigameManager_GameTotem_dataClass extends ByteArrayAsset
{
public function MinigameManager_GameTotem_dataClass()
{
super();
}
}
}
@@ -0,0 +1,140 @@
package game
{
import com.sbi.client.SFEvent;
public class MinigameXtCommManager
{
private static var _miCallback:Function;
public static const PVP_REQUEST_OR_ACCEPT:int = 0;
public static const PVP_DENY_DENIED_OR_CANCEL:int = 1;
public function MinigameXtCommManager()
{
super();
}
public static function init() : void
{
XtReplyDemuxer.addModule(handleXtReply,"m");
}
public static function destroy() : void
{
XtReplyDemuxer.removeModule(handleXtReply);
}
public static function sendMinigameInfoRequest(gameDefIds:Array, subRoom:Boolean = false, callback:Function = null) : void
{
_miCallback = callback;
gMainFrame.server.setXtObject_Str("mi",gameDefIds,true,subRoom);
}
public static function sendMinigameJoinRequest(gameId:int, subRoom:Boolean = false, playMultiPlayer:Boolean = false, proModeId:int = 0) : void
{
var mjra:Array = [gameId,playMultiPlayer ? "1" : "0",proModeId];
gMainFrame.server.setXtObject_Str("mj",mjra,true,subRoom);
}
public static function sendMinigameStartRequest(gameId:int, subRoom:Boolean = false) : void
{
var mjra:Array = [gameId];
gMainFrame.server.setXtObject_Str("ms",mjra,true,subRoom);
}
public static function sendMinigameLeaveRequest() : void
{
gMainFrame.server.setXtObject_Str("ml",null,true,true);
}
public static function sendMinigameMessageRequest(messages:Array, inRoom:Boolean) : void
{
gMainFrame.server.setXtObject_Str("mm",messages,true,inRoom);
}
public static function sendMinigamePvpMsg(gameDefId:int, flag:int, userName:String = "") : void
{
if(userName != "")
{
gMainFrame.server.setXtObject_Str("mp",[gameDefId,flag,userName]);
}
else
{
gMainFrame.server.setXtObject_Str("mp",[gameDefId,flag]);
}
}
public static function sendMinigameCustomPvpJoinMsg(gameDefId:int, isCancel:int, userName:String) : void
{
gMainFrame.server.setXtObject_Str("mcp",[gameDefId,isCancel,userName]);
}
public static function sendMinigameLeaderboardRequest(gameId:int) : void
{
var mlbra:Array = [gameId];
gMainFrame.server.setXtObject_Str("mlb",mlbra);
}
public static function handleXtReply(evt:SFEvent) : void
{
var data:* = evt.obj;
switch(data[0])
{
case "mi":
handleMinigameInfo(data);
break;
case "ms":
MinigameManager.startGame(data);
break;
case "mj":
MinigameManager.joinGameResponse(data);
break;
case "ml":
case "mm":
MinigameManager.messageGame(data);
break;
case "me":
MinigameManager.minigameEndResponse(data);
break;
case "mr":
MinigameManager.minigameRoomRemovedResponse(data);
break;
case "mp":
MinigameManager.pvpResponse(data);
break;
case "mg":
MinigameManager.minigameGems(data);
break;
case "ma":
MinigameManager.minigamePetMastery(data);
break;
case "mlb":
MinigameManager.leaderBoardResponse(data);
break;
default:
throw new Error("MinigameManager illegal data:" + data[0]);
}
}
private static function handleMinigameInfo(data:Object) : void
{
var cmi:MinigameInfo = null;
var di:int = 2;
var minigameInfosLength:int = parseInt(data[di++]);
for(var hmi:int = 0; hmi < minigameInfosLength; hmi++)
{
cmi = new MinigameInfo();
cmi.init(parseInt(data[di++]),parseInt(data[di++]),data[di++],data[di++],parseInt(data[di++]),parseInt(data[di++]),parseInt(data[di++]),parseInt(data[di++]),parseInt(data[di++]),parseInt(data[di++]),parseInt(data[di++]),parseInt(data[di++]),parseInt(data[di++]),parseFloat(data[di++]),null,parseInt(data[di++]),parseInt(data[di++]),parseInt(data[di++]));
MinigameManager.minigameInfoCache.setMinigameInfo(cmi.gameDefId,cmi);
}
if(_miCallback != null)
{
_miCallback();
_miCallback = null;
}
}
}
}
@@ -0,0 +1,511 @@
package game
{
import com.sbi.corelib.audio.SBAudio;
import com.sbi.corelib.audio.SBMusic;
import com.sbi.loader.LoaderCache;
import flash.display.Loader;
import flash.display.MovieClip;
import flash.events.Event;
import flash.events.KeyboardEvent;
import flash.events.MouseEvent;
import flash.geom.Rectangle;
import flash.media.Sound;
import flash.media.SoundChannel;
import flash.media.SoundTransform;
import flash.ui.Keyboard;
import flash.utils.Dictionary;
import flash.utils.getTimer;
import gui.GuiManager;
public class SoundManager
{
private static const BARWIDTH:int = 136;
public var _soundVolume:Dictionary;
public var _soundChannel:Dictionary;
public var _sound:Dictionary;
private var _soundsPlaying:Dictionary;
private var _soundLimit:int;
public var _sounds:Array;
public var _soundToolInstace:MovieClip;
public var _barSound:Dictionary;
public var _minigame:GameBase;
private var _currentDragger:MovieClip;
private var _soundVolumeByName:Dictionary;
private var _lastTimeFadeIn:Number;
private var _lastTimeFadeOut:Number;
private var _fadeInStream:SBMusic;
private var _fadeOutStream:SBMusic;
private var SoundTool:Class = SoundManager_SoundTool;
public function SoundManager(minigame:GameBase, soundLimit:int = 0)
{
super();
this._soundVolume = new Dictionary(true);
this._barSound = new Dictionary(true);
this._soundChannel = new Dictionary(true);
this._sound = new Dictionary(true);
this._soundsPlaying = new Dictionary(true);
this._soundVolumeByName = new Dictionary(true);
this._sounds = new Array();
this._minigame = minigame;
this._soundLimit = soundLimit;
if(Boolean(this._minigame) && Boolean(this._minigame.stage))
{
this._minigame.stage.addEventListener(KeyboardEvent.KEY_DOWN,this.keyboardPressed,false,0,true);
}
else
{
gMainFrame.stage.addEventListener(KeyboardEvent.KEY_DOWN,this.keyboardPressed,false,0,true);
}
if(!MainFrame.isInitialized())
{
LoaderCache.contentURL = "../../";
}
}
public function setVolumes(volumes:Dictionary) : void
{
var key:Object = null;
for(key in volumes)
{
this._soundVolumeByName[key] = volumes[key];
}
}
private function getSound(name:String) : Object
{
var o:Object = null;
if(name == null)
{
return null;
}
for each(o in this._sounds)
{
if(o.name == name)
{
return o;
}
}
return null;
}
public function addSound(sndClass:Class, volume:Number, name:String = null) : void
{
var snd:Object = this.getSound(name);
if(snd == null)
{
snd = new Object();
snd.sound = new sndClass() as Sound;
if(Boolean(name))
{
snd.name = name;
}
this._sounds.push(snd);
this._sound[sndClass] = snd.sound;
}
if(volume >= 0)
{
this._soundVolume[snd.sound] = volume;
}
else
{
this._soundVolume[snd.sound] = this._soundVolumeByName[name];
}
this._soundsPlaying[snd.sound] = 0;
var st:SoundTransform = new SoundTransform(0,0);
var sc:SoundChannel = snd.sound.play(0,0,st);
if(Boolean(sc))
{
sc.stop();
}
}
public function addStream(name:String, volume:Number) : SBMusic
{
var snd:Object = new Object();
var stream:SBMusic = new SBMusic(name + ".mp3",false,volume);
snd.sound = stream;
snd.name = name;
this._soundVolume[snd.sound] = volume;
this._sounds.push(snd);
return snd.sound;
}
public function play(sndClass:Class, startTime:Number = 0, loops:int = 0) : SoundChannel
{
var volume:Number = NaN;
var st:SoundTransform = null;
var sc:SoundChannel = null;
var sound:Sound = this._sound[sndClass];
if(Boolean(sound))
{
if(SBAudio.isMusicMuted)
{
volume = 0;
}
else
{
volume = Number(this._soundVolume[sound]);
}
st = new SoundTransform(volume,0);
if(this._soundLimit > 0)
{
if(this._soundsPlaying[sound] >= this._soundLimit && loops == 0)
{
return null;
}
sc = sound.play(startTime,loops,st);
if(Boolean(sc))
{
this._soundsPlaying[sc] = sound;
++this._soundsPlaying[sound];
if(loops == 0)
{
sc.addEventListener(Event.SOUND_COMPLETE,this.soundComplete);
}
}
return sc;
}
return sound.play(startTime,loops,st);
}
return null;
}
private function soundComplete(e:Event) : void
{
e.target.removeEventListener(Event.SOUND_COMPLETE,this.soundComplete);
--this._soundsPlaying[this._soundsPlaying[e.target]];
this._soundsPlaying[e.target] = null;
}
private function doFadeIn(e:Event) : void
{
var fadeInValue:Number = (getTimer() - this._lastTimeFadeIn) / 1000;
if(fadeInValue >= 1)
{
fadeInValue = 1;
gMainFrame.stage.removeEventListener(Event.ENTER_FRAME,this.doFadeIn);
}
var volume:Number = this._soundVolume[this._fadeInStream] * fadeInValue;
var currentSC:SoundChannel = this._fadeInStream.sc;
var st:SoundTransform = new SoundTransform(volume,0);
this._fadeInStream.sc.soundTransform = st;
if(fadeInValue == 1)
{
this._fadeInStream = null;
}
}
private function doFadeOut(e:Event) : void
{
var fadeOutValue:Number = (getTimer() - this._lastTimeFadeOut) / 1000;
if(fadeOutValue >= 1)
{
fadeOutValue = 1;
gMainFrame.stage.removeEventListener(Event.ENTER_FRAME,this.doFadeOut);
}
var volume:Number = this._soundVolume[this._fadeOutStream] * (1 - fadeOutValue);
var currentSC:SoundChannel = this._fadeOutStream.sc;
var st:SoundTransform = new SoundTransform(volume,0);
this._fadeOutStream.sc.soundTransform = st;
if(fadeOutValue == 1)
{
this._fadeOutStream.sc.stop();
this._fadeOutStream = null;
}
}
public function destroy() : void
{
if(Boolean(this._fadeInStream))
{
gMainFrame.stage.removeEventListener(Event.ENTER_FRAME,this.doFadeIn);
this._fadeInStream = null;
}
if(Boolean(this._fadeOutStream))
{
this._fadeOutStream.sc.stop();
this._fadeOutStream = null;
gMainFrame.stage.removeEventListener(Event.ENTER_FRAME,this.doFadeOut);
}
}
public function fadeOut(stream:SBMusic) : void
{
if(SBAudio.isMusicMuted)
{
stream.stop();
return;
}
this._lastTimeFadeOut = getTimer();
this._fadeOutStream = stream;
gMainFrame.stage.addEventListener(Event.ENTER_FRAME,this.doFadeOut,false,0,true);
}
public function playStream(stream:SBMusic, startTime:Number = 0, loops:int = 0, fade:Boolean = false) : SoundChannel
{
var st:SoundTransform = null;
if(SBAudio.isMusicMuted)
{
fade = false;
}
if(stream == null)
{
return null;
}
var volume:Number = Number(this._soundVolume[stream]);
if(fade)
{
st = new SoundTransform(0,0);
gMainFrame.stage.addEventListener(Event.ENTER_FRAME,this.doFadeIn,false,0,true);
this._lastTimeFadeIn = getTimer();
this._fadeInStream = stream;
}
else
{
st = new SoundTransform(volume,0);
}
stream.stop();
stream.play(startTime,loops,st);
if(stream.sc == null)
{
return null;
}
this._soundChannel[stream] = stream.sc;
stream.sc.soundTransform = st;
if(SBAudio.isMusicMuted)
{
stream.mute();
}
return stream.sc;
}
public function pauseStream(stream:SBMusic) : void
{
stream.pause();
}
public function unpauseStream(stream:SBMusic) : void
{
stream.unpause();
}
public function togglePauseStream(stream:SBMusic) : void
{
stream.togglePause();
}
public function stop(sound:SoundChannel) : void
{
--this._soundsPlaying[this._soundsPlaying[sound]];
sound.stop();
}
private function onPlay(event:MouseEvent) : void
{
if(this._barSound[event.target.parent] is Sound)
{
this.playToolSound(this._barSound[event.target.parent]);
return;
}
this.playStream(this._barSound[event.target.parent],0,9999);
}
private function onStop(event:MouseEvent) : void
{
var sound:Sound = null;
if(this._barSound[event.target.parent] is Sound)
{
sound = this._barSound[event.target.parent];
if(Boolean(this._soundChannel[sound]))
{
this._soundChannel[sound].stop();
}
return;
}
this._barSound[event.target.parent].stop();
}
public function onComplete(event:Event) : void
{
var bar:MovieClip = null;
var snd:Object = null;
var volume:int = 0;
var loader:Loader = this._soundToolInstace.getChildAt(0) as Loader;
var content:Object = Object(loader.content);
content.background.x = 0;
content.background.y = 0;
content.background.width = 900;
content.background.height = Math.max(900,50 + this._sounds.length / 4 * 65);
content.title.x = 0.5 * (content.background.width - content.title.width);
for(var i:int = 0; i < this._sounds.length; i++)
{
bar = content.createBar();
volume = int(this._soundVolume[this._sounds[i].sound] * 100);
bar.volume.text = String(volume);
bar.song_text.text = this._sounds[i].name;
bar.scaleX = 0.5;
bar.scaleY = 0.5;
bar.x = 30 + i % 4 * bar.width * 1.1;
bar.y = 50 + Math.floor(i / 4) * bar.height;
this._barSound[bar] = this._sounds[i].sound;
bar.slider.x = volume / 100 * BARWIDTH;
bar.slider.addEventListener(MouseEvent.MOUSE_DOWN,this.onPress);
bar.slider.addEventListener(MouseEvent.MOUSE_UP,this.onRelease);
bar.volume.addEventListener(Event.CHANGE,this.onVolumeChange);
bar.play_btn.addEventListener(MouseEvent.MOUSE_DOWN,this.onPlay);
bar.stop_btn.addEventListener(MouseEvent.MOUSE_DOWN,this.onStop);
}
this._soundToolInstace.removeEventListener(Event.COMPLETE,this.onComplete);
this._soundToolInstace.addEventListener(MouseEvent.MOUSE_WHEEL,this.onMouseWheel);
}
private function onKeyDownS(e:KeyboardEvent) : void
{
if(Boolean(this._soundToolInstace))
{
switch(e.keyCode)
{
case Keyboard.PAGE_DOWN:
this._soundToolInstace.y -= 10;
break;
case Keyboard.PAGE_UP:
if(this._soundToolInstace.y < 0)
{
this._soundToolInstace.y += 10;
}
}
}
}
private function onMouseWheel(e:MouseEvent) : void
{
var loader:Loader = this._soundToolInstace.getChildAt(0) as Loader;
if(e.delta > 0)
{
if(e.currentTarget.y < 0)
{
e.currentTarget.y += 10;
}
}
else if(e.currentTarget.y > 1100 - loader.content.height)
{
e.currentTarget.y -= 10;
}
}
private function onPress(event:MouseEvent) : void
{
event.target.startDrag(false,new Rectangle(0,20,BARWIDTH * 2,0));
this._currentDragger = event.target as MovieClip;
event.target.stage.addEventListener(MouseEvent.MOUSE_UP,this.onRelease);
}
private function onRelease(event:MouseEvent) : void
{
var volume:int = 0;
var transform:SoundTransform = null;
if(Boolean(this._currentDragger))
{
volume = int(this._currentDragger.x / BARWIDTH * 100);
this._currentDragger.stopDrag();
Object(this._currentDragger.parent).volume.text = String(volume);
this._soundVolume[this._barSound[Object(this._currentDragger.parent)]] = volume / 100;
if(Boolean(this._soundChannel[this._barSound[Object(this._currentDragger.parent)]]))
{
transform = this._soundChannel[this._barSound[Object(this._currentDragger.parent)]].soundTransform;
transform.volume = volume / 100;
this._soundChannel[this._barSound[Object(this._currentDragger.parent)]].soundTransform = transform;
}
}
this._currentDragger = null;
}
private function onVolumeChange(event:Event) : void
{
var transform:SoundTransform = null;
if(parseInt(event.target.text) > 200)
{
event.target.text = String(200);
}
else if(parseInt(event.target.text) < 0)
{
event.target.text = String(0);
}
var volume:Number = parseInt(event.target.text) / 100;
this._soundVolume[this._barSound[event.target.parent]] = volume;
event.target.parent.slider.x = volume * BARWIDTH;
if(Boolean(this._soundChannel[this._barSound[event.target.parent]]))
{
transform = this._soundChannel[this._barSound[event.target.parent]].soundTransform;
transform.volume = volume;
this._soundChannel[this._barSound[event.target.parent]].soundTransform = transform;
}
}
public function invokeSoundTool() : void
{
if(this._soundToolInstace == null)
{
this._soundToolInstace = new this.SoundTool();
this._soundToolInstace.addEventListener(Event.COMPLETE,this.onComplete);
GuiManager.guiLayer.addChild(this._soundToolInstace);
}
else
{
this.closeSoundTool();
}
}
private function playToolSound(sound:Sound) : void
{
var volume:Number = Number(this._soundVolume[sound]);
var st:SoundTransform = new SoundTransform(volume,0);
var looping:Boolean = false;
if(Boolean(this._soundChannel[sound]))
{
looping = true;
this._soundChannel[sound].stop();
delete this._soundChannel[sound];
}
this._soundChannel[sound] = sound.play(0,0,st);
}
public function closeSoundTool() : void
{
GuiManager.guiLayer.removeChild(this._soundToolInstace);
Loader(this._soundToolInstace.getChildAt(0)).unloadAndStop();
this._soundToolInstace = null;
}
private function keyboardPressed(event:KeyboardEvent) : void
{
if(event.keyCode == Keyboard.F6)
{
this.invokeSoundTool();
}
else
{
this.onKeyDownS(event);
}
}
}
}
@@ -0,0 +1,31 @@
package game
{
import flash.utils.ByteArray;
import mx.core.MovieClipLoaderAsset;
[Embed(source="/_assets/assets.swf", symbol="symbol1")]
public class SoundManager_SoundTool extends MovieClipLoaderAsset
{
private static var bytes:ByteArray = null;
public var dataClass:Class = SoundManager_SoundTool_dataClass;
public function SoundManager_SoundTool()
{
super();
initialWidth = 8000 / 20;
initialHeight = 5000 / 20;
}
override public function get movieClipData() : ByteArray
{
if(bytes == null)
{
bytes = ByteArray(new this.dataClass());
}
return bytes;
}
}
}
@@ -0,0 +1,16 @@
package game
{
import mx.core.ByteArrayAsset;
[ExcludeClass]
[Embed(source="/_assets/3_game.SoundManager_SoundTool_dataClass.bin", mimeType="application/octet-stream")]
public class SoundManager_SoundTool_dataClass extends ByteArrayAsset
{
public function SoundManager_SoundTool_dataClass()
{
super();
}
}
}