public static Crew CreateNewCrew(ColonyController home, int membersCount)
{
if (crewsList.Count >= RecruitingCenter.GetCrewsSlotsCount())
{
return(null);
}
if (crewsList.Count > MAX_CREWS_COUNT)
{
AnnouncementCanvasController.MakeImportantAnnounce(Localization.GetAnnouncementString(GameAnnouncements.CrewsLimitReached));
GameMaster.LoadingFail();
return(null);
}
Crew c = new GameObject(Localization.NameCrew()).AddComponent <Crew>();
if (crewsContainer == null)
{
crewsContainer = new GameObject("crewsContainer");
}
c.transform.parent = crewsContainer.transform;
c.ID = nextID; nextID++;
c.atHome = true;
//normal parameters
c.membersCount = (byte)membersCount;
//attributes
c.SetAttributes(home);
//
crewsList.Add(c);
listChangesMarkerValue++;
return(c);
}
public void ReplenishButton()
{
if (showingCrew == null)
{
replenishButton.SetActive(false);
}
else
{
if (showingCrew.membersCount == Crew.MAX_MEMBER_COUNT)
{
replenishButton.SetActive(false);
}
else
{
var colony = GameMaster.realMaster.colonyController;
float hireCost = RecruitingCenter.REPLENISH_COST;
if (colony.energyCrystalsCount >= hireCost)
{
colony.GetEnergyCrystals(hireCost);
showingCrew.AddMember();
PrepareButtons();
}
else
{
AnnouncementCanvasController.NotEnoughMoneyAnnounce();
}
}
}
}
private void SendColonists()
{
if (completed)
{
return;
}
if (anchorBasement.colonistsArrived >= COLONISTS_SEND_LIMIT)
{
if (colony.storage.GetResourceCount(COST_RESOURCE_ID) >= COLONISTS_SEND_COST)
{
if (hexBuilder.totalHousing > hexBuilder.colonistsCount)
{
anchorBasement.GetColonists(COLONISTS_SEND_LIMIT);
colony.storage.GetResources(COST_RESOURCE_ID, COLONISTS_SEND_COST);
hexBuilder.AddColonist();
colony.RemoveCitizens(COLONISTS_SEND_LIMIT, false);
settleWindow.Refresh();
}
else
{
AnnouncementCanvasController.MakeImportantAnnounce(localizer.notEnoughLivingSpace);
}
}
else
{
AnnouncementCanvasController.MakeImportantAnnounce(localizer.notEnoughSuppliesMsg);
}
}
else
{
AnnouncementCanvasController.MakeImportantAnnounce(localizer.notEnoughColonistsMsg);
}
}
public float BuyResource(ResourceType rt, float volume)
{
var colony = GameMaster.realMaster.colonyController;
if (colony.energyCrystalsCount <= 0f)
{
return(0f);
}
float p = ResourceType.prices[rt.ID], money = 0f;
if (p != 0)
{
money = colony.GetEnergyCrystals(volume * ResourceType.prices[rt.ID]);
volume = money / ResourceType.prices[rt.ID];
if (volume <= 0f)
{
return(0f);
}
else
{
if (volume > 99f)
{
AnnouncementCanvasController.MakeAnnouncement(Localization.GetBuyMsg(rt, volume, money));
}
}
}
colony.storage.AddResource(rt, volume);
colony.gears_coefficient -= gearsDamage * volume;
return(volume);
}
public void StartEndQuest(byte routeIndex)
{
int endIndex = (int)QuestSection.Endgame;
if (activeQuests[endIndex] == Quest.NoQuest || activeQuests[endIndex] == null)
{
questAccessMap[endIndex] = true;
if ((Knowledge.ResearchRoute)routeIndex == Knowledge.ResearchRoute.Foundation)
{
var scn = new FoundationRouteScenario();
GameMaster.realMaster.BindScenario(scn);
scn.StartScenario();
}
else
{
activeQuests[endIndex] = new Quest(QuestType.Endgame, routeIndex);
}
}
else
{
AnnouncementCanvasController.MakeImportantAnnounce(Localization.GetAnnouncementString(GameAnnouncements.AlreadyHaveEndquest));
}
if (openedQuest == -1 & GetComponent <Image>().enabled)
{
PrepareBasicQuestWindow();
}
}
public bool StartHiring()
{
if (finding)
{
return(true);
}
else
{
if (Crew.crewsList.Count < GetCrewsSlotsCount())
{
if (colony.energyCrystalsCount >= hireCost)
{
colony.GetEnergyCrystals(hireCost);
finding = true;
return(true);
}
else
{
AnnouncementCanvasController.NotEnoughMoneyAnnounce();
return(false);
}
}
else
{
AnnouncementCanvasController.MakeImportantAnnounce(Localization.GetRefusalReason(RefusalReason.NotEnoughSlots));
if (GameMaster.soundEnabled)
{
GameMaster.audiomaster.Notify(NotificationSound.NotEnoughSlots);
}
return(false);
}
}
}
protected override void LabourResult(int iterations)
{
if (iterations < 1)
{
return;
}
workflow -= iterations;
int memCount = (int)((workersCount / (float)maxWorkers) * Crew.MAX_MEMBER_COUNT);
if (workersCount < memCount)
{
memCount = workersCount;
}
if (memCount > 0)
{
Crew c = Crew.CreateNewCrew(colony, memCount);
workersCount -= memCount;
workflow = 0;
finding = false;
AnnouncementCanvasController.MakeAnnouncement(Localization.GetCrewAction(LocalizedCrewAction.Ready, c));
hireCost = hireCost * (1 + GameConstants.HIRE_COST_INCREASE);
hireCost = ((int)(hireCost * 100)) / 100f;
if (showOnGUI)
{
rcenterObserver.SelectCrew(c);
}
}
}
override public void LevelUp(bool returnToUI)
{
if (!GameMaster.realMaster.weNeedNoResources)
{
ResourceContainer[] cost = GetUpgradeCost();
if (!colony.storage.CheckBuildPossibilityAndCollectIfPossible(cost))
{
AnnouncementCanvasController.NotEnoughResourcesAnnounce();
return;
}
}
if (level > 3)
{
SetBlockers();
}
level++;
nextStageConditionMet = CheckUpgradeCondition();
SetModel();
buildingObserver.CheckUpgradeAvailability();
Quest.ResetHousingQuest();
AnnouncementCanvasController.MakeAnnouncement(Localization.LevelReachedString(level));
if (GameMaster.soundEnabled)
{
GameMaster.audiomaster.Notify(NotificationSound.HQ_Upgraded);
}
GameMaster.realMaster.eventTracker?.BuildingUpgraded(this);
}
private static AnnouncementCanvasController GetCurrent()
{
if (_currentLog == null)
{
_currentLog = Instantiate(Resources.Load <GameObject>("UIPrefs/logCanvas"), UIController.GetCurrent()?.transform).GetComponent <AnnouncementCanvasController>();
}
return(_currentLog);
}
public void CostPanel_Build()
{
switch (costPanelMode)
{
case CostPanelMode.SurfaceMaterialChanging:
ResourceType rt = ResourceType.GetResourceTypeById(costPanel_selectedButton.y);
if (colony.storage.CheckBuildPossibilityAndCollectIfPossible(new ResourceContainer[] { new ResourceContainer(rt, PlaneExtension.INNER_RESOLUTION * PlaneExtension.INNER_RESOLUTION) }))
{
observingSurface.ChangeMaterial(rt.ID, true);
costPanel.transform.GetChild(0).GetChild(costPanel_selectedButton.x).GetComponent <Image>().overrideSprite = null;
}
else
{
AnnouncementCanvasController.NotEnoughResourcesAnnounce();
}
break;
case CostPanelMode.ColumnBuilding:
{
if (colony.storage.CheckBuildPossibilityAndCollectIfPossible(ResourcesCost.GetCost(Structure.COLUMN_ID)))
{
// float supportPoints = observingSurface.myChunk.CalculateSupportPoints(observingSurface.pos.x, observingSurface.pos.y, observingSurface.pos.z);
// if (supportPoints <= 1)
// {
Structure s = Structure.GetStructureByID(Structure.COLUMN_ID);
s.SetBasement(observingSurface, new PixelPosByte(7, 7));
PoolMaster.current.BuildSplash(s.transform.position);
SetCostPanelMode(CostPanelMode.Disabled);
Plane p;
if ((s as IPlanable).TryGetPlane(observingSurface.faceIndex, out p) && !p.isTerminal)
{
mycanvas.Select(p);
}
else
{
ReturnButton();
}
// }
// else
// {
// observingSurface.myChunk.ReplaceBlock(observingSurface.pos, BlockType.Cave, observingSurface.material_id, ResourceType.CONCRETE_ID, false);
// }
}
else
{
AnnouncementCanvasController.NotEnoughResourcesAnnounce();
}
}
break;
case CostPanelMode.BlockBuilding:
BlockBuildingSite bbs = new BlockBuildingSite(observingSurface, ResourceType.GetResourceTypeById(costPanel_selectedButton.y));
SetCostPanelMode(CostPanelMode.Disabled);
mycanvas.ShowWorksite(bbs);
break;
}
}
override public void LevelUp(bool returnToUI)
{
if (upgradedIndex == -1)
{
return;
}
if (!GameMaster.realMaster.weNeedNoResources)
{
ResourceContainer[] cost = GetUpgradeCost();
if (!colony.storage.CheckBuildPossibilityAndCollectIfPossible(cost))
{
AnnouncementCanvasController.NotEnoughResourcesAnnounce();
return;
}
}
Factory upgraded = GetStructureByID(upgradedIndex) as Factory;
upgraded.Prepare();
PixelPosByte setPos = new PixelPosByte(surfaceRect.x, surfaceRect.z);
if (upgraded.surfaceRect.size == 16)
{
setPos = new PixelPosByte(0, 0);
}
int workers = workersCount;
workersCount = 0;
if (upgraded.rotate90only & (modelRotation % 2 != 0))
{
upgraded.modelRotation = (byte)(modelRotation - 1);
}
else
{
upgraded.modelRotation = modelRotation;
}
//
upgraded.SetRecipe(recipe);
upgraded.productionMode = productionMode;
upgraded.productionModeValue = productionModeValue;
upgraded.workPaused = workPaused;
upgraded.workflow = workflow;
upgraded.inputResourcesBuffer = inputResourcesBuffer; inputResourcesBuffer = 0;
upgraded.outputResourcesBuffer = outputResourcesBuffer; outputResourcesBuffer = 0;
//
upgraded.SetBasement(basement, setPos);
upgraded.AddWorkers(workers);
if (isActive)
{
upgraded.SetActivationStatus(true, true);
}
if (returnToUI)
{
upgraded.ShowOnGUI();
}
GameMaster.realMaster.eventTracker?.BuildingUpgraded(this);
}
public void Next()
{
if (currentStep == FoundationScenarioStep.AnchorStart)
{
AnnouncementCanvasController.MakeAnnouncement(localizer.GetAnnounceTitle(currentStep, QUEST_INFO_1));
scenarioQuest.MakeQuestCompleted();
}
currentStep++;
StartSubscenario();
}
public void SubmitButton() // for save option only
{
int si = listController.selectedButtonIndex;
if (si < 0 || savenames == null || si >= savenames.Length)
{
return;
}
string name = savenames[listController.selectedButtonIndex];
bool redrawList = false;
if (workWithTerrains)
{// ПЕРЕЗАПИСЬ СОХРАНЕНИЯ ТЕРРЕЙНА
if (deleteSubmit)
{
File.Delete(GetTerrainSaveFullpath(name));
redrawList = true;
}
else
{
GameMaster.realMaster.SaveTerrain(name);
redrawList = true;
}
}
else
{ // ПЕРЕЗАПИСЬ СОХРАНЕНИЯ ИГРЫ
if (deleteSubmit)
{
File.Delete(GetGameSaveFullpath(name));
redrawList = true;
}
else
{
if (GameMaster.realMaster.SaveGame(name))
{
AnnouncementCanvasController.MakeAnnouncement(Localization.GetAnnouncementString(GameAnnouncements.GameSaved));
redrawList = true;
}
else
{
AnnouncementCanvasController.MakeAnnouncement(Localization.GetAnnouncementString(GameAnnouncements.SavingFailed));
if (GameMaster.soundEnabled)
{
GameMaster.audiomaster.Notify(NotificationSound.SystemError);
}
}
}
}
submitWindow.SetActive(false);
if (redrawList)
{
PrepareSavesList();
}
}
public void ToMainMenu()
{
AnnouncementCanvasController.EnableDecisionWindow(
Localization.GetPhrase(LocalizedPhrase.AskReturnToMainMenu),
this.ReturnToMainMenu,
Localization.GetWord(LocalizedWord.Yes),
AnnouncementCanvasController.DisableDecisionPanel,
Localization.GetWord(LocalizedWord.No),
true
);
}
public void ExitButton()
{
AnnouncementCanvasController.EnableDecisionWindow(
Localization.GetPhrase(LocalizedPhrase.AskExit),
this.ExitGame,
Localization.GetWord(LocalizedWord.Yes),
AnnouncementCanvasController.DisableDecisionPanel,
Localization.GetWord(LocalizedWord.No),
true
);
}
public void StartShipService(Ship s)
{
if (servicingShip != s)
{
servicingShip.Undock();
}
servicingShip = s;
loadingTimer = LOADING_TIME;
if (announceNewShips)
{
AnnouncementCanvasController.MakeAnnouncement(Localization.GetAnnouncementString(GameAnnouncements.ShipArrived));
}
}
public void SellResource(ResourceType rt, float volume)
{
var colony = GameMaster.realMaster.colonyController;
float vol = colony.storage.GetResources(rt, volume);
float money = vol * ResourceType.prices[rt.ID] * GameMaster.sellPriceCoefficient;
colony.AddEnergyCrystals(money);
colony.gears_coefficient -= gearsDamage * vol;
if (vol > 99f)
{
AnnouncementCanvasController.MakeAnnouncement(Localization.GetSellMsg(rt, vol, money));
}
}
public void Dismiss() // экспедиция вернулась домой и распускается
{
//зависимость : Disappear()
if (stage == ExpeditionStage.Disappeared | stage == ExpeditionStage.Dismissed)
{
return;
}
else
{
AnnouncementCanvasController.MakeAnnouncement(Localization.GetCrewAction(LocalizedCrewAction.Returned, crew));
if (crew != null)
{
crew.CountMission(missionCompleted);
crew.SetCurrentExpedition(null);
crew = null;
}
QuantumTransmitter.StopTransmission(transmissionID);
Hangar.ReturnShuttle(shuttleID);
if (destination != null)
{
destination.DeassignExpedition(this);
}
if (suppliesCount > 0)
{
GameMaster.realMaster.colonyController.storage.AddResource(ResourceType.Supplies, suppliesCount);
}
if (expeditionsList.Contains(this))
{
expeditionsList.Remove(this);
}
if (crystalsCollected > 0)
{
GameMaster.realMaster.colonyController.AddEnergyCrystals(crystalsCollected);
crystalsCollected = 0;
}
stage = ExpeditionStage.Dismissed;
if (missionCompleted)
{
expeditionsSucceed++;
Knowledge.GetCurrent()?.ExpeditionsCheck(expeditionsSucceed);
}
if (subscribedToUpdate & !GameMaster.sceneClearing)
{
GameMaster.realMaster.labourUpdateEvent -= this.LabourUpdate;
subscribedToUpdate = false;
}
changesMarkerValue++;
}
}
public void LaunchButton()
{
if (observingExpedition == null)
{
if (selectedCrew != null && selectedCrew.atHome)
{
var storage = colony.storage;
bool TESTMODE = GameMaster.realMaster.weNeedNoResources;
if (TESTMODE || suppliesSlider.value <= storage.GetResourceCount(ResourceType.Supplies) &&
crystalsSlider.value <= colony.energyCrystalsCount &&
storage.GetResourceCount(ResourceType.Fuel) >= FUEL_BASE_COST
)
{
int shID = Hangar.GetFreeShuttleID();
if (shID != Hangar.NO_SHUTTLE_VALUE)
{
var t = QuantumTransmitter.GetFreeTransmitter();
if (t != null)
{
if (storage.TryGetResources(ResourceType.Fuel, FUEL_BASE_COST))
{
var e = new Expedition(selectedDestination, selectedCrew, shID, t, storage.GetResources(ResourceType.Supplies, suppliesSlider.value), colony.GetEnergyCrystals(crystalsSlider.value));
var mc = mycanvas.uicontroller;
if (mc.currentMode == UIMode.Standart)
{
observingExpedition = e;
}
else
{
observingExpedition = e;
RedrawWindow();
mc.ShowExpedition(e);
}
}
else
{
AnnouncementCanvasController.MakeAnnouncement(Localization.GetExpeditionErrorText(ExpeditionComposingErrors.NotEnoughFuel));
}
RedrawWindow();
}
}
}
}
}
else
{
observingExpedition.EndMission();
}
}
public void Next()
{
switch (currentStep)
{
case FoundationScenarioStep.AnchorBuilding:
scenarioQuest?.MakeQuestCompleted();
break;
case FoundationScenarioStep.AnchorStart:
AnnouncementCanvasController.MakeAnnouncement(localizer.GetAnnounceTitle(currentStep, QUEST_INFO_1));
scenarioQuest.MakeQuestCompleted();
break;
}
currentStep++;
StartSubscenario();
}
public void Prepare()
{
if (prepared)
{
return;
}
else
{
prepared = true;
}
vegetationShaderWindPropertyID = Shader.PropertyToID("_Windpower");
if (!GameMaster.loading)
{
windVector = Random.insideUnitCircle;
newWindVector = windVector;
}
Shader.SetGlobalFloat(vegetationShaderWindPropertyID, 1);
sun = FindObjectOfType <Light>();
if (sun == null)
{
sun = new GameObject("sun").AddComponent <Light>();
sun.type = LightType.Directional;
}
sunTransform = sun.transform;
decorations = new List <Transform>();
skyboxMaterial = RenderSettings.skybox;
gm = GameMaster.realMaster;
globalMap = gm.globalMap;
SetEnvironment(Environment.defaultEnvironment);
if (gm.gameMode != GameMode.Editor)
{
RefreshVisual();
RecalculateCelestialDecorations();
}
else
{
}
islandStability = DEFAULT_ISLAND_STABILITY;
globalMap?.LinkEnvironmentMaster(this);
if (GameMaster.realMaster.IsInTestMode)
{
AnnouncementCanvasController.MakeAnnouncement("environment master loaded");
}
}
private void Update()
{
if (loading | gameSpeed == 0)
{
return;
}
autosaveTimer -= Time.deltaTime;
if (autosaveTimer <= 0f)
{
SetPause(true);
AnnouncementCanvasController.MakeAnnouncement("autosaving!");
SaveGame("autosave_time");
SetPause(false);
autosaveTimer = AUTOSAVE_TIME;
}
gameSpeed = _gameSpeed;
}
override public void LevelUp(bool returnToUI)
{
if (upgradedIndex == -1)
{
return;
}
if (!GameMaster.realMaster.weNeedNoResources)
{
ResourceContainer[] cost = GetUpgradeCost();
if (!colony.storage.CheckBuildPossibilityAndCollectIfPossible(cost))
{
AnnouncementCanvasController.NotEnoughResourcesAnnounce();
return;
}
}
WorkBuilding upgraded = GetStructureByID(upgradedIndex) as WorkBuilding;
upgraded.Prepare();
PixelPosByte setPos = new PixelPosByte(surfaceRect.x, surfaceRect.z);
if (upgraded.surfaceRect.size == 16)
{
setPos = new PixelPosByte(0, 0);
}
int workers = workersCount;
workersCount = 0;
if (upgraded.rotate90only & (modelRotation % 2 != 0))
{
upgraded.modelRotation = (byte)(modelRotation - 1);
}
else
{
upgraded.modelRotation = modelRotation;
}
upgraded.AddWorkers(workers);
upgraded.SetBasement(basement, setPos);
GameMaster.realMaster.eventTracker?.BuildingUpgraded(this);
if (returnToUI)
{
upgraded.ShowOnGUI();
}
//copied to factory.levelup
}
/// ===============================
public Expedition(PointOfInterest i_destination, Crew c, int i_shuttleID, QuantumTransmitter transmitter, float i_supplies, float i_crystals)
{
// СДЕЛАТЬ: проверка компонентов и вывод ошибок
ID = nextID++;
stage = ExpeditionStage.WayIn;
destination = i_destination; destination.AssignExpedition(this);
crew = c; c.SetCurrentExpedition(this);
if (Hangar.OccupyShuttle(i_shuttleID))
{
shuttleID = i_shuttleID;
}
else
{
AnnouncementCanvasController.MakeAnnouncement(Localization.GetExpeditionErrorText(ExpeditionComposingErrors.ShuttleUnavailable));
Dismiss();
}
if (transmitter != null)
{
transmissionID = transmitter.StartTransmission();
hasConnection = true;
}
else
{
transmissionID = QuantumTransmitter.NO_TRANSMISSION_VALUE;
hasConnection = false;
}
suppliesCount = (byte)i_supplies;
crystalsCollected = (ushort)i_crystals;
//#creating map marker
GlobalMap gmap = GameMaster.realMaster.globalMap;
mapMarker = new FlyingExpedition(this, gmap.cityPoint, destination, FLY_SPEED);
gmap.AddPoint(mapMarker, true);
//
expeditionsList.Add(this);
listChangesMarker++;
}
override protected void LabourResult(int iterations)
{
if (iterations < 1)
{
return;
}
shuttleID = nextShuttleID++;
status = HangarStatus.ShuttleInside;
if (workersCount > 0)
{
FreeWorkers();
}
workflow = 0f;
listChangesMarkerValue++;
if (showOnGUI)
{
hangarObserver.PrepareHangarWindow();
}
AnnouncementCanvasController.MakeAnnouncement(Localization.GetPhrase(LocalizedPhrase.ShuttleConstructed));
}
public void Charge()
{
ColonyController colony = GameMaster.realMaster.colonyController;
if (colony.energyCrystalsCount >= 1)
{
if (colony.energyStored != colony.totalEnergyCapacity)
{
colony.GetEnergyCrystals(1);
colony.AddEnergy(GameConstants.ENERGY_IN_CRYSTAL);
if (GameMaster.soundEnabled)
{
GameMaster.audiomaster.Notify(NotificationSound.BatteryCharged);
}
}
}
else
{
AnnouncementCanvasController.NotEnoughMoneyAnnounce();
}
}
public void StartConstructing()
{
if (observingHangar.status == Hangar.HangarStatus.ConstructingShuttle)
{
observingHangar.StopConstruction();
PrepareHangarWindow();
}
else
{
ColonyController colony = GameMaster.realMaster.colonyController;
if (colony.storage.CheckBuildPossibilityAndCollectIfPossible(ResourcesCost.GetCost(ResourcesCost.SHUTTLE_BUILD_COST_ID)))
{
observingHangar.StartConstruction();
PrepareHangarWindow();
}
else
{
AnnouncementCanvasController.NotEnoughResourcesAnnounce();
}
}
}
/*
* override public bool IsLevelUpPossible(ref string refusalReason)
* {
* if (workFinished && !awaitingElevatorBuilding)
* {
* //Block b = basement.myChunk.GetBlock(lastWorkObjectPos.x, lastWorkObjectPos.y - 1, lastWorkObjectPos.z);
* //if (b != null && b.type == BlockType.Cube) return true;
* else
* {
* refusalReason = Localization.GetRefusalReason(RefusalReason.NoBlockBelow);
* return false;
* }
* }
* else
* {
* refusalReason = Localization.GetRefusalReason(RefusalReason.WorkNotFinished);
* return false;
* }
* }
*/
override public void LevelUp(bool returnToUI)
{
//if (b != null && b.type == BlockType.Cube)
{
if (!GameMaster.realMaster.weNeedNoResources)
{
ResourceContainer[] cost = GetUpgradeCost();
if (cost != null && cost.Length != 0)
{
if (!colony.storage.CheckBuildPossibilityAndCollectIfPossible(cost))
{
AnnouncementCanvasController.NotEnoughResourcesAnnounce();
return;
}
}
}
// workObject = b as CubeBlock;
UpgradeMine((byte)(level + 1));
GameMaster.realMaster.eventTracker?.BuildingUpgraded(this);
}
}
public void AddArtifact(Artifact a, int slotIndex)
{
if (a != null && !a.destructed)
{
if (!a.researched)
{
GameMaster.audiomaster.Notify(NotificationSound.Disagree);
AnnouncementCanvasController.MakeImportantAnnounce(Localization.GetPhrase(LocalizedPhrase.ArtifactNotResearched));
return;
}
else
{
if (affectionPath != Path.TechPath)
{
GameMaster.audiomaster.Notify(NotificationSound.Disagree);
AnnouncementCanvasController.MakeImportantAnnounce(Localization.GetPhrase(LocalizedPhrase.AffectionTypeNotMatch));
return;
}
else
{
if (artifacts == null)
{
artifacts = new Artifact[4];
}
else
{
if (artifacts[slotIndex] != null)
{
artifacts[slotIndex].ChangeStatus(Artifact.ArtifactStatus.OnConservation);
}
}
artifacts[slotIndex] = a;
a.ChangeStatus(Artifact.ArtifactStatus.UsingInMonument);
RecalculateAffection();
}
}
}
}
public virtual void LevelUp(bool returnToUI)
{
if (upgradedIndex == -1)
{
return;
}
if (!GameMaster.realMaster.weNeedNoResources)
{
ResourceContainer[] cost = GetUpgradeCost();
if (!GameMaster.realMaster.colonyController.storage.CheckBuildPossibilityAndCollectIfPossible(cost))
{
AnnouncementCanvasController.NotEnoughResourcesAnnounce();
return;
}
}
Building upgraded = GetStructureByID(upgradedIndex) as Building;
PixelPosByte setPos = new PixelPosByte(surfaceRect.x, surfaceRect.z);
if (upgraded.surfaceRect.size == PlaneExtension.INNER_RESOLUTION)
{
setPos = new PixelPosByte(0, 0);
}
if (upgraded.rotate90only & (modelRotation % 2 != 0))
{
upgraded.modelRotation = (byte)(modelRotation - 1);
}
else
{
upgraded.modelRotation = modelRotation;
}
upgraded.SetBasement(basement, setPos);
GameMaster.realMaster.eventTracker?.BuildingUpgraded(this);
if (returnToUI)
{
upgraded.ShowOnGUI();
}
}