// Token: 0x060002F7 RID: 759 RVA: 0x000195B8 File Offset: 0x000177B8
private void SpawnOnHitTerrain(Vector3 hitPoint, GameObject prefab)
{
TerrainModifier componentInChildren = prefab.GetComponentInChildren <TerrainModifier>();
if (componentInChildren)
{
if (!PrivateArea.CheckAccess(hitPoint, componentInChildren.GetRadius(), true, false))
{
return;
}
if (Location.IsInsideNoBuildLocation(hitPoint))
{
return;
}
}
TerrainModifier.SetTriggerOnPlaced(true);
GameObject gameObject = UnityEngine.Object.Instantiate <GameObject>(prefab, hitPoint, Quaternion.LookRotation(this.m_character.transform.forward));
TerrainModifier.SetTriggerOnPlaced(false);
IProjectile component = gameObject.GetComponent <IProjectile>();
if (component != null)
{
component.Setup(this.m_character, Vector3.zero, this.m_attackHitNoise, null, this.m_weapon);
}
}
/// <summary>
/// Create the terrain for the road
/// </summary>
/// <param name="sections">The number of sections</param>
/// <param name="tm">The terrain modifier</param>
private void CreateCrossRoadsTerrain(int sections, TerrainModifier tm)
{
float couveSize = 2.5f;
_roadNetworkNode.OrderRoads();
IMaterialFrequency materialFrequency = _roadNetworkNode.GetComponent <OverridableMaterialFrequency>();
if (materialFrequency == null)
{
materialFrequency = RoadConstructorHelper.MaterialFrequencySet;
}
RoadNetworkNode roadA, roadB, roadC, roadD;
RoadCrossSection rA, rB, rC, rD;
RoadUnionHelper.DefineCrossSectionOffSet(couveSize, 0, _roadNetworkNode, out roadA, out rA);
RoadUnionHelper.DefineCrossSectionOffSet(couveSize, 1, _roadNetworkNode, out roadB, out rB);
RoadUnionHelper.DefineCrossSectionOffSet(couveSize, 2, _roadNetworkNode, out roadC, out rC);
RoadUnionHelper.DefineCrossSectionOffSet(couveSize, 3, _roadNetworkNode, out roadD, out rD);
int connectionSet = IntersectionManager.Instance.AddLinkedIntersecions(rA, rB, rC, rD);
DrawDetailsCrossRoad drs = new DrawDetailsCrossRoad(connectionSet, _roadNetworkNode, RoadConstructorHelper.GetMainMaterial(materialFrequency));
drs.ModifyTerrain(_roadNetworkNode.BuildData, tm);
RoadConstructorHelper.ApplyLeadingStrights(_roadNetworkNode, tm, 0);
RoadConstructorHelper.ApplyLeadingStrights(_roadNetworkNode, tm, 1);
RoadConstructorHelper.ApplyLeadingStrights(_roadNetworkNode, tm, 2);
RoadConstructorHelper.ApplyLeadingStrights(_roadNetworkNode, tm, 3);
}
/// <summary>
/// Apply the terrain height
/// </summary>
/// <param name="tm">The terrain modifier</param>
public void ApplyTerrain(TerrainModifier tm)
{
OutterInner outterInner = BuildArray(false, tm);
for (int i = 0; i < _totalRoads; i++)
{
int rightRoad = i + 1;
if (rightRoad > _totalRoads - 1)
{
rightRoad -= _totalRoads;
}
int leftRoad = i - 1;
if (leftRoad < 0)
{
leftRoad += _totalRoads;
}
RectVector3 r;
r = new RectVector3(outterInner.Inner[i].Left, outterInner.Outter[i].Left, outterInner.Inner[i].Right, outterInner.Outter[i].Right);
tm.ApplyToTerrain(r, true);
r = new RectVector3(outterInner.Outter[i].CurbRightEnd, outterInner.Outter[i].Right, outterInner.Outter[rightRoad].CurbLeftEnd, outterInner.Inner[i].Right);
tm.ApplyToTerrain(r, true);
r = new RectVector3(outterInner.Outter[i].CurbLeftEnd, outterInner.Outter[i].Left, outterInner.Outter[leftRoad].CurbRightEnd, outterInner.Inner[i].Left);
tm.ApplyToTerrain(r, true);
r = new RectVector3(_roadNetworkNode.transform.position, _roadNetworkNode.transform.position, outterInner.Inner[i].Left, outterInner.Inner[i].Right);
tm.ApplyToTerrain(r, true);
}
}
public void ApplyCurb(GeneratedCurb curb, TerrainModifier terrainModifier)
{
// Todo height of TPP apply
if (meshFilter == null)
{
meshFilter = GetComponent <MeshFilter>();
meshCollider = GetComponent <MeshCollider>();
}
Vector3[] trVerts = new Vector3[curb.RenderVertices.Length];
for (int i = 0; i < trVerts.Length; i++)
{
trVerts[i] = curb.RenderVertices[i] + new Vector3(0f, terrainModifier.GetTensorHeight(curb.RenderVertices[i].x, curb.RenderVertices[i].z), 0f);
}
meshFilter.mesh.Clear();
meshFilter.mesh.vertices = trVerts;
meshFilter.mesh.uv = curb.RenderUVs;
meshFilter.mesh.subMeshCount = 1;
meshFilter.mesh.SetTriangles(curb.RenderTriangles, 0);
meshFilter.mesh.RecalculateNormals();
meshCollider.sharedMesh = meshFilter.mesh;
}
internal static bool DebugToggle(out int count)
{
count = 0;
if (EnvMan.instance != null)
{
debugTerrain = !debugTerrain;
foreach (TerrainModifier mod in TerrainModifier.GetAllInstances().Where(x => x != null && x.m_playerModifiction))
{
Light light = SetupLight(mod);
count++;
}
EnvMan.instance.m_dirLight.enabled = !debugTerrain;
foreach (Heightmap map in Heightmap.GetAllHeightmaps().Where(x => x != null))
{
Material mat = m_materialInstance(map);
if (mat != null)
{
if (debugTerrain)
{
mat.SetTexture("_DiffuseTex0", Texture2D.whiteTexture);
}
else
{
mat.SetTexture("_DiffuseTex0", map.m_material.GetTexture("_DiffuseTex0"));
}
}
}
return(true);
}
else
{
return(false);
}
}
public static void Prefix(ref TerrainModifier __instance)
{
if (Commands.debugTerrain && __instance.m_playerModifiction)
{
Commands.SetupLight(__instance);
}
}
/// <summary>
/// Build the array
/// </summary>
/// <param name="buildMesh">Weather to build the mesh or not</param>
/// <param name="tm">The terrain modifier</param>
/// <returns>The array details of the cross road</returns>
private CrossRoadsArray BuildArray(bool buildMesh, TerrainModifier tm)
{
RoadCrossRoadOrder order;
MeshBuilderSection mbs;
RoadCrossSection leftIntersectionInner, leftIntersectionOutter, rightIntersectionInner, rightIntersectionOutter, middleIntersectionInner, oppositeIntersectionInner;
UpdateRoadNodesEndPoints(out order, out mbs, out leftIntersectionInner, out leftIntersectionOutter, out rightIntersectionInner, out rightIntersectionOutter, out middleIntersectionInner, out oppositeIntersectionInner);
if (buildMesh)
{
mbs.DirectBuild(leftIntersectionInner, order.LeftRoad);
mbs.DirectBuild(rightIntersectionInner, order.RightRoad);
mbs.DirectBuild(middleIntersectionInner, order.MiddleRoad);
mbs.DirectBuild(oppositeIntersectionInner, order.OppositeRoad);
}
else
{
tm.ApplyToTerrain(leftIntersectionInner, order.LeftRoad);
tm.ApplyToTerrain(rightIntersectionInner, order.RightRoad);
tm.ApplyToTerrain(middleIntersectionInner, order.MiddleRoad);
tm.ApplyToTerrain(oppositeIntersectionInner, order.OppositeRoad);
}
CrossRoadsArray ja = new CrossRoadsArray();
ja.LeftSide[7] = middleIntersectionInner.Left;
ja.LeftSide[4] = middleIntersectionInner.CurbLeftLip;
ja.LeftSide[1] = middleIntersectionInner.CurbLeftEnd;
ja.LeftSide[5] = leftIntersectionInner.Right;
ja.LeftSide[2] = leftIntersectionInner.CurbRightLip;
ja.LeftSide[6] = leftIntersectionOutter.Right;
ja.LeftSide[3] = AddSlope(leftIntersectionOutter.CurbRightLip, middleIntersectionInner.Angle);
ja.RightSide[7] = middleIntersectionInner.Right;
ja.RightSide[4] = middleIntersectionInner.CurbRightLip;
ja.RightSide[1] = middleIntersectionInner.CurbRightEnd;
ja.RightSide[5] = rightIntersectionInner.Left;
ja.RightSide[2] = rightIntersectionInner.CurbLeftLip;
ja.RightSide[6] = rightIntersectionOutter.Left;
ja.RightSide[3] = AddSlope(rightIntersectionOutter.CurbLeftLip, middleIntersectionInner.Angle - (float)(Mathf.PI));
ja.LeftFarSide[7] = oppositeIntersectionInner.Left;
ja.LeftFarSide[4] = oppositeIntersectionInner.CurbLeftLip;
ja.LeftFarSide[1] = oppositeIntersectionInner.CurbLeftEnd;
ja.LeftFarSide[5] = rightIntersectionInner.Right;
ja.LeftFarSide[2] = rightIntersectionInner.CurbRightLip;
ja.LeftFarSide[6] = rightIntersectionOutter.Right;
ja.LeftFarSide[3] = AddSlope(rightIntersectionOutter.CurbRightLip, oppositeIntersectionInner.Angle);
ja.RightFarSide[7] = oppositeIntersectionInner.Right;
ja.RightFarSide[4] = oppositeIntersectionInner.CurbRightLip;
ja.RightFarSide[1] = oppositeIntersectionInner.CurbRightEnd;
ja.RightFarSide[5] = leftIntersectionInner.Left;
ja.RightFarSide[2] = leftIntersectionInner.CurbLeftLip;
ja.RightFarSide[6] = leftIntersectionOutter.Left;
ja.RightFarSide[3] = AddSlope(leftIntersectionOutter.CurbLeftLip, oppositeIntersectionInner.Angle - (float)(Mathf.PI));
return(ja);
}
public static void DeleteTMod(TerrainModifier modifier)
{
ZNetView znview = modifier.gameObject.GetComponent <ZNetView>();
if (!znview || znview.GetZDO() == null)
{
return;
}
bool has_copy = false;
foreach (ZDO item in zdos_to_save)
{
if (item.m_uid == znview.GetZDO().m_uid)
{
has_copy = true;
break;
}
}
if (!has_copy)
{
zdos_to_save.Add(znview.GetZDO().Clone());
}
modifier.enabled = false;
znview.ClaimOwnership();
if (!new string[3] {
"mud_road(Clone)", "digg(Clone)", "path(Clone)"
}.Contains(modifier.name))
{
Debug.LogWarning("Deleting " + modifier.name);
}
Debug.Log("Deleting " + modifier.name);
ZNetScene.instance.Destroy(modifier.gameObject);
}
/// <summary>
/// Apply to terrain
/// </summary>
/// <param name="TerrainModifier">The Terrain Modifier helper</param>
public void ModifiyTerrain(TerrainModifier tm)
{
foreach (RoadNetworkNode rnn in _roadNetworkNode.Details.Roads)
{
string[] stringArray = new string[2] {
_roadNetworkNode.name, rnn.name
};
Array.Sort(stringArray);
string streetFullName = string.Join("-", stringArray);
StreetData sd = StreetManager.Instance[streetFullName];
RoadCrossSection rsc = sd.GetFirst;
if (rsc == null)
{
continue;
}
RoadCrossSection rsca = sd.GetSecond;
if (rsca == null)
{
continue;
}
tm.ApplyToTerrain(rsc, rsca);
}
}
/// <summary>
/// Modify the terrain for the Junction
/// </summary>
public void ApplyTerrain(TerrainModifier terrainModifier)
{
JunctionArray ja = BuildArray(false, terrainModifier);
RectVector3 rect;
rect = new RectVector3(ja.LeftSide[6], ja.LeftSide[7], ja.RightSide[6], ja.RightSide[7]);
terrainModifier.ApplyToTerrain(rect, true);
rect = new RectVector3(ja.LeftFarSide[5], ja.LeftFarSide[4], ja.LeftSide[6], ja.LeftSide[5]);
terrainModifier.ApplyToTerrain(rect, true);
rect = new RectVector3(ja.RightSide[6], ja.RightSide[5], ja.RightFarSide[5], ja.RightFarSide[4]);
terrainModifier.ApplyToTerrain(rect, true);
rect = new RectVector3(ja.RightSide[6], ja.RightFarSide[5], ja.LeftSide[6], ja.LeftFarSide[5]);
terrainModifier.ApplyToTerrain(rect, true);
// pavements
rect = new RectVector3(ja.LeftSide[1], ja.LeftSide[4], ja.LeftSide[2], ja.LeftSide[3]);
terrainModifier.ApplyToTerrain(rect, true);
rect = new RectVector3(ja.RightSide[1], ja.RightSide[4], ja.RightSide[2], ja.RightSide[3]);
terrainModifier.ApplyToTerrain(rect, true);
rect = new RectVector3(ja.LeftFarSide[1], ja.LeftFarSide[2], ja.LeftFarSide[6], ja.LeftFarSide[3]);
terrainModifier.ApplyToTerrain(rect, true);
rect = new RectVector3(ja.RightFarSide[3], ja.RightFarSide[2], ja.RightFarSide[6], ja.RightFarSide[1]);
terrainModifier.ApplyToTerrain(rect, true);
rect = new RectVector3(ja.LeftFarSide[6], ja.LeftFarSide[3], ja.RightFarSide[6], ja.RightFarSide[3]);
terrainModifier.ApplyToTerrain(rect, true);
}
/// <summary>
/// Apply the strights to the terrain
/// </summary>
/// <param name="_roadNetworkNode">The main road network node</param>
/// <param name="tm">The Terrain modifier</param>
/// <param name="index">The index of the road to use</param>
public static void ApplyLeadingStrights(RoadNetworkNode _roadNetworkNode, TerrainModifier tm, int index)
{
string[] stringArray = new string[2] {
_roadNetworkNode.name, _roadNetworkNode.Details.Roads[index].name
};
Array.Sort(stringArray);
string streetFullName = string.Join("-", stringArray);
StreetData street = StreetManager.Instance[streetFullName];
RoadCrossSection rsc = street.GetFirst;
if (rsc == null)
{
return;
}
RoadCrossSection rsca = street.GetSecond;
if (rsca == null)
{
return;
}
tm.ApplyToTerrain(rsc, rsca);
}
public void ModifyTerrain()
{
CreateMesh(true);
TerrainModifier tm = gameObject.GetComponent <TerrainModifier>();
tm.ApplyTerrainHeight(gameObject);
}
public bool TerrainVSModifier(TerrainModifier modifier)
{
Vector3 position1 = modifier.transform.position;
float num1 = modifier.GetRadius() + 4f;
Vector3 position2 = this.transform.position;
float num2 = (float)((double)this.m_width * (double)this.m_scale * 0.5);
return((double)position1.x + (double)num1 >= (double)position2.x - (double)num2 && (double)position1.x - (double)num1 <= (double)position2.x + (double)num2 && ((double)position1.z + (double)num1 >= (double)position2.z - (double)num2 && (double)position1.z - (double)num1 <= (double)position2.z + (double)num2));
}
void OnTriggerExit2D(Collider2D aCollider)
{
TerrainModifier modifier = aCollider.GetComponent <TerrainModifier> ();
if (modifier != null)
{
SetDefaultSpeedAndDrag();
}
}
// Token: 0x06000D85 RID: 3461 RVA: 0x000602A8 File Offset: 0x0005E4A8
public bool TerrainVSModifier(TerrainModifier modifier)
{
Vector3 position = modifier.transform.position;
float num = modifier.GetRadius() + 4f;
Vector3 position2 = base.transform.position;
float num2 = (float)this.m_width * this.m_scale * 0.5f;
return(position.x + num >= position2.x - num2 && position.x - num <= position2.x + num2 && position.z + num >= position2.z - num2 && position.z - num <= position2.z + num2);
}
public void Abort()
{
if (_modifier != null)
{
_modifier.Abort();
_modifier = null;
}
aborted = true;
}
public static void ApplyTerrainModifiers(this Transform transform, TerrainModifier[] modifiers, Vector3 pos, Quaternion rot, Vector3 scale)
{
for (int i = 0; i < (int)modifiers.Length; i++)
{
TerrainModifier terrainModifier = modifiers[i];
Vector3 vector3 = Vector3.Scale(terrainModifier.worldPosition, scale);
Vector3 vector31 = pos + (rot * vector3);
terrainModifier.Apply(vector31, scale.y);
}
}
// Update is called once per frame
void Update()
{
if (terrainModifier == null)
{
if (generationRenderer.TerrainModifier != null)
{
terrainModifier = generationRenderer.TerrainModifier;
}
}
}
public void CommonEffect(Player player)
{
//Spawn location structure
var pos = originLocation;
var rot = Quaternion.LookRotation(originForward) * Quaternion.Euler(0, 90, 0);
var getLocationMethods = typeof(ZoneSystem).GetMethods(BindingFlags.NonPublic | BindingFlags.Instance);
var method = (from MethodInfo m in getLocationMethods where m.Name == "GetLocation" && m.GetParameters().Any(param => param.ParameterType == typeof(string)) select m).FirstOrDefault();
if (method == null)
{
throw new NullReferenceException("Could not find ZoneSystem.GetLocation method");
}
ZoneSystem.ZoneLocation location = (ZoneSystem.ZoneLocation)method.Invoke(ZoneSystem.instance, new object[] { houseLocationName });
//m_didZoneTest = true;
List <GameObject> spawnedGhostObjects = new List <GameObject>();
typeof(ZoneSystem).GetMethod("SpawnLocation", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(ZoneSystem.instance, new object[] { location, spawnSeed, pos, rot, ZoneSystem.SpawnMode.Full, spawnedGhostObjects });
//Set up for bed spawning
var bedPos = originLocation + originForward * commonBedDisplacement;
var bedRot = rot;
//Get piece table
var pieceTableName = "_HammerPieceTable";
var pieceTable = (from PieceTable table in Resources.FindObjectsOfTypeAll <PieceTable>() where table.gameObject.name == pieceTableName select table).FirstOrDefault();
if (pieceTable == null || pieceTable.m_pieces.Count <= 0)
{
throw new NullReferenceException("Could not find hammer piece table");
}
pieceTable.UpdateAvailable(null, null, false, true); //noPlacementCost set to true - other fields don't matter
//Select piece
int category = -1;
Vector2Int pieceIndex = pieceTable.GetPieceIndexVec(bedPieceName, ref category);
pieceTable.SetCategory(category);
pieceTable.SetSelected(pieceIndex);
//Place piece
var piece = pieceTable.GetSelectedPiece();
piece.m_description = magicBedDesc;
TerrainModifier.SetTriggerOnPlaced(trigger: true);
GameObject gameObject = UnityEngine.Object.Instantiate(piece.gameObject, bedPos, bedRot);
TerrainModifier.SetTriggerOnPlaced(trigger: false);
WearNTear wear = gameObject.GetComponent <WearNTear>();
if ((bool)wear)
{
wear.OnPlaced();
}
piece.m_description = "";
}
private static void SetVariables(TerrainModifier __instance)
{
if (!modEnabled.Value)
{
return;
}
__instance.m_smoothRadius = smoothRadius.Value;
__instance.m_smoothPower = smoothPower.Value;
__instance.m_levelRadius = levelRadius.Value;
__instance.m_paintRadius = paintRadius.Value;
}
// Token: 0x06000F8D RID: 3981 RVA: 0x0006E258 File Offset: 0x0006C458
private static int SortByModifiers(TerrainModifier a, TerrainModifier b)
{
if (a.m_playerModifiction != b.m_playerModifiction)
{
return(a.m_playerModifiction.CompareTo(b.m_playerModifiction));
}
if (a.m_sortOrder == b.m_sortOrder)
{
return(a.GetCreationTime().CompareTo(b.GetCreationTime()));
}
return(a.m_sortOrder.CompareTo(b.m_sortOrder));
}
/// <summary>
/// Modifiy the terrain
/// </summary>
/// <param name="roadBuilderObject">The road object</param>
/// <param name="tm">The terrain modifier</param>
public void ModifyTerrain(IRoadBuildData roadBuilderObject, TerrainModifier tm)
{
List <Guid> list = IntersectionManager.Instance[_connectionSet];
MeshBuilderFiveRoad jb = new MeshBuilderFiveRoad(
roadBuilderObject,
list,
_roadNetworkNode,
_materialName);
jb.ApplyTerrain(tm);
}
public static void Flatten(float radiusX, float radiusY)
{
if (radiusY <= 0f)
{
radiusY = radiusX;
}
else if (radiusX <= 0f)
{
radiusX = radiusY;
}
if (radiusX > 80f)
{
radiusX = 80f;
Plugin.blogWarning("X Length Capped At 80");
}
if (radiusY > 80f)
{
radiusY = 80f;
Plugin.blogWarning("Y Length Capped At 80");
}
if (radiusX <= 0f)
{
radiusX = 1f;
radiusY = 1f;
Plugin.blogWarning("Must Be Greater Than Zero");
}
Transform transform = Player.m_localPlayer.transform;
Vector3 position = transform.position;
//Log.Message("Attempting To Flatten...");
GameObject prefab = ZNetScene.instance.GetPrefab("raise");
if (prefab.GetComponent <Piece>() == null || prefab == null)
{
Plugin.blogWarning("Flatten Creation Corrupted : Cancelling!");
return;
}
TerrainModifier.SetTriggerOnPlaced(true);
int num = 0;
while ((float)num < radiusX)
{
int num2 = 0;
while ((float)num2 < radiusY)
{
Terrain.SpawnFloor(position + Vector3.down * 0.5f + transform.forward * (float)num + transform.right * (float)num2, transform.rotation, prefab);
num2++;
}
num++;
}
TerrainModifier.SetTriggerOnPlaced(false);
//Plugin.blogWarning("Flatten Radius Required");
}
public static void ApplyTerrainModifiers(
this Transform transform,
TerrainModifier[] modifiers,
Vector3 pos,
Quaternion rot,
Vector3 scale)
{
for (int index = 0; index < modifiers.Length; ++index)
{
TerrainModifier modifier = modifiers[index];
Vector3 vector3 = Vector3.Scale(modifier.worldPosition, scale);
modifier.Apply(Vector3.op_Addition(pos, Quaternion.op_Multiply(rot, vector3)), (float)scale.y);
}
}
void OnTriggerEnter2D(Collider2D aCollider)
{
TerrainModifier modifier = aCollider.GetComponent <TerrainModifier> ();
if (modifier != null)
{
m_RigidBody.drag = modifier.dragModifier;
if (modifier.speedModifier != 0)
{
currentSpeed = modifier.speedModifier;
}
}
}
internal static Light SetupLight(TerrainModifier mod)
{
Light light = mod.GetComponent <Light>();
if (light == null)
{
light = mod.gameObject.AddComponent <Light>();
mod.gameObject.AddComponent <LightManager>();
}
light.color = new Color(mod.m_level ? 1f : 0f, mod.m_smooth ? 1f : 0f, (mod.m_paintCleared && !mod.m_level && !mod.m_smooth) ? 1f : 0f, 1f);
light.intensity = Settings.lightStrength.Value;
light.enabled = debugTerrain;
return(light);
}
private void DoCollapse()
{
if (_modifier == null)
{
aborted = false;
_modifier = new TerrainModifier(_source)
{
mod = _mod,
keepBorder = _keepBorder,
heightError = _hightError,
progressBar = TerrainCenter.progressBar
};
TerrainCenter.coroutine.StartCoroutine(RunCollapse(), this);
}
}
// Token: 0x06000D84 RID: 3460 RVA: 0x000601E4 File Offset: 0x0005E3E4
private void ApplyModifier(TerrainModifier modifier, float[] baseHeights, float[] levelOnly)
{
if (modifier.m_level)
{
this.LevelTerrain(modifier.transform.position + Vector3.up * modifier.m_levelOffset, modifier.m_levelRadius, modifier.m_square, baseHeights, levelOnly, modifier.m_playerModifiction);
}
if (modifier.m_smooth)
{
this.SmoothTerrain2(modifier.transform.position + Vector3.up * modifier.m_levelOffset, modifier.m_smoothRadius, modifier.m_square, levelOnly, modifier.m_smoothPower, modifier.m_playerModifiction);
}
if (modifier.m_paintCleared)
{
this.PaintCleared(modifier.transform.position, modifier.m_paintRadius, modifier.m_paintType, modifier.m_paintHeightCheck, false);
}
}
public void SetTrack(DiscreteTrack track, TerrainModifier terrainModifier)
{
if (job != null)
{
job.Abort();
job = null;
}
pathC = 0;
job = new JobCarvisualize();
job.deltaT = deltaT;
job.DiscreteTrack = track;
job.TerrainModifier = terrainModifier;
job.Start();
}
public void RemoveTerrainGround()
{
if (Blueprint)
{
return;
}
if (Type == BuildingType.Path)
{
TerrainModifier.ChangeTexture(GridX, GridY, 1, 1, TerrainTextureType.Grass);
}
else
{
TerrainModifier.ChangeTexture(GridX, GridY, RotWidth(), RotHeight(), Type == BuildingType.Field ? TerrainTextureType.Field : TerrainTextureType.Building, -0.8f, -0.2f);
}
}
