/*----------Functions----------*/
//PUBLIC
/// <summary>
/// Initialise this object with the information needed for the event
/// </summary>
/// <param name="to">The state that the state machine has been changed to</param>
/// <param name="toScreen">The screen object that will be displayed for the new state. This can be null if there was no screen assigned</param>
/// <param name="from">The state the state machine was in previous to the change. This can be null for the first instance</param>
/// <param name="fromScreen">The screen object that was used to display the screen previously. This can be null for the first instance or if no screen was assigned</param>
public ScreenStateTransitionEventArgs(string to, ScreenBase toScreen, string from, ScreenBase fromScreen)
{
ToState = to;
ToScreen = toScreen;
FromState = from;
FromScreen = fromScreen;
}
public EatResponse OnEvent(EventId id, object cookie)
{
ScreenBase screenBase = (ScreenBase)cookie;
if (id != EventId.ScreenLoaded)
{
if (id == EventId.ScreenClosing)
{
screenBase = (ScreenBase)cookie;
if (this.screen != screenBase && !Service.ScreenController.IsFatalAlertActive())
{
this.canShowParticles = true;
this.ShowAllParticleElements();
}
}
}
else
{
screenBase = (ScreenBase)cookie;
if (screenBase != this.screen)
{
this.canShowParticles = false;
this.HideAllParticleElements();
}
}
return(EatResponse.NotEaten);
}
void ShowH264Headers(Elt[] ppsElts, Elt[] spsElts, Elt[] sliceElts)
{
if (m_ScreenHeaders[(int)H264HeaderEltType_t.H264HeaderEltType_PPS] == null)
{
m_ScreenHeaders[(int)H264HeaderEltType_t.H264HeaderEltType_PPS] = new ScreenHeader(ppsElts);
ScreenBase.AddToTabControl(m_ScreenHeaders[(int)H264HeaderEltType_t.H264HeaderEltType_PPS], tabControlHdrs);
}
else
{
m_ScreenHeaders[(int)H264HeaderEltType_t.H264HeaderEltType_PPS].Elts = ppsElts;
}
if (m_ScreenHeaders[(int)H264HeaderEltType_t.H264HeaderEltType_SPS] == null)
{
m_ScreenHeaders[(int)H264HeaderEltType_t.H264HeaderEltType_SPS] = new ScreenHeader(spsElts);
ScreenBase.AddToTabControl(m_ScreenHeaders[(int)H264HeaderEltType_t.H264HeaderEltType_SPS], tabControlHdrs);
}
else
{
m_ScreenHeaders[(int)H264HeaderEltType_t.H264HeaderEltType_SPS].Elts = spsElts;
}
if (m_ScreenHeaders[(int)H264HeaderEltType_t.H264HeaderEltType_SliceHeader] == null)
{
m_ScreenHeaders[(int)H264HeaderEltType_t.H264HeaderEltType_SliceHeader] = new ScreenHeader(sliceElts);
ScreenBase.AddToTabControl(m_ScreenHeaders[(int)H264HeaderEltType_t.H264HeaderEltType_SliceHeader], tabControlHdrs);
}
else
{
m_ScreenHeaders[(int)H264HeaderEltType_t.H264HeaderEltType_SliceHeader].Elts = sliceElts;
}
}
public static void Postfix(ref CraftingCampaignBehavior __instance, Hero hero, WeaponDesign weaponDesign, int modifierTier, Crafting.OverrideData overrideData)
{
ScreenBase topScreen = ScreenManager.TopScreen;
if (topScreen != null && Input.IsKeyDown(InputKey.LeftShift) && !TLSmithingFasterOperationCounts.Flag)
{
TLSmithingFasterOperationCounts.Flag = true;
int maxcounts = TLSmithingFasterOperationCounts.GetMaxCounts(ref __instance, hero, weaponDesign, modifierTier, overrideData);
maxcounts = Math.Min(maxcounts, 4);
for (int i = 0; i < maxcounts; i++)
{
__instance.CreateCraftedWeapon(hero, weaponDesign, modifierTier, overrideData);
}
TLSmithingFasterOperationCounts.Flag = false;
}
if (topScreen != null && Input.IsKeyDown(InputKey.LeftControl) && !TLSmithingFasterOperationCounts.Flag)
{
TLSmithingFasterOperationCounts.Flag = true;
int maxcounts = TLSmithingFasterOperationCounts.GetMaxCounts(ref __instance, hero, weaponDesign, modifierTier, overrideData);
for (int i = 0; i < maxcounts; i++)
{
__instance.CreateCraftedWeapon(hero, weaponDesign, modifierTier, overrideData);
}
TLSmithingFasterOperationCounts.Flag = false;
}
}
public static string OpenScreen(List <string> strings)
{
if (CampaignCheats.CheckParameters(strings, 0) || CampaignCheats.CheckHelp(strings))
{
return("Format is \"ui.open_screen [TypeName]\".");
}
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
Func <Type, bool> modify_by_why;
modify_by_why = null;
for (int i = 0; i < assemblies.Length; i++)
{
IEnumerable <Type> types = assemblies[i].GetTypes();
Func <Type, bool> predicate;
if ((predicate = modify_by_why) == null)
{
predicate = (modify_by_why = ((Type t) => t.Name == strings[0]));
}
Type type = types.FirstOrDefault(predicate);
if (type != null && type.BaseType == typeof(ScreenBase))
{
MethodInfo methodInfo = typeof(ViewCreatorManager).GetMethods(BindingFlags.Static | BindingFlags.Public).FirstOrDefault((MethodInfo m) => m.Name == "CreateScreenView" && m.GetParameters().Length == 0);
ScreenBase screenBase = ((methodInfo != null) ? methodInfo.MakeGenericMethod(new Type[]
{
type
}).Invoke(null, null) : null) as ScreenBase;
if (screenBase != null)
{
ScreenManager.PushScreen(screenBase);
return("Pushed Screen " + type.Name + ".");
}
}
}
return("Could not find screen with name " + strings[0] + ".");
}
public ScreenManager AddScreen(ScreenType type, ScreenBase value)
{
value.Manager = this;
value.Deactivate();
screens.Add(type, value);
return(this);
}
public ScreenMonitor(ScreenBase screen)
{
Screen = screen;
InitializeComponent();
lblId.Content = Screen.Id;
lblPort.Content = Screen.Port;
this.Title += " - " + Screen.Id + " - " + Screen.Port;
txtbLog.Text = "";
log("Starting Screen ...");
IPEndPoint ep = new IPEndPoint(IPAddress.Any, Screen.Port);
server = new TcpListener(ep);
server.Start();
log("Waiting for a connection... ");
server.BeginAcceptTcpClient(Callback, null);
}
public static void Postfix(ScreenBase __instance)
{
if (__instance is GauntletPartyScreen screen && !PartyController.CurrentInstance.WidgetsAdded)
{
PartyController.AddPartyWidgets(screen);
}
}
public SquadJoinActionModule(Squad squad, ScreenBase screen, UXButton button)
{
this.squad = squad;
this.screen = screen;
this.button = button;
this.biSource = string.Empty;
}
private void ModSettingsClick(int playerNr)
{
ScreenBase screen = UIScreen.Open(ScreenType.OPTIONS, 1);
inModOptions = true;
GameObject.Find("btQuit").GetComponent <LLButton>().onClick = new LLClickable.ControlDelegate(QuitClick);
mainmenu.lbTitle.text = "MOD SETTINGS";
var vcount = 0;
var hcount = 0;
foreach (string mod in mods)
{
var obj = Instantiate(button, screen.transform);
obj.SetText(mod, 50);
obj.transform.localScale = new Vector3(0.4f, 0.3f);
obj.transform.position = new Vector3(-1.5f + (0.75f * hcount), 0.80f - (0.125f * vcount));
obj.onClick = delegate(int pNr) { ModSubSettingsClick(mod); };
modButtons.Add(obj);
if (vcount < 12)
{
vcount++;
}
else
{
hcount++; vcount = 0;
}
}
}
private IEnumerator SwitchScreen(ScreenBase screen, bool skipFadeout)
{
if(CurrentScreen != null)
{
if (skipFadeout)
{
StopAllCoroutines ();
}
else
{
yield return StartCoroutine (CurrentScreen.OnScreenFadeOut ());
}
CurrentScreen.OnScreenExit ();
CurrentScreen.gameObject.SetActive (false);
}
CurrentScreen = screen;
CurrentScreen.gameObject.SetActive (true);
CurrentScreen.OnScreenEnter();
yield return StartCoroutine (CurrentScreen.OnScreenFadeIn ());
isSwitching = false;
}
private void OnChangeScreen(object sender, ScreenType screenType)
{
_currentScreenType = screenType;
switch (_currentScreenType)
{
case ScreenType.MainMenu:
_currentScreen = MainScreen;
break;
case ScreenType.LevelSelector:
_currentScreen = LevelSelectorScreen;
break;
case ScreenType.Game:
_currentScreen = LevelScreen;
break;
case ScreenType.Exit:
Exit();
break;
default:
throw new ArgumentOutOfRangeException(nameof(screenType));
}
}
public Player(PlayerDataBase _playerData, LaneBase _laneController, MonoBehaviour _mono, ScreenBase _screenController)
{
playerData = _playerData;
laneController = _laneController;
mono = _mono;
screenController = _screenController;
}
public void RecalculateCurrencyTrayVisibility()
{
UXController uXController = Service.Get <UXController>();
if (uXController == null || !uXController.MiscElementsManager.IsLoaded())
{
return;
}
bool flag = false;
for (int i = this.screens.Count - 1; i >= 0; i--)
{
ScreenBase screenBase = this.screens[i].Screen as ScreenBase;
if (screenBase != null && screenBase.IsLoaded() && screenBase.ShowCurrencyTray)
{
flag = true;
uXController.MiscElementsManager.DetachCurrencyTray();
screenBase.UpdateCurrencyTrayAttachment();
break;
}
}
if (!flag)
{
uXController.MiscElementsManager.DetachCurrencyTray();
}
}
private void DoLogin(object obj)
{
ScreenBase loginView = ServiceLocator.ServiceLocator.Instance.RepresentationLayerMain.ShowLoginScreen();
loginView.RaiseUserInputReadyEvent(new LoginButtonClickedEventArgs());
IsAuthenticated = true;
}
public void LoadScreen(int id, bool isRight)
{
this.id = id;
Debug.Log("LoadScreen " + id + " loading: " + loading + " activeScreen: " + activeScreen);
if (loading)
{
return;
}
MainEvents.OnUIFX("swipe");
loading = true;
if (activeScreen != null)
{
activeScreen.SetCenterPosition();
activeScreen.MoveTo(isRight, timeToTransition);
lastActiveScreen = activeScreen;
}
activeScreen = all [id];
activeScreen.gameObject.SetActive(true);
activeScreen.SetInitialPosition(isRight);
activeScreen.MoveTo(isRight, timeToTransition);
}
private void DoLogout(object obj)
{
Debug.WriteLine("click logout");
ScreenBase homeScreenView = ServiceLocator.ServiceLocator.Instance.RepresentationLayerMain.ShowMenuScreen();
homeScreenView.RaiseUserInputReadyEvent(new LoginButtonClickedEventArgs());
}
private string GetDescription(ScreenBase screen)
{
var descrioptionBuilder = new StringBuilder();
descrioptionBuilder.Append($"Screen Type: {Screen.ToString()}; ");
return(descrioptionBuilder.ToString());
}
private static void OnCharacterPortraitPopUpOpened(CharacterObject characterObject)
{
if (characterObject == null || LocationComplex.Current == null)
{
return;
}
Location locationOfCharacter = LocationComplex.Current.GetLocationOfCharacter(characterObject.HeroObject);
if (!characterObject.HeroObject.IsPrisoner)
{
return;
}
heroToTalk = characterObject.HeroObject;
MenuContext menuContext = Campaign.Current.CurrentMenuContext;
if (menuContext == null)
{
return;
}
GameOverlays.MenuOverlayType menuOverlayType = Campaign.Current.GameMenuManager.GetMenuOverlayType(menuContext);
if (menuOverlayType == GameOverlays.MenuOverlayType.SettlementWithCharacters)
{
// get menu overlay layer, see GauntletMenuOverlayBase;
ScreenBase topScreen = ScreenManager.TopScreen;
if (topScreen == null)
{
return;
}
GauntletLayer gauntletLayer = topScreen.FindLayer <ScreenLayer>("BasicLayer") as GauntletLayer;
if (gauntletLayer == null)
{
return;
}
// get _moviesAndDatasources, its public
// and there will be ViewModel for SettlementMenuOverlayVM;
var movieAndDatasource = gauntletLayer._moviesAndDatasources.FirstOrDefault(p => p.Item2 is SettlementMenuOverlayVM);
if (movieAndDatasource == null)
{
return;
}
SettlementMenuOverlayVM dataSource = movieAndDatasource.Item2 as SettlementMenuOverlayVM;
// it has prop ContextList;
// you should add new items there, example ExecuteOnSetAsActiveContextMenuItem;
GameMenuOverlayActionVM overlayItem = new GameMenuOverlayActionVM(
OnTalkToPrisonerAction,
GameTexts.FindText("str_menu_overlay_context_list", "Conversation").ToString(),
true,
1, // ID for Conversation
"");
dataSource.ContextList.Add(overlayItem);
}
}
private void button1_Click(object sender, EventArgs e)
{
//1st group of radio-buttons (Speaker settings):
VoiceOutput VoiceOutput = new VoiceOutput();
ISpeaker Speaker = null;
if (IPhoneHeadset.Checked)
{
Speaker = new IphoneHeadset(VoiceOutput, "IphoneX", true);
}
else if (SamsungHeadset.Checked)
{
Speaker = new SamsungHeadset(VoiceOutput, "SamsungA", true);
}
else if (PhoneSpeaker.Checked)
{
Speaker = new PhoneSpeaker(VoiceOutput, "model-ABC");
}
else
{
};
//there is an option not to select radio button without assertion error
if (Speaker != null)
{
VoiceOutput.DataOutput("Speaker selected");
Speaker.Play(null);
}
else
{
VoiceOutput.DataOutput("Speaker is not selected");
}
//2nd group of radio-buttons (Screen settings)
TextOutput TextOutput = new TextOutput();
ScreenBase Screen = null;
string screenType = null;
if (MonochromeScreen.Checked)
{
Screen = new MonochromeScreen(TextOutput, 2.0, 200);
screenType = nameof(MonochromeScreen);
}
else if (ColorfulScreen.Checked)
{
Screen = new ColorfulScreen(TextOutput, 7.0, 500, true);
screenType = nameof(ColorfulScreen);
}
//there is an option not to select radio button without assertion error
if (Screen != null)
{
textBox1.Text = "Set screen to Mobile... \n Selected screen is " + screenType;
}
else
{
textBox1.Text = "Screen is not selected";
}
}
public MetroWindow GetWindowForModel(ScreenBase model)
{
if (model != null && _modelToWindows.ContainsKey(model))
{
return(_modelToWindows[model]);
}
return(null);
}
public void AddScreen(ScreenBase screen)
{
this.AddScreen(screen, true);
if (!UXUtils.ShouldShowHudBehindScreen(screen.AssetName))
{
Service.UXController.HUD.Visible = false;
}
}
public void AddScreen(ScreenBase screen, QueueScreenBehavior subType)
{
this.AddScreen(screen, true, subType);
if (!UXUtils.ShouldShowHudBehindScreen(screen.AssetName))
{
Service.Get <UXController>().HUD.Visible = false;
}
}
public Screen(int height, int width, int numOfColors, string resolution, ScreenBase screenBase)
{
Height = height;
Width = width;
NumberOfColors = numOfColors;
Resolution = resolution;
Dysplay = screenBase;
}
public void RemoveScreen(ScreenBase screen)
{
if (this.RemoveScreenHelper(screen))
{
this.UpdateScrimAndDepths();
}
this.PopAndShowNextQueuedScreen();
}
public ScreenParticleHandler(ScreenBase screenBase)
{
this.particleFxes = new List <ScreenParticleFXCookie>();
this.screen = screenBase;
EventManager eventManager = Service.EventManager;
eventManager.RegisterObserver(this, EventId.ScreenLoaded, EventPriority.Default);
eventManager.RegisterObserver(this, EventId.ScreenClosing, EventPriority.Default);
}
public EatResponse OnEvent(EventId id, object cookie)
{
if (id == EventId.ScreenLoaded)
{
ScreenBase screen = (ScreenBase)cookie;
this.OnScreenReady(screen);
}
return(EatResponse.NotEaten);
}
public static Rectangle GetBoundingRectangle(ScreenBase screen, GameObjectBase gameObject, GameContext gameContext)
{
var startX = (int)((screen.OriginX + gameObject.Column) * gameContext.GameObjectWidth);
var startY = (int)((screen.OriginY + gameObject.Row) * gameContext.GameObjectHeight);
var width = (int)gameContext.GameObjectWidth * gameObject.ColumnSpan;
var height = (int)gameContext.GameObjectHeight * gameObject.RowSpan;
return(new Rectangle(startX, startY, width, height));
}
public static Rectangle GetBoundingRectangle(ScreenBase screen, GameContext gameContext)
{
var startX = (int)(screen.OriginX * gameContext.GameObjectWidth);
var startY = (int)(screen.OriginY * gameContext.GameObjectHeight);
var width = (int)gameContext.GameObjectWidth * screen.Columns;
var height = (int)gameContext.GameObjectHeight * screen.Rows;
return(new Rectangle(startX, startY, width, height));
}
public static void Prefix(ref ScreenBase __instance, ref ScreenLayer layer)
{
if (__instance is GauntletPartyScreen && screenLayer != null && layer.Input.IsCategoryRegistered(HotKeyManager.GetCategory("PartyHotKeyCategory")))
{
__instance.RemoveLayer(screenLayer);
enhancementVm.OnFinalize();
enhancementVm = null;
screenLayer = null;
}
}
private void OpenPrizeInventoryScreen()
{
this.holonetScreen.Close(null);
ScreenBase screenBase = Service.UXController.HUD.CreatePrizeInventoryScreen();
if (screenBase != null)
{
Service.ScreenController.AddScreen(screenBase);
}
}
void screen_Finished(object sender, ScreenBase.ScreenEventArgs e)
{
if(e.Screen.ScreenType==ScreenTypeEnum.LoadingScreen)
{
e.Screen.Dismiss();
mainPanel.Controls.Remove(e.Screen);
DisplayScreen(homeScreen,false);
stackScreen.Clear();
stackScreen.Push(homeScreen); //initial
}
}
public void addScreen(string name, ScreenBase screen)
{
if (screen.ScreenType == ScreenTypeEnum.LoadingScreen)
{
loadingScreen = screen;
}
else if (screen.ScreenType == ScreenTypeEnum.HomeScreen)
{
homeScreen = screen;
}
screen.BackColor = MetroColors.White;
screen.Finished += screen_Finished;
hashScreen.Add(name, screen);
}
public void DisplayScreen(ScreenBase screen, bool isAdvancing)
{
if (screen==null)
{
throw new Exception();
}
if (activeScreen != null && activeScreen.IsHavingCommandScreen)
{
HideCommandBar();
}
if (isAdvancing) //not adding homescreen as bottomest screen
{
topNavigationButton.Visible = false;
topNavigationButton.Image = Properties.Resources.back;
AnimationUtil.Animate(topNavigationButton, AnimationUtil.Effect.Slide, 100, 90);
stackScreen.Push(activeScreen);
//AnimationUtil.Animate(activeScreen, AnimationUtil.Effect.Slide, 100, 180);
activeScreen.Visible = false;
}
else
{
AnimationUtil.Animate(topNavigationButton, AnimationUtil.Effect.Slide, 50, 90);
topNavigationButton.Visible = false;
if (activeScreen != null && activeScreen.ScreenType != ScreenTypeEnum.LoadingScreen)
{
//AnimationUtil.Animate(activeScreen, AnimationUtil.Effect.Slide, 100, 180);
activeScreen.Visible = false;
}
}
lblScreenName.Visible = false;
if (screen.ScreenType == ScreenTypeEnum.Others)
{
lblScreenName.Text = screen.Name;
}
else
{
lblScreenName.Text = " ";
}
AnimationUtil.Animate(lblScreenName, AnimationUtil.Effect.Slide, 100, 180);
screen.Dock = DockStyle.Fill;
screen.Visible = false;
mainPanel.Controls.Add(screen);
//AnimationUtil.Animate(screen, AnimationUtil.Effect.Slide, 500, 270);
screen.Visible = true;
screen.Refresh();
screen.ActivateScreen();
activeScreen = screen;
}
public void CloseTab(ScreenBase tabToClose)
{
Tabs.Remove(tabToClose);
}
