Need help to create a mod

Lots of code

GenericLoadProgressBar.as:

package
{
import olympus.gui.progressbars.ProgressBar;

public dynamic class GenericLoadProgressBar extends ProgressBar
{

public function GenericLoadProgressBar()
{
super();
}
}
}

In Widgets - Transition Screens - TransitionScreenMoleculeMain.as:

package widgets.TransitionScreen
{
import olympus.core.widget.WidgetBase;
import widgets.TransitionScreen.controls.TransitionScreenAnimation;
import olympus.input.InputAction;
import flash.display.MovieClip;
import olympus.input.InputTrigger;
import olympus.constants.KeyCodes;
import olympus.constants.InputActionPriorities;
import olympus.io.CommunicationManager;
import olympus.io.InputActionManager;
import olympus.core.TooltipManager;
import widgets.shared.constants.TransitionScreenMode;
import widgets.TransitionScreen.controls.OverlayLoadAnimation;
import widgets.TransitionScreen.controls.WhiteFadeAnimation;
import widgets.TransitionScreen.controls.GenericLoadAnimation;
import gamedata.Gameplay.ScreenSlam.UiScreenSlamMessage;
import widgets.TransitionScreen.constants.TransitionScreenTunables;
import olympus.core.UISettings;
import olympus.constants.GameStates;
import olympus.audio.Audio;
import olympus.core.Ticker;
import flash.events.Event;
import olympus.events.TickerEvent;

public class TransitionScreenMoleculeMain extends WidgetBase
{

public function TransitionScreenMoleculeMain()
{
super();
CommunicationManager.RegisterServiceHandler("IsTransitionScreenVisible",this.HandleIsTransitionScreenVisible,this);
}

protected var mMode:int;

protected var mTransitionAnimation:TransitionScreenAnimation;

protected var mInputActionExit:InputAction;

protected var mbHiding:Boolean;

protected var mLotName:String;

protected var mHouseholdName:String;

protected var mTipList:Array;

protected var mTipIndex:int;

protected var mLeftTip:MovieClip;

protected var mRightTip:MovieClip;

override public function Initialize() : void
{
super.Initialize();
visible = false;
this.mInputActionExit = InputAction.WhenTriggered(InputTrigger.FromKeyBinding(KeyCodes.ESC)).CallFunction(this.HandleEscapeKey).SetPriority(InputActionPriorities.ESC_DROPDOWN_MENU);
AddMessageListener("LotDisplayInfo",this.HandleLotDisplayInfo);
AddMessageListener("GameStateChanged",this.HandleGameStateChanged);
var _loc1_:uint = CommunicationManager.CallGameService("GetGameState",null) as uint;
this.HandleGameStateChanged(_loc1_);
}

override public function Unload() : void
{
super.Unload();
InputActionManager.UnregisterAction(this.mInputActionExit);
}

override public function Show(param1:Object = null) : void
{
var _loc3_:TransitionScreenAnimation = null;
TooltipManager.getInstance().Clear();
if(this.mMode != TransitionScreenMode.NONE)
{
if(this.mTransitionAnimation.currentLabel == TransitionScreenAnimation.FRAME_HOLD)
{
this.OnTransitionAnimationInComplete(null);
}
return;
}
super.Show(param1);
var _loc2_:int = this.mMode = param1.mode;
switch(_loc2_)
{
case TransitionScreenMode.BUILD_TO_LIVE:
_loc3_ = new OverlayLoadAnimation(_loc2_);
if("text" in param1)
{
(_loc3_ as OverlayLoadAnimation).SetOverlayText(param1.text);
}
break;
case TransitionScreenMode.MAIN_MENU_TO_CAS:
case TransitionScreenMode.CAS_TO_MAIN_MENU:
_loc3_ = new WhiteFadeAnimation(_loc2_);
break;
default:
_loc3_ = new GenericLoadAnimation(_loc2_);
}
this.mTransitionAnimation = _loc3_;
addChild(_loc3_);
this.HandleStageResized(stage.stageWidth,stage.stageHeight);
_loc3_.addEventListener(TransitionScreenAnimation.ANIMATION_IN_COMPLETE,this.OnTransitionAnimationInComplete,false,0,true);
_loc3_.addEventListener(TransitionScreenAnimation.ANIMATION_OUT_COMPLETE,this.OnTransitionAnimationOutComplete,false,0,true);
_loc3_.StartIntroAnimation();
InputActionManager.RegisterAction(this.mInputActionExit);
}

override public function Hide(param1:Object = null) : void
{
var _loc3_:UiScreenSlamMessage = null;
if((this.mbHiding) || this.mMode == TransitionScreenMode.NONE)
{
return;
}
this.mbHiding = true;
var _loc2_:Number = 0;
if((TransitionScreenMode.IsToLive(this.mMode)) && (this.mLotName))
{
_loc3_ = new UiScreenSlamMessage({});
_loc3_.type = UiScreenSlamMessage.TYPE_TRAVEL_BILLBOARD;
_loc3_.size = UiScreenSlamMessage.TYPE_TRAVEL_BILLBOARD;
_loc3_.header = this.mLotName;
if(this.mHouseholdName)
{
_loc3_.subtitle = this.mHouseholdName;
}
CommunicationManager.SendUIMessage("ShowScreenSlam",_loc3_);
this.mLotName = null;
}
switch(this.mMode)
{
case TransitionScreenMode.MAIN_MENU_TO_CAS:
case TransitionScreenMode.CAS_TO_MAIN_MENU:
_loc2_ = TransitionScreenTunables.WHITE_FADE_OUT_DELAY;
break;
case TransitionScreenMode.NHD_MAP_TO_LIVE_PLAY:
if(!UISettings.SessionSettings.GetValue("GP.hasEnteredLiveMode",GameStates.ConvertStateIdToName(GameStates.PLAY)))
{
Audio.PlayAudio(Audio.GE_NEW_GAME);
UISettings.SessionSettings.SetValue("GP.hasEnteredLiveMode",true,GameStates.ConvertStateIdToName(GameStates.PLAY));
}
break;
}
if(_loc2_ > 0)
{
Ticker.Add(this,_loc2_,this.OnOutroDelayTimeout);
}
else
{
this.OnOutroDelayTimeout(null);
}
}

override public function HandleStageResized(param1:Number, param2:Number) : void
{
if(this.mMode == TransitionScreenMode.NONE)
{
return;
}
super.HandleStageResized(param1,param2);
this.mTransitionAnimation.HandleStageResized(param1,param2);
}

protected function HandleLotDisplayInfo(param1:Object) : void
{
this.mLotName = param1["lot_name"];
this.mHouseholdName = param1["household_name"];
}

protected function OnTransitionAnimationInComplete(param1:Event) : void
{
CommunicationManager.SendMessage("TransitionScreenUp",{"mode":this.mMode});
}

protected function OnTransitionAnimationOutComplete(param1:Event) : void
{
CommunicationManager.TraceAutomation("IntroLoadingScreen; status:exited");
InputActionManager.UnregisterAction(this.mInputActionExit);
this.mMode = TransitionScreenMode.NONE;
this.mbHiding = false;
this.mTransitionAnimation.removeEventListener(TransitionScreenAnimation.ANIMATION_IN_COMPLETE,this.OnTransitionAnimationInComplete);
this.mTransitionAnimation.removeEventListener(TransitionScreenAnimation.ANIMATION_OUT_COMPLETE,this.OnTransitionAnimationOutComplete);
removeChild(this.mTransitionAnimation);
this.mTransitionAnimation = null;
super.Hide(null);
CommunicationManager.SendMessage("TransitionScreenHidden",null);
}

protected function HandleEscapeKey() : Boolean
{
return false;
}

protected function OnOutroDelayTimeout(param1:TickerEvent) : void
{
this.mTransitionAnimation.StartOutroAnimation();
}

protected function HandleGameStateChanged(param1:uint) : void
{
if(param1 == GameStates.STARTUP)
{
this.Show({"mode":TransitionScreenMode.START_UP});
}
}

protected function HandleIsTransitionScreenVisible() : Boolean
{
return this.visible;
}
}
}

Widgets - Transitions - Constants - TransitionScreenTunables.as:

package widgets.TransitionScreen.constants
{
import olympus.localization.KeysLOAD;

public class TransitionScreenTunables extends Object
{

public function TransitionScreenTunables()
{
super();
}

public static const WHITE_FADE_OUT_DELAY:Number = 2000;

public static const FROM_LIVE_CAMERA_ZOOM_OUT_SPEED:Number = -0.2;

public static const GENERIC_LOAD_TIP_LIST:Array = [KeysLOAD.LOADING_SCREEN_TIP_01,KeysLOAD.LOADING_SCREEN_TIP_02,KeysLOAD.LOADING_SCREEN_TIP_03,KeysLOAD.LOADING_SCREEN_TIP_04,KeysLOAD.LOADING_SCREEN_TIP_05,KeysLOAD.LOADING_SCREEN_TIP_06,KeysLOAD.LOADING_SCREEN_TIP_07,KeysLOAD.LOADING_SCREEN_TIP_08,KeysLOAD.LOADING_SCREEN_TIP_09,KeysLOAD.LOADING_SCREEN_TIP_10,KeysLOAD.LOADING_SCREEN_TIP_11,KeysLOAD.LOADING_SCREEN_TIP_12,KeysLOAD.LOADING_SCREEN_TIP_13,KeysLOAD.LOADING_SCREEN_TIP_14,KeysLOAD.LOADING_SCREEN_TIP_15,KeysLOAD.LOADING_SCREEN_TIP_16,KeysLOAD.LOADING_SCREEN_TIP_17,KeysLOAD.LOADING_SCREEN_TIP_18,KeysLOAD.LOADING_SCREEN_TIP_19,KeysLOAD.LOADING_SCREEN_TIP_20];

public static const GENERIC_LOAD_TIP_TIMER:Number = 5000;

public static const GENERIC_LOAD_TIP_FADE_IN_DURATION:Number = 250;

public static const GENERIC_LOAD_TIP_FADE_OUT_DURATION:Number = 500;

public static const GENERIC_LOAD_PROGRESS_BAR_INTERP_PERCENT:Number = 0.5;

public static const GENERIC_LOAD_PROGRESS_BAR_INTERP_TIME:Number = 3000;

public static const GENERIC_LOAD_PROGRESS_BAR_INTERP_TIME_MULTIPLIER:Number = 1.7;

public static const GENERIC_LOAD_PROGRESS_BAR_MAX_INTERP_TIME:Number = 1000;
}
}

Widgets - TransitionScreen - Controls - GenericLoadAnimation.as:

package widgets.TransitionScreen.controls
{
import flash.display.MovieClip;
import olympus.gui.progressbars.ProgressBar;
import flash.text.TextField;
import olympus.motion.Tween;
import olympus.utils.MovieClipUtils;
import olympus.motion.Animation;
import widgets.TransitionScreen.constants.TransitionScreenTunables;
import olympus.events.TweenEvent;
import flash.events.Event;
import olympus.core.Ticker;
import widgets.shared.constants.TransitionScreenMode;
import olympus.io.EventManager;
import olympus.audio.Audio;
import olympus.events.TickerEvent;
import olympus.localization.LocKey;

public class GenericLoadAnimation extends TransitionScreenAnimation
{

public function GenericLoadAnimation(param1:int = 0)
{
addFrameScript(0,this.frame1);
super(param1);
this.mPlumbobLogoPercentY = this.mcPlumbobLogo.y / mcBg.height;
this.mProgressBarPlumbobOffset = this.mcProgressBar.y - this.mcPlumbobLogo.y;
this.mTipTextPlumbobOffset = this.txtTip.y - this.mcPlumbobLogo.y;
}

public var mcPlumbobLogo:MovieClip;

public var mcProgressBar:ProgressBar;

public var txtTip:TextField;

protected var mTipList:Array;

protected var mTipIndex:int;

protected var mTipFadeInTween:Tween;

protected var mTipFadeOutTween:Tween;

protected var mProgressInterpValueStart:Number = 0;

protected var mProgressInterpValueEnd:Number = 0;

protected var mProgressInterpValueRange:Number = 0;

protected var mProgressInterpTimeTotal:int;

protected var mProgressInterpTime:int;

protected var mbLoadComplete:Boolean;

protected var mPlumbobLogoPercentY:Number = 0;

protected var mProgressBarPlumbobOffset:Number = 0;

protected var mTipTextPlumbobOffset:Number = 0;

override protected function ConfigUI() : void
{
MovieClipUtils.AddFrameScript(this.mcPlumbobLogo,FRAME_HOLD,OnAnimationInComplete);
MovieClipUtils.AddFrameScript(this.mcPlumbobLogo,FRAME_END,OnAnimationOutComplete);
this.mcProgressBar.SetRange(0,100);
this.mTipFadeInTween = Tween.QuickAnimation(Animation.FADE_IN,TransitionScreenTunables.GENERIC_LOAD_TIP_FADE_IN_DURATION,this.txtTip);
this.mTipFadeOutTween = Tween.QuickAnimation(Animation.FADE_OUT,TransitionScreenTunables.GENERIC_LOAD_TIP_FADE_OUT_DURATION,this.txtTip);
this.mTipFadeOutTween.addEventListener(TweenEvent.TWEEN_COMPLETE,this.OnTipFadeOutComplete,false,0,true);
this.mTipList = TransitionScreenTunables.GENERIC_LOAD_TIP_LIST.concat();
this.mTipList.sort(this.RandomSort);
this.mTipIndex = 0;
this.ShowNextTip();
}

override protected function OnRemovedFromStage(param1:Event) : void
{
super.OnRemovedFromStage(param1);
this.mTipFadeInTween.Stop();
this.mTipFadeOutTween.Stop();
Ticker.Remove(this);
Ticker.Remove(this.mcProgressBar);
}

override public function HandleStageResized(param1:Number, param2:Number) : void
{
super.HandleStageResized(param1,param2);
var _loc3_:MovieClip = this.mcPlumbobLogo;
_loc3_.scaleX = this.mcProgressBar.scaleX = this.txtTip.scaleX = 1 / scaleX;
_loc3_.scaleY = this.mcProgressBar.scaleY = this.txtTip.scaleY = 1 / scaleY;
_loc3_.x = 0.5 * mcBg.width;
_loc3_.y = this.mPlumbobLogoPercentY * mcBg.height;
this.mcProgressBar.x = _loc3_.x;
this.mcProgressBar.y = _loc3_.y + this.mProgressBarPlumbobOffset;
this.txtTip.x = _loc3_.x - this.txtTip.width * 0.5;
this.txtTip.y = _loc3_.y + this.mTipTextPlumbobOffset;
}

override public function StartIntroAnimation() : void
{
super.StartIntroAnimation();
this.mcPlumbobLogo.gotoAndPlay(FRAME_START);
if(mTransitionMode == TransitionScreenMode.START_UP)
{
EventManager.DispatchGameStateEvent(Audio.GAMESTATE_ENTER,"LoadingScreen",Audio.GAMESTATE_SUBSTATE_FRONTEND);
}
this.mbLoadComplete = false;
this.mcProgressBar.SetValue(0,false);
this.mProgressInterpTimeTotal = TransitionScreenTunables.GENERIC_LOAD_PROGRESS_BAR_INTERP_TIME;
this.RecalculateProgressBarInterpValues();
Ticker.Add(this.mcProgressBar,0,this.OnProgressBarTick);
}

override public function StartOutroAnimation() : void
{
this.mProgressInterpValueStart = this.mcProgressBar.Value;
this.mProgressInterpValueEnd = this.mcProgressBar.Maximum;
this.mProgressInterpValueRange = this.mProgressInterpValueEnd - this.mProgressInterpValueStart;
this.mProgressInterpTimeTotal = TransitionScreenTunables.GENERIC_LOAD_PROGRESS_BAR_MAX_INTERP_TIME;
this.mProgressInterpTime = 0;
this.mbLoadComplete = true;
}

protected function OnTipTimerUp(param1:TickerEvent) : void
{
this.mTipFadeOutTween.Start();
}

protected function OnTipFadeOutComplete(param1:TweenEvent) : void
{
this.mTipIndex++;
if(this.mTipIndex >= this.mTipList.length)
{
this.mTipIndex = 0;
}
this.ShowNextTip();
}

protected function OnProgressBarTick(param1:TickerEvent) : void
{
this.mProgressInterpTime = this.mProgressInterpTime + param1.deltaTime;
if(this.mProgressInterpTime >= this.mProgressInterpTimeTotal)
{
if(this.mbLoadComplete)
{
this.mcProgressBar.SetValue(this.mcProgressBar.Maximum);
Ticker.Remove(this.mcProgressBar);
super.StartOutroAnimation();
this.mcPlumbobLogo.gotoAndPlay(FRAME_OUTRO);
}
else
{
this.mcProgressBar.SetValue(this.mProgressInterpValueEnd);
this.mProgressInterpTimeTotal = this.mProgressInterpTimeTotal * TransitionScreenTunables.GENERIC_LOAD_PROGRESS_BAR_INTERP_TIME_MULTIPLIER;
this.RecalculateProgressBarInterpValues();
}
}
else
{
this.mcProgressBar.SetValue(this.mProgressInterpValueStart + this.mProgressInterpValueRange * this.mProgressInterpTime / this.mProgressInterpTimeTotal);
}
}

protected function RandomSort(param1:LocKey, param2:LocKey) : Number
{
return Math.random() < 0.5?-1:1;
}

protected function ShowNextTip() : void
{
this.txtTip.text = (this.mTipList[this.mTipIndex] as LocKey).toString();
this.mTipFadeInTween.Start();
Ticker.Add(this,TransitionScreenTunables.GENERIC_LOAD_TIP_TIMER,this.OnTipTimerUp);
}

protected function RecalculateProgressBarInterpValues() : void
{
this.mProgressInterpValueStart = this.mcProgressBar.Value;
this.mProgressInterpValueEnd = (this.mcProgressBar.Maximum + this.mProgressInterpValueStart) * TransitionScreenTunables.GENERIC_LOAD_PROGRESS_BAR_INTERP_PERCENT;
this.mProgressInterpValueRange = this.mProgressInterpValueEnd - this.mProgressInterpValueStart;
this.mProgressInterpTime = 0;
}

function frame1() : *
{
stop();
}
}
}

Widgets - TransitionScreen - Controls - OverlayLoadAnimation.as

package widgets.TransitionScreen.controls
{
import olympus.controls.LoadingIndicator;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;

public class OverlayLoadAnimation extends TransitionScreenAnimation
{

public function OverlayLoadAnimation(param1:int = 0)
{
addFrameScript(0,this.frame1);
super(param1);
this.mOverlayText.autoSize = TextFieldAutoSize.LEFT;
this.mOverlayText.visible = false;
this.mSpinnerToTextVerticalSpacing = this.mLoadingIndicator.y - this.mOverlayText.y;
}

public var mLoadingIndicator:LoadingIndicator;

public var mOverlayText:TextField;

protected var mSpinnerToTextVerticalSpacing:Number = 0;

public function SetOverlayText(param1:String) : void
{
if(param1)
{
this.mOverlayText.text = param1;
this.mOverlayText.x = 0.5 * (mcBg.width - this.mOverlayText.width);
}
this.mOverlayText.visible = !(param1 == null);
}

override public function HandleStageResized(param1:Number, param2:Number) : void
{
super.HandleStageResized(param1,param2);
var _loc3_:LoadingIndicator = this.mLoadingIndicator;
var _loc4_:TextField = this.mOverlayText;
_loc3_.scaleX = _loc4_.scaleX = 1 / scaleX;
_loc3_.scaleY = _loc4_.scaleY = 1 / scaleY;
_loc3_.x = 0.5 * (mcBg.width - _loc3_.width);
_loc3_.y = 0.5 * (mcBg.height - _loc3_.height);
_loc4_.x = 0.5 * (mcBg.width - _loc4_.width);
_loc4_.y = this.mLoadingIndicator.y - this.mSpinnerToTextVerticalSpacing;
}

function frame1() : *
{
stop();
}
}
}

Widgets - TransitionScreen - Controls - TransitionScreenAnimation.as

package widgets.TransitionScreen.controls
{
import olympus.controls.GUIComponent;
import flash.display.MovieClip;
import olympus.utils.MovieClipUtils;
import widgets.shared.constants.TransitionScreenMode;
import olympus.io.EventManager;
import olympus.audio.Audio;
import flash.events.Event;

public class TransitionScreenAnimation extends GUIComponent
{

public function TransitionScreenAnimation(param1:int = 0)
{
super();
this.mTransitionMode = param1;
}

public static const ANIMATION_IN_COMPLETE:String = "animationInComplete";

public static const ANIMATION_OUT_COMPLETE:String = "animationOutComplete";

public static const FRAME_START:String = "start";

public static const FRAME_HOLD:String = "hold";

public static const FRAME_OUTRO:String = "outro";

public static const FRAME_END:String = "end";

public static const STAGE_SIZE_INCREASE:Number = 4;

public static const ANIMATION_OFFSET:Number = -2;

public var mcBg:MovieClip;

protected var mTransitionMode:int;

override protected function ConfigUI() : void
{
super.ConfigUI();
MovieClipUtils.AddFrameScript(this,FRAME_HOLD,this.OnAnimationInComplete);
MovieClipUtils.AddFrameScript(this,FRAME_END,this.OnAnimationOutComplete);
x = x + ANIMATION_OFFSET;
y = y + ANIMATION_OFFSET;
}

public function HandleStageResized(param1:Number, param2:Number) : void
{
var _loc3_:Number = (param1 + STAGE_SIZE_INCREASE) / this.mcBg.width;
var _loc4_:Number = (param2 + STAGE_SIZE_INCREASE) / this.mcBg.height;
this.scaleX = _loc3_;
this.scaleY = _loc4_;
}

public function StartIntroAnimation() : void
{
gotoAndPlay(FRAME_START);
if(TransitionScreenMode.HasTransitionMusic(this.mTransitionMode))
{
if(TransitionScreenMode.IsFromLive(this.mTransitionMode))
{
EventManager.DispatchGameStateEvent(Audio.GAMESTATE_ENTER,"LoadingScreen",Audio.GAMESTATE_SUBSTATE_TRANSITION);
}
else if(TransitionScreenMode.IsToLive(this.mTransitionMode))
{
EventManager.DispatchGameStateEvent(Audio.GAMESTATE_ENTER,"LoadingScreen",Audio.GAMESTATE_SUBSTATE_PLAY);
}
else if(this.mTransitionMode == TransitionScreenMode.NHD_MAP_TO_BUILD)
{
EventManager.DispatchGameStateEvent(Audio.GAMESTATE_ENTER,"LoadingScreen",Audio.GAMESTATE_SUBSTATE_BUILD);
}

}
}

public function StartOutroAnimation() : void
{
gotoAndPlay(FRAME_OUTRO);
if(TransitionScreenMode.HasTransitionMusic(this.mTransitionMode))
{
if(TransitionScreenMode.IsFromLive(this.mTransitionMode))
{
EventManager.DispatchGameStateEvent(Audio.GAMESTATE_LEAVE,"LoadingScreen",Audio.GAMESTATE_SUBSTATE_TRANSITION);
}
else if(TransitionScreenMode.IsToLive(this.mTransitionMode))
{
EventManager.DispatchGameStateEvent(Audio.GAMESTATE_LEAVE,"LoadingScreen",Audio.GAMESTATE_SUBSTATE_PLAY);
}
else if(this.mTransitionMode == TransitionScreenMode.NHD_MAP_TO_BUILD)
{
EventManager.DispatchGameStateEvent(Audio.GAMESTATE_LEAVE,"LoadingScreen",Audio.GAMESTATE_SUBSTATE_BUILD);
}

}
}

protected function OnAnimationInComplete() : void
{
stop();
dispatchEvent(new Event(ANIMATION_IN_COMPLETE));
}

protected function OnAnimationOutComplete() : void
{
stop();
dispatchEvent(new Event(ANIMATION_OUT_COMPLETE));
}
}
}

Widgets - TransitionScreen - Controls - WhiteFadeAnimation.as:

package widgets.TransitionScreen.controls
{
public class WhiteFadeAnimation extends TransitionScreenAnimation
{

public function WhiteFadeAnimation(param1:int = 0)
{
addFrameScript(0,this.frame1);
super(param1);
}

function frame1() : *
{
stop();
}
}
}

Sign in to Mod The Sims