public async void ShouldAddReviewIfDataCorrect() { var reviewModel = new ReviewModel() { EntityId = 1, Rating = 1, UserId = 1 }; var list = new List <GuideReview>(); var guide = new Guide(); var repo = new Mock <IRepository <Guide> >(); var gameRepo = new Mock <IRepository <Game> >(); var userRepo = new Mock <IRepository <User> >(); var reviewRepo = new Mock <IRepository <GuideReview> >(); reviewRepo.Setup(x => x.GetAllBy(It.IsAny <Expression <Func <GuideReview, bool> > >())).Returns(Task.FromResult(list)); repo.Setup(x => x.GetSingleEntity(It.IsAny <Expression <Func <Guide, bool> > >())).Returns(Task.FromResult(guide)); repo.Setup(x => x.Exists(It.IsAny <Expression <Func <Guide, bool> > >())).Returns(Task.FromResult(true)); var guideService = new GuideService(repo.Object, gameRepo.Object, userRepo.Object, reviewRepo.Object); var guideController = new GuideController(guideService); var result = await guideController.AddReview(reviewModel); var OkResult = Assert.IsType <OkObjectResult>(result); var ResultValue = Assert.IsAssignableFrom <ResultDto <BaseDto> >(OkResult.Value); Assert.Null(ResultValue.Error); }
public async void ShouldGetGuideIfDataCorrect() { var id = 1; var repo = new Mock <IRepository <Guide> >(); var gameRepo = new Mock <IRepository <Game> >(); var userRepo = new Mock <IRepository <User> >(); var reviewRepo = new Mock <IRepository <GuideReview> >(); Guide guide = new Guide(); User user = new User(); Game game = new Game(); repo.Setup(x => x.GetSingleEntity(It.IsAny <Expression <Func <Guide, bool> > >())).Returns(Task.FromResult(guide)); userRepo.Setup(x => x.GetSingleEntity(It.IsAny <Expression <Func <User, bool> > >())).Returns(Task.FromResult(user)); gameRepo.Setup(x => x.GetSingleEntity(It.IsAny <Expression <Func <Game, bool> > >())).Returns(Task.FromResult(game)); var guideService = new GuideService(repo.Object, gameRepo.Object, userRepo.Object, reviewRepo.Object); var guideController = new GuideController(guideService); var result = await guideController.GetGuide(id); var OkResult = Assert.IsType <OkObjectResult>(result); var ResultValue = Assert.IsAssignableFrom <ResultDto <GuideDto> >(OkResult.Value); Assert.Null(ResultValue.Error); }
public async void ShouldNotAddReviewIfGuideNotFound() { var reviewModel = new ReviewModel() { EntityId = 1, Rating = 1, UserId = 1 }; var repo = new Mock <IRepository <Guide> >(); var gameRepo = new Mock <IRepository <Game> >(); var userRepo = new Mock <IRepository <User> >(); var reviewRepo = new Mock <IRepository <GuideReview> >(); repo.Setup(x => x.Exists(It.IsAny <Expression <Func <Guide, bool> > >())).Returns(Task.FromResult(false)); var guideService = new GuideService(repo.Object, gameRepo.Object, userRepo.Object, reviewRepo.Object); var guideController = new GuideController(guideService); var result = await guideController.AddReview(reviewModel); var badRequest = Assert.IsType <BadRequestObjectResult>(result); var errorResult = Assert.IsAssignableFrom <ResultDto <BaseDto> >(badRequest.Value); string error = "Nie odnaleziono poradnika"; Assert.Contains(error, errorResult.Error); }
public async void ShouldNotUpdateGuideIfGameNotFound() { var id = 1; var guideModel = new GuideModel(); var repo = new Mock <IRepository <Guide> >(); var gameRepo = new Mock <IRepository <Game> >(); var userRepo = new Mock <IRepository <User> >(); var reviewRepo = new Mock <IRepository <GuideReview> >(); var guide = new Guide(); repo.Setup(x => x.GetSingleEntity(It.IsAny <Expression <Func <Guide, bool> > >())).Returns(Task.FromResult(guide)); userRepo.Setup(x => x.Exists(It.IsAny <Expression <Func <User, bool> > >())).Returns(Task.FromResult(true)); gameRepo.Setup(x => x.Exists(It.IsAny <Expression <Func <Game, bool> > >())).Returns(Task.FromResult(false)); var guideService = new GuideService(repo.Object, gameRepo.Object, userRepo.Object, reviewRepo.Object); var guideController = new GuideController(guideService); var result = await guideController.UpdateGuide(id, guideModel); var badRequest = Assert.IsType <BadRequestObjectResult>(result); var errorResult = Assert.IsAssignableFrom <ResultDto <BaseDto> >(badRequest.Value); string error = "Podana gra nie zostaĆa znaleziona"; Assert.Contains(error, errorResult.Error); }
public async void ShouldNotGetGuideIfGameNotFound() { var id = 1; var repo = new Mock <IRepository <Guide> >(); var gameRepo = new Mock <IRepository <Game> >(); var userRepo = new Mock <IRepository <User> >(); var reviewRepo = new Mock <IRepository <GuideReview> >(); Guide guide = new Guide(); User user = new User(); Game game = null; repo.Setup(x => x.GetSingleEntity(It.IsAny <Expression <Func <Guide, bool> > >())).Returns(Task.FromResult(guide)); userRepo.Setup(x => x.GetSingleEntity(It.IsAny <Expression <Func <User, bool> > >())).Returns(Task.FromResult(user)); gameRepo.Setup(x => x.GetSingleEntity(It.IsAny <Expression <Func <Game, bool> > >())).Returns(Task.FromResult(game)); var guideService = new GuideService(repo.Object, gameRepo.Object, userRepo.Object, reviewRepo.Object); var guideController = new GuideController(guideService); var result = await guideController.GetGuide(id); var badRequest = Assert.IsType <BadRequestObjectResult>(result); var errorResult = Assert.IsAssignableFrom <ResultDto <GuideDto> >(badRequest.Value); string error = "Nie odnaleziono gry"; Assert.Contains(error, errorResult.Error); }
private void Initialize() { guideController = null; guideCustomController = null; showing = false; GuideManagerData.CurrentStep = 1; }
public ActionResult Index(GuestWebParams param) { GuestContext model = new GuestContext(); if (WebSecurity.IsAuthenticated) { DateTime firstDate = ((param != null) && param.TestDate.HasValue) ? param.TestDate.Value.Date : DateTime.Now.Date; model.GuideDurties = new List <HotelGuideResult>(); List <GuestOrder> list = GuestProvider.GetActiveHotelOrders(UrlLanguage.CurrentLanguage, WebSecurity.CurrentUserId, firstDate, firstDate.AddDays(1.0)); if ((list != null) && (list.Count > 0)) { GuideController controller = new GuideController(); foreach (GuestOrder order in list) { HotelGuideParam param2 = new HotelGuideParam { h = order.hotelid, ln = UrlLanguage.CurrentLanguage, pb = new DateTime?(order.period.begin.Value), pe = new DateTime?(order.period.end.Value) }; HotelGuideResult item = controller.HotelGuide(param2); model.GuideDurties.Add(item); } } } else { model.ShowAuthenticationMessage = true; } return(base.View(model)); }
public override void SimulationStep(ushort buildingID, ref Building buildingData, ref Building.Frame frameData) { base.SimulationStep(buildingID, ref buildingData, ref frameData); if (!MarketBuffers.ContainsKey(buildingID)) { AddMarketBufferToBuildingData(buildingID); } var marketBuffer = MarketBuffers[buildingID]; SimulationManager instance = Singleton <SimulationManager> .instance; uint num = (instance.m_currentFrameIndex & 3840U) >> 8; if (num == 15U) { buildingData.m_finalImport = buildingData.m_tempImport; buildingData.m_finalExport = buildingData.m_tempExport; marketBuffer.amountSold2[index] = marketBuffer.amountSold1[index]; buildingData.m_tempImport = 0; buildingData.m_tempExport = 0; marketBuffer.amountSold1[index] = 0; } if (m_info != null && m_info.m_class != null && m_info.m_class.m_service == ItemClass.Service.Fishing) { GuideController properties = Singleton <GuideManager> .instance.m_properties; if (properties != null && Singleton <BuildingManager> .instance.m_fishFactoryMarketBuilt != null) { Singleton <BuildingManager> .instance.m_fishFactoryMarketBuilt.Activate(properties.m_fishFactoryMarketBuilt, buildingID); } } }
public void Show() { if (GuideEnabled && !showing) { Debug.Log("Current Step:" + GuideManagerData.CurrentStep); showing = true; var guide = Instantiate(Resources.Load <GameObject>(GuidePrefab), GameObject.Find("Canvas").transform); guideController = guide.GetComponent <GuideController>(); var path = string.Format("{0}/{1}", LoadRelativePath, GuideManagerData.CurrentGuideLevelData.GuideDataPath); guideController.GuideText = Instantiate(Resources.Load(path)) as TextAsset; guideController.Generate(); var customControllerName = string.Format("{0}Controller", guideController.name); var customControllerType = Type.GetType(string.Format("{0}, Assembly-CSharp", customControllerName)); if (customControllerType != null) { guideCustomController = guideController.gameObject.AddComponent(customControllerType) as GuideCustomInterface; } guideController.name = string.Format("Level {0} Step {1}", GuideManagerData.CurrentLevel, GuideManagerData.CurrentStep); GuideManagerData.CurrentGuideData = guideController.GuideData; GameMainManager.Instance.netManager.MakePointInGuide(LevelLoader.instance.level, GuideManagerData.CurrentStep, (ret, res) => { }); } }
public override ToolBase.ToolErrors CheckBuildPosition(ushort relocateID, ref Vector3 position, ref float angle, float waterHeight, float elevation, ref Segment3 connectionSegment, out int productionRate, out int constructionCost) { if (this.m_transportLineInfo == null) { return(base.CheckBuildPosition(relocateID, ref position, ref angle, waterHeight, elevation, ref connectionSegment, out productionRate, out constructionCost)); } ToolBase.ToolErrors toolErrors1 = ToolBase.ToolErrors.None; Vector3 pos; Vector3 dir; bool isQuay; if (this.m_info.m_placementMode == BuildingInfo.PlacementMode.Shoreline && BuildingTool.SnapToCanal(position, out pos, out dir, out isQuay, 40f, false)) { angle = Mathf.Atan2(dir.x, -dir.z); pos += dir * this.m_quayOffset; position.x = pos.x; position.z = pos.z; if (!isQuay && !this.m_supportCanals) { toolErrors1 |= ToolBase.ToolErrors.ShoreNotFound; } } ToolBase.ToolErrors toolErrors2 = toolErrors1 | base.CheckBuildPosition(relocateID, ref position, ref angle, waterHeight, elevation, ref connectionSegment, out productionRate, out constructionCost); //begin mod //end mod Vector3 position1 = Building.CalculatePosition(position, angle, this.m_connectionOffset); Vector3 position2 = position1; uint laneID; byte offset; if (ShipDockAI.FindConnectionPath(ref position2, out laneID, out offset)) { position1.y = position2.y; connectionSegment.a = position1; connectionSegment.b = position2; if (!Singleton <TerrainManager> .instance.HasWater(Segment2.XZ(connectionSegment), 50f, false)) { toolErrors2 |= ToolBase.ToolErrors.CannotConnect; } } else { toolErrors2 |= ToolBase.ToolErrors.CannotConnect; } GuideController properties = Singleton <GuideManager> .instance.m_properties; if (properties != null) { if ((toolErrors2 & ToolBase.ToolErrors.CannotConnect) != ToolBase.ToolErrors.None) { Singleton <BuildingManager> .instance.m_harborPlacement.Activate(properties.m_harborPlacement); } else { Singleton <BuildingManager> .instance.m_harborPlacement.Deactivate(); } } return(toolErrors2); }
void OnClick() { if (GuideController.Instance.guideSelected.transform.parent != this.transform) { GuideController guideController = GuideController.Instance; UIAnchor anchor = guideController.guideSelected.GetComponent <UIAnchor>(); switch (type) { case UIGuideButton.TOWER: audio.volume = (float)PlayerInfo.Instance.userInfo.volumeSound / 100; audio.PlayScheduled(0.5f); anchor.relativeOffset.x = PlayConfig.AnchorGuideSelectedTower; guideController.regSelected.SetActive(true); guideController.regInfo.SetActive(true); guideController.regNote.SetActive(false); guideController.loadTower(); break; case UIGuideButton.ENEMY: audio.volume = (float)PlayerInfo.Instance.userInfo.volumeSound / 100; audio.PlayScheduled(0.5f); anchor.relativeOffset.x = PlayConfig.AnchorGuideSelectedEnemy; guideController.regSelected.SetActive(true); guideController.regInfo.SetActive(true); guideController.regNote.SetActive(false); guideController.loadEnemy(); break; case UIGuideButton.NOTE: audio.volume = (float)PlayerInfo.Instance.userInfo.volumeSound / 100; audio.PlayScheduled(0.5f); anchor.relativeOffset.x = PlayConfig.AnchorGuideSelectedNote; guideController.regSelected.SetActive(false); guideController.regInfo.SetActive(false); guideController.regNote.SetActive(true); break; case UIGuideButton.CLICK: audio.volume = (float)PlayerInfo.Instance.userInfo.volumeSound / 100; audio.PlayScheduled(0.5f); return; } guideController.guideSelected.transform.parent = this.transform; guideController.guideSelected.transform.localScale = Vector3.one; anchor.container = this.gameObject; anchor.enabled = true; } }
public void InvalidMaterialNoteNotIntegerCreditTest() { List <string> notes = new List <string>() { "pish pish Iron is X Credits" }; GuideController guideController = new GuideController(); Assert.Throws <ArgumentException>(() => guideController.ProcessNotes(notes)); }
public void InvalidIUnitNoteIUAlreadyDefinedTest() { List <string> notes = new List <string>() { "pish is I", "pish is V" }; GuideController guideController = new GuideController(); Assert.Throws <InvalidOperationException>(() => guideController.ProcessNotes(notes)); }
public void InvalidIUQuestionNoteIUNotDefinedTest() { List <string> notes = new List <string>() { "pish is X", "how much is pish tegj glob glob ?" }; GuideController guideController = new GuideController(); Assert.Throws <InvalidOperationException>(() => guideController.ProcessNotes(notes)); }
public void InvalidIUnitNoteNotRomanNumeralTest() { List <string> notes = new List <string>() { "pish is J" }; GuideController guideController = new GuideController(); Assert.Throws <ArgumentException>(() => guideController.ProcessNotes(notes)); }
public void InvalidMaterialNoteMaterialAlreadyDefinedTest() { List <string> notes = new List <string>() { "pish is X", "pish pish Iron is 3910 Credits", "pish Iron is 10 Credits" }; GuideController guideController = new GuideController(); Assert.Throws <InvalidOperationException>(() => guideController.ProcessNotes(notes)); }
// Start is called before the first frame update void Start() { guideController = transform.GetComponent <GuideController>(); vectors = guideController.Guide(canvas, GameObject.Find("PauseButton").GetComponent <RectTransform>(), GuideType.Rect, TranslateType.Slow, 0.5f); //Debug.Log("1234"+GameObject.Find("/MapCube (32)").name); GameObject.Find("Text1").GetComponent <Text>().enabled = true;//activate current canvas GameObject.Find("Image1").GetComponent <Image>().enabled = true; //Invoke("Test", 1); //count++; //Debug.Log("1:" + vectors[0] + "2:" + vectors[1] + "3:" + vectors[2] + "4:" + vectors[3]); }
public void InvalidMaterialQuestionNoteMaterialNotDefinedTest() { List <string> notes = new List <string>() { "glob is I", "prok is V", "pish is X", "tegj is L", "how many Credits is glob prok Silver ?" }; GuideController guideController = new GuideController(); Assert.Throws <InvalidOperationException>(() => guideController.ProcessNotes(notes)); }
public void InvalidIUnitNoteNoIsTest() { List <string> notes = new List <string>() { "pish iss X" }; GuideController guideController = new GuideController(); guideController.ProcessNotes(notes); Assert.IsNotEmpty(guideController.Responses); Assert.IsTrue(guideController.Responses.Count == 1); Assert.AreEqual("I have no idea what you are talking about", guideController.Responses[0]); }
public static void Main(string[] args) { GuideController guideController = new GuideController(); try { guideController.Process(); } catch (Exception e) { Console.WriteLine("Something went wrong. Please review the input provided."); Console.WriteLine(e.Message); } }
public void FindMaterialSuccessTest() { List <string> notes = new List <string>() { "pish is X", "pish pish Iron is 3910 Credits" }; GuideController guideController = new GuideController(); guideController.ProcessNotes(notes); Material material = guideController.Guide.FindMaterialByName("Iron"); Assert.IsNotNull(material); Assert.AreEqual("Iron", material.Name); }
public void InvalidNoteTest() { List <string> notes = new List <string>() { "how much wood could a woodchuck chuck if a woodchuck could chuck wood ?" }; GuideController guideController = new GuideController(); guideController.ProcessNotes(notes); Assert.IsNotEmpty(guideController.Responses); Assert.IsTrue(guideController.Responses.Count == 1); Assert.AreEqual("I have no idea what you are talking about", guideController.Responses[0]); }
private void GuidePanel_Load(object sender, EventArgs e) { try { _inLoad = true; Cursor.Current = Cursors.WaitCursor; _model = new GuideModel(); _controller = new GuideController(_model); ChannelType channelType = ChannelType.Television; if (MainForm.Session.ContainsKey(SessionKey.ChannelType)) { channelType = (ChannelType)MainForm.Session[SessionKey.ChannelType]; } _controller.Initialize(channelType, 24, ArgusTV.WinForms.Controls.EpgControl.EpgHoursOffset, "All Channels"); _channelTypeComboBox.SelectedIndex = (int)_model.ChannelType; _groupsBindingSource.DataSource = _model.ChannelGroups; _channelGroupsComboBox.DisplayMember = "GroupName"; _channelGroupsComboBox.ValueMember = "ChannelGroupId"; if (MainForm.Session.ContainsKey(SessionKey.ChannelGroupId)) { _channelGroupsComboBox.SelectedValue = (Guid)MainForm.Session[SessionKey.ChannelGroupId]; } DateTime guideDate = GetCurrentGuideDate(); if (MainForm.Session.ContainsKey(SessionKey.GuideDate)) { guideDate = (DateTime)MainForm.Session[SessionKey.GuideDate]; } _gotoNowTime = true; _guideDatePicker.Value = guideDate; RefreshEpg(true); } catch (Exception ex) { MessageBox.Show(this, ex.Message, null, MessageBoxButtons.OK, MessageBoxIcon.Error); } finally { Cursor.Current = Cursors.Default; _inLoad = false; } }
public void ValidMaterialNoteTest() { List <string> notes = new List <string>() { "pish is X", "pish pish Iron is 3910 Credits" }; GuideController guideController = new GuideController(); guideController.ProcessNotes(notes); Assert.IsNotNull(guideController.Guide.MaterialList); Assert.AreEqual(1, guideController.Guide.MaterialList.Count); Assert.AreEqual("Iron", guideController.Guide.MaterialList[0].Name); Assert.AreEqual(195.5, guideController.Guide.MaterialList[0].CreditValue); }
public ActionResult Summary([Bind(Prefix = "OrderFindForm")] OrderModel model) { SummaryContext context = new SummaryContext { ShowOrderFindForm = true }; if (base.ModelState.IsValid) { DateTime? currentDate = model.CurrentDate; DateTime dateFrom = currentDate.HasValue ? currentDate.GetValueOrDefault() : DateTime.Now.Date; List <GuestClaim> claims = GuestProvider.FindGuestClaims(UrlLanguage.CurrentLanguage, 0, model.ClaimName, new int?(Convert.ToInt32(model.Claim)), null); if ((claims != null) && (claims.Count > 0)) { int?nullable2; ReservationState reservationState = BookingProvider.GetReservationState(UrlLanguage.CurrentLanguage, claims[0].claim); if ((reservationState != null) && (nullable2 = reservationState.claimId).HasValue) { context.Claim = reservationState; context.ShowOrderFindForm = false; context.Hotels = new List <DepartureHotel>(); foreach (GuestClaim claim in claims) { nullable2 = null; context.Hotels.AddRange(GuestProvider.GetDepartureInfo(UrlLanguage.CurrentLanguage, dateFrom, dateFrom.AddDays(1.0), nullable2, new int?(claim.claim))); } context.GuideDurties = new List <HotelGuideResult>(); List <GuestOrder> list2 = GuestProvider.GetActiveHotelOrders(claims, dateFrom, dateFrom.AddDays(1.0)); if ((list2 != null) && (list2.Count > 0)) { GuideController controller = new GuideController(); foreach (GuestOrder order in list2) { HotelGuideParam param = new HotelGuideParam { h = order.hotelid, ln = UrlLanguage.CurrentLanguage, pb = new DateTime?(order.period.begin.Value), pe = new DateTime?(order.period.end.Value) }; HotelGuideResult item = controller.HotelGuide(param); context.GuideDurties.Add(item); } } } } } context.OrderFindNotFound = context.Claim == null; return(base.View(context)); }
public void WriteToConsoleOKTest() { List <string> outputLines = new List <string> { "Goodbye World", "Bar foo" }; string testOutput = string.Format("Goodbye World{0}Bar foo{0}", Environment.NewLine); using (StringWriter sw = new StringWriter()) { Console.SetOut(sw); GuideController.WriteToOutput(outputLines); Assert.AreEqual(testOutput, sw.ToString()); } }
public void ValidIUnitNoteOKTest() { List <string> notes = new List <string>() { "pish is X" }; GuideController guideController = new GuideController(); guideController.ProcessNotes(notes); Assert.IsNotNull(guideController.Guide.IntergalacticUnitList); Assert.AreEqual(1, guideController.Guide.IntergalacticUnitList.Count); Assert.AreEqual("pish", guideController.Guide.IntergalacticUnitList[0].Name); Assert.AreEqual(new RomanNumeral("X").AbsoluteValue, guideController.Guide.IntergalacticUnitList[0].RomanValue.AbsoluteValue); Assert.AreEqual((int)RomanNumeral.RomanSymbol.X, guideController.Guide.IntergalacticUnitList[0].RomanValue.AbsoluteValue); }
public void ReadFromConsoleOKTest() { string testInput = string.Format("Hello World{0}Foo bar{0}", Environment.NewLine); List <string> inputLines; using (StringReader sr = new StringReader(testInput)) { Console.SetIn(sr); inputLines = GuideController.ReadFromInput(); } Assert.IsNotEmpty(inputLines); Assert.IsTrue(inputLines.Count == 2); Assert.AreEqual("Hello World", inputLines[0]); Assert.AreEqual("Foo bar", inputLines[1]); }
// Not much to see from here on public override void SimulationStep(ushort buildingID, ref Building buildingData, ref Building.Frame frameData) { Util.buildingFlags(ref buildingData); if ((buildingData.m_flags & Building.Flags.Completed) == Building.Flags.None) { bool flag = (buildingData.m_flags & Building.Flags.Upgrading) != Building.Flags.None; int constructionTime = this.GetConstructionTime(); if (constructionTime == 0) { frameData.m_constructState = 255; } else { frameData.m_constructState = (byte)Mathf.Min(255, (int)frameData.m_constructState + 1088 / constructionTime); } if (frameData.m_constructState == 255) { this.BuildingCompleted(buildingID, ref buildingData); GuideController properties3 = Singleton <GuideManager> .instance.m_properties; if (properties3 != null) { Singleton <BuildingManager> .instance.m_buildingLevelUp.Deactivate(buildingID, true); } } else if (flag) { GuideController properties4 = Singleton <GuideManager> .instance.m_properties; if (properties4 != null) { Singleton <BuildingManager> .instance.m_buildingLevelUp.Activate(properties4.m_buildingLevelUp, buildingID); } } if (flag) { this.SimulationStepActive(buildingID, ref buildingData, ref frameData); } } else { this.SimulationStepActive(buildingID, ref buildingData, ref frameData); } Util.buildingFlags(ref buildingData); }
// Use this for initialization void Start() { buttonSprites = Resources.LoadAll <Sprite>("buttons"); play = buttonSprites[5]; pause = buttonSprites[7]; playPauseButton = GameObject.Find("Play/Pause"); nextButton = GameObject.Find("Next"); lastButton = GameObject.Find("Last"); slowerButton = GameObject.Find("Slower"); fasterButton = GameObject.Find("Faster"); finishedRotation = true; ct = GetComponent <CubeTransformer>(); gc = GameObject.Find("Canvas/Guide").GetComponent <GuideController>(); playPauseButton.GetComponent <Button>().interactable = nextButton.GetComponent <Button>().interactable = lastButton.GetComponent <Button>().interactable = slowerButton.GetComponent <Button>().interactable = fasterButton.GetComponent <Button>().interactable = false; }
public override void UpdateGuide(GuideController guideController) { if (this.m_waterConsumption != 0) { BuildingTypeGuide waterPumpMissingGuide = Singleton<WaterManager>.instance.m_waterPumpMissingGuide; if (waterPumpMissingGuide != null) { int waterCapacity = Singleton<DistrictManager>.instance.m_districts.m_buffer[0].GetWaterCapacity(); int sewageCapacity = Singleton<DistrictManager>.instance.m_districts.m_buffer[0].GetSewageCapacity(); if (waterCapacity == 0 && sewageCapacity != 0) { waterPumpMissingGuide.Activate(guideController.m_waterPumpMissing, this.m_info); } else { waterPumpMissingGuide.Deactivate(); } } } base.UpdateGuide(guideController); }