private void ShootDuck() { // Shoot the duck if (GetCollision()) { if (Hud.Hud.NumShotsLeft > 0) { // Post message to the score board. ScoreMessage message = new ScoreMessage() { ScoreIncrement = 10 }; Channels.PostMessage("score", message); DuckHitMessage duckHitMessage = new DuckHitMessage() { State = DuckIndicatorStateEnum.Hit }; Channels.PostMessage("duckhit", duckHitMessage); Channels.PostMessage("soundeffects", new SoundEffectMessage() { SoundEffectToPlay = "death" }); State = DuckStateEnum.Dead; } } }
public void PropagateScore() { _scoreUI.SetScore(LeftScore, RightScore); var scoreMessage = new ScoreMessage(LeftScore, RightScore); _server.SendToAll(scoreMessage); }
// ================================ /// <summary>Call this function to reset the game</summary> /// <param name="ResetLogs">Whether the logs should be reset</param> internal static void Reset(bool ResetLogs) { // track manager for (int i = 0; i < TrackManager.Tracks.Length; i++) { TrackManager.Tracks[i] = new TrackManager.Track(); } // train manager TrainManager.Trains = new TrainManager.Train[] { }; // game Interface.ClearMessages(); CurrentInterface = InterfaceType.Normal; RouteComment = ""; RouteImage = ""; RouteAccelerationDueToGravity = 9.80665; RouteRailGauge = 1.435; RouteInitialAirPressure = 101325.0; RouteInitialAirTemperature = 293.15; RouteInitialElevation = 0.0; RouteSeaLevelAirPressure = 101325.0; RouteSeaLevelAirTemperature = 293.15; Stations = new RouteStation[] { }; CurrentRoute.Sections = new Section[] { }; BufferTrackPositions = new double[] { }; //Messages = new Message[] { }; MarkerTextures = new Texture[] { }; PointsOfInterest = new PointOfInterest[] { }; PrecedingTrainTimeDeltas = new double[] { }; PrecedingTrainSpeedLimit = double.PositiveInfinity; CurrentRoute.BogusPretrainInstructions = new BogusPretrainInstruction[] { }; TrainName = ""; TrainStart = TrainStartMode.EmergencyBrakesNoAts; CurrentRoute.NoFogStart = (float)Math.Max(1.33333333333333 * Interface.CurrentOptions.ViewingDistance, 800.0); CurrentRoute.NoFogEnd = (float)Math.Max(2.66666666666667 * Interface.CurrentOptions.ViewingDistance, 1600.0); CurrentRoute.PreviousFog = new Fog(CurrentRoute.NoFogStart, CurrentRoute.NoFogEnd, Color24.Grey, 0.0); CurrentRoute.CurrentFog = new Fog(CurrentRoute.NoFogStart, CurrentRoute.NoFogEnd, Color24.Grey, 0.5); CurrentRoute.NextFog = new Fog(CurrentRoute.NoFogStart, CurrentRoute.NoFogEnd, Color24.Grey, 1.0); InfoTotalTriangles = 0; InfoTotalTriangleStrip = 0; InfoTotalQuads = 0; InfoTotalQuadStrip = 0; InfoTotalPolygon = 0; InfoStaticOpaqueFaceCount = 0; if (ResetLogs) { LogRouteName = ""; LogTrainName = ""; LogDateTime = DateTime.Now; CurrentScore = new Score(); ScoreMessages = new ScoreMessage[] { }; ScoreLogs = new ScoreLog[64]; ScoreLogCount = 0; BlackBoxEntries = new BlackBoxEntry[256]; BlackBoxEntryCount = 0; BlackBoxNextUpdate = 0.0; } // renderer Renderer.Reset(); }
// ================================ /// <summary>Call this function to reset the game</summary> /// <param name="ResetLogs">Whether the logs should be reset</param> /// <param name="ResetRenderer">Whether the renderer should be reset</param> internal static void Reset(bool ResetLogs, bool ResetRenderer) { // track manager for (int i = 0; i < Program.CurrentRoute.Tracks.Count; i++) { int key = Program.CurrentRoute.Tracks.ElementAt(i).Key; Program.CurrentRoute.Tracks[key] = new Track(); } // train manager TrainManager.Trains = new TrainManager.Train[] { }; // game Interface.ClearMessages(); CurrentInterface = InterfaceType.Normal; Program.CurrentRoute.Comment = ""; Program.CurrentRoute.Image = ""; Program.CurrentRoute.Atmosphere.AccelerationDueToGravity = 9.80665; Program.CurrentRoute.Atmosphere.InitialAirPressure = 101325.0; Program.CurrentRoute.Atmosphere.InitialAirTemperature = 293.15; Program.CurrentRoute.Atmosphere.InitialElevation = 0.0; Program.CurrentRoute.Atmosphere.SeaLevelAirPressure = 101325.0; Program.CurrentRoute.Atmosphere.SeaLevelAirTemperature = 293.15; Program.CurrentRoute.BufferTrackPositions = new double[] { }; //Messages = new Message[] { }; Program.Renderer.Marker.MarkerTextures = new Texture[] { }; Program.CurrentRoute.PointsOfInterest = new PointOfInterest[] { }; PrecedingTrainTimeDeltas = new double[] { }; PrecedingTrainSpeedLimit = double.PositiveInfinity; Program.CurrentRoute.BogusPreTrainInstructions = new BogusPreTrainInstruction[] { }; TrainName = ""; TrainStart = TrainStartMode.EmergencyBrakesNoAts; Program.CurrentRoute.NoFogStart = (float)Math.Max(1.33333333333333 * Interface.CurrentOptions.ViewingDistance, 800.0); Program.CurrentRoute.NoFogEnd = (float)Math.Max(2.66666666666667 * Interface.CurrentOptions.ViewingDistance, 1600.0); Program.CurrentRoute.PreviousFog = new Fog(Program.CurrentRoute.NoFogStart, Program.CurrentRoute.NoFogEnd, Color24.Grey, 0.0); Program.CurrentRoute.CurrentFog = new Fog(Program.CurrentRoute.NoFogStart, Program.CurrentRoute.NoFogEnd, Color24.Grey, 0.5); Program.CurrentRoute.NextFog = new Fog(Program.CurrentRoute.NoFogStart, Program.CurrentRoute.NoFogEnd, Color24.Grey, 1.0); if (ResetLogs) { LogRouteName = ""; LogTrainName = ""; LogDateTime = DateTime.Now; CurrentScore = new Score(); ScoreMessages = new ScoreMessage[] { }; ScoreLogs = new ScoreLog[64]; ScoreLogCount = 0; BlackBoxEntries = new BlackBoxEntry[256]; BlackBoxEntryCount = 0; BlackBoxNextUpdate = 0.0; } // renderer if (ResetRenderer) { Program.Renderer.InfoTotalTriangles = 0; Program.Renderer.InfoTotalTriangleStrip = 0; Program.Renderer.InfoTotalQuads = 0; Program.Renderer.InfoTotalQuadStrip = 0; Program.Renderer.InfoTotalPolygon = 0; Program.Renderer.Reset(); } }
public bool ScoreHandler(BaseMessage msg) { ScoreMessage castMsg = (ScoreMessage)msg; Score += castMsg.score; return(true); }
public void SendScore(int score, Vector3 scorePos, int lives) { ScoreMessage msg = new ScoreMessage(); msg.score = score; msg.scorePos = scorePos; msg.lives = lives; NetworkServer.SendToAll(MyMsgType.Score, msg); }
private void HandleScore(ScoreMessage scoreMessage) { ViewController.Instance.UpdateLog(scoreMessage.PlayerName, "Gained " + scoreMessage.ScoreDif.ToString() + " points"); if (scoreMessage.MissedBy > 0) { ViewController.Instance.UpdateLog(scoreMessage.PlayerName, "Missed bid by " + scoreMessage.MissedBy.ToString() + " points"); } ViewController.Instance.UpdateScoreInfo(scoreMessage.PlayerName, scoreMessage.Score); }
private void CmdChangeFace(int id, bool lv) { ScoreMessage msg = new ScoreMessage(); msg.clinetid = id; msg.facedirection = lv; msg.scorePos = Vector3.zero; msg.lives = 0; Debug.Log("Server cmd"); NetworkServer.SendToAll(100, msg); }
public void SendScore(int score, Vector3 scorePos, int lives) { ScoreMessage msg = new ScoreMessage(); msg.score = score; msg.scorePos = scorePos; msg.lives = lives; Debug.Log("Sending score..."); myClient.Send(MyMsgType.Score, msg); }
private void ShowScoreString(string scoreText, string timeRewardText) { for (int i = 0; i < scoreMessages.Length; i++) { if (scoreMessages[i].gameObject.activeSelf == false) { ScoreMessage scoreMessage = scoreMessages[i]; scoreMessage.SetText(scoreText, timeRewardText); break; } } }
/// <summary>Call this function to reset the game</summary> /// <param name="ResetLogs">Whether the logs should be reset</param> internal static void Reset(bool ResetLogs) { // track manager for (int i = 0; i < Program.CurrentRoute.Tracks.Count; i++) { int key = Program.CurrentRoute.Tracks.ElementAt(i).Key; Program.CurrentRoute.Tracks[key] = new Track(); } // train manager Program.TrainManager.Trains = new TrainBase[] { }; // game Interface.LogMessages.Clear(); Program.CurrentHost.MissingFiles.Clear(); if (Program.Renderer.CurrentInterface != InterfaceType.Menu) { Program.Renderer.CurrentInterface = InterfaceType.Normal; } Program.CurrentRoute.Comment = ""; Program.CurrentRoute.Image = ""; Program.CurrentRoute.Atmosphere = new Atmosphere(); Program.CurrentRoute.LightDefinitions = new LightDefinition[] { }; Program.CurrentRoute.BufferTrackPositions = new double[] { }; //Messages = new Message[] { }; Program.Renderer.Marker.MarkerTextures = new Texture[] { }; Program.CurrentRoute.PointsOfInterest = new PointOfInterest[] { }; Program.CurrentRoute.PrecedingTrainTimeDeltas = new double[] { }; Interface.CurrentOptions.PrecedingTrainSpeedLimit = double.PositiveInfinity; Program.CurrentRoute.BogusPreTrainInstructions = new BogusPreTrainInstruction[] { }; Interface.CurrentOptions.TrainName = ""; Interface.CurrentOptions.TrainStart = TrainStartMode.EmergencyBrakesNoAts; Program.CurrentRoute.NoFogStart = (float)Math.Max(1.33333333333333 * Interface.CurrentOptions.ViewingDistance, 800.0); Program.CurrentRoute.NoFogEnd = (float)Math.Max(2.66666666666667 * Interface.CurrentOptions.ViewingDistance, 1600.0); Program.CurrentRoute.PreviousFog = new Fog(Program.CurrentRoute.NoFogStart, Program.CurrentRoute.NoFogEnd, Color24.Grey, 0.0); Program.CurrentRoute.CurrentFog = new Fog(Program.CurrentRoute.NoFogStart, Program.CurrentRoute.NoFogEnd, Color24.Grey, 0.5); Program.CurrentRoute.NextFog = new Fog(Program.CurrentRoute.NoFogStart, Program.CurrentRoute.NoFogEnd, Color24.Grey, 1.0); if (ResetLogs) { LogRouteName = ""; LogTrainName = ""; LogDateTime = DateTime.Now; CurrentScore = new Score(); ScoreMessages = new ScoreMessage[] { }; ScoreLogs = new ScoreLog[64]; ScoreLogCount = 0; BlackBoxEntries = new BlackBoxEntry[256]; BlackBoxEntryCount = 0; BlackBoxNextUpdate = 0.0; } }
public void OnChangePos(NetworkMessage netMsg) { ScoreMessage msg = netMsg.ReadMessage <ScoreMessage>(); Debug.Log("OnScoreMessage " + msg.clinetid); if (msg.clinetid == 33) { return; } if (GameManager.Instance.ID != msg.clinetid) { changeScale(msg.facedirection); } }
/// <summary> /// 同步分数 /// </summary> /// <param name="self"></param> private static void SyncScore(this GameController self) { Room room = self.GetParent <Room>(); for (int i = 0; i < room.Players.Length; i++) { var p = room.Players[i]; var msg = new ScoreMessage { Seat = p.SeatIndex, Score = p.GetComponent <ScoreComponent>().Score }; foreach (Player player in room.Players) { room.SendActor(player, msg); } } }
internal ScoreMessage PushLocal(object message, Color? color, GUIStyle style, GUIStyle styleHighDensity, int? messageQueueID, ScoreFlashFollow3D follow3D) { // Unity fails on compiling: (int)ScoreFlash.DefaultMessageQueueID.Default // if this instance of ScoreFlash is not enabled - there's no point in registering the message if (!this.enabled) { return new ScoreMessage(this, this, message); } #region Initializing the Message // note: messageQueueID null => do not put the message in the queue (used internally) // if we have a value here, we're never in the scene view => false if (messageQueueID.HasValue) { SetIsSceneView(false); } IHasVisualDesigner scoreFlashLayout = this; if (message is ScoreFlashLayout) { ScoreFlashLayout sender = (ScoreFlashLayout)message; scoreFlashLayout = sender; message = sender.MessageForScoreFlash; } ScoreMessage msg = new ScoreMessage(this, scoreFlashLayout, message); if (follow3D != null) { msg.SetScoreFlashFollow3D(follow3D); if (msg.FollowLocation != null && !allFollow3Ds.Contains(msg.FollowLocation)) { allFollow3Ds.Add(msg.FollowLocation); } } msg.isDebug = isDebugMode; msg.pos = NGUtil.Scale(new Vector2(fadeInOffsetX, fadeInOffsetY)); msg.rotationSpeed = fadeOutInitialRotationSpeed; msg.useRealTime = timeReference == TimeReference.UseRealTime; if (msg.scoreFlashRenderer == null) { if (rendering == RenderingType.CustomRenderer && scoreFlashRenderer != null) { // do we still have objects in the pool? if so => take on from there ;-) ScoreFlashRendererBase objectFromPool = GetRendererFromPool(); if (objectFromPool != null) { msg.scoreFlashRenderer = objectFromPool; } else { Transform parent = scoreFlashRenderer.RequiresCustomParent && customParent != null ? customParent : this.transform; msg.scoreFlashRenderer = scoreFlashRenderer.CreateInstance(parent); msg.scoreFlashRenderer.name = string.Format("Renderer_{0:0000}", rendererIndex++); } } } else { // if we have a renderer "delivered" with the message, do the parent assignment now if (scoreFlashRenderer.RequiresCustomParent && customParent != null) { msg.scoreFlashRenderer.transform.SetParent(customParent); } else { msg.scoreFlashRenderer.transform.SetParent(this.transform); } } // if a style is passed to the method, this overwrites the font definition! if (style == null && rendering == RenderingType.UnityGUI_Font) { style = GetStyleFromPool(); style.font = CurrentFont; style.normal.textColor = Color.white; style.alignment = (TextAnchor)NGAlignment.ConvertAlignment(msg.InnerAnchor, NGAlignment.AlignmentType.TextAnchor); style.wordWrap = false; } // if we are using UnityGUI, the following is relevant ... if (style == null) { if (CurrentSkin == null && msg.scoreFlashRenderer == null) { Debug.LogError( string.Format( "You have not assigned a GUISkin and called PushLocal without a style - this won't work! " + "Either assign a GUISkin to ScoreFlash, or use one of the Push-methods that take a " + "GUIStyle as parameter! Message '{0}' will not be shown!", message), this); return msg; } if (CurrentSkin != null) { if (CurrentSkin.FindStyle(guiStyleName) == null) { if (!hasWarnedMissingCustomStyle) { Debug.LogWarning( string.Format("Your GUISkin does not have custom style '{0}' - please add that custom style " + "and configure it with your desired font. Using label style instead!", guiStyleName), CurrentSkin); hasWarnedMissingCustomStyle = true; } style = GetStyleFromPool(CurrentSkin.label); } else { style = GetStyleFromPool(CurrentSkin.FindStyle(guiStyleName)); } // we need these two and people (including myself) forget to assign them => hardcode it! //style.alignment = TextAnchor.UpperCenter; // this is now overridden with innerAnchor // this may be overridden when the message exceeds maxWidth style.wordWrap = false; } } if (styleHighDensity == null) { styleHighDensity = style; } // this is just an initial reference position - it may be overwritten later! if (follow3D == null) { msg.ScreenAlign = scoreFlashLayout.ScreenAlign; msg.InnerAnchor = scoreFlashLayout.LockInnerAnchor ? msg.ScreenAlign : scoreFlashLayout.InnerAnchor; msg.OriginalPosition = NGAlignment.GetScreenBasedReferencePosition(msg.ScreenAlign, Vector2.zero, IsSceneView); msg.ReferencePosition = NGAlignment.GetScreenBasedReferencePosition(msg.ScreenAlign, scoreFlashLayout.Position, IsSceneView); } if (style != null) { AssignStyle(msg, style, styleHighDensity); } if (!color.HasValue) { AssignColors(msg); } else { AssignAlphaMultipliedColor(msg, color.Value); } // when passing a custom renderer, don't use the one ScoreFlash might define if (msg.scoreFlashRenderer != null) { // this is put down here because ScoreFlashRendererUnityGUI needs the style to calculate the size msg.scoreFlashRenderer.Initialize(msg); Rect pos = msg.Position; Vector2 size = msg.scoreFlashRenderer.GetSize(msg); pos.width = size.x; pos.height = size.y; msg.Position = pos; } if (messageQueueID.HasValue) { if (!scoreMessages.ContainsKey(messageQueueID.Value)) { scoreMessages[messageQueueID.Value] = new NGQueue<ScoreMessage>(); } NGQueue<ScoreMessage> messageQueue = scoreMessages[messageQueueID.Value]; messageQueue.Enqueue(msg); if (messageQueue.Count > maxSimultanuousMessages) { messageQueue.QueueOrderedList[messageQueue.Count - maxSimultanuousMessages - 1].LocalTimeScale = 8; } AnimateMessages(); // make sure everything is immediately initialized #if LOGGING_FACADE // if narayana games Logging Facade is available, we add some logging log.DebugFormat("Received score message: '{0}'", msg.Text); #endif } return msg; #endregion Initializing the Message }
private void AnimatePhases(float myDeltaTime, ScoreMessage msg, float addToRead) { if (msg.Age < fadeInTimeSeconds) { // phase 1: fade in float diffFrac = msg.Age / fadeInTimeSeconds; msg.CurrentTextColor = NGEasing.EaseOnCurve(fadeInColorCurve, msg.fadeInColor, msg.readColorStart, diffFrac); msg.pos.x = NGEasing.EaseOnCurve(fadeInOffsetXCurve, NGUtil.Scale(fadeInOffsetX), 0, diffFrac); msg.pos.y = NGEasing.EaseOnCurve(fadeInOffsetYCurve, NGUtil.Scale(fadeInOffsetY), 0, diffFrac); msg.Scale = NGEasing.EaseOnCurve(fadeInScaleCurve, fadeInScale, 1, diffFrac); } else if (msg.Age < (fadeInTimeSeconds + readTimeSeconds + addToRead)) { // phase 2: read float diffFrac = (msg.Age - fadeInTimeSeconds) / (readTimeSeconds + addToRead); msg.CurrentPhase = ScoreMessage.Phase.Read; msg.CurrentTextColor = NGEasing.EaseOnCurve(readColorCurve, msg.readColorStart, msg.readColorEnd, diffFrac); msg.Scale = NGEasing.EaseOnCurve(readScaleCurve, 1, readScale, diffFrac); msg.velocity.x = NGEasing.EaseOnCurve(readVelocityXCurve, 0, NGUtil.Scale(readFloatRightVelocity), diffFrac); msg.velocity.y = NGEasing.EaseOnCurve(readVelocityCurve, 0, NGUtil.Scale(readFloatUpVelocity), diffFrac); msg.pos.x += msg.velocity.x * myDeltaTime; msg.pos.y -= msg.velocity.y * myDeltaTime; } else { // phase 3: fade out float diffFrac = (msg.Age - (fadeInTimeSeconds + readTimeSeconds + addToRead)) / fadeOutTimeSeconds; msg.CurrentPhase = ScoreMessage.Phase.FadeOut; msg.CurrentTextColor = NGEasing.EaseOnCurve(fadeOutColorCurve, msg.readColorEnd, msg.fadeOutColor, diffFrac); msg.Scale = NGEasing.EaseOnCurve(fadeOutScaleCurve, readScale, fadeOutScale, diffFrac); msg.velocity.x = NGEasing.EaseOnCurve(fadeOutVelocityXCurve, NGUtil.Scale(readFloatRightVelocity), NGUtil.Scale(fadeOutFloatRightVelocity), diffFrac); msg.velocity.y = NGEasing.EaseOnCurve(fadeOutVelocityCurve, NGUtil.Scale(readFloatUpVelocity), NGUtil.Scale(fadeOutFloatUpVelocity), diffFrac); msg.pos.x += msg.velocity.x * myDeltaTime; msg.pos.y -= msg.velocity.y * myDeltaTime; msg.rotationSpeed += fadeOutRotationAcceleration * myDeltaTime; msg.Rotation += msg.rotationSpeed * myDeltaTime; } // assign outline color with alpha based on current value from phase msg.OutlineColor = colorOutline; msg.OutlineColorAlpha = msg.CurrentTextColor.a * colorOutline.a; }
/// <summary> /// Calculates a pixel offset based on msg.Alignment.ScreenAlign. /// </summary> /// <remarks> /// You'll want to use this when your GUI system only supports top left /// positioning (like UnityGUI does, for example). It gives you an offset /// vector that you can use in your implementation of /// <see cref="ScoreFlashRendererBase.UpdateMessage(ScoreMessage)"/> /// to calculate an offset, or in your rendering code (e.g. when using /// UnityGUI). This only works, when your renderer returns correct and /// reliable values for width and height, so if your GUI system supports /// it, it's preferable to use its positioning system instead. See /// <see cref="NGAlignment.ConvertAlignment(NGAlignment.ScreenAlign, NGAlignment.AlignmentType)"/> for a /// convenient way to convert ScoreFlashs alignment enumeration /// to GUIText.TextAnchors, NGUI style and EZ GUI style. /// </remarks> /// <param name="msg"></param> /// <returns></returns> public static Vector2 GetAlignBasedOffset(ScoreMessage msg) { return NGAlignment.GetAlignBasedOffset(msg.InnerAnchor, msg.Position); }
internal void AssignAlphaMultipliedColor(ScoreMessage msg, Color color) { msg.fadeInColor = color; msg.readColorStart = color; msg.readColorEnd = color; msg.fadeOutColor = color; /* * apply multipliers on all colorSelectionModes except FadePhases * FadePhases has the alpha values assigned through the colors * for each phase, so we don't need this here */ msg.fadeInColor.a *= alphaFadeInMultiplier; msg.readColorStart.a *= alphaReadStartMultiplier; msg.readColorEnd.a *= alphaReadEndMultiplier; msg.fadeOutColor.a *= alphaFadeOutMultiplier; }
public void onMessageReceived(NetworkMessage netMsg) { ScoreMessage msg = netMsg.ReadMessage <ScoreMessage>(); NetworkServer.SendToAll(MyMsgType.Score, msg); }
private void HandleMessage(string message) { try { lock (MessageTasks) { ErrorResponse errorResponse = JsonConvert.DeserializeObject <ErrorResponse>(message); if (errorResponse.IsValid()) { Debug.Log("ErrorResponse: " + errorResponse.ErrorMessage); return; } DisconnectMessage disconnectMessage = JsonConvert.DeserializeObject <DisconnectMessage>(message); if (disconnectMessage.IsValid()) { HandleDisconnect(disconnectMessage); return; } RestartMessage restartMessage = JsonConvert.DeserializeObject <RestartMessage>(message); if (restartMessage.IsValid()) { HandleRestart(restartMessage); return; } GameTypeMessage gameTypeMessage = JsonConvert.DeserializeObject <GameTypeMessage>(message); if (gameTypeMessage.IsValid()) { ViewController.Instance.UpdateGameTypes(gameTypeMessage.GameTypes); return; } JoinResponse joinResponse = JsonConvert.DeserializeObject <JoinResponse>(message); if (joinResponse.IsValid()) { HandleJoinResponse(joinResponse); return; } AvailableGamesMessage gamesMessage = JsonConvert.DeserializeObject <AvailableGamesMessage>(message); if (gamesMessage.IsValid()) { ViewController.Instance.UpdateAvailableGames(gamesMessage.AvailableGames); return; } JoinMessage joinMessage = JsonConvert.DeserializeObject <JoinMessage>(message); if (joinMessage.IsValid()) { HandleJoin(joinMessage); return; } StartMessage startMessage = JsonConvert.DeserializeObject <StartMessage>(message); if (startMessage.IsValid()) { HandleStart(startMessage); return; } BidMessage bidMessage = JsonConvert.DeserializeObject <BidMessage>(message); if (bidMessage.IsValid()) { HandleBid(bidMessage); return; } KittyMessage kittyMessage = JsonConvert.DeserializeObject <KittyMessage>(message); if (kittyMessage.IsValid()) { HandleKitty(kittyMessage); return; } TrumpMessage trumpMessage = JsonConvert.DeserializeObject <TrumpMessage>(message); if (trumpMessage.IsValid()) { HandleTrump(trumpMessage); return; } MeldPointsMessage meldPointsMessage = JsonConvert.DeserializeObject <MeldPointsMessage>(message); if (meldPointsMessage.IsValid()) { HandleMeldPoints(meldPointsMessage); return; } MeldMessage meldMessage = JsonConvert.DeserializeObject <MeldMessage>(message); if (meldMessage.IsValid()) { HandleMeld(meldMessage); return; } PassMessage passMessage = JsonConvert.DeserializeObject <PassMessage>(message); if (passMessage.IsValid()) { HandlePass(passMessage); return; } ScoreMessage scoreMessage = JsonConvert.DeserializeObject <ScoreMessage>(message); if (scoreMessage.IsValid()) { HandleScore(scoreMessage); return; } TurnMessage turnMessage = JsonConvert.DeserializeObject <TurnMessage>(message); if (turnMessage.IsValid()) { HandleTurn(turnMessage); return; } TrickMessage trickMessage = JsonConvert.DeserializeObject <TrickMessage>(message); if (trickMessage.IsValid()) { HandleTrick(trickMessage); return; } TrickInfoMessage trickInfoMessage = JsonConvert.DeserializeObject <TrickInfoMessage>(message); if (trickInfoMessage.IsValid()) { HandleTrickInfo(trickInfoMessage); return; } GameOverMessage gameOverMessage = JsonConvert.DeserializeObject <GameOverMessage>(message); if (gameOverMessage.IsValid()) { HandleGameOver(gameOverMessage); return; } } } catch (Exception err) { Debug.Log("OnMessage error: " + err.Message); Debug.Log("OnMessage stack trace: " + err.StackTrace); } }
/// <summary> /// Update the message. The implementation needs /// to make sure that you update position, scale, color and outline /// color as well as the text. /// </summary> /// <param name="msg">the current version of the message</param> public override void UpdateMessage(ScoreMessage msg) { this.msg = msg; // we don't need to do anything here, because the renderer // pulls the information from ScoreMessage msg while rendering // NGUI / EZ GUI solutions do the "interesting stuff" in this method }
private float CalcAddToRead(ScoreMessage msg) { float addToRead = 0; if (msg.Text.Length > readMinLengthCharsToAddTime) { addToRead = readAddTimeSeconds; // this should usually not happen; for "ultra-long texts"; if that's still not sufficient: simply ignore ... if (msg.Text.Length > 2 * readMinLengthCharsToAddTime) { addToRead += readAddTimeSeconds; } } return addToRead; }
/// <summary> /// Shortcut for pushing messages in a specific color directly using this ScoreFlashLayout instance. /// </summary> /// <remarks> /// Calls <see cref="IScoreFlash.PushLocal(object, Color)"/> on <see cref="defaultScoreFlash"/> /// (or using the single ScoreFlash instance if defaultScoreFlash wasn't assigned). /// </remarks> /// <param name="message">the message to send, could also be a custom renderer (or any object)</param> /// <param name="color"> /// Use this to control the color the message is sent with. Uses RGB from <c>color</c>, /// and multiplies <c>color.a</c> with the current alpha value depending on the settings /// in the ScoreFlash instance that this message was pushed to /// </param> /// <returns>return the ScoreMessage representing msg</returns> public ScoreMessage Push(object message, Color color) { HandlePreviousMessage(); messageForScoreFlash = message; currentMessage = DefaultScoreFlash.PushLocal(this, color, this.GetInstanceID()); ApplyMessageSettings(currentMessage); return currentMessage; }
private void ApplyMessageSettings(ScoreMessage msg) { msg.FreezeOnRead = freezeOnRead; }
/// <summary> /// The size of the achievement on the screen, based on texture size of /// <c>textureAchievementNormalEarned</c>. /// </summary> /// <param name="msg">ignored</param> public override Vector2 GetSize(ScoreMessage msg) { return new Vector2(textureAchievementNormalEarned.width, textureAchievementNormalEarned.height); }
// ================================ internal static void Reset(bool ResetLogs) { // track manager TrackManager.CurrentTrack = new TrackManager.Track(); // train manager TrainManager.Trains = new TrainManager.Train[] { }; // game Debug.ClearMessages(); CurrentInterface = InterfaceType.Normal; RouteComment = ""; RouteImage = ""; RouteAccelerationDueToGravity = 9.80665; RouteRailGauge = 1.435; RouteInitialAirPressure = 101325.0; RouteInitialAirTemperature = 293.15; RouteInitialElevation = 0.0; RouteSeaLevelAirPressure = 101325.0; RouteSeaLevelAirTemperature = 293.15; Stations = new Station[] { }; Sections = new Section[] { }; BufferTrackPositions = new double[] { }; Messages = new Message[] { }; MarkerTextures = new Textures.Texture[] { }; PointsOfInterest = new PointOfInterest[] { }; PrecedingTrainTimeDeltas = new double[] { }; PrecedingTrainSpeedLimit = double.PositiveInfinity; BogusPretrainInstructions = new BogusPretrainInstruction[] { }; TrainName = ""; TrainStart = TrainStartMode.EmergencyBrakesNoAts; NoFogStart = (float)Math.Max(1.33333333333333 * Options.Current.ViewingDistance, 800.0); NoFogEnd = (float)Math.Max(2.66666666666667 * Options.Current.ViewingDistance, 1600.0); PreviousFog = new Fog(NoFogStart, NoFogEnd, new Color24(128, 128, 128), 0.0); CurrentFog = new Fog(NoFogStart, NoFogEnd, new Color24(128, 128, 128), 0.5); NextFog = new Fog(NoFogStart, NoFogEnd, new Color24(128, 128, 128), 1.0); InfoTotalTriangles = 0; InfoTotalTriangleStrip = 0; InfoTotalQuads = 0; InfoTotalQuadStrip = 0; InfoTotalPolygon = 0; InfoStaticOpaqueFaceCount = 0; if (ResetLogs) { LogRouteName = ""; LogTrainName = ""; LogDateTime = DateTime.Now; CurrentScore = new Score(); ScoreMessages = new ScoreMessage[] { }; ScoreLogs = new ScoreLog[64]; ScoreLogCount = 0; BlackBoxEntries = new BlackBoxEntry[256]; BlackBoxEntryCount = 0; BlackBoxNextUpdate = 0.0; } // renderer Renderer.Reset(); }
public void OnScore(NetworkMessage netMsg) { ScoreMessage msg = netMsg.ReadMessage <ScoreMessage>(); Debug.Log("OnScoreMessage " + msg.score); }
private void AssignColors(ScoreMessage msg) { switch (colorSelectionMode) { case ColorControl.FadePhases: msg.fadeInColor = fadeInColor; msg.readColorStart = readColorStart; msg.readColorEnd = readColorEnd; msg.fadeOutColor = fadeOutColor; break; case ColorControl.UseColorFromSkin: if (msg.style == null) { Debug.LogError( "Trying to use ColorControl.UseColorFromSkin without a skin assigned or a GUIStyle passed! " + " You either need to assign a skin, or pass a GUIStyle in the push-method, or choose another " + " Color Selection Mode!"); } else { AssignAlphaMultipliedColor(msg, msg.style.normal.textColor); } break; case ColorControl.Sequence: if (CheckForColors(msg)) { AssignAlphaMultipliedColor(msg, colors[colorIndex++ % colors.Count]); } break; case ColorControl.Random: if (CheckForColors(msg)) { int index = Random.Range(0, colors.Count); int counter = 0; /* * we check for colors.Count > 2 because with only * two colors to pick from, our "use previous color prevention" * would lead to the two colors simply alterating; so in * that case, to achieve a bit of randomness, being able * to show the same color twice is actually better */ while (colors.Count > 2 && (previousIndex == index || usedColorIndices.Contains(index))) { index = Random.Range(0, colors.Count); /* * we only try twice the number of available colors * if that fails, either we had very bad luck or the * number of colors has meanwhile changed and we might * never find an index from the available numbers that * is not yet used; colors.Count * 2 is really just * a heuristic; you could put any number in here */ if (usedColorIndices.Count >= colors.Count || counter > colors.Count * 2) { #if LOGGING_FACADE log.DebugFormat( "Cleared used indices usedColorIndices.Count={0} >= colors.Count={1} || counter={2} > colors.Count * 2={3}", usedColorIndices.Count, colors.Count, counter, colors.Count * 2); #endif usedColorIndices.Clear(); counter++; } } #if LOGGING_FACADE log.DebugFormat("Using color: {0}", index); #endif previousIndex = index; usedColorIndices.Add(index); AssignAlphaMultipliedColor(msg, colors[index]); } break; } }
private void SpreadMessages(float myDeltaTime, ScoreMessage msg, ScoreMessage nextMsg) { float distance = Mathf.Abs(Mathf.Abs(msg.pos.y) - Mathf.Abs(nextMsg.pos.y)); float requiredHeight = NGUtil.Scale(minDistanceBetweenMessages) + nextMsg.Position.height; if (distance < requiredHeight) { msg.pos.y -= myDeltaTime * (requiredHeight - distance) * spreadSpeed; float addToRead = CalcAddToRead(msg); if (msg.Age < fadeInTimeSeconds + readTimeSeconds + addToRead) { msg.AddDeltaTimeToAge(myDeltaTime); } msg.UpdateRenderer(); } }
private void AssignStyle(ScoreMessage msg, GUIStyle style, GUIStyle styleHighDensity) { msg.style = NGUtil.IsHighDensityDisplay ? styleHighDensity : style; msg.style.alignment = (TextAnchor)NGAlignment.ConvertAlignment(msg.InnerAnchor, NGAlignment.AlignmentType.TextAnchor); //msg.style.alignment = TextAnchor.UpperLeft; // initialize position (y will be assigned in Update) GUIContent msgText = new GUIContent(msg.Text); Vector2 size = msg.style.CalcSize(msgText); float maxWidth = msg.MaxWidth; if (size.x > maxWidth) { msg.style.wordWrap = true; #if LOGGING_FACADE log.DebugFormat("Applying width fix for '{0}' (word wrapping activated!)", msg.Text); #endif size.x = maxWidth; size.y = msg.style.CalcHeight(msgText, size.x); } Rect position = msg.Position; position.width = size.x; position.height = size.y; msg.Position = position; msg.styleOutline = GetStyleFromPool(msg.style); }
/// <summary> /// Update the message. /// </summary> /// <param name="msg">the current version of the message</param> public override void UpdateMessage(ScoreMessage msg) { transform.position = msg.FollowLocation.CurrentTranslatedPosition; transform.LookAt(msg.Follow3D.referenceCamera.transform.position, msg.Follow3D.referenceCamera.transform.up); // are we visible (we may be behind the player when rendering ScoreFlashFollow3D stuff) text.enabled = msg.IsVisible; // push text and color to Unity UI label text.text = msg.Text; text.color = msg.CurrentTextColor; Vector2 position = new Vector2(msg.Position.x, msg.Position.y); position -= msg.OriginalPosition; rt.anchoredPosition = new Vector2(position.x, -position.y); // ... ok, I guess these are kind of obvious, aren't they? text.transform.localScale = msg.Scale * Vector3.one; textTransform.localRotation = Quaternion.Euler(0, 180, -msg.Rotation); }
private bool CheckForColors(ScoreMessage msg) { if (colors == null || colors.Count == 0) { if (msg.style == null) { Debug.LogError( "No colors assigned, no skin assigned - please set up ScoreFlash correctly: " +"Either assign colors, or a skin, or select Color Selection Mode: FadePhases!"); } else { Debug.LogWarning( string.Format("No Colors assigned - cannot use Color Selection Mode: {0}! Using skin color as fallback!", colorSelectionMode)); AssignAlphaMultipliedColor(msg, msg.style.normal.textColor); } return false; } return true; }
/// <summary> /// The size of the message on screen. This is using /// text.preferredWith and text.preferredHeight. /// </summary> /// <param name="msg">the current version of the message</param> public override Vector2 GetSize(ScoreMessage msg) { text.text = msg.Text; DoLayout(); return new Vector2(text.preferredWidth, rt.sizeDelta.y); }
/// <summary> /// Shortcut for pushing messages in a specific color directly using this ScoreFlashFollow3D instance. /// </summary> /// <remarks> /// Calls <see cref="IScoreFlash.PushWorld(ScoreFlashFollow3D, object, Color)"/> on <see cref="defaultScoreFlash"/> /// (or using the single ScoreFlash instance if defaultScoreFlash wasn't assigned). /// </remarks> /// <param name="message">the message to send, could also be a custom renderer (or any object)</param> /// <param name="color"> /// Use this to control the color the message is sent with. Uses RGB from <c>color</c>, /// and multiplies <c>color.a</c> with the current alpha value depending on the settings /// in the ScoreFlash instance that this message was pushed to /// </param> /// <returns>return the ScoreMessage representing msg during </returns> public ScoreMessage Push(object message, Color color) { HandlePreviousMessage(); currentMessage = DefaultScoreFlash.PushWorld(this, message, color); ApplyMessageSettings(currentMessage); return currentMessage; }
public override void Initialize(ScoreMessage msg) { Vector2 sd = rt.sizeDelta; sd.x = msg.MaxWidth; rt.sizeDelta = sd; text.text = msg.Text; /* * Note: We simply keep the anchor, pivot and text alignment as * set up in the prefab - this gives us more flexibility! */ DoLayout(); }