public Building(BuildingType buildingType, Island island)
{
this.BuildingType = buildingType;
this.ResourceManager = new ResourceManager();
this.BuildState = 0;
this.Island = island;
this.ConstructionResourceNeeded = new List<Tuple<ResourceType, int>>();
this.Name = String.Empty;
switch (buildingType)
{
case BuildingType.Scierie:
this.ConstructionResourceNeeded.Add(new Tuple<ResourceType, int>(ResourceType.Or, 3));
this.ResourceManager.addResource(ResourceType.Bois, "bois", 0, 4);
//ressourceNeeded = "or";
//consumptionCost = 3;
//ressourceProduced = "bois";
//productionCost = 4;
this.ConstructionTime = 5;
break;
case BuildingType.Mine:
this.ResourceManager.addResource(ResourceType.Or, "Or", 0, 1);
this.ConstructionTime = 0;
break;
case BuildingType.Usine:
this.ConstructionTime = 0;
break;
case BuildingType.Ferme:
this.ConstructionTime = 0;
break;
}
//this.build();
}
/// <summary>
/// Method used to communicate with the game logic and draw some feedback about the building chosen.
/// It will call BuilderManager to change the logic and highlight the correct option
/// </summary>
/// <param name="type">Type of building chosen</param>
public void SelectBuilding(BuildingType type)
{
Vector3 pos = m_BuildingButtons[(int)type].GetComponent<Transform>().position;
m_Highlight.GetComponent<Transform>().position = pos;
BuilderManager.Singleton.SelectBuilding(type);
}
public Building(TowerDefenseGame masterGame, ContentManager content, GameTile parentTile, BuildingType type, Texture2D image)
{
this.masterGame = masterGame;
this.content = content;
this.tile = parentTile;
this.type = type;
this.buildingTexture = image;
}
public void initBuildingType()
{
//Create a new buildingtype and pass the type of building, the area of that building, the number of similar building, and the number of agents currently working at that building type
bType = new BuildingType (myType, myArea);
//bType.farmerVal = _myGameController.farmerList.Count;
//bType.farmVal = _myGameController.farmBuildingList.Count;
}
public static BuildingInfo Get(BuildingType t)
{
if (infos == null)
infos = new SortedDictionary<BuildingType, BuildingInfo>();
if (!infos.ContainsKey(t))
Create(t);
return infos[t];
}
public BuildingBlocks(AnvilWorld world, ModelData md, BuildingType buildingType)
{
BlockManager bm = world.GetBlockManager();
ModelDataModel mdm = md.GetModelByTypeId((int)buildingType);
if (mdm == null)
{
// This can happen until we have models for everything in the config file
Height = 0;
GroundLevelOffset = 0;
return;
}
GroundLevelOffset = mdm.GroundLevelOffset;
IntVector3 corner1 = new IntVector3();
corner1.X = mdm.Corner1[0].x;
corner1.Y = mdm.Corner1[0].y;
corner1.Z = mdm.Corner1[0].z;
IntVector3 corner2 = new IntVector3();
corner2.X = mdm.Corner2[0].x;
corner2.Y = mdm.Corner2[0].y;
corner2.Z = mdm.Corner2[0].z;
// Handle rotation
/*
* Block entities aren't drawing right. We're flipping the Z-axis here which might be the cause..
*
blocks = new AlphaBlock[Math.Abs(corner1.X - corner2.X) + 1, Math.Abs(corner1.Y - corner2.Y) + 1, Math.Abs(corner1.Z - corner2.Z) + 1];
for (int x = corner1.X; x <= corner2.X; x++)
{
for (int y = corner1.Y; y <= corner2.Y; y++)
{
for (int z = 0; z <= Math.Abs(corner2.Z - corner1.Z); z++)
{
blocks[x - corner1.X, y - corner1.Y, z] = bm.GetBlock(x, y, corner2.Z - z);
}
}
}
*/
blocks = new AlphaBlock[Math.Abs(corner1.X - corner2.X) + 1, Math.Abs(corner1.Y - corner2.Y) + 1, Math.Abs(corner1.Z - corner2.Z) + 1];
for (int x = corner1.X; x <= corner2.X; x++)
{
for (int y = corner1.Y; y <= corner2.Y; y++)
{
for (int z = corner1.Z; z <= corner2.Z; z++)
{
blocks[x - corner1.X, y - corner1.Y, z - corner1.Z] = bm.GetBlock(x, y, z);
}
}
}
Height = Math.Abs(corner1.Y - corner2.Y) + 1;
}
public ConstructionHandler(BuildingType type, ResourceType[] costTypes, uint[] costAmounts, float constructionTime, CPoint position)
{
this.Location = new ConstructionBuilding(this, costTypes, costAmounts, constructionTime, position);
this.BuildingType = type;
// request required resources
for (int i = 0; i < costTypes.Length; i++)
BunkaGame.ResourceManager.RequestResource(costTypes[i], costAmounts[i], this.Location);
}
/// <summary>
/// Returns a Service to retrieve building with network connectivity
/// </summary>
/// <param name="type">The type of buildings to create</param>
/// <returns>A service to create network buildings</returns>
public static IBuildingSvc createBuilding(BuildingType type)
{
switch (type) {
case BuildingType.SDP :
return new BuildingSvcImplDB();
default :
return new BuildingSvcImplDB();
}
}
public void Add(int regionId, int x, int y, BuildingType type)
{
IBuilding building = null;// this._buildingRepository.Get(type);
ITile tile = this._tileService.GetTile(regionId, x, y );
tile.AddBuilding(building);
this._tileService.SaveTile(tile);
}
public void Initialise(Vector2 Pos,Vector2 Dims, BuildingType Ftype_)
{
Items = new List<Villager.Items>();
Type = BuildingType.buildingSite;
FType = Ftype_;
Position = Pos;
Dimensions = Dims;
IsBuilt = false;
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="Building" /> class.
/// </summary>
/// <param name="id">Building id.</param>
/// <param name="type">Building type.</param>
/// <param name="level">Building level.</param>
public Building(
int id,
BuildingType type = BuildingType.UNKNOWN,
int level = 0)
{
Id = id;
Type = type;
Level = level;
}
public Tower(TowerDefenseGame masterGame, ContentManager content, GameTile parentTile, BuildingType type, Texture2D image)
: base(masterGame, content, parentTile, type, image)
{
range = 2;
rateOfFire = 30;
nextFire = 0;
damage = 2;
projectiles = new List<Projectile>();
}
// create a building object of a specific type
public Building CreateBuilding(BuildingType type, CPoint position)
{
if (type > BuildingType.CONVERSION)
return CreateConversionBuilding(type, position);
else if (type > BuildingType.PRODUCTION)
return CreateProductionBuilding(type, position);
else
return null;
}
public void AddBuilding(BuildingType Group)
{
Building newBuilding = Instantiate(BuildingToCreate) as Building;
newBuilding.gameObject.name = BuildingToCreate.name + " - " + (Group.Builds.Count + 1).ToString() ;
newBuilding.gameObject.transform.parent = Group.transform;
newBuilding.gameObject.SetActive(true);
Group.Builds.Add(newBuilding);
}
public void Init(BuildingDefinition bd, UIController uiCtrl)
{
nameText.text = bd.name;
priceText.text = "$" + bd.buildPrice;
powerText.text = "¤" + bd.powerUse;
buildingType = bd.type;
this.uiCtrl = uiCtrl;
}
// For a Required Blueprint (like Terraformer, Generator, etc)
public Blueprint(string Name, TileData.Types _type, BuildingType tType)
{
buildingName = Name;
memoryCost = 0;
nanoBotCost = 0;
tileType = _type;
description = " ";
buildingType = tType;
}
/// <summary>
/// Initializes a new copy of <see cref="BuildingData"/> struct.
/// </summary>
/// <param name="id">Id value.</param>
/// <param name="type">Structure type.</param>
/// <param name="level">Level value</param>
public BuildingData(
int id,
BuildingType type,
int level)
: this()
{
Id = id;
Type = type;
Level = level;
}
public Building(BuildingType type, int level)
{
this.Abbreviation = type.Abbreviation;
this.Category = type.Category;
this.Height = type.Height;
this.ID = type.ID;
this.Name = type.Name;
this.Width = type.Width;
this.Level = level;
}
public void ScrollOnSelect()
{
Debug.Log (buildingList[0].name);
buildingList = new Transform[] {buildingList[1], buildingList[2], buildingList[3], buildingList[4], buildingList[0]};
buildingTypeList = new BuildingType[] {buildingTypeList[1], buildingTypeList[2], buildingTypeList[3], buildingTypeList[4], buildingTypeList[0]};
for(int i = 0; i < buildingList.Length; i++){
buildingList[i].position = new Vector3(transform.position.x + 1 * i - 2.5F, transform.position.y, transform.position.z);
buildingList[i].localScale = new Vector3(1 / Mathf.Sqrt(i + 1), 1 / Mathf.Sqrt(i + 1), 1 / Mathf.Sqrt(i + 1));
}
selectedType = buildingTypeList[0];
}
public Building getBuilding(BuildingType buildingType)
{
foreach(Building item in this.BuildingList)
{
if(item.BuildingType == buildingType)
{
return item;
}
}
return null;
}
//Buildings
public List<Building> GetBuildingsOfType(BuildingType type)
{
List<Building> results = new List<Building>();
foreach (var item in Buildings)
{
if (item.m_buildingtype == type)
results.Add(item);
}
return results;
}
public static IPathSvc createPath(BuildingType type)
{
switch (type) {
case BuildingType.PATH_DB :
return new PathSvcImplDB((BoundaryDataContext)MainFactory.getDb("Boundary", true));
case BuildingType.PATH_GIS :
return new PathSvcImplGIS();
default:
return null;
}
}
// Use this for initialization
void Start()
{
buildingList = new Transform[] {cannonBuilding, rocketBuilding, laserBuilding, factoryBuilding, repairBuilding};
buildingTypeList = new BuildingType[] {BuildingType.Cannon, BuildingType.Rocket, BuildingType.Laser, BuildingType.Factory, BuildingType.Repair};
for(int i = 0; i < buildingList.Length; i++){
Transform buildingListObject = (Transform) Transform.Instantiate(buildingList[i], new Vector3(transform.position.x + 1 * i - 2.5F, transform.position.y, transform.position.z), transform.rotation);
buildingListObject.localScale = new Vector3(1 / Mathf.Sqrt(i + 1), 1 / Mathf.Sqrt(i + 1), 1 / Mathf.Sqrt(i + 1));
buildingListObject.parent = transform;
}
selectedType = buildingTypeList[0];
}
public Building(Game game, BuildingType type,Building_Manager parent, Vector3 position,float scale = 1.0f, bool rotate90 = false)
: base(game)
{
addComponent(new Spatial(game, this,Vector3.Zero));
if(rotate90)
getComponent<Spatial>().transform = Matrix.CreateScale(scale) * Matrix.CreateRotationY((float)Math.PI/2.0f) * Matrix.CreateTranslation(position);
else
getComponent<Spatial>().transform = Matrix.CreateScale(scale) * Matrix.CreateTranslation(position);
addComponent(new Collidable(game, this, CollisionType.environment, onHit, 0, 1000,parent.getComponent<Collidable>(),1400));
Model m;
switch (type)
{
case BuildingType.Bridge:
m = Game.Content.Load<Model>(@"Models\Buildings\Bridge");
break;
case BuildingType.Building_With_Tower:
m = Game.Content.Load<Model>(@"Models\Buildings\Building_With_Tower");
break;
case BuildingType.Building:
m = Game.Content.Load<Model>(@"Models\Buildings\Building_02");
break;
case BuildingType.Circular_Tower:
m = Game.Content.Load<Model>(@"Models\Buildings\Circular_Tower");
break;
case BuildingType.City_Building:
m = Game.Content.Load<Model>(@"Models\Buildings\City_Building");
break;
case BuildingType.Iffel_Tower:
m = Game.Content.Load<Model>(@"Models\Buildings\Iffel_Tower");
break;
case BuildingType.Pointed_Tower:
m = Game.Content.Load<Model>(@"Models\Buildings\Pointed_Tower");
break;
case BuildingType.Skyscraper:
m = Game.Content.Load<Model>(@"Models\Buildings\Skyscraper");
break;
case BuildingType.Tower:
m = Game.Content.Load<Model>(@"Models\Buildings\Tower");
break;
case BuildingType.Triangle_Building:
m = Game.Content.Load<Model>(@"Models\Buildings\Triangle_Building");
break;
case BuildingType.Warehouse:
m = Game.Content.Load<Model>(@"Models\Buildings\Warehouse");
break;
default:
m = Game.Content.Load<Model>(@"Models\Buildings\Building");
break;
}
addComponent(new Drawable3D(game,this,m));
parent.addBuilding(this);
}
public Building(BuildingType t, Sector s, DateTime d)
{
this.type = t;
this.sector = s;
this.date = d;
this.hitpoints = Info.Hitpoints;
this.number = 1;
this.UpgradingFrom = BuildingType.None;
Sector.Buildings.Add(this);
if (Sector.Owner != null)
Sector.Owner.Buildings.Add(this);
}
private int x, y; //position
#endregion Fields
#region Constructors
public Building()
{
name = "";
x = 0;
y = 0;
width = 0;
height = 0;
buildingType = BuildingType.NULL;
door = new Position();
lit = true;
roofType = WOOD_ROOF;
}
/// <summary>
///
/// </summary>
/// <param name="app"></param>
public Tower(Autodesk.Revit.UI.UIApplication app)
{
m_app = app;
m_origin = XYZ.Zero;
m_baseSquareHalfLength = 40.0;
m_topCircleRadius = 25.0;
m_buildingHeight = 500.0;
m_buildingType = BuildingType.SharpCorner;
m_unfoldOriginPoint = new XYZ(6.0 * m_baseSquareHalfLength, 0, 0);
m_verticalDivisionList = new List<double>(new double[] { 50.0, 47.5, 45.0, 42.5, 40.0, 37.5, 35.0, 32.5, 30.0, 27.5, 25.0, 22.5, 20.0, 17.5, 15.0, 12.5 });
m_verticalDivisions = 12;
m_structuralDivisions = 9;
}
public void Add(int regionId, int x, int y, BuildingType type)
{
string sql = @"Update Where RegionId = @RegionId;";
using (SqlConnection conn = new SqlConnection(this._connectionString))
{
using (SqlCommand cmd = new SqlCommand(sql, conn))
{
cmd.Parameters.Add(new SqlParameter("@RegionId", regionId));
conn.Open();
cmd.ExecuteNonQuery();
}
}
}
public Squares(int SquareSize, Vector2 Location, int x, int y, int defDist)
{
sqrLoc = Location;
typeOfSquare = SqrFlags.Unoccupied;
Building = BuildingType.None;
TowerHere = null;
rect = new Rectangle((int)Location.X, (int)Location.Y, SquareSize, SquareSize);
sqrCoord = new Coordinates(x, y, defDist);
PixelScreenPos = new Vector2(rect.X + rect.Width / 2, rect.Y + rect.Height / 2);
}
/// <summary>
/// Adds a new building requirement to profile.
/// </summary>
/// <param name="type">Structure type.</param>
/// <param name="level">Structure level.</param>
/// <param name="id">Id value.</param>
/// <returns></returns>
public BuildingData AddBuildingRequirement(
BuildingType type,
int level,
int id = 0)
{
if (BuildingRequirements.Any(i => i.Type == type))
{
return BuildingRequirements.First(i => i.Type == type);
}
var br = new BuildingData(id, type, level);
BuildingRequirements.Add(br);
return br;
}
public Building(BuildingType type, ILocation location)
{
this.Type = type;
this.Location = location;
}
public void OpenBuilding(BuildingType buildingType)
{
SetMainScreen(MainScreenEnum.Buildings);
buildingsController.OpenBuilding(buildingType);
}
public int GetConfigIDByBuildingType(BuildingType type)
{
return(110000001 + (int)type * 10000);
}
public void OpenBuildingUpgrade(BuildingType buildingType)
{
SetMainScreen(MainScreenEnum.Builder);
// TODO set upgrade to buildingType
}
public float GetBuildingUpgradeRatio(BuildingType building)
{
switch (building)
{
case BuildingType.Abbey:
float purchased = TownPurchases["abbey.meditation"].PurchasedUpgrades.Count
+ TownPurchases["abbey.prayer"].PurchasedUpgrades.Count
+ TownPurchases["abbey.flagellation"].PurchasedUpgrades.Count;
int all = DarkestDungeonManager.Data.UpgradeTrees["abbey.meditation"].Upgrades.Count
+ DarkestDungeonManager.Data.UpgradeTrees["abbey.prayer"].Upgrades.Count
+ DarkestDungeonManager.Data.UpgradeTrees["abbey.flagellation"].Upgrades.Count;
return(purchased / all);
case BuildingType.Tavern:
float purchasedTavern = TownPurchases["tavern.bar"].PurchasedUpgrades.Count
+ TownPurchases["tavern.gambling"].PurchasedUpgrades.Count
+ TownPurchases["tavern.brothel"].PurchasedUpgrades.Count;
int allTavern = DarkestDungeonManager.Data.UpgradeTrees["tavern.bar"].Upgrades.Count
+ DarkestDungeonManager.Data.UpgradeTrees["tavern.gambling"].Upgrades.Count
+ DarkestDungeonManager.Data.UpgradeTrees["tavern.brothel"].Upgrades.Count;
return(purchasedTavern / allTavern);
case BuildingType.Sanitarium:
float purchasedSan = TownPurchases["sanitarium.cost"].PurchasedUpgrades.Count
+ TownPurchases["sanitarium.disease_quirk_cost"].PurchasedUpgrades.Count
+ TownPurchases["sanitarium.slots"].PurchasedUpgrades.Count;
int allSan = DarkestDungeonManager.Data.UpgradeTrees["sanitarium.cost"].Upgrades.Count
+ DarkestDungeonManager.Data.UpgradeTrees["sanitarium.disease_quirk_cost"].Upgrades.Count
+ DarkestDungeonManager.Data.UpgradeTrees["sanitarium.slots"].Upgrades.Count;
return(purchasedSan / allSan);
case BuildingType.Blacksmith:
float purchasedBlack = TownPurchases["blacksmith.weapon"].PurchasedUpgrades.Count
+ TownPurchases["blacksmith.armour"].PurchasedUpgrades.Count
+ TownPurchases["blacksmith.cost"].PurchasedUpgrades.Count;
int allBlack = DarkestDungeonManager.Data.UpgradeTrees["blacksmith.weapon"].Upgrades.Count
+ DarkestDungeonManager.Data.UpgradeTrees["blacksmith.armour"].Upgrades.Count
+ DarkestDungeonManager.Data.UpgradeTrees["blacksmith.cost"].Upgrades.Count;
return(purchasedBlack / allBlack);
case BuildingType.Guild:
float purchasedGuild = TownPurchases["guild.skill_levels"].PurchasedUpgrades.Count
+ TownPurchases["guild.cost"].PurchasedUpgrades.Count;
int allGuild = DarkestDungeonManager.Data.UpgradeTrees["guild.skill_levels"].Upgrades.Count
+ DarkestDungeonManager.Data.UpgradeTrees["guild.cost"].Upgrades.Count;
return(purchasedGuild / allGuild);
case BuildingType.CampingTrainer:
float purchasedCamp = TownPurchases["camping_trainer.cost"].PurchasedUpgrades.Count;
int allCamp = DarkestDungeonManager.Data.UpgradeTrees["camping_trainer.cost"].Upgrades.Count;
return(purchasedCamp / allCamp);
case BuildingType.NomadWagon:
float purchasedWagon = TownPurchases["nomad_wagon.numitems"].PurchasedUpgrades.Count
+ TownPurchases["nomad_wagon.cost"].PurchasedUpgrades.Count;
int allWagon = DarkestDungeonManager.Data.UpgradeTrees["nomad_wagon.numitems"].Upgrades.Count
+ DarkestDungeonManager.Data.UpgradeTrees["nomad_wagon.cost"].Upgrades.Count;
return(purchasedWagon / allWagon);
case BuildingType.StageCoach:
float purchasedCoach = TownPurchases["stage_coach.numrecruits"].PurchasedUpgrades.Count
+ TownPurchases["stage_coach.rostersize"].PurchasedUpgrades.Count
+ TownPurchases["stage_coach.upgraded_recruits"].PurchasedUpgrades.Count;
int allCoach = DarkestDungeonManager.Data.UpgradeTrees["stage_coach.numrecruits"].Upgrades.Count
+ DarkestDungeonManager.Data.UpgradeTrees["stage_coach.rostersize"].Upgrades.Count
+ DarkestDungeonManager.Data.UpgradeTrees["stage_coach.upgraded_recruits"].Upgrades.Count;
return(purchasedCoach / allCoach);
case BuildingType.Graveyard:
case BuildingType.Statue:
return(1);
default:
Debug.LogError("Building type " + building.ToString() + " not handled in estate upgrade ratio.");
return(0);
}
}
/// <summary>
/// Start new building placement
/// </summary>
public void StartCraft(BuildingType _buildingType)
{
ghostManager.CancelPlacement();
ghostManager.StartPlacement(_buildingType);
}
// Applies mod config to building attributes
public static void Process(BuildingDef def, GameObject go, BuildingType type = BuildingType.None)
{
Helper.Log(" === [BuildingModifier] Process === " + def.PrefabID);
bool error = false;
ModifiersAll.Add(def.PrefabID);
// If a modifier has been applied, skip it
if (ModifiersFound.Contains(def.PrefabID))
{
return;
}
// Get building config modifiers
Dictionary <string, object> entry = Config.Modifiers[def.PrefabID];
try
{
//BuildingDef def = Assets.GetBuildingDef(entry.Key);
//BuildingDef def = __instance;
//if (!def.PrefabID.Equals(entry.Key)) continue;
foreach (KeyValuePair <string, object> modifier in entry)
{
try
{
Type valueType = modifier.Value.GetType();
Helper.Log(" === [BuildingModifier] " + modifier.Key + ": " + valueType + "; " + modifier.Value);
ModifiersAll.Add(def.PrefabID + "_" + modifier.Key);
if (valueType.Equals(typeof(JObject)))
{ // Is a Component of the building
try
{
GameObject building = null;
if (type == BuildingType.Building)
{
building = go;
}
else if (type == BuildingType.BuildingComplete)
{
building = def.BuildingComplete;
}
else if (type == BuildingType.BuildingPreview)
{
building = def.BuildingPreview;
}
else if (type == BuildingType.BuildingUnderConstruction)
{
building = def.BuildingUnderConstruction;
}
if (building != null)
{
UnityEngine.Object _building = building;
ProcessObject(ref _building, def, modifier.Key, modifier);
Debug.Log(" === [BuildingModifier] Found: " + def.PrefabID + "_" + modifier.Key);
ModifiersFound.Add(def.PrefabID + "_" + modifier.Key);
}
else // def.Building
{
error = true;
}
}
catch (Exception ex)
{
//Debug.LogError(ex);
error = true;
Debug.Log(" === [BuildingModifier] JObject Warning: " + def.PrefabID + "_" + modifier.Key);
}
}
/*
* else if (valueType.Equals(typeof(String)))
* { // Basic attributes in BuildingDef with complex Types
*
* // Tries to find the Type
* FieldInfo fi = AccessTools.Field(typeof(BuildingDef), modifier.Key);
* string path = (string)modifier.Value;
* string className = path.Substring(0, path.LastIndexOf("."));
* string fieldName = path.Substring(path.LastIndexOf(".") + 1);
* //Debug.Log(className + ", " + fieldName);
* Type classType = Type.GetType(className + ", Assembly-CSharp");
* //Debug.Log("Type: " + classType);
* FieldInfo fi2 = AccessTools.Field(classType, fieldName);
* //Debug.Log("FINAL: " + fi2.GetValue(null));
*
* fi.SetValue(def, fi2.GetValue(null));
* Debug.Log(" === [BuildingModifier] Found: " + def.PrefabID + "_" + modifier.Key);
* ModifiersFound.Add(def.PrefabID + "_" + modifier.Key);
* }
*/
else
{ // Basic attributes in BuildingDef with system types
bool found = SetValue(def, new JProperty(modifier.Key, modifier.Value), typeof(BuildingDef));
Debug.Log(" === [BuildingModifier] Found: " + def.PrefabID + "_" + modifier.Key);
ModifiersFound.Add(def.PrefabID + "_" + modifier.Key);
}
}
catch (Exception ex)
{
Debug.LogError(ex);
//Debug.Log(ex.StackTrace);
Debug.Log(" === [BuildingModifier] Attribute Warning: " + def.PrefabID + "_" + modifier.Key);
}
}
}
catch (Exception ex)
{
error = true;
//Debug.LogError(ex);
Debug.Log(" === [BuildingModifier] Warning: " + def.PrefabID + "_" + entry);
}
if (!error)
{
Debug.Log(" === [BuildingModifier] Found: " + def.PrefabID);
ModifiersFound.Add(def.PrefabID);
}
}
public CPos?ChooseBuildLocation(string actorType, bool distanceToBaseIsImportant, BuildingType type)
{
var ai = Map.Rules.Actors[actorType];
var bi = ai.TraitInfoOrDefault <BuildingInfo>();
if (bi == null)
{
return(null);
}
// Find the buildable cell that is closest to pos and centered around center
Func <CPos, CPos, int, int, CPos?> findPos = (center, target, minRange, maxRange) =>
{
var cells = Map.FindTilesInAnnulus(center, minRange, maxRange);
// Sort by distance to target if we have one
if (center != target)
{
cells = cells.OrderBy(c => (c - target).LengthSquared);
}
else
{
cells = cells.Shuffle(Random);
}
foreach (var cell in cells)
{
if (!World.CanPlaceBuilding(cell, ai, bi, null))
{
continue;
}
if (distanceToBaseIsImportant && !bi.IsCloseEnoughToBase(World, Player, ai, cell))
{
continue;
}
return(cell);
}
return(null);
};
var baseCenter = GetRandomBaseCenter();
switch (type)
{
case BuildingType.Defense:
// Build near the closest enemy structure
var closestEnemy = World.ActorsHavingTrait <Building>().Where(a => !a.Disposed && Player.Stances[a.Owner] == Stance.Enemy)
.ClosestTo(World.Map.CenterOfCell(defenseCenter));
var targetCell = closestEnemy != null ? closestEnemy.Location : baseCenter;
return(findPos(defenseCenter, targetCell, Info.MinimumDefenseRadius, Info.MaximumDefenseRadius));
case BuildingType.Refinery:
// Try and place the refinery near a resource field
var nearbyResources = Map.FindTilesInAnnulus(baseCenter, Info.MinBaseRadius, Info.MaxBaseRadius)
.Where(a => resourceTypeIndices.Get(Map.GetTerrainIndex(a)))
.Shuffle(Random).Take(Info.MaxResourceCellsToCheck);
foreach (var r in nearbyResources)
{
var found = findPos(baseCenter, r, Info.MinBaseRadius, Info.MaxBaseRadius);
if (found != null)
{
return(found);
}
}
// Try and find a free spot somewhere else in the base
return(findPos(baseCenter, baseCenter, Info.MinBaseRadius, Info.MaxBaseRadius));
case BuildingType.Building:
return(findPos(baseCenter, baseCenter, Info.MinBaseRadius, distanceToBaseIsImportant ? Info.MaxBaseRadius : Map.Grid.MaximumTileSearchRange));
}
// Can't find a build location
return(null);
}
public CPos?ChooseBuildLocation(string actorType, bool distanceToBaseIsImportant, int maxBaseDistance, BuildingType type)
{
var bi = Map.Rules.Actors[actorType].Traits.GetOrDefault <BuildingInfo>();
if (bi == null)
{
return(null);
}
Func <WPos, CPos, CPos?> findPos = (pos, center) =>
{
for (var k = MaxBaseDistance; k >= 0; k--)
{
var tlist = world.FindTilesInCircle(center, k)
.OrderBy(a => (a.CenterPosition - pos).LengthSquared);
foreach (var t in tlist)
{
if (world.CanPlaceBuilding(actorType, bi, t, null))
{
if (bi.IsCloseEnoughToBase(world, p, actorType, t))
{
if (NoBuildingsUnder(Util.ExpandFootprint(FootprintUtils.Tiles(Map.Rules, actorType, bi, t), false)))
{
return(t);
}
}
}
}
}
return(null);
};
switch (type)
{
case BuildingType.Defense:
Actor enemyBase = FindEnemyBuildingClosestToPos(baseCenter.CenterPosition);
return(enemyBase != null?findPos(enemyBase.CenterPosition, defenseCenter) : null);
case BuildingType.Refinery:
var tilesPos = world.FindTilesInCircle(baseCenter, MaxBaseDistance)
.Where(a => resourceTypes.Contains(world.GetTerrainType(new CPos(a.X, a.Y))))
.OrderBy(a => (a.CenterPosition - baseCenter.CenterPosition).LengthSquared);
return(tilesPos.Any() ? findPos(tilesPos.First().CenterPosition, baseCenter) : null);
case BuildingType.Building:
for (var k = 0; k < maxBaseDistance; k++)
{
foreach (var t in world.FindTilesInCircle(baseCenter, k))
{
if (world.CanPlaceBuilding(actorType, bi, t, null))
{
if (distanceToBaseIsImportant && !bi.IsCloseEnoughToBase(world, p, actorType, t))
{
continue;
}
if (NoBuildingsUnder(Util.ExpandFootprint(FootprintUtils.Tiles(Map.Rules, actorType, bi, t), false)))
{
return(t);
}
}
}
}
break;
}
// Can't find a build location
return(null);
}
public CPos?ChooseBuildLocation(string actorType, BuildingType type)
{
return(ChooseBuildLocation(actorType, true, MaxBaseDistance, type));
}
public int Add(BuildingType bt)
{
_connection.Insert(bt);
return(bt.BuildingTypeID);
}
public void Update(BuildingType bt)
{
_connection.Update(bt);
}
public bool CheckHasBuilding(BuildingType type) => buildings.Any(x => x.type == type);
public void Create(string district, string propertyType, string buildingType, int?year, int price, int size, int?floor,
int?maxFloors)
{
if (district == null)
{
throw new ArgumentException(nameof(district));
}
var property = new RealEstateProperty()
{
Size = size,
Price = price,
Year = year < 1800 ? null : year,
Floor = floor <= 0 ? null : floor,
TotalNumberOfFloors = maxFloors <= 0 ? null : maxFloors,
};
// District Entity
var districtEntity = this.db
.Districts
.FirstOrDefault(d => d.Name.Trim() == district.Trim());
if (districtEntity == null)
{
districtEntity = new District()
{
Name = district
};
}
property.District = districtEntity;
// Property Type Entity
var propertyTypeEntity = this.db
.PropertyTypes
.FirstOrDefault(pt => pt.Name.Trim() == propertyType.Trim());
if (propertyTypeEntity == null)
{
propertyTypeEntity = new PropertyType()
{
Name = propertyType
};
}
property.PropertyType = propertyTypeEntity;
// Building Type Entity
var buildingTypeEntity = this.db
.BuildingTypes
.FirstOrDefault(bt => bt.Name.Trim() == buildingType.Trim());
if (buildingTypeEntity == null)
{
buildingTypeEntity = new BuildingType()
{
Name = buildingType
};
}
property.BuildingType = buildingTypeEntity;
this.db.RealEstateProperties.Add(property);
this.db.SaveChanges();
this.UpdateTags(property.Id);
}
protected Builder(ILevelManager level, BuildingType type)
{
this.Level = level;
this.BuildingType = type;
}
private void BuyBuildingUpgrade(BuildingType type, int buildingNO)
{
this.m_Buildings[type][buildingNO].FinishUpgradeWithoutCommunication();
this.ReCalculateResource();
}
public Estate(int id, Address address, LegalForm legalForm, Category category, BuildingType type)
{
this.id = id;
this.address = address;
this.legalForm = legalForm;
this.category = category;
this.type = type;
}
public static ProjectorConfig GenerateBuildingConfig(BuildingTypeVO vo, UXSprite frameSprite)
{
ProjectorConfig projectorConfig = ProjectorUtils.GenerateGeometryConfig(vo, frameSprite, false);
BuildingType type = vo.Type;
if (type <= BuildingType.Turret)
{
if (type == BuildingType.Barracks)
{
projectorConfig.AnimationName = "IdleClosed";
goto IL_5A;
}
if (type != BuildingType.Turret)
{
goto IL_4F;
}
}
else if (type != BuildingType.Storage)
{
if (type != BuildingType.Armory)
{
goto IL_4F;
}
projectorConfig.AnimationName = "Idle";
goto IL_5A;
}
projectorConfig.AnimationName = null;
goto IL_5A;
IL_4F:
projectorConfig.AnimationName = "Active";
IL_5A:
type = vo.Type;
if (type <= BuildingType.Starport)
{
if (type != BuildingType.ChampionPlatform)
{
if (type == BuildingType.Starport)
{
projectorConfig.Metered = true;
projectorConfig.MeterValue = 1f;
}
}
else
{
projectorConfig.AttachmentAssets = new string[]
{
vo.AssetName
};
}
}
else if (type != BuildingType.Turret)
{
if (type == BuildingType.Trap)
{
projectorConfig.SnapshotFrameDelay = 4;
}
}
else if (!string.IsNullOrEmpty(vo.TurretUid))
{
TurretTypeVO turretTypeVO = Service.Get <IDataController>().Get <TurretTypeVO>(vo.TurretUid);
projectorConfig.TrackerName = turretTypeVO.TrackerName;
}
return(projectorConfig);
}
/// <summary>
/// Uggly implement of getting buliding's excel sheet name
/// </summary>
public string GetBuildingConfigDataName(BuildingType type)
{
switch (type)
{
case (BuildingType.Fruit):
return("SHUIGUO");
case (BuildingType.Veg):
return("SHUCAI");
case (BuildingType.Rice):
return("DAMI");
case (BuildingType.Fertilizer):
return("HUAFEI");
case (BuildingType.Well):
return("JING");
case (BuildingType.WaterCollector):
return("LUSHUI");
case (BuildingType.ZombiePlant):
return("JSFADIANZHAN");
case (BuildingType.PowerPlant):
return("TAIYANGNENG");
case (BuildingType.PineWood):
return("SONGSHU");
case (BuildingType.StockHouse):
return("ZHUJUAN");
case (BuildingType.FeedFactory):
return("SILIAO");
case (BuildingType.WaterFactory):
return("KAUNGQUANSHUI");
case (BuildingType.OilFactory):
return("LIANYOU");
case (BuildingType.SteelFactory):
return("LIANGANG");
case (BuildingType.ConcreteFactory):
return("HUNNINGTU");
case (BuildingType.WoodFactory):
return("MUCAIJIAGONG");
case (BuildingType.RadioStation):
return(null);
case (BuildingType.StoreHouse):
return("CANGKU");
case (BuildingType.Battery):
return("DIANCHIZU");
case (BuildingType.PowerGym):
return("JIANSHENFANG");
case (BuildingType.Wall):
return("QIANG");
case (BuildingType.Gate):
return("DAMEN");
}
return("");
}
public Building(Settlement owner, BuildingType type)
{
Owner = owner;
Type = type;
}
public BuildingPlacement()
{
isOn = false;
keepOn = false;
currentBuilding = BuildingType.off;
}
public List <Building> GetBuildingsOfType(BuildingType type) => buildings.Where(x => x.type == type).ToList();
/// <summary>
/// Uggly implement of getting buliding's attribute
/// return count of list
/// </summary>
public int GetBuildingAttribute(Building building, int level)
{
BuildingType type = building.buildingType;
NBuildingInfo info = GetBuildingInfo(building.BuildingID);
BuildingFunc func = GetBuildingFuncByConfigID(info.configID);
List <BuildingAttributeData> dataList = new List <BuildingAttributeData>();
switch (type)
{
case (BuildingType.Rice):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("DAMI");
DAMI data = dataMap[level] as DAMI;
dataList.Add(new BuildingAttributeData("生长速度", data.DamiSpd));
dataList.Add(new BuildingAttributeData("单次最高产量", data.DamiCap));
break;
}
case (BuildingType.Veg):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("SHUCAI");
SHUCAI data = dataMap[level] as SHUCAI;
dataList.Add(new BuildingAttributeData("生长速度", data.ShucaiSpd));
dataList.Add(new BuildingAttributeData("单次最高产量", data.ShucaiCap));
break;
}
case (BuildingType.Fertilizer):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("HUAFEI");
HUAFEI data = dataMap[level] as HUAFEI;
dataList.Add(new BuildingAttributeData("生长速度", data.HuafeiSpd));
dataList.Add(new BuildingAttributeData("单次最高产量", data.HuafeiCap));
break;
}
case (BuildingType.Fruit):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("SHUIGUO");
SHUIGUO data = dataMap[level] as SHUIGUO;
dataList.Add(new BuildingAttributeData("生长速度", data.ShuiguoSpd));
dataList.Add(new BuildingAttributeData("单次最高产量", data.ShuiguoCap));
break;
}
case (BuildingType.FeedFactory):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("SILIAO");
SILIAO data = dataMap[level] as SILIAO;
dataList.Add(new BuildingAttributeData("加工速度", data.SiliaoSpd));
dataList.Add(new BuildingAttributeData("最大加工量", data.SiliaoCap));
break;
}
case (BuildingType.Well):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("JING");
JING data = dataMap[level] as JING;
dataList.Add(new BuildingAttributeData("渗水速度", data.JingSpd));
dataList.Add(new BuildingAttributeData("容量", data.JingCap));
break;
}
case (BuildingType.WaterCollector):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("LUSHUI");
LUSHUI data = dataMap[level] as LUSHUI;
dataList.Add(new BuildingAttributeData("收集速度", data.LushuiSpd));
dataList.Add(new BuildingAttributeData("单次最大收集量", data.LushuiCap));
break;
}
case (BuildingType.WaterFactory):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("KUANGQUANSHUI");
KUANGQUANSHUI data = dataMap[level] as KUANGQUANSHUI;
dataList.Add(new BuildingAttributeData("加工速度", data.KuangquanshuiSpd));
dataList.Add(new BuildingAttributeData("最大加工量", data.KuangquanshuiCap));
break;
}
case (BuildingType.RadioStation):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("WUXIANDIAN");
WUXIANDIAN data = dataMap[level] as WUXIANDIAN;
dataList.Add(new BuildingAttributeData("接受时间(秒)", data.WuxiandianDis));
break;
}
case (BuildingType.Radar):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("LEIDA");
LEIDA data = dataMap[level] as LEIDA;
dataList.Add(new BuildingAttributeData("接受时间(秒)", data.LeidaDis));
break;
}
case (BuildingType.StoreHouse):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("CANGKU");
CANGKU data = dataMap[level] as CANGKU;
dataList.Add(new BuildingAttributeData("仓库容量", data.CangkuCap));
break;
}
case (BuildingType.Battery):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("DIANCHIZU");
DIANCHIZU data = dataMap[level] as DIANCHIZU;
dataList.Add(new BuildingAttributeData("电量储存量", data.DianchizuCap));
break;
}
case (BuildingType.PowerGym):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("JIANSHENFANG");
JIANSHENFANG data = dataMap[level] as JIANSHENFANG;
dataList.Add(new BuildingAttributeData("能量转化率", data.JianshenfangSpd));
dataList.Add(new BuildingAttributeData("每日转化上限", data.JianshenfangCap));
break;
}
case (BuildingType.ZombiePlant):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("JSFADIANZHAN");
JSFADIANZHAN data = dataMap[level] as JSFADIANZHAN;
dataList.Add(new BuildingAttributeData("能量转化率", data.JsfadianzhanSpd));
dataList.Add(new BuildingAttributeData("单次最大储电量", data.JsfadianzhanCap));
break;
}
case (BuildingType.PowerPlant):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("TAIYANGNENG");
TAIYANGNENG data = dataMap[level] as TAIYANGNENG;
dataList.Add(new BuildingAttributeData("发电速率", data.TaiyangnengSpd));
dataList.Add(new BuildingAttributeData("单次最大储电量", data.TaiyangnengCap));
break;
}
case (BuildingType.OilFactory):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("LIANYOU");
LIANYOU data = dataMap[level] as LIANYOU;
dataList.Add(new BuildingAttributeData("炼油速度", data.LianyouSpd));
dataList.Add(new BuildingAttributeData("最高炼油量", data.LianyouCap));
break;
}
case (BuildingType.SteelFactory):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("LIANGANG");
LIANGANG data = dataMap[level] as LIANGANG;
dataList.Add(new BuildingAttributeData("炼钢速度", data.LiangangSpd));
dataList.Add(new BuildingAttributeData("最高炼钢量", data.LiangangCap));
break;
}
case (BuildingType.ConcreteFactory):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("HUNNINGTU");
HUNNINGTU data = dataMap[level] as HUNNINGTU;
dataList.Add(new BuildingAttributeData("搅拌速度", data.HunningtuSpd));
dataList.Add(new BuildingAttributeData("最高搅拌量", data.HunningtuCap));
break;
}
case (BuildingType.PineWood):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("SONGSHU");
SONGSHU data = dataMap[level] as SONGSHU;
dataList.Add(new BuildingAttributeData("生长速度", data.SongshuSpd));
dataList.Add(new BuildingAttributeData("单次最高产量", data.SongshuCap));
break;
}
case (BuildingType.WoodFactory):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("MUCAIJIAGONG");
MUCAIJIAGONG data = dataMap[level] as MUCAIJIAGONG;
dataList.Add(new BuildingAttributeData("加工速度", data.MucaijiagongSpd));
dataList.Add(new BuildingAttributeData("最大加工量", data.MucaijiagongCap));
break;
}
case (BuildingType.Gate):
{
var dataMap = ConfigDataStatic.GetConfigDataTable("DAMEN");
DAMEN data = dataMap[level] as DAMEN;
dataList.Add(new BuildingAttributeData("耐久度", data.DamenDura));
break;
}
}
if (func == BuildingFunc.Collect)
{
BuildingAttributeData data = dataList[0];
//add buff
//calculate distribution
}
attributeDataList = dataList;
return(attributeDataList.Count);
}
private void Initialize(SmartEntity entity, ShooterComponent shooterComp, StateComponent stateComponent, TransformComponent transformComponent, HealthType healthType)
{
this.Entity = entity;
this.shooterController = Service.ShooterController;
this.ShooterComp = shooterComp;
this.StateComponent = stateComponent;
this.TransformComponent = transformComponent;
this.IdleState = new IdleState(this);
this.TurnState = new TurnState(this);
this.WarmupState = new WarmupState(this);
this.PreFireState = new PreFireState(this);
this.PostFireState = new PostFireState(this);
this.CooldownState = new CooldownState(this);
this.StunState = new StunState(this);
this.shooterController.Reload(shooterComp);
base.SetLegalTransition <IdleState, StunState>();
base.SetLegalTransition <IdleState, TurnState>();
base.SetLegalTransition <IdleState, WarmupState>();
base.SetLegalTransition <TurnState, IdleState>();
base.SetLegalTransition <TurnState, StunState>();
base.SetLegalTransition <TurnState, WarmupState>();
base.SetLegalTransition <WarmupState, IdleState>();
base.SetLegalTransition <WarmupState, PreFireState>();
base.SetLegalTransition <WarmupState, StunState>();
base.SetLegalTransition <PreFireState, IdleState>();
base.SetLegalTransition <PreFireState, PostFireState>();
base.SetLegalTransition <PreFireState, StunState>();
base.SetLegalTransition <PostFireState, CooldownState>();
base.SetLegalTransition <PostFireState, IdleState>();
base.SetLegalTransition <PostFireState, PreFireState>();
base.SetLegalTransition <PostFireState, StunState>();
base.SetLegalTransition <CooldownState, IdleState>();
base.SetLegalTransition <CooldownState, StunState>();
base.SetLegalTransition <CooldownState, WarmupState>();
base.SetLegalTransition <StunState, IdleState>();
if (entity.TroopComp != null && entity.TroopComp.TroopType.Type == TroopType.Champion && entity.TeamComp.TeamType == TeamType.Defender)
{
entity.StateComp.CurState = EntityState.Disable;
entity.StateComp.ForceUpdateAnimation = true;
}
this.SetState(this.IdleState);
this.healthType = healthType;
this.ownerTeam = this.Entity.TeamComp.TeamType;
this.lastLookAtX = (this.lastLookAtZ = 0);
this.shotIndex = 0;
TroopComponent troopComp = this.Entity.TroopComp;
BuildingComponent buildingComp = this.Entity.BuildingComp;
if (troopComp != null)
{
this.gunSequences = troopComp.TroopShooterVO.Sequences;
}
else if (buildingComp != null)
{
string uid = null;
BuildingType type = buildingComp.BuildingType.Type;
if (type != BuildingType.Turret)
{
if (type == BuildingType.Trap)
{
uid = this.Entity.TrapComp.Type.TurretTED.TurretUid;
}
}
else
{
uid = buildingComp.BuildingType.TurretUid;
}
TurretTypeVO turretTypeVO = Service.StaticDataController.Get <TurretTypeVO>(uid);
this.gunSequences = turretTypeVO.Sequences;
}
else
{
Service.Logger.Error("Attaching AttackFSM to Unsupported Entity. No Troop, Building, or Trap Componenet found.");
}
}
/// <summary>
/// An uggly implement of gettting buliding's controller
/// this is temporary ,will be removed in time
/// </summary>
public Building GetTypeBuilding(BuildingType type)
{
Transform parent = GameObject.Find("mainscene/buildings").transform;
switch (type)
{
case (BuildingType.Fruit):
return(parent.Find("fruitfarm").GetComponent <Building>());
case (BuildingType.Veg):
return(parent.Find("vegfarm").GetComponent <Building>());
case (BuildingType.Rice):
return(parent.Find("grainfarm").GetComponent <Building>());
case (BuildingType.Fertilizer):
return(parent.Find("fertilizer").GetComponent <Building>());
case (BuildingType.Well):
return(parent.Find("well").GetComponent <Building>());
case (BuildingType.WaterCollector):
return(parent.Find("watercollector").GetComponent <Building>());
case (BuildingType.ZombiePlant):
return(null);
case (BuildingType.PowerPlant):
return(parent.Find("windpowerplant").GetComponent <Building>());
case (BuildingType.PineWood):
return(parent.Find("pinewood").GetComponent <Building>());
case (BuildingType.StockHouse):
return(parent.Find("stockhouse").GetComponent <Building>());
case (BuildingType.FeedFactory):
return(parent.Find("feedfactory").GetComponent <Building>());
case (BuildingType.WaterFactory):
return(parent.Find("waterfactory").GetComponent <Building>());
case (BuildingType.OilFactory):
return(parent.Find("oilfactory").GetComponent <Building>());
case (BuildingType.SteelFactory):
return(parent.Find("steelfactory").GetComponent <Building>());
case (BuildingType.ConcreteFactory):
return(parent.Find("concretefactory").GetComponent <Building>());
case (BuildingType.WoodFactory):
return(parent.Find("woodfactory").GetComponent <Building>());
case (BuildingType.RadioStation):
return(parent.Find("radiostation").GetComponent <Building>());
case (BuildingType.Radar):
return(parent.Find("radar").GetComponent <Building>());
case (BuildingType.StoreHouse):
return(parent.Find("storehouse").GetComponent <Building>());
case (BuildingType.Battery):
return(parent.Find("battery").GetComponent <Building>());
case (BuildingType.PowerGym):
return(null);
case (BuildingType.Wall):
return(null);
case (BuildingType.Gate):
return(parent.Find("gate").GetComponent <Building>());
case (BuildingType.Turret0):
return(parent.Find("turret0").GetComponent <Building>());
case (BuildingType.Turret1):
return(parent.Find("turret1").GetComponent <Building>());
case (BuildingType.Turret2):
return(parent.Find("turret2").GetComponent <Building>());
case (BuildingType.Turret3):
return(parent.Find("turret3").GetComponent <Building>());
case (BuildingType.Turret4):
return(parent.Find("turret5").GetComponent <Building>());
case (BuildingType.Turret5):
return(parent.Find("turret6").GetComponent <Building>());
case (BuildingType.Turret6):
return(parent.Find("turret7").GetComponent <Building>());
}
return(null);
}
public EatResponse OnEvent(EventId id, object cookie)
{
switch (id)
{
case EventId.BuildingLevelUpgraded:
case EventId.BuildingSwapped:
if (!this.IsFueInProgress() && this.IsCurrentWorldHome())
{
SmartEntity entity = ((ContractEventData)cookie).Entity;
this.GetCurrentCombineMeshHelper().BuildingObjectDestroyed(entity, this.meshCombiners, false);
}
break;
case EventId.BuildingConstructed:
break;
default:
{
if (id != EventId.BuildingViewReady && id != EventId.BuildingViewFailed)
{
switch (id)
{
case EventId.ClearableCleared:
if (!this.IsFueInProgress())
{
this.GetCurrentCombineMeshHelper().BuildingObjectDestroyed(BuildingType.Clearable, this.meshCombiners, true);
}
return(EatResponse.NotEaten);
case EventId.ClearableStarted:
IL_38:
switch (id)
{
case EventId.WorldLoadComplete:
if ((!this.IsCurrentWorldHome() || this.isStartupTasksCompleted) && !this.IsCurrentWorldUserWarBase())
{
this.CombineAllMeshTypes();
}
return(EatResponse.NotEaten);
case EventId.WorldInTransitionComplete:
case EventId.WorldOutTransitionComplete:
IL_51:
if (id == EventId.PostBuildingEntityKilled)
{
BuildingType buildingType = (BuildingType)cookie;
if (!this.IsFueInProgress())
{
this.GetCurrentCombineMeshHelper().BuildingObjectDestroyed(buildingType, this.meshCombiners, true);
}
return(EatResponse.NotEaten);
}
if (id == EventId.GameStateChanged)
{
IState currentState = Service.GameStateMachine.CurrentState;
Type previousStateType = (Type)cookie;
if (currentState is HomeState)
{
if (!this.isStartupTasksCompleted)
{
this.CombineAllMeshTypes();
}
else if (this.IsPreviousStateEditMode(previousStateType))
{
this.CombineAllMeshTypes();
}
}
else if (this.DidJustTransitionFromHomeToEditState(previousStateType, currentState))
{
this.UncombineAllMeshTypes(false);
}
return(EatResponse.NotEaten);
}
if (id != EventId.ShaderResetOnEntity)
{
return(EatResponse.NotEaten);
}
if ((!this.IsCurrentWorldHome() || this.isStartupTasksCompleted) && !this.IsCurrentWorldUserWarBase())
{
this.CombineAllMeshTypes();
}
return(EatResponse.NotEaten);
case EventId.WorldReset:
if (this.isSomeMeshesCombined)
{
this.UncombineAllMeshTypes(true);
}
return(EatResponse.NotEaten);
}
goto IL_51;
case EventId.StartupTasksCompleted:
this.isStartupTasksCompleted = true;
return(EatResponse.NotEaten);
}
goto IL_38;
}
SmartEntity entity2 = ((EntityViewParams)cookie).Entity;
if (!this.IsFueInProgress() && this.isStartupTasksCompleted && Service.WorldTransitioner.IsEverythingLoaded() && this.IsCurrentWorldHome())
{
this.GetCurrentCombineMeshHelper().BuildingObjectAdded(entity2, this.meshCombiners);
}
break;
}
}
return(EatResponse.NotEaten);
}
public override void OnFrame(Bot bot)
{
BuildingType pylonType = BuildingType.LookUp[UnitTypes.PYLON];
BuildingType gatewayType = BuildingType.LookUp[UnitTypes.GATEWAY];
Point2D hideLocation = GetHideLocation();
if (hideLocation == null)
{
return;
}
foreach (Unit unit in bot.Observation.Observation.RawData.Units)
{
if (unit.Alliance != Alliance.Neutral)
{
continue;
}
if (SC2Util.DistanceSq(unit.Pos, hideLocation) > 20 * 20)
{
continue;
}
bot.DrawText("Neutral structure: " + unit.UnitType);
}
Agent pylon = null;
Agent gateway = null;
int gatewayCount = 0;
foreach (Agent agent in bot.UnitManager.Agents.Values)
{
if (agent.Unit.UnitType != UnitTypes.PYLON &&
agent.Unit.UnitType != UnitTypes.GATEWAY &&
agent.Unit.UnitType != UnitTypes.WARP_GATE)
{
continue;
}
if (agent.DistanceSq(HideLocation) > 20 * 20)
{
continue;
}
if (agent.Unit.UnitType == UnitTypes.PYLON)
{
pylon = agent;
}
else if (agent.Unit.UnitType == UnitTypes.GATEWAY || agent.Unit.UnitType == UnitTypes.WARP_GATE)
{
gatewayCount++;
gateway = agent;
}
}
if (pylon == null && bot.Minerals() >= 100 && BuildRequests.Count == 0)
{
Point2D placement = ProxyBuildingPlacer.FindPlacement(GetHideLocation(), pylonType.Size, UnitTypes.PYLON);
if (placement != null)
{
BuildRequests.Add(new BuildRequest()
{
Type = UnitTypes.PYLON, Pos = placement
});
}
}
else if (gatewayCount < 2 && pylon != null && pylon.Unit.BuildProgress > 0.99 && bot.Minerals() >= 150)
{
Point2D placement = ProxyBuildingPlacer.FindPlacement(GetHideLocation(), gatewayType.Size, UnitTypes.GATEWAY);
if (placement != null)
{
BuildRequests.Add(new BuildRequest()
{
Type = UnitTypes.GATEWAY, Pos = placement
});
}
}
List <BuildRequest> doneRequests = new List <BuildRequest>();
foreach (BuildRequest request in BuildRequests)
{
if (request.worker != null && !Bot.Main.UnitManager.Agents.ContainsKey(request.worker.Unit.Tag))
{
request.worker = null;
}
if (request.worker == null)
{
foreach (Agent agent in Units)
{
if (BuildingType.BuildingAbilities.Contains((int)agent.CurrentAbility()))
{
continue;
}
request.worker = agent;
break;
}
}
if (!ProxyBuildingPlacer.CheckPlacement(request.Pos, BuildingType.LookUp[request.Type].Size, request.Type, null, true))
{
doneRequests.Add(request);
continue;
}
foreach (Agent agent in bot.UnitManager.Agents.Values)
{
if (agent.Unit.UnitType == request.Type &&
agent.DistanceSq(request.Pos) < 4)
{
doneRequests.Add(request);
break;
}
}
}
foreach (BuildRequest request in doneRequests)
{
BuildRequests.Remove(request);
}
foreach (Agent agent in Units)
{
bool building = false;
foreach (BuildRequest request in BuildRequests)
{
if (request.worker == null || request.worker.Unit.Tag != agent.Unit.Tag)
{
continue;
}
building = true;
if (agent.DistanceSq(request.Pos) <= 10 * 10)
{
agent.Order(BuildingType.LookUp[request.Type].Ability, request.Pos);
}
else
{
agent.Order(Abilities.MOVE, request.Pos);
}
break;
}
if (building)
{
continue;
}
if (agent.DistanceSq(GetHideLocation()) >= 4 * 4)
{
agent.Order(Abilities.MOVE, GetHideLocation());
continue;
}
}
}
public void CreateBuilding(Vector3 position, BuildingType type)
{
GameObject buildingPrefab = BuildingPrefabBank(type);
GameObject building = Instantiate(buildingPrefab, position, Quaternion.identity);
}
public string GetName(int ID)
{
BuildingType btype = _connection.Table <BuildingType>().FirstOrDefault(t => t.BuildingTypeID == ID);
return(btype == null ? "": btype.BuildingTypeName);
}
public void SetType(BuildingType newType)
{
type = newType;
Appearance.ActualizeBody();
}
