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);
}
