private void Start()
{
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
m_scrollingData = active.GameLogic.ScrollingSpeed;
ScrollingLayer = mg_jr_SpriteDrawingLayers.DrawingLayers.OBSTACLE_0;
}
public virtual void Awake()
{
IsFirstGameAfterLoading = true;
IntroGary = null;
m_minigame = MinigameManager.GetActive <mg_JetpackReboot>();
m_gameBalance = base.gameObject.AddComponent <mg_jr_GameData>();
ScrollingSpeed = base.gameObject.AddComponent <mg_jr_ScrollingSpeed>();
Odometer = base.gameObject.AddComponent <mg_jr_Odometer>();
Odometer.Init(m_gameBalance, m_minigame.GoalManager);
m_timeToZoomCameraForTurbo = m_gameBalance.TurboCameraZoomRate * Mathf.Abs(1.1600001f);
ScrollingSpeed.Init(m_gameBalance, Odometer);
ScrollingSpeed.ScrollingEnabled = false;
Player = m_minigame.Resources.GetPooledResourceByComponent <mg_jr_Penguin>(mg_jr_ResourceList.GAME_PREFAB_PENGUIN);
Player.transform.parent = base.transform;
GameObject pooledResource = m_minigame.Resources.GetPooledResource(mg_jr_ResourceList.GAME_PREFAB_EFFECT_TRANSITION);
m_transition = pooledResource.GetComponent <mg_jr_Transition>();
m_transition.transform.parent = base.transform;
GameObject gameObject = new GameObject("mg_jr_EnvironmentManager");
gameObject.transform.parent = base.transform;
EnvironmentManager = gameObject.AddComponent <mg_jr_EnvironmentManager>();
GameObject gameObject2 = new GameObject("mg_jr_LevelContainer");
gameObject2.transform.parent = base.transform;
m_levelManager = gameObject2.AddComponent <mg_jr_LevelManager>();
m_levelManager.Init(ScrollingSpeed, this);
m_turboSpeedLines = m_minigame.Resources.GetPooledResourceByComponent <mg_jr_SpeedLineScreenFx>(mg_jr_ResourceList.PREFAB_TURBO_SPEEDLINES);
m_turboSpeedLines.transform.parent = base.transform;
m_turboSpeedLines.gameObject.SetActive(value: false);
m_turboPlayArea = new Bounds(Vector3.zero, new Vector3(10f * Camera.main.aspect, 10f, 40f));
}
private void Start()
{
m_miniGame = MinigameManager.GetActive <mg_JetpackReboot>();
m_odometer = m_miniGame.GameLogic.Odometer;
Localizer localizer = null;
if (Service.IsSet <Localizer>())
{
localizer = Service.Get <Localizer>();
}
m_distanceUnit = ((localizer == null) ? "m" : localizer.GetTokenTranslation("Activity.MiniGames.MetersDistance"));
if (m_miniGame.PlayerStats.BestDistance == 0)
{
base.gameObject.SetActive(value: false);
return;
}
Text[] componentsInChildren = base.gameObject.GetComponentsInChildren <Text>();
Text[] array = componentsInChildren;
foreach (Text text in array)
{
if (text.gameObject.name == "mg_jr_DistanceLabel")
{
m_distanceLabel = text;
m_distanceLabel.text = m_miniGame.PlayerStats.BestDistance + m_distanceUnit;
}
else if (text.gameObject.name == "mg_jr_SignTitle")
{
m_signLabel = text;
m_signLabel.text = ((localizer == null) ? "Longest Flight" : localizer.GetTokenTranslation("Activity.MiniGames.Flight"));
}
}
}
private void Start()
{
m_renderer = GetComponentInChildren <SpriteRenderer>();
m_miniGame = MinigameManager.GetActive <mg_JetpackReboot>();
m_resources = m_miniGame.Resources;
Assert.NotNull(m_renderer, "This component requires a sprite renderer");
}
private void Start()
{
Assert.NotNull(m_scrolling, "Level manager needs a reference to a scrolling component. Make sure Init is called after component creation");
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
m_environmentManager = active.GameLogic.EnvironmentManager;
}
protected virtual void Awake()
{
m_miniGame = MinigameManager.GetActive <mg_JetpackReboot>();
Assert.NotNull(m_miniGame, "mini game not found");
m_renderer = GetComponentsInChildren <SpriteRenderer>(includeInactive: true)[0];
Assert.NotNull(m_renderer, "Renderer not found");
}
private void Start()
{
m_renderers = GetComponentsInChildren <SpriteRenderer>();
m_miniGame = MinigameManager.GetActive <mg_JetpackReboot>();
m_resources = m_miniGame.Resources;
Assert.IsTrue(m_renderers.Length > 0, "This component requires at least one sprite renderer");
}
public virtual void Explode()
{
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
mg_jr_Resources resources = active.Resources;
GameObject pooledResource = resources.GetPooledResource(mg_jr_ResourceList.GAME_PREFAB_EFFECT_OBSTACLE_EXPLOSION);
Bounds bounds = WidestBounds();
if (bounds.size.x < 1.5f)
{
pooledResource.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
}
SpriteRenderer component = pooledResource.GetComponent <SpriteRenderer>();
Assert.NotNull(component, "Explosion effect must have a spriterenderer");
component.sortingOrder = mg_jr_SpriteDrawingLayers.Instance.SpriteOrder(mg_jr_SpriteDrawingLayers.DrawingLayers.OBSTACLE_0);
Vector3 center = component.bounds.center;
Vector3 vector = pooledResource.transform.position - center;
pooledResource.transform.position = bounds.center + vector;
pooledResource.transform.parent = active.GameLogic.transform;
if (Random.value >= 0.5f)
{
active.PlaySFX(mg_jr_Sound.OBSTACLE_EXPLODE_01.ClipName());
}
else
{
active.PlaySFX(mg_jr_Sound.OBSTACLE_EXPLODE_02.ClipName());
}
resources.ReturnPooledResource(base.gameObject);
}
public override void OnCollection()
{
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
active.Resources.ReturnPooledResource(base.gameObject);
GameObject instancedResource = active.Resources.GetInstancedResource(mg_jr_ResourceList.GAME_PREFAB_EFFECT_COIN_PICKUP);
SpriteRenderer component = GetComponent <SpriteRenderer>();
SpriteRenderer component2 = instancedResource.GetComponent <SpriteRenderer>();
Assert.NotNull(component2, "Effect must have a spriterenderer");
component2.sortingOrder = mg_jr_SpriteDrawingLayers.Instance.SpriteOrder(mg_jr_SpriteDrawingLayers.DrawingLayers.OBSTACLE_0);
Vector3 center = component2.bounds.center;
Vector3 vector = instancedResource.transform.position - center;
if (component != null)
{
instancedResource.transform.position = component.bounds.center + vector;
}
else
{
DisneyMobile.CoreUnitySystems.Logger.LogWarning(base.gameObject, "Gameobject" + base.gameObject.name + "spawning coin pickup effect has no spriterenderer.");
instancedResource.transform.position = base.transform.position + vector;
}
if (base.Quantity == 10)
{
active.PlaySFX(mg_jr_Sound.PICKUP_COIN_10.ClipName());
}
else
{
active.PlaySFX(mg_jr_Sound.PICKUP_COIN.ClipName());
}
}
private void Awake()
{
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
mg_jr_Resources resources = active.Resources;
Vector3 position = new Vector3(-16f, active.VisibleWorldBounds.max.y, 0f);
base.transform.position = position;
m_highestLinePosition = active.VisibleWorldBounds.max.y;
m_lowestLinePosition = active.VisibleWorldBounds.min.y;
float num = m_highestLinePosition - m_lowestLinePosition;
m_lineSpacing = num / (float)(m_maxLineFX - 2);
for (int i = 0; i < m_maxLineFX; i++)
{
GameObject pooledResource = resources.GetPooledResource(mg_jr_ResourceList.GAME_PREFAB_EFFECT_SPEEDLINE);
Animator component = pooledResource.GetComponent <Animator>();
Assert.NotNull(component, "SpeedLine needs an animator");
pooledResource.transform.position = new Vector3(base.transform.position.x, m_highestLinePosition - (float)i * m_lineSpacing, 0f);
pooledResource.transform.parent = base.transform;
SpriteRenderer component2 = pooledResource.GetComponent <SpriteRenderer>();
component2.sortingOrder = mg_jr_SpriteDrawingLayers.Instance.SpriteOrder(mg_jr_SpriteDrawingLayers.DrawingLayers.FX_OVERLAY_0);
m_speedLines.Add(component);
}
m_speedLines = m_speedLines.OrderBy((Animator item) => Random.Range(0, m_speedLines.Count)).ToList();
}
public override void OnCollection()
{
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
active.Resources.ReturnPooledResource(base.gameObject);
active.PlaySFX(mg_jr_Sound.PICKUP_JETPACK.ClipName());
}
protected void Awake()
{
if (Service.IsSet <Localizer>())
{
localizer = Service.Get <Localizer>();
}
m_miniGame = MinigameManager.GetActive <mg_JetpackReboot>();
Assert.NotNull(m_miniGame, "mini game not found");
m_animator = GetComponent <Animator>();
Assert.NotNull(m_animator, "Gary Animator not found");
CurrentDialogText = null;
IsIntroFinished = false;
if (localizer != null)
{
m_dialogs.Add(localizer.GetTokenTranslation("Activity.MiniGames.StartDialog1"));
m_dialogs.Add(localizer.GetTokenTranslation("Activity.MiniGames.StartDialog2"));
m_dialogs.Add(localizer.GetTokenTranslation("Activity.MiniGames.StartDialog3"));
m_dialogs.Add(localizer.GetTokenTranslation("Activity.MiniGames.StartDialog4"));
m_dialogs.Add(localizer.GetTokenTranslation("Activity.MiniGames.StartDialog5"));
}
else
{
m_dialogs.Add("Hello {0}! I need your help!");
m_dialogs.Add("My Magnetron 3000 has gone haywire...");
m_dialogs.Add("...and shot coins all over the sky!");
m_dialogs.Add("Use your jetpack to fly as far as you can...");
m_dialogs.Add("...and collect the coins while avoiding obstacles!");
}
}
private void OnTouchDrag(Vector2 _position, int touchId = 0)
{
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
if (active != null && active.GameLogic != null && (!IsTouchOrMouseClickOverUI(touchId) || m_isWaitingForUp[touchId]))
{
active.GameLogic.OnTouchDrag(touchId, _position);
}
}
protected virtual void Awake()
{
m_miniGame = MinigameManager.GetActive <mg_JetpackReboot>();
Assert.NotNull(m_miniGame, "mini game not found");
m_warning = GetComponent <mg_jr_Warning>();
if (m_warning == null)
{
m_warning = base.gameObject.AddComponent <mg_jr_Warning>();
}
}
private void Awake()
{
m_miniGame = MinigameManager.GetActive <mg_JetpackReboot>();
Assert.NotNull(m_miniGame, "mini game not found");
m_snowballSpawnSocket = base.transform.Find("mg_jr_SnowballSocket");
Assert.NotNull(m_snowballSpawnSocket, "Snowball socket not found");
m_cannonRenderer = GetComponentsInChildren <SpriteRenderer>(includeInactive: true)[0];
Assert.NotNull(m_cannonRenderer, "Cannon renderer not found");
m_animator = GetComponent <Animator>();
Assert.NotNull(m_animator, "Cannon Animator not found");
ShootSound = mg_jr_Sound.FIRE_RED_CANNON;
}
private void Awake()
{
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
SpriteRenderer component = GetComponent <SpriteRenderer>();
Assert.NotNull(component, "spriterenderer required by mg_jr_StretchToFillScreen");
float x = component.sprite.bounds.size.x;
float y = component.sprite.bounds.size.y;
float num = active.MainCamera.orthographicSize * 2f;
float num2 = num * active.MainCamera.aspect;
base.transform.localScale = new Vector3(num2 / x, num / y, 1f);
base.transform.position = new Vector3(active.VisibleWorldBounds.min.x, active.VisibleWorldBounds.max.y, 0f);
}
private void Awake()
{
m_levelDefinitions = new Dictionary <EnvironmentTypeAndDifficultyID, List <mg_jr_LevelDefinition> >();
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
m_resources = active.Resources;
m_fillLevelsTillX = Camera.main.RightEdgeInWorld() * 2f;
m_availableDifficulties = new Dictionary <EnvironmentType, DifficultyRange>();
LoadLevelDeffinitions(Resources.LoadAll <TextAsset>("JetpackReboot/Levels/forest/"));
LoadLevelDeffinitions(Resources.LoadAll <TextAsset>("JetpackReboot/Levels/cave/"));
LoadLevelDeffinitions(Resources.LoadAll <TextAsset>("JetpackReboot/Levels/town/"));
LoadLevelDeffinitions(Resources.LoadAll <TextAsset>("JetpackReboot/Levels/water/"));
LoadLevelDeffinitions(Resources.LoadAll <TextAsset>("JetpackReboot/Levels/common/"));
Resources.UnloadUnusedAssets();
}
public override void Explode()
{
if (!m_isHit)
{
IsHit = true;
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
if (Random.value >= 0.5f)
{
active.PlaySFX(mg_jr_Sound.OBSTACLE_EXPLODE_01.ClipName());
}
else
{
active.PlaySFX(mg_jr_Sound.OBSTACLE_EXPLODE_02.ClipName());
}
}
}
private void OnTouchDown(Vector2 _position, int touchId = 0)
{
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
if (active != null && active.GameLogic != null)
{
if (!m_isWaitingForUp.ContainsKey(touchId))
{
m_isWaitingForUp.Add(touchId, value: false);
}
if (!IsTouchOrMouseClickOverUI(touchId))
{
m_isWaitingForUp[touchId] = true;
active.GameLogic.OnTouchPress(_isDown: true, touchId, _position);
}
}
}
private void KillPenguin()
{
SetThrusting(_thrusting: false);
MinigameManager.GetActive().PlaySFX(mg_jr_Sound.PLAYER_EXPLODE.ClipName());
MinigameManager.GetActive().PlaySFX(mg_jr_Sound.PLAYER_DEATH.ClipName());
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
GameObject pooledResource = active.Resources.GetPooledResource(mg_jr_ResourceList.GAME_PREFAB_EFFECT_PENGUIN_EXPLOSION);
SpriteRenderer component = pooledResource.GetComponent <SpriteRenderer>();
Assert.NotNull(component, "Effect must have a spriterenderer");
Vector3 center = component.bounds.center;
Vector3 vector = pooledResource.transform.position - center;
pooledResource.transform.position = m_penguinRenderer.bounds.center + vector;
m_animator.SetTrigger("Kill");
m_currentState = PenguinState.DYING;
}
public static mg_jr_Environment CreateEnvironment(EnvironmentType _environmentType, EnvironmentVariant _variant, mg_jr_ScrollingSpeed _scrolling)
{
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
GameObject gameObject = new GameObject("mg_jr_environment_" + _environmentType.ToString().ToLowerInvariant());
mg_jr_Environment mg_jr_Environment2 = gameObject.AddComponent <mg_jr_Environment>();
mg_jr_Environment2.Type = _environmentType;
mg_jr_Environment2.Variant = _variant;
mg_jr_Environment2.m_scrolling = _scrolling;
foreach (EnvironmentLayer value in Enum.GetValues(typeof(EnvironmentLayer)))
{
if (value != EnvironmentLayer.MAX)
{
mg_jr_ParallaxLayer instancedParallaxLayer = active.Resources.GetInstancedParallaxLayer(_environmentType, _variant, value);
instancedParallaxLayer.Init(active.GameLogic.TurboPlayArea);
Assert.NotNull(instancedParallaxLayer, "There should be a parallaxlayer for every environment and layer combination");
mg_jr_Environment2.SetLayer(value, instancedParallaxLayer);
}
}
return(mg_jr_Environment2);
}
private void Awake()
{
m_miniGame = MinigameManager.GetActive <mg_JetpackReboot>();
TurboDevice = GetComponent <mg_jr_TurboDevice>();
if (TurboDevice == null)
{
TurboDevice = base.gameObject.AddComponent <mg_jr_TurboDevice>();
}
m_collecter = GetComponent <mg_jr_Collector>();
if (m_collecter == null)
{
m_collecter = base.gameObject.AddComponent <mg_jr_Collector>();
}
m_obstacleDestroyer = GetComponent <mg_jr_ObstacleDestroyer>();
m_obstacleDestroyer.enabled = false;
m_obstacleDestroyer.ObstacleDestroyed += OnCoinsCollected;
Assert.NotNull(m_obstacleDestroyer, "ObstacleDestroyer required");
m_collecter.CoinCollected += OnCoinsCollected;
m_collecter.RobotPenguinCollected += OnRobotPenguinCollected;
m_collecter.TurboCollected += OnTuboCollected;
CoinsCollectedSession = 0;
m_blinker = GetComponent <mg_jr_Blinker>();
if (m_blinker == null)
{
m_blinker = base.gameObject.AddComponent <mg_jr_Blinker>();
}
m_robotTurboPositions[0] = base.transform.Find("mg_jr_TopRobotSocket");
m_robotTurboPositions[1] = base.transform.Find("mg_jr_MiddleRobotSocket");
m_robotTurboPositions[2] = base.transform.Find("mg_jr_BottomRobotSocket");
for (int i = 0; i < m_robotTurboPositions.Length; i++)
{
Assert.NotNull(m_robotTurboPositions[i], "Robot turbo position not found");
}
m_penguinSpritesContainer = base.transform.Find("mg_jr_penguinSprites").gameObject;
m_animator = m_penguinSpritesContainer.GetComponent <Animator>();
Assert.NotNull(m_animator);
GameObject gameObject = base.transform.Find("mg_jr_penguinSprites/mg_jr_PenguinSprite").gameObject;
m_penguinRenderer = gameObject.GetComponent <SpriteRenderer>();
m_penguinRenderer.sortingOrder = mg_jr_SpriteDrawingLayers.Instance.SpriteOrder(mg_jr_SpriteDrawingLayers.DrawingLayers.PLAYER_PENGUIN);
GameObject gameObject2 = base.transform.Find("mg_jr_penguinSprites/mg_jr_Penguin_Thrust").gameObject;
Assert.NotNull(gameObject2, "Thruster gameobject not found");
m_thrustRenderer = gameObject2.GetComponent <SpriteRenderer>();
Assert.NotNull(m_thrustRenderer, "Thruster has no spriterenderer");
m_thrustRenderer.sortingOrder = mg_jr_SpriteDrawingLayers.Instance.SpriteOrder(mg_jr_SpriteDrawingLayers.DrawingLayers.PLAYER_PENGUIN_THRUST);
GameObject gameObject3 = base.transform.Find("mg_jr_penguinSprites/mg_jr_Penguin_Tint").gameObject;
Assert.NotNull(gameObject3, "Skin gameobject not found");
m_skinRenderer = gameObject3.GetComponent <SpriteRenderer>();
Assert.NotNull(m_skinRenderer, "Skin has no spriterenderer");
m_skinRenderer.sortingOrder = mg_jr_SpriteDrawingLayers.Instance.SpriteOrder(mg_jr_SpriteDrawingLayers.DrawingLayers.TINT);
GameObject gameObject4 = base.transform.Find("mg_jr_penguinSprites/mg_jr_PenguinTurboDome").gameObject;
Assert.NotNull(gameObject4, "Skin gameobject not found");
m_domeRenderer = gameObject4.GetComponent <SpriteRenderer>();
Assert.NotNull(m_domeRenderer, "Skin has no spriterenderer");
m_domeRenderer.sortingOrder = mg_jr_SpriteDrawingLayers.Instance.SpriteOrder(mg_jr_SpriteDrawingLayers.DrawingLayers.DOME);
m_mainCamera = Camera.main;
m_limitUp = m_mainCamera.orthographicSize - m_penguinData.DistanceToTopOfScreenLimit;
m_limitDown = 0f - m_mainCamera.orthographicSize + m_penguinData.DistanceToBottomOfScreenLimit;
}
private void Awake()
{
m_miniGame = MinigameManager.GetActive <mg_JetpackReboot>();
}
private void Awake()
{
mg_JetpackReboot active = MinigameManager.GetActive <mg_JetpackReboot>();
active.InputManager = this;
}
