void EventForCreatingAnother()
{
GameEvent.Register(GameEventType.MineralsChanged, argsA =>
{
if (_producingWorker == null && argsA.Minerals >= 50)
{
// After he collected minerals, another worker will be built
var baseCenter = BuildingHelper.GetMyBuildings <BaseCenter>()[0];
baseCenter.ProduceUnit(UnitType.Worker);
// After creating (it means after few seconds), he will need to go gather too
_producingWorker = GameEvent.Register(GameEventType.UnitProduced, argsB =>
{
if (argsB.MyUnit is Worker)
{
Worker worker = (Worker)argsB.MyUnit;
Gather(worker);
argsB.ThisGameEvent.UnregisterEvent();
_producingWorker = null;
}
});
}
// This event will work only while there are not enough workers.
// After that, minerals will be left to go over 150.
if (UnitHelper.GetMyUnits <Worker>().Length >= 7)
{
argsA.ThisGameEvent.UnregisterEvent();
}
});
}
public void BuildingStage(Runner.NextStageStarter startNextStage)
{
// A first building
Event.Register(EventType.MineralsChanged, args =>
{
if (args.Minerals > 150)
{
var baseCenter = BuildingHelper.GetBuildings <BaseCenter>()[0];
var position = BuildingHelper.ClosestEmptySpaceTo(baseCenter);
FindWorkerThatGathers().CreateBuilding(BuildingType.NubianArmory, position);
// We only need one army production building for now
args.ThisEvent.UnregisterEvent();
}
});
// Worker will return to work afterwards
Event.Register(EventType.BuildingCreated, args =>
{
if (
args.MyBuilding.GetType().Equals(typeof(NubianArmory))
&&
args.MyUnit.GetType().Equals(typeof(Worker))
)
{
var worker = (Worker)args.MyUnit;
worker.SendGather(MaterialHelper.GetNearestMineralsTo(worker));
BuildArmy(startNextStage);
}
args.ThisEvent.UnregisterEvent();
});
}
void EventForCreatingAnother()
{
Event.Register(EventType.MineralsChanged, argsA =>
{
if (argsA.Minerals > 50)
{
// After he collected minerals, another worker will be built
var baseCenter = BuildingHelper.GetBuildings <BaseCenter>()[0];
baseCenter.CreateWorker();
// After creating (it means after few seconds), he will need to go gather too
Event.Register(EventType.UnitCreated, argsB =>
{
if (argsB.MyUnit.GetType().Equals(typeof(Worker)))
{
Worker worker = (Worker)argsB.MyUnit;
worker.SendGather(MaterialHelper.GetNearestMineralsTo(worker));
argsB.ThisEvent.UnregisterEvent();
}
});
}
argsA.ThisEvent.UnregisterEvent();
// This event will work only while there are not enough workers.
// After that, minerals will be left to go over 150.
if (UnitHelper.GetUnits <Worker>().Length >= 5)
{
argsA.ThisEvent.UnregisterEvent();
}
});
}
/// <summary>
/// Sends the Worker to Create a Building of a specific type.
/// </summary>
/// <param name="buildingType">Type of the Building to be created.</param>
/// <param name="position">Position where the Building will be placed.
/// Use Position.IsValidPlacement to check if the position can be used.</param>
/// <returns>Instance of the building in a progress state.</returns>
public IBuilding CreateBuilding(BuildingType buildingType, Position position)
{
// TODO:
// 1. send worker to the position near building, queued event when arrival
// 2. start construction object, queued event when finished
// 2.5. if interrupted, worker can repeat step 1 and continue on 2 without creating a new object
// 3. finished event, return to gather
StopGathering();
var player = Player.CurrentPlayer;
var actor = Create <Building>(
BuildingHelper.DetermineBuildingType(buildingType),
BuildingPlacement.PlaceProgressBuilding(
BuildingHelper.FindBuildingInFaction(buildingType, UnitController),
new List <UnitController> {
UnitController
},
UnitController.FactionIndex,
position,
Quaternion.identity,
GameManager.Instance.ResourceManagerFaction[UnitController.FactionIndex]
),
player
);
// TODO: make sure the CurrentPlayer stays the same after the movement
Tutorial.Instance.CreateBuilding();
// TODO: asynchronous after the movement
GameManager.Instance.FiredEvent(player, GameEventType.BuildingStartedConstruction, new Arguments
{
MyUnit = this,
MyBuilding = actor
});
return(actor);
}
/// <summary>
/// The Initialize.
/// </summary>
/// <param name="station">The station<see cref="VehicleStation"/>.</param>
/// <param name="building">The building<see cref="Building"/>.</param>
/// <param name="recipe">The recipe<see cref="Recipe"/>.</param>
/// <param name="count">The count<see cref="float"/>.</param>
/// <param name="item">The item<see cref="Item"/>.</param>
public void Initialize(VehicleStation station, Building building, Recipe recipe, float count, Item item = null)
{
this._station = station;
this._building = building;
this._count = Mathf.Ceil(count * 10) / 10;
this._recipe = recipe;
this._item = item;
base.transform.Find <Image>("Thumb").sprite = this.GetThumbIcon();
Image image = base.transform.Find <Image>("ItemImage");
if (this._recipe != null)
{
_item = this._recipe.OutputItems[0].Item;
}
if (_item != null)
{
image.sprite = GetItemIcon();
image.gameObject.SetActive(true);
}
else
{
image.gameObject.SetActive(false);
}
this._settingsCog = base.transform.Find <Button>("ConnectionCog");
this._valueText = base.transform.Find <Text>("ValueContainer/Value");
this._valueText.text = _count.ToString("N1");
this._valueText.transform.parent.gameObject.SetActive(true);
// VoxelTycoon.UI.ContextMenu.For(this._settingsCog, PickerBehavior.OverlayToRight, new Action<VoxelTycoon.UI.ContextMenu>(this.SetupContextMenu));
this.SetSettingsCogVisibility(false);
Tooltip.For(this, null, BuildingHelper.GetBuildingName(_building), GetTooltipText, 0);
}
public static void Postfix(CityServiceWorldInfoPanel __instance)
{
InstanceID instanceID = (InstanceID)__instance.GetType()
.GetField("m_InstanceID", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(__instance);
var building = BuildingManager.instance.m_buildings.m_buffer[instanceID.Building].Info;
if (building.GetService() == ItemClass.Service.FireDepartment ||
building.GetService() == ItemClass.Service.Garbage ||
building.GetService() == ItemClass.Service.HealthCare ||
building.GetService() == ItemClass.Service.Disaster ||
building.GetService() == ItemClass.Service.PoliceDepartment)
{
return;
}
if (BuildingHelper.DisplayDistrictsButton(building.m_buildingAI))
{
return;
}
var toggleButton = __instance.component.Find("ServiceRestrictionToggleButton") as UIButton;
if (toggleButton == null)
{
return;
}
toggleButton.isEnabled = false;
toggleButton.tooltip = "Service Restrictions does not currently cover this building.";
}
// Use this for initialization
void Start()
{
bh = transform.root.GetComponent <BuildingHelper>();
if (GetComponent <MeshRenderer>() != null)
{
bh.mrs.Add(GetComponent <MeshRenderer>());
}
}
private void button20_Click(object sender, EventArgs e) //support vill button
{
var acc = getSelectedAcc();
var vill = getSelectedVillage();
DefaultConfigurations.SupplyVillagePlan(acc, vill);
BuildingHelper.RemoveCompletedTasks(vill, acc);
UpdateBuildTab();
}
private void button6_Click(object sender, EventArgs e) //deff vill button
{
var acc = GetSelectedAcc();
var vill = GetSelectedVillage();
DefaultConfigurations.DeffVillagePlan(acc, vill);
BuildingHelper.RemoveCompletedTasks(vill, acc);
UpdateUc();
}
public int GetBuildingLevel(BuildingTypes builing)
{
const string str = "#main_buildrow_";
var html = GetHeadQScreenHtml();
var id = $"{str}{BuildingHelper.GetNameForType(builing)}";
var hqTableElement = html.Select(id);
return(HtmlParse.GetCurrentLevelOfBuilingFromTableRow(hqTableElement));
}
public void UpdateUc()
{
Account acc = GetSelectedAcc();
var vill = GetSelectedVillage();
if (vill == null)
{
return;
}
RefreshBuildingsList(vill);
//Building Tasks ListView
UpdateBuildTasks(vill);
foreach (var task in vill.Build.DemolishTasks)
{
var item = new ListViewItem();
//building
item.SubItems[0].Text = "Demolish " + VillageHelper.BuildingTypeToString(vill.Build.Buildings.FirstOrDefault(x => x.Id == task.BuildingId).Type);
item.SubItems.Add(task.Level.ToString()); //lvl
item.SubItems.Add(task.BuildingId.ToString()); //buildingId
buildListView.Items.Add(item);
}
//Currently building ListView
currentlyBuildinglistView.Items.Clear();
foreach (var building in vill.Build.CurrentlyBuilding)
{
var item = new ListViewItem();
item.SubItems[0].Text = building.Building.ToString();
item.SubItems.Add(building.Level.ToString()); //lvl
item.SubItems.Add(building.Duration == DateTime.MinValue ? "/" : building.Duration.ToString()); //execute at
currentlyBuildinglistView.Items.Add(item);
}
autoBuildResType.SelectedIndex = 0;
autoBuildResStrat.SelectedIndex = 0;
autoBuildResLevel.Value = 10;
AutoBuildBonusBuildings.Checked = vill.Build.AutoBuildResourceBonusBuildings;
buildTypeComboBox.Enabled = false;
buildRadioButton.Checked = true;
instaUpgradeUpDown.Enabled = vill.Build.InstaBuild;
instaUpgradeUpDown.Value = vill.Build.InstaBuildHours;
var prereqComboList = BuildingHelper.SetPrereqCombo(acc, vill);
prereqCombo.Items.Clear();
prereqComboList.ForEach(x => prereqCombo.Items.Add(x));
if (0 < prereqComboList.Count)
{
prereqCombo.SelectedIndex = 0;
}
}
private void button4_Click(object sender, EventArgs e) //all villages off tasks
{
var acc = getSelectedAcc();
foreach (var vill in acc.Villages)
{
DefaultConfigurations.OffVillagePlan(acc, vill);
BuildingHelper.RemoveCompletedTasks(vill, acc);
}
}
private void buildButton_Click(object sender, EventArgs e) //build button
{
var acc = getSelectedAcc();
var vill = getSelectedVillage(acc);
var indicies = buildingsList.SelectedIndices;
if (indicies.Count > 0)
{
selectedBuilding = vill.Build.Buildings[indicies[0]];
}
else
{
return; //no building selected :(
}
if (buildRadioButton.Checked)
{
var task = new BuildingTask
{
TaskType = BuildingHelper.BuildingType.General,
Level = (int)buildLevelUpDown.Value,
BuildingId = selectedBuilding.Id
};
//Create building task, construct new building
if (selectedBuilding.Type == Classificator.BuildingEnum.Site)
{
Enum.TryParse(buildTypeComboBox.SelectedItem.ToString(), out Classificator.BuildingEnum building);
task.Building = building;
task.ConstructNew = true;
}
else //upgrade existing building
{
task.Building = selectedBuilding.Type;
}
BuildingHelper.AddBuildingTask(acc, vill, task);
}
else if (demolishRadioButton.Checked)
{
DemolishTask dt = new DemolishTask
{
Building = selectedBuilding.Type,
BuildingId = selectedBuilding.Id,
Level = (int)buildLevelUpDown.Value
};
vill.Build.DemolishTasks.Add(dt);
//TODO: ReStartDemolish
TaskExecutor.AddTaskIfNotExistInVillage(acc, vill, new DemolishBuilding()
{
ExecuteAt = DateTime.Now, vill = vill
});
}
UpdateBuildTab();
}
void WorkersCanExpand()
{
var baseCenter = BuildingHelper.GetMyBuildings <BaseCenter>()[0];
if (baseCenter != null && baseCenter.CanNowProduceUnit(UnitType.Worker))
{
baseCenter.ProduceUnit(UnitType.Worker);
}
// TODO: make workers expand to other minerals over the map
BuildingTest.FindWorkerThatGathers().MoveTo(PlaceType.MyBase.UnderRampLeft);
}
private void Start()
{
List <Resource> resources = new List <Resource>();
foreach (var resourceSource in FindObjectsOfType <ResourceSource>())
{
resources.Add(Resource.CreateResourceActor <Resource>(resourceSource.gameObject));
}
// Initialize Resources to use the shared list
Instance.Players[0].SharedResources = resources;
foreach (var player in Players)
{
// Spawn starting Bases and Workers
Player.CurrentPlayer = player;
Actor.Create <BaseCenter>(
BuildingHelper.InstantiateProgressBuilding(
BuildingHelper.FindBuildingInFaction(BuildingType.BaseCenter, null),
BaseCenterProgressPrefab,
player.FactionIndex,
player.MyBase.Center,
Quaternion.identity)
.Place()
.gameObject
, player);
for (var workerIndex = 0; workerIndex < StartingWorkers; workerIndex++)
{
Actor.Create <Worker>(
UnitHelper.InstantiateUnit(
WorkerPrefab,
// Workers will be spawned near the first Base
PositionHelper.PositionToLocation(((BaseCenter)player.Buildings[0]).SpawnPosition),
player.FactionIndex),
player);
}
// Initialize (single) enemy player for each of them
var enemyFactionIndex = player.Faction.EnemyFactionIndexes()[0];
foreach (var enemyPlayer in Players)
{
if (enemyPlayer.FactionIndex != enemyFactionIndex)
{
continue;
}
player.EnemyBase = enemyPlayer.MyBase;
break;
}
}
// Start the Test (build workaround)
// No longer required, the GameTestRunner is included in the project
//StartTest();
}
private static List <UnitQueueItem> GetActiveQueue(RequestManager reqManager, int village, BuildingTypes building)
{
var typeStr = BuildingHelper.GetNameForType(building);
var url = $"https://sv36.tribalwars.se/game.php?village={village}&screen={typeStr}";
var res = reqManager.SendGETRequest(url, null, null, true);
CQ htmlString = RequestManager.GetResponseStringFromResponse(res);
var list = htmlString
.Select($"#trainqueue_wrap_{typeStr} tbody tr")
.Where(ele => ele.ClassName.Length > 0)
.Select(ele => GetUnitQueueItem(ele, typeStr));
return(list.ToList());
}
public void TryToLocate(ShopItem item)
{
if (tryToLacate)
{
Destroy(tryToLacate);
}
else
{
tryToLacate = Instantiate(item.Prefab, GridManager.GetGridCenter(), Quaternion.identity);
bh = tryToLacate.GetComponent <BuildingHelper>();
bh.SetStart(GridManager.GetGridCenter());
uIManager.ChangeActiveBuildingPanel(true);
}
}
public static GameObject PlaceProgressBuilding(Building building, List <UnitController> builderUnits,
int factionIndex, Position position, Quaternion rotation, ResourceManager resourceManager)
{
Vector3 location = PositionHelper.PositionToLocation(position);
try
{
BuildingHelper.CheckValidPlacement(building, position, location, false);
}
catch (Exception)
{
// Visualizing the error placement
if (GameManager.Instance.Debug)
{
building.ClosePoints(GameManager.Instance.Grid, position.PointLocation);
}
throw;
}
for (int x = 0; x < building.cost.Length; x++)
{
if (building.cost[x] > 0 && resourceManager.resourceTypes[x].amount < building.cost[x])
{
throw new InvalidOperationException(
"Not enough resources for placing the " + building + " building");
}
}
for (int x = 0; x < building.cost.Length; x++)
{
if (building.cost[x] > 0)
{
resourceManager.resourceTypes[x].amount -= building.cost[x];
}
}
GameObject buildingObject;
if (building.autoBuild)
{
buildingObject = BuildingHelper.InstantiateProgressBuilding(
building, building.obj, factionIndex, position, rotation)
.gameObject;
}
else
{
buildingObject = BuildingHelper.InstantiateProgressBuilding(
building, building.progressObj, factionIndex, position, rotation)
.gameObject;
UnitSelection.SetTarget(builderUnits, buildingObject, buildingObject.transform.position);
}
return(buildingObject);
}
public void Initialize(VehicleStation station, VehicleStation connectedStation)
{
this._station = station;
this._connectedStation = connectedStation;
base.transform.Find <Image>("Thumb").sprite = this.GetThumbIcon();
base.transform.GetComponent <Button>().onClick.AddListener(delegate()
{
GameCameraViewHelper.TryGoTo(this._connectedStation, 70f);
});
this._settingsCog = base.transform.Find <Button>("ConnectionCog");
VoxelTycoon.UI.ContextMenu.For(this._settingsCog, PickerBehavior.OverlayToRight, new Action <VoxelTycoon.UI.ContextMenu>(this.SetupContextMenu));
this.SetSettingsCogVisibility(true);
Tooltip.For(this, null, BuildingHelper.GetBuildingName(connectedStation), "", 0);
}
static void Postfix(BuildUI __instance)
{
try
{
// Custom Building
foreach (BuildingInfo info in BuildingHelper.buildingsToRegister)
{
object[] tabs = BuildingHelper.getTabByName(info.tabCategory);
BuildUI.inst.AddBuilding((BuildTab)(tabs[0]), (BuildTabVR)(tabs[1]), info.uniqueName, info.preqBuilding, info.buildingButtonSize);
}
}catch (Exception err) {
helper.Log(err.ToString());
}
}
public static bool Prefix(ushort buildingID, ref Building data, TransferManager.TransferReason material,
TransferManager.TransferOffer offer)
{
if (DistrictHelper.BuildingTransfer(buildingID, material, offer))
{
DebugHelper.Log($"Transfer Request Accepted.");
return(true);
}
BuildingHelper.MoveRequest(buildingID, ref data, material, offer);
{
DebugHelper.Log("Moving Transfer Request.");
return(false);
}
}
public void SelfTests()
{
// GameManager starting Unit creation
Assert.AreEqual(1, BuildingHelper.GetMyBuildings <IBuilding>().Length);
Assert.AreEqual(1, BuildingHelper.GetMyBuildings <BaseCenter>().Length);
var units = GameManager.Instance.StartingWorkers;
Assert.AreEqual(units, UnitHelper.GetMyUnits <IUnit>().Length);
Assert.AreEqual(units, UnitHelper.GetMyUnits <Worker>().Length);
// Position Grid coordinate calculation Unit Test
var center = PlaceType.MyBase.Center;
Assert.AreEqual(center.PointLocation, new Position(center.X, center.Y).PointLocation);
}
void BuildArmy(Action startNextStage)
{
GameEvent.Register(GameEventType.MineralsChanged, argsMinerals =>
{
// First wave starts at 5 units
if (!MyBotData.Rushed && MyBotData.Army >= 5)
{
startNextStage();
MyBotData.Rushed = true;
}
// Production ends after 20
else if (MyBotData.Army >= 20)
{
argsMinerals.ThisGameEvent.UnregisterEvent();
return;
}
if (_producingDonkeyGun != null || argsMinerals.Minerals <= 100)
{
return;
}
foreach (NubianArmory armory in BuildingHelper.GetMyBuildings <NubianArmory>())
{
if (armory.QueuedUnits >= 2)
{
continue;
}
if (armory.CanNowProduceUnit(UnitType.DonkeyGun))
{
armory.ProduceUnit(UnitType.DonkeyGun);
// Additional mineral sink: producing one more expensive Unit if too rich
if (armory.CanNowProduceUnit(UnitType.WraithRaider))
{
armory.ProduceUnit(UnitType.WraithRaider);
}
_producingDonkeyGun = GameEvent.Register(GameEventType.UnitProduced, argsUnit =>
{
if (argsUnit.MyUnit is DonkeyGun)
{
MyBotData.Army++;
BotRunner.Log("My army contains " + MyBotData.Army + " battle units");
argsUnit.ThisGameEvent.UnregisterEvent();
_producingDonkeyGun = null;
}
});
}
}
});
}
private void AutBuildResButton_Click(object sender, EventArgs e) //auto res build button
{
var acc = GetSelectedAcc();
var vill = GetSelectedVillage(acc);
var task = new BuildingTask
{
TaskType = BuildingType.AutoUpgradeResFields,
Level = (int)autoBuildResLevel.Value,
ResourceType = (ResTypeEnum)autoBuildResType.SelectedIndex,
BuildingStrategy = (BuildingStrategyEnum)autoBuildResStrat.SelectedIndex
};
BuildingHelper.AddBuildingTask(acc, vill, task);
UpdateUc();
}
public static bool Prefix(ushort buildingID, ref Building data, TransferManager.TransferReason reason,
TransferManager.TransferOffer offer)
{
Debug.Log("Start Transfer Called");
if (DistrictHelper.CanTransfer(buildingID, reason, offer))
{
Debug.Log("Transfer Request Accepted.");
return(true);
}
BuildingHelper.MoveRequest(buildingID, ref data, reason, offer);
{
Debug.Log("Moving Transfer Request.");
return(false);
}
}
public bool AddBuildingUppgradeToActiveQeueu(BuildingTypes building, string csrfToken, int currentVillage)
{
var uppgradeUrl = UpgradeBuildingUrl
.Replace("__village__", currentVillage.ToString())
.Replace("__type__", "main")
.Replace("__csrfToken__", csrfToken);
var url = $"{BaseUrl}{uppgradeUrl}";
var postData = $"id={BuildingHelper.GetNameForType(building)}&force=1&destroy=0&source={currentVillage}";
var resNotParsed = _reqManager.GeneratePOSTRequest(url, postData, null, null, true);
var res = _reqManager.GetResponse(resNotParsed);
var htmlStr = RequestManager.GetResponseStringFromResponse(res);
return(htmlStr.Contains("Byggnationen har beordrats"));
}
private void button2_Click(object sender, EventArgs e)
{
var acc = GetSelectedAcc();
var vill = GetSelectedVillage(acc);
Enum.TryParse(prereqCombo.SelectedItem.ToString(), out BuildingEnum building);
BuildingHelper.AddBuildingPrerequisites(acc, vill, building);
BuildingHelper.AddBuildingTask(acc, vill, new BuildingTask()
{
Building = building,
Level = 1,
TaskType = BuildingType.General
});
UpdateUc();
}
private void CreateNotFoundBuilding(BuildingTag tag, OutputUnitState serverBuilding)
{
var enemyBuild = BuildingHelper.CreateBuilding(world,
buildingAssets.Get1[0].BuildingsAssets["Enemy" + tag.ToString()],
buildingAssets.Get1[0].InBuildingCanvasesAssets["None"],
serverBuilding.Position.ToUnityVector(),
serverBuilding.RotationInEulerAngle.ToUnityVector(),
tag,
serverBuilding.Id);
enemyBuild.Set <EnemyBuildingComponent>();
var hb = enemyBuild.Get <HealthComponent>();
hb.MaxHp = serverBuilding.Health;
hb.CurrentHp = serverBuilding.Health;
}
public static bool Prefix(ushort buildingID, ref Building data, TransferManager.TransferReason material,
TransferManager.TransferOffer offer)
{
Debug.Log("Start Transfer Called");
if (DistrictHelper.CanTransfer(buildingID, material, offer))
{
Debug.Log(
$"Transfer Request Accepted from {DistrictManager.instance.GetDistrictName(DistrictManager.instance.GetDistrict(data.m_position))}");
return(true);
}
BuildingHelper.MoveRequest(buildingID, ref data, material, offer);
{
Debug.Log(
$"Moving Transfer Request from {DistrictManager.instance.GetDistrictName(DistrictManager.instance.GetDistrict(data.m_position))}");
return(false);
}
}
private void buildingsList_SelectedIndexChanged(object sender, EventArgs e)
{
selectedBuilding = null;
var acc = getSelectedAcc();
var vill = getSelectedVillage();
var indicies = buildingsList.SelectedIndices;
if (indicies.Count > 0)
{
selectedBuilding = vill.Build.Buildings[indicies[0]];
}
//buildlevelupdown
if (selectedBuilding != null)
{
buildLevelUpDown.Value = selectedBuilding.Level + 1;
}
//construct new building
buildTypeComboBox.Items.Clear();
if (selectedBuilding == null)
{
return;
}
if (selectedBuilding.Type == Classificator.BuildingEnum.Site)
{
buildTypeComboBox.Enabled = true;
for (int i = 5; i <= 45; i++)
{
if (BuildingHelper.BuildingRequirementsAreMet((Classificator.BuildingEnum)i, vill, acc.AccInfo.Tribe ?? Classificator.TribeEnum.Natars))
{
buildTypeComboBox.Items.Add(((Classificator.BuildingEnum)i).ToString());
}
}
if (buildTypeComboBox.Items.Count > 0)
{
buildTypeComboBox.SelectedIndex = 0;
}
}
else
{
buildTypeComboBox.Enabled = false;
}
}
