public D2GS(String character, String account, UInt32 chickenLife, UInt32 potLife) { //ConnectedToGs = false; m_d2gsConnection = new D2gsConnection(); m_d2gsReader = new D2gsReader(ref m_d2gsConnection, character); m_d2gsHandler = new D2gsHandler(ref m_d2gsConnection); m_gsPing = new GameServerPing(ref m_d2gsConnection); m_gameThread = new GameThread(m_d2gsConnection, chickenLife, potLife); m_asciiMap = new AsciiMap(m_gameThread.GameData, m_d2gsConnection); m_d2gsConnection.StartThread += delegate { m_d2gsHandlerThread = new Thread(m_d2gsHandler.ThreadFunction); m_d2gsHandlerThread.Name = account + " [D2Gs]:"; m_d2gsReaderThread = new Thread(m_d2gsReader.ThreadFunction); m_d2gsReaderThread.Name = account + " [D2GS]:"; m_d2gsHandlerThread.Start(); m_d2gsReaderThread.Start(); }; m_d2gsHandler.StartPinging += delegate { m_gsPingThread = new Thread(m_gsPing.Run); m_gsPingThread.Name = account + " [D2GS]:"; m_gsPingThread.Start(); m_mapThread = new Thread(m_asciiMap.ThreadFunction); m_mapThread.Start(); }; m_botThread = new Thread(m_gameThread.BotThread); m_botThread.Name = account + " [BOT]:"; m_botThread.Start(); SubscribeGameServerEvents(); }
public void DoUpdate(string versionName, string url) { var str = GlobalSettings.Default.ClientVersion; var split = str.LastIndexOf('-'); int verNum = 0; string curBranch = str; if (split != -1) { int.TryParse(str.Substring(split + 1), out verNum); curBranch = str.Substring(0, split); } _UpdaterAlert = UIScreen.GlobalShowAlert(new UIAlertOptions() { Title = "", Message = GameFacade.Strings.GetString("f101", "27"), Buttons = new UIAlertButton[0] }, true); Api.GetUpdateList((updates) => { UIScreen.RemoveDialog(_UpdaterAlert); GameThread.InUpdate(() => { UpdatePath path = null; if (updates != null) { path = UpdatePath.FindPath(updates.ToList(), str, versionName); } if (path == null) { path = new UpdatePath(new List <ApiUpdate>() { new ApiUpdate() { version_name = versionName, full_zip = url } }, true); path.MissingInfo = true; } ShowUpdateDialog(path); }); }); }
public void GetFSOV(uint shardID, uint lotLocation, Action <byte[]> callback) { var client = Client(); var request = new RestRequest("userapi/city/" + shardID + "/" + lotLocation + ".fsov", Method.GET); request.AddHeader("authorization", "bearer " + AuthKey); client.ExecuteAsync(request, (resp, h) => { var ok = resp.StatusCode == System.Net.HttpStatusCode.OK; byte[] dat = resp.RawBytes; GameThread.NextUpdate(x => { callback(ok?dat:null); }); }); }
public static void WorkerLoop() { int loggedIn = 0; int loginAttempts = 0; while (true) { if (!LoginSent) { LoginSent = true; Console.WriteLine("Attempting Login... (" + (loginAttempts++) + ")"); Login(); } GameThread.OnWork.WaitOne(1000); GameThread.DigestUpdate(null); } }
public TSOVersionPatchScreen() : base() { Background = new UISetupBackground(); Add(Background); Version = Content.Content.Get().VersionString; CanUpdate = Version == Patchable; GameThread.NextUpdate((state) => { UIAlert.Alert(GameFacade.Strings.GetString("f101", "14"), GameFacade.Strings.GetString("f101", "15", new string[] { Version, GameFacade.Strings.GetString("f101", CanUpdate ? "16" : "17") }), true); }); }
public void MessageReceived(AriesClient client, object message) { if (message is RequestClientSession || message is HostOnlinePDU) { this.AsyncProcessMessage(message); } else if (message is AnnouncementMsgPDU) { GameThread.InUpdate(() => { UIScreen.GlobalShowAnnouncement((AnnouncementMsgPDU)message); }); } else if (message is ChangeRoommateResponse) { } }
public void UploadFSOF(uint shardID, uint lotLocation, byte[] data, Action <bool> callback) { var client = Client(); var request = new RestRequest("userapi/city/" + shardID + "/uploadfacade/" + lotLocation, Method.POST); request.AddFile("application/octet-stream", data, lotLocation + ".fsof"); request.AddHeader("authorization", "bearer " + AuthKey); client.ExecuteAsync(request, (resp, h) => { var ok = resp.StatusCode == System.Net.HttpStatusCode.OK; GameThread.NextUpdate(x => { callback(ok); }); }); }
/// <summary> /// Setup anything that needs a GraphicsDevice /// </summary> /// <param name="layer"></param> public void Initialize(GraphicsDevice device) { /** * Setup world state, this object acts as a facade * to world objects as well as providing various * state settings for the world and helper functions */ State = new WorldState(device, device.Viewport.Width, device.Viewport.Height, this); GameThread.InUpdate(() => { State.AmbientLight = new Texture2D(device, 256, 256); State.OutsidePx = new Texture2D(device, 1, 1); }); HasInitGPU = true; HasInit = HasInitGPU & HasInitBlueprint; }
public ClientDataService(IModelSerializer serializer, FSO.Content.Content content, IKernel kernel) : base(serializer, content) { AddProvider(kernel.Get <ClientAvatarProvider>()); AddProvider(kernel.Get <ClientLotProvider>()); AddProvider(kernel.Get <ClientCityProvider>()); AddProvider(kernel.Get <ClientNeighProvider>()); AddProvider(kernel.Get <ClientMayorRatingProvider>()); CityClient = kernel.Get <AriesClient>("City"); CityClient.AddSubscriber(this); //When a new object is made, this data will be requested automatically SetDefaultDataStruct(typeof(Avatar), MaskedStruct.SimPage_Main); PollInterval = GameThread.SetInterval(PollTopics, 5000); }
private void PurchaseRegulator_OnError(object data) { GameThread.NextUpdate(x => { ShowCreationProgressBar(false); //TODO: Find error messages in lang table var reason = (PurchaseLotFailureReason)data; string error = "An error occurred."; switch (reason) { case PurchaseLotFailureReason.INSUFFICIENT_FUNDS: error = GameFacade.Strings.GetString("215", "26"); break; case PurchaseLotFailureReason.NOT_OFFLINE_FOR_MOVE: error = GameFacade.Strings.GetString("211", "53"); break; case PurchaseLotFailureReason.IN_LOT_CANT_EVICT: error = GameFacade.Strings.GetString("211", "64"); break; case PurchaseLotFailureReason.LOT_TAKEN: case PurchaseLotFailureReason.LOT_NOT_PURCHASABLE: error = GameFacade.Strings.GetString("211", "46"); break; case PurchaseLotFailureReason.NAME_TAKEN: error = GameFacade.Strings.GetString("247", "15"); break; default: error = GameFacade.Strings.GetString("211", "55") + " (" + reason.ToString() + ")"; break; } UIScreen.GlobalShowAlert(new UIAlertOptions { Message = error, //TODO: Find something in string tables? Title = "", Width = 300 }, true); }); }
public void WriteEmail(uint avatarId, string subject) { DataService.Get <Avatar>(avatarId).ContinueWith(x => { GameThread.InUpdate(() => { var msg = Chat.WriteLetter(UserReference.Wrap(x.Result)); Chat.SetEmailMessage(msg, new MessageItem() { Subject = subject, Body = "" }); if (msg != null) { Chat.ShowWindow(msg); } }); }); }
private void RefreshCity(BindingChange[] changes) { if (CurrentCity.Value != null) { var mapData = LotTileEntry.GenFromCity(CurrentCity.Value); var neighJSON = CurrentCity.Value.City_NeighJSON; //We know if lots are online, we can update the data service DataService.GetMany <Lot>(mapData.Select(x => (object)(uint)x.packed_pos).ToArray()).ContinueWith(x => { if (!x.IsCompleted) { return; } foreach (var lot in x.Result) { var mapItem = mapData.FirstOrDefault(y => y.packed_pos == lot.Id); if (mapItem != null) { lot.Lot_IsOnline = (mapItem.flags & LotTileFlags.Online) == LotTileFlags.Online; } } }); GameThread.NextUpdate((state) => { View.populateCityLookup(mapData); if (neighJSON != LastLotJSON) { try { var neigh = JsonConvert.DeserializeObject <List <Rendering.City.Model.CityNeighbourhood> >(neighJSON); Rendering.City.Model.CityNeighbourhood.Init(neigh); View.NeighGeom.Data = neigh; View.NeighGeom.Generate(GameFacade.GraphicsDevice); } catch { } LastLotJSON = neighJSON; } }); } }
protected override void OnAfterTransition(RegulatorState oldState, RegulatorState newState, object data) { switch (newState.Name) { case "StartPurchase": if (!Network.CityClient.IsConnected) { ThrowErrorAndReset("City server disconnected"); return; } CurrentRequest = data as PurchaseLotRequest; AsyncTransition("SendPurchaseRequest"); break; case "SendPurchaseRequest": Network.CityClient.Write(new FSO.Server.Protocol.Electron.Packets.PurchaseLotRequest { LotLocation_X = CurrentRequest.X, LotLocation_Y = CurrentRequest.Y, Name = CurrentRequest.Name, StartFresh = CurrentRequest.StartFresh, MayorMode = CurrentRequest.Mayor }); break; case "ReceivedPurchaseResponse": var response = data as FSO.Server.Protocol.Electron.Packets.PurchaseLotResponse; if (response.Status == Server.Protocol.Electron.Packets.PurchaseLotStatus.FAILED) { //Error ThrowErrorAndReset(response.Reason); } else { AsyncTransition("PurchaseComplete"); GameThread.NextUpdate(x => { OnPurchased(response.NewFunds); }); } break; case "PurchaseComplete": AsyncTransition("Idle"); break; } }
private void DPISlider_OnChange(UIElement element) { GameThread.NextUpdate((cb) => { FSOEnvironment.DPIScaleFactor = DPISlider.Value / 4f; GlobalSettings.Default.DPIScaleFactor = FSOEnvironment.DPIScaleFactor; var width = Math.Max(1, GameFacade.Game.Window.ClientBounds.Width); var height = Math.Max(1, GameFacade.Game.Window.ClientBounds.Height); UIScreen.Current.ScaleX = UIScreen.Current.ScaleY = FSOEnvironment.DPIScaleFactor; GlobalSettings.Default.GraphicsWidth = (int)(width / FSOEnvironment.DPIScaleFactor); GlobalSettings.Default.GraphicsHeight = (int)(height / FSOEnvironment.DPIScaleFactor); UIScreen.Current.GameResized(); GlobalSettings.Default.Save(); }); }
/// <summary> /// Certain actions are invoked on the audio thread. /// Here we simulate this process on a correctly named thread to avoid endless blocking. /// </summary> /// <param name="action">The action to perform.</param> private void runOnAudioThread(Action action) { var resetEvent = new ManualResetEvent(false); new Thread(() => { action(); resetEvent.Set(); }) { Name = GameThread.PrefixedThreadNameFor("Audio") }.Start(); if (!resetEvent.WaitOne(TimeSpan.FromSeconds(10))) { throw new TimeoutException(); } }
public static void EnterGameMode(string lotName, bool external) { GameThread.NextUpdate((x) => { var screen = new TS1GameScreen(); var last = GameFacade.Screens.CurrentUIScreen; GameFacade.Screens.RemoveCurrent(); GameFacade.Screens.AddScreen(screen); ((LoadingScreen)last).Close(); var children = new List <UIElement>(last.GetChildren()); for (int i = 0; i < children.Count; i++) { last.Remove(children[i]); screen.Add(children[i]); } screen.Initialize(lotName, external); }); }
public CameraManager(GameThread updateThread) { thread = updateThread; scheduler.Add(() => { new Thread(() => { while (!cancelSource.Token.IsCancellationRequested) { syncCameraDevices(); Thread.Sleep(1000); } }) { IsBackground = true }.Start(); }); }
public Texture2D Get(GraphicsDevice device) { lock (this) { if (_Instance == null || _Instance.IsDisposed) //|| ((CachableTexture2D)result).BeingDisposed) { using (var stream = GetStream()) { if (Thread.CurrentThread == FSOEnvironment.GameThread) { _Instance = Process(device, stream); } else { //We need to get into the game thread to do this work _Instance = GameThread.NextUpdate <Texture2D>(x => { return(Process(device, stream)); }).Result; } } if (!FSOEnvironment.DirectX) { GC.SuppressFinalize(_Instance); //do not run the default finalizer on the texture. } if (ReplacePath != null) { using (var str = File.Open(ReplacePath, FileMode.Open, FileAccess.Read, FileShare.Read)) { var hidef = ImageLoader.FromStream(device, str); hidef.Tag = new { obj = this, _Instance }; _Instance.Tag = hidef; } } else { _Instance.Tag = this; //form a destiny bond with the texture } } return(_Instance); } }
public void Initialize(string cityName, int cityMap, TerrainController terrainController) { Title.SetTitle(cityName); GameFacade.CurrentCityName = cityName; InitializeMap(cityMap); InitializeMouse(); ZoomLevel = 5; //screen always starts at far zoom, city visible. CityRenderer.m_ZoomProgress = 0; JoinLotProgress = new UIJoinLotProgress(); ControllerUtils.BindController <JoinLotProgressController>(JoinLotProgress); terrainController.Init(CityRenderer); CityRenderer.SetController(terrainController); GameThread.NextUpdate(x => { FSOFacade.Hints.TriggerHint("screen:city"); }); }
public void GetFacadeAsync(uint shardID, uint location, Action <byte[]> callback) { //var client = Client(); var request = new RestRequest("userapi/city/" + shardID + "/" + location + ".fsof"); client.ExecuteAsync(request, (resp, h) => { GameThread.NextUpdate(x => { if (resp.StatusCode != System.Net.HttpStatusCode.OK) { callback(null); } else { callback(resp.RawBytes); } }); }); }
public void AsyncAPILotThumbnail(uint shardId, uint lotId, Action <Texture2D> callback) { Api.GetThumbnailAsync(shardId, lotId, (data) => { if (data != null) { GameThread.NextUpdate(x => { if (UIScreen.Current != this) { return; } using (var mem = new MemoryStream(data)) { callback(ImageLoader.FromStream(GameFacade.GraphicsDevice, mem)); } }); } }); }
public void DisplayChange(int change) { var newLabel = new UILabel(); newLabel.Y = -20f; newLabel.CaptionStyle = MoneyLabel.CaptionStyle.Clone(); newLabel.CaptionStyle.Size = 15; newLabel.CaptionStyle.Color = (change > 0) ? UIStyle.Current.PosMoney : UIStyle.Current.NegMoney; newLabel.Alignment = FSO.Client.UI.Framework.TextAlignment.Right | FSO.Client.UI.Framework.TextAlignment.Middle; newLabel.Size = new Microsoft.Xna.Framework.Vector2(128, 24); newLabel.Caption = ((change > 0) ? "+" : "-") + "§" + Math.Abs(change); Add(newLabel); GameFacade.Screens.Tween.To(newLabel, 1.5f, new Dictionary <string, float>() { { "Y", -50 }, { "Opacity", 0 } }); GameThread.SetTimeout(() => { Remove(newLabel); }, 1500); }
public override bool Execute(VM vm) { if (Traces != null && vm.Driver.DesyncTick != 0) { vm.Trace.CompareFirstError(Traces.FirstOrDefault(x => x.TickID == vm.Driver.DesyncTick)); } vm.Driver.DesyncTick = 0; if (!Run) { return(true); } if (vm.FSOVDoAsyncLoad) { vm.FSOVDoAsyncLoad = false; vm.FSOVAsyncLoading = true; Task.Run(() => { vm.FSOVClientJoin = (vm.Context.Architecture == null); vm.LoadAsync(State); if (VM.UseWorld && vm.Context.Blueprint.SubWorlds.Count == 0) { VMLotTerrainRestoreTools.RestoreSurroundings(vm, vm.HollowAdj); } GameThread.InUpdate(() => { vm.LoadComplete(); }); }); } else { vm.Load(State); if (VM.UseWorld && vm.Context.Blueprint.SubWorlds.Count == 0) { VMLotTerrainRestoreTools.RestoreSurroundings(vm, vm.HollowAdj); } } return(true); }
protected BasicGameHost(string gameName = @"") { Instance = this; AppDomain.CurrentDomain.UnhandledException += exceptionHandler; Dependencies.Cache(this); name = gameName; threads = new[] { DrawThread = new GameThread(DrawFrame, @"Draw") { OnThreadStart = DrawInitialize, }, UpdateThread = new GameThread(UpdateFrame, @"Update") { OnThreadStart = UpdateInitialize, Monitor = { HandleGC = true } }, InputThread = new InputThread(null, @"Input") //never gets started. }; Clock = UpdateThread.Clock; MaximumUpdateHz = GameThread.DEFAULT_ACTIVE_HZ; MaximumDrawHz = (DisplayDevice.Default?.RefreshRate ?? 0) * 4; // Note, that RegisterCounters only has an effect for the first // BasicGameHost to be passed into it; i.e. the first BasicGameHost // to be instantiated. FrameStatistics.RegisterCounters(this); Environment.CurrentDirectory = System.IO.Path.GetDirectoryName(FullPath); setActive(true); AddInternal(inputManager = new UserInputManager(this)); Dependencies.Cache(inputManager); }
public void MessageReceived(AriesClient client, object message) { if (client == City) { if (message is FindLotResponse) { AsyncProcessMessage(message); } } else if (client == Client) { if (message is RequestClientSession || message is HostOnlinePDU || message is FSOVMTickBroadcast || message is FSOVMDirectToClient || message is ServerByePDU) { if (message is ServerByePDU) { } //force in order this.SyncProcessMessage(message); } if (message is FSOVMProtocolMessage) { var msg = (FSOVMProtocolMessage)message; GameThread.InUpdate(() => { if (msg.UseCst) { if (msg.Title != "") { msg.Title = GameFacade.Strings.GetString("223", msg.Title); } msg.Message = GameFacade.Strings.GetString("223", msg.Message); } UIAlert.Alert(msg.Title, msg.Message, true); }); } } }
internal PerformanceMonitor(GameThread thread, IEnumerable <StatisticsCounterType> counters) { Clock = thread.Clock; threadName = thread.Name; isActive = thread.IsActive.GetBoundCopy(); isActive.BindValueChanged(_ => updateEnabledState()); currentFrame = FramesPool.Get(); foreach (var c in counters) { ActiveCounters[(int)c] = true; } for (int i = 0; i < FrameStatistics.NUM_PERFORMANCE_COLLECTION_TYPES; i++) { var t = (PerformanceCollectionType)i; endCollectionDelegates[i] = new InvokeOnDisposal(() => endCollecting(t)); } }
public virtual void InitBlueprint(Blueprint blueprint) { this.Blueprint = blueprint; Platform?.Dispose(); InitDefaultGraphicsMode(); State.ProjectTilePos = EstTileAtPosWithScrollHeight; Entities = new WorldEntities(blueprint); Architecture = new WorldArchitecture(blueprint); Static?.InitBlueprint(blueprint); State.Changes = blueprint.Changes; GameThread.InUpdate(() => { Light?.Init(blueprint); State.Rooms.Init(blueprint); }); HasInitBlueprint = true; HasInit = HasInitGPU & HasInitBlueprint; }
public void GetUpdateList(string branchName, Action <ApiUpdate[]> callback) { var client = Client(); var request = new RestRequest("userapi/updates/" + branchName); client.ExecuteAsync(request, (resp, h) => { GameThread.NextUpdate(x => { if (resp.StatusCode != System.Net.HttpStatusCode.OK) { callback(null); } else { var obj = JsonConvert.DeserializeObject <ApiUpdate[]>(resp.Content); callback(obj); } }); }); }
public static void RunOnAudioThread(Action action) { var resetEvent = new ManualResetEvent(false); new Thread(() => { ThreadSafety.IsAudioThread = true; action(); resetEvent.Set(); }) { Name = GameThread.PrefixedThreadNameFor("Audio") }.Start(); if (!resetEvent.WaitOne(TimeSpan.FromSeconds(10))) { throw new TimeoutException(); } }
public static float[] DequantizeDepth(GraphicsDevice gd, Texture2D depthIn) { var wait = new AutoResetEvent(false); float[] data = null; GameThread.InUpdate(() => { var targetPrep = new RenderTarget2D(gd, depthIn.Width, depthIn.Height, false, SurfaceFormat.Vector4, DepthFormat.None); var target = new RenderTarget2D(gd, depthIn.Width, depthIn.Height, false, SurfaceFormat.Single, DepthFormat.None); gd.SetRenderTarget(targetPrep); var effect = SpriteEffect; EnsureBatch(gd); effect.CurrentTechnique = effect.Techniques["DerivativeDepth"]; effect.Parameters["pixelSize"].SetValue(new Vector2(1f / depthIn.Width, 1f / depthIn.Height)); Batch.Begin(rasterizerState: RasterizerState.CullNone, effect: effect); Batch.Draw(depthIn, Vector2.Zero, Color.White); Batch.End(); gd.SetRenderTarget(target); effect.CurrentTechnique = effect.Techniques["DequantizeDepth"]; Batch.Begin(rasterizerState: RasterizerState.CullNone, effect: effect); Batch.Draw(targetPrep, Vector2.Zero, Color.White); Batch.End(); gd.SetRenderTarget(null); data = new float[depthIn.Width * depthIn.Height]; target.GetData <float>(data); target.Dispose(); targetPrep.Dispose(); wait.Set(); }); wait.WaitOne(); return(data); }
public static void EnterGameMode(string lotName, bool external) { GameThread.NextUpdate((x) => { var mode = NeighSelectionMode.Normal; if (lotName.Length > 1 && lotName[0] == '!') { switch (lotName[1]) { case 'n': mode = NeighSelectionMode.MoveIn; break; case 'm': mode = NeighSelectionMode.MoveInMagic; break; } } var screen = new TS1GameScreen(mode); if (mode != NeighSelectionMode.Normal) { screen.StartMoveIn(int.Parse(lotName.Substring(2))); } var last = GameFacade.Screens.CurrentUIScreen; GameFacade.Screens.RemoveCurrent(); GameFacade.Screens.AddScreen(screen); var load = (last as LoadingScreen); if (load != null) { load.Close(); var children = new List <UIElement>(last.GetChildren()); for (int i = 0; i < children.Count; i++) { last.Remove(children[i]); screen.Add(children[i]); } } screen.Initialize(lotName, external); }); }