public override Construction.Placement DoPlacement(Construction.Target target)
{
Quaternion quaternion1 = target.socket.rotation;
if (target.socket.male && target.socket.female)
{
quaternion1 = Quaternion.op_Multiply(target.socket.rotation, Quaternion.Euler(180f, 0.0f, 180f));
}
Transform transform = ((Component)target.entity).get_transform();
Matrix4x4 localToWorldMatrix = transform.get_localToWorldMatrix();
Vector3 vector3_1 = ((Matrix4x4) ref localToWorldMatrix).MultiplyPoint3x4(target.socket.position);
Quaternion quaternion2;
if (this.useFemaleRotation)
{
quaternion2 = Quaternion.op_Multiply(transform.get_rotation(), quaternion1);
}
else
{
Vector3 vector3_2 = new Vector3((float)vector3_1.x, 0.0f, (float)vector3_1.z);
Vector3 vector3_3;
((Vector3) ref vector3_3).\u002Ector((float)target.player.eyes.position.x, 0.0f, (float)target.player.eyes.position.z);
Vector3 vector3_4 = vector3_3;
Vector3 vector3_5 = Vector3.op_Subtraction(vector3_2, vector3_4);
quaternion2 = Quaternion.op_Multiply(Quaternion.LookRotation(((Vector3) ref vector3_5).get_normalized()), quaternion1);
}
Construction.Placement placement = new Construction.Placement();
Quaternion quaternion3 = Quaternion.op_Multiply(quaternion2, Quaternion.Inverse(this.rotation));
Vector3 vector3_6 = Quaternion.op_Multiply(quaternion3, this.position);
placement.position = Vector3.op_Subtraction(vector3_1, vector3_6);
placement.rotation = quaternion3;
return(placement);
}
public override Construction.Placement DoPlacement(Construction.Target target)
{
Quaternion quaternion;
Quaternion quaternion1 = target.socket.rotation;
if (target.socket.male && target.socket.female)
{
quaternion1 = target.socket.rotation * Quaternion.Euler(180f, 0f, 180f);
}
Transform transforms = target.entity.transform;
Vector3 vector3 = transforms.localToWorldMatrix.MultiplyPoint3x4(target.socket.position);
if (!this.useFemaleRotation)
{
Vector3 vector31 = new Vector3(vector3.x, 0f, vector3.z);
Vector3 vector32 = new Vector3(target.player.eyes.position.x, 0f, target.player.eyes.position.z);
Vector3 vector33 = vector31 - vector32;
quaternion = Quaternion.LookRotation(vector33.normalized) * quaternion1;
}
else
{
quaternion = transforms.rotation * quaternion1;
}
Construction.Placement placement = new Construction.Placement();
Quaternion quaternion2 = quaternion * Quaternion.Inverse(this.rotation);
placement.position = vector3 - (quaternion2 * this.position);
placement.rotation = quaternion2;
return(placement);
}
public override bool DoCheck(Construction.Placement place)
{
Vector3 position = Vector3.op_Addition(place.position, Quaternion.op_Multiply(place.rotation, this.worldPosition));
List <BuildingBlock> list1 = (List <BuildingBlock>)Pool.GetList <BuildingBlock>();
double sphereRadius = (double)this.sphereRadius;
List <BuildingBlock> list2 = list1;
int layerMask = ((LayerMask) ref this.layerMask).get_value();
QueryTriggerInteraction queryTriggers = this.queryTriggers;
Vis.Entities <BuildingBlock>(position, (float)sphereRadius, list2, layerMask, queryTriggers);
bool flag = list1.Count > 0;
if (flag && this.wantsCollide)
{
// ISSUE: cast to a reference type
Pool.FreeList <BuildingBlock>((List <M0>&) ref list1);
return(true);
}
if (flag && !this.wantsCollide)
{
// ISSUE: cast to a reference type
Pool.FreeList <BuildingBlock>((List <M0>&) ref list1);
return(false);
}
// ISSUE: cast to a reference type
Pool.FreeList <BuildingBlock>((List <M0>&) ref list1);
return(!this.wantsCollide);
}
public override bool DoCheck(Construction.Placement place)
{
Vector3 position = Vector3.op_Addition(place.position, Quaternion.op_Multiply(place.rotation, this.worldPosition));
List <BaseEntity> list1 = (List <BaseEntity>)Pool.GetList <BaseEntity>();
double sphereRadius = (double)this.sphereRadius;
List <BaseEntity> list2 = list1;
int layerMask = ((LayerMask) ref this.layerMask).get_value();
QueryTriggerInteraction queryTriggers = this.queryTriggers;
Vis.Entities <BaseEntity>(position, (float)sphereRadius, list2, layerMask, queryTriggers);
foreach (object obj in list1)
{
bool flag = obj.GetType().IsAssignableFrom(((object)this.searchType).GetType());
if (flag && this.wantsCollide)
{
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list1);
return(true);
}
if (flag && !this.wantsCollide)
{
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list1);
return(false);
}
}
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list1);
return(!this.wantsCollide);
}
public override bool DoCheck(Construction.Placement place)
{
Vector3 position = Vector3.op_Addition(place.position, Quaternion.op_Multiply(place.rotation, this.worldPosition));
List <BaseEntity> list1 = (List <BaseEntity>)Pool.GetList <BaseEntity>();
double sphereRadius = (double)this.sphereRadius;
List <BaseEntity> list2 = list1;
int layerMask = ((LayerMask) ref this.layerMask).get_value();
QueryTriggerInteraction queryTriggers = this.queryTriggers;
Vis.Entities <BaseEntity>(position, (float)sphereRadius, list2, layerMask, queryTriggers);
foreach (Component component1 in list1)
{
PlantEntity component2 = (PlantEntity)component1.GetComponent <PlantEntity>();
if (Object.op_Implicit((Object)component2) && this.wantsCollide)
{
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list1);
return(true);
}
if (Object.op_Implicit((Object)component2) && !this.wantsCollide)
{
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list1);
return(false);
}
}
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list1);
return(!this.wantsCollide);
}
public override bool DoCheck(Construction.Placement place)
{
Vector3 position = Vector3.op_Addition(place.position, Quaternion.op_Multiply(place.rotation, this.worldPosition));
List <BaseEntity> list1 = (List <BaseEntity>)Pool.GetList <BaseEntity>();
double sphereRadius = (double)this.sphereRadius;
List <BaseEntity> list2 = list1;
int layerMask = ((LayerMask) ref this.layerMask).get_value();
QueryTriggerInteraction queryTriggers = this.queryTriggers;
Vis.Entities <BaseEntity>(position, (float)sphereRadius, list2, layerMask, queryTriggers);
foreach (BaseEntity baseEntity in list1)
{
BaseEntity ent = baseEntity;
bool flag = ((IEnumerable <BaseEntity>) this.entityTypes).Any <BaseEntity>((Func <BaseEntity, bool>)(x => (int)x.prefabID == (int)ent.prefabID));
if (flag && this.wantsCollide)
{
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list1);
return(true);
}
if (flag && !this.wantsCollide)
{
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list1);
return(false);
}
}
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list1);
return(!this.wantsCollide);
}
public override bool DoCheck(Construction.Placement place)
{
if (SocketMod_TerrainCheck.IsInTerrain(Vector3.op_Addition(place.position, Quaternion.op_Multiply(place.rotation, this.worldPosition))) == this.wantsInTerrain)
{
return(true);
}
Construction.lastPlacementError = this.fullName + ": not in terrain";
return(false);
}
public override bool DoCheck(Construction.Placement place)
{
if (this.wantsCollide == GamePhysics.CheckSphere(Vector3.op_Addition(place.position, Quaternion.op_Multiply(place.rotation, this.worldPosition)), this.sphereRadius, ((LayerMask) ref this.layerMask).get_value(), (QueryTriggerInteraction)0))
{
return(true);
}
Construction.lastPlacementError = "Failed Check: Sphere Test (" + this.hierachyName + ")";
return(false);
}
public override bool DoCheck(Construction.Placement place)
{
if ((double)Vector3Ex.DotDegrees(this.worldNormal, Quaternion.op_Multiply(place.rotation, Vector3.get_up())) < (double)this.withinDegrees)
{
return(true);
}
Construction.lastPlacementError = "Failed Check: AngleCheck (" + this.hierachyName + ")";
return(false);
}
public override bool DoCheck(Construction.Placement place)
{
if (SocketMod_TerrainCheck.IsInTerrain(place.position + (place.rotation * this.worldPosition)) == this.wantsInTerrain)
{
return(true);
}
Construction.lastPlacementError = string.Concat(this.fullName, ": not in terrain");
return(false);
}
public override bool DoCheck(Construction.Placement place)
{
if (this.worldNormal.DotDegrees(place.rotation * Vector3.up) < this.withinDegrees)
{
return(true);
}
Construction.lastPlacementError = string.Concat("Failed Check: AngleCheck (", this.hierachyName, ")");
return(false);
}
public override bool DoCheck(Construction.Placement place)
{
if (WaterLevel.Test(Vector3.op_Addition(place.position, Quaternion.op_Multiply(place.rotation, this.worldPosition))) == this.wantsInWater)
{
return(true);
}
Construction.lastPlacementError = "Failed Check: InWater (" + this.hierachyName + ")";
return(false);
}
public override bool DoCheck(Construction.Placement place)
{
if (WaterLevel.Test(place.position + (place.rotation * this.worldPosition)) == this.wantsInWater)
{
return(true);
}
Construction.lastPlacementError = string.Concat("Failed Check: InWater (", this.hierachyName, ")");
return(false);
}
public override bool DoCheck(Construction.Placement place)
{
if (this.DoCheck(place.position, place.rotation))
{
return(true);
}
Construction.lastPlacementError = "Failed Check: IsInArea (" + this.hierachyName + ")";
return(false);
}
public override bool DoCheck(Construction.Placement place)
{
Vector3 vector3 = place.position + (place.rotation * this.worldPosition);
if (this.wantsCollide == GamePhysics.CheckSphere(vector3, this.sphereRadius, this.layerMask.@value, QueryTriggerInteraction.UseGlobal))
{
return(true);
}
Construction.lastPlacementError = string.Concat("Failed Check: Sphere Test (", this.hierachyName, ")");
return(false);
}
public override Construction.Placement DoPlacement(Construction.Target target)
{
if (!Object.op_Implicit((Object)target.entity) || !Object.op_Implicit((Object)((Component)target.entity).get_transform()))
{
return((Construction.Placement)null);
}
Vector3 worldPosition = target.GetWorldPosition();
Quaternion worldRotation = target.GetWorldRotation(true);
if (this.rotationDegrees > 0)
{
Construction.Placement placement = new Construction.Placement();
float num1 = float.MaxValue;
float num2 = 0.0f;
for (int index = 0; index < 360; index += this.rotationDegrees)
{
Quaternion quaternion1 = Quaternion.Euler(0.0f, (float)(this.rotationOffset + index), 0.0f);
Vector3 direction = ((Ray) ref target.ray).get_direction();
Quaternion quaternion2 = worldRotation;
Vector3 vector3 = Quaternion.op_Multiply(Quaternion.op_Multiply(quaternion1, quaternion2), Vector3.get_up());
float num3 = Vector3.Angle(direction, vector3);
if ((double)num3 < (double)num1)
{
num1 = num3;
num2 = (float)index;
}
}
for (int index = 0; index < 360; index += this.rotationDegrees)
{
Quaternion quaternion1 = Quaternion.op_Multiply(worldRotation, Quaternion.Inverse(this.rotation));
Quaternion quaternion2 = Quaternion.op_Multiply(Quaternion.op_Multiply(Quaternion.Euler(target.rotation), Quaternion.Euler(0.0f, (float)(this.rotationOffset + index) + num2, 0.0f)), quaternion1);
Vector3 vector3 = Quaternion.op_Multiply(quaternion2, this.position);
placement.position = Vector3.op_Subtraction(worldPosition, vector3);
placement.rotation = quaternion2;
if (this.CheckSocketMods(placement))
{
return(placement);
}
}
}
Construction.Placement placement1 = new Construction.Placement();
Quaternion quaternion = Quaternion.op_Multiply(worldRotation, Quaternion.Inverse(this.rotation));
Vector3 vector3_1 = Quaternion.op_Multiply(quaternion, this.position);
placement1.position = Vector3.op_Subtraction(worldPosition, vector3_1);
placement1.rotation = quaternion;
if (!this.TestRestrictedAngles(worldPosition, worldRotation, target))
{
return((Construction.Placement)null);
}
return(placement1);
}
public override Construction.Placement DoPlacement(Construction.Target target)
{
if (!target.entity || !target.entity.transform)
{
return(null);
}
Vector3 worldPosition = target.GetWorldPosition();
Quaternion worldRotation = target.GetWorldRotation(true);
if (this.rotationDegrees > 0)
{
Construction.Placement placement = new Construction.Placement();
float single = Single.MaxValue;
float single1 = 0f;
for (int i = 0; i < 360; i += this.rotationDegrees)
{
Quaternion quaternion = Quaternion.Euler(0f, (float)(this.rotationOffset + i), 0f);
Vector3 vector3 = target.ray.direction;
Vector3 vector31 = (quaternion * worldRotation) * Vector3.up;
float single2 = Vector3.Angle(vector3, vector31);
if (single2 < single)
{
single = single2;
single1 = (float)i;
}
}
for (int j = 0; j < 360; j += this.rotationDegrees)
{
Quaternion quaternion1 = worldRotation * Quaternion.Inverse(this.rotation);
Quaternion quaternion2 = Quaternion.Euler(target.rotation);
Quaternion quaternion3 = Quaternion.Euler(0f, (float)(this.rotationOffset + j) + single1, 0f);
Quaternion quaternion4 = (quaternion2 * quaternion3) * quaternion1;
placement.position = worldPosition - (quaternion4 * this.position);
placement.rotation = quaternion4;
if (this.CheckSocketMods(placement))
{
return(placement);
}
}
}
Construction.Placement placement1 = new Construction.Placement();
Quaternion quaternion5 = worldRotation * Quaternion.Inverse(this.rotation);
placement1.position = worldPosition - (quaternion5 * this.position);
placement1.rotation = quaternion5;
if (!this.TestRestrictedAngles(worldPosition, worldRotation, target))
{
return(null);
}
return(placement1);
}
private bool TestPlacingThroughRock(ref Construction.Placement placement, Construction.Target target)
{
RaycastHit raycastHit;
OBB oBB = new OBB(placement.position, Vector3.one, placement.rotation, this.bounds);
Vector3 center = target.player.GetCenter(true);
Vector3 vector3 = target.ray.origin;
if (Physics.Linecast(center, vector3, 65536, QueryTriggerInteraction.Ignore))
{
return(false);
}
if (Physics.Linecast(vector3, (oBB.Trace(target.ray, out raycastHit, Single.PositiveInfinity) ? raycastHit.point : oBB.ClosestPoint(vector3)), 65536, QueryTriggerInteraction.Ignore))
{
return(false);
}
return(true);
}
public virtual bool CheckSocketMods(Construction.Placement placement)
{
foreach (SocketMod socketMod in this.socketMods)
{
socketMod.ModifyPlacement(placement);
}
foreach (SocketMod socketMod in this.socketMods)
{
if (!socketMod.DoCheck(placement))
{
if (socketMod.FailedPhrase.IsValid())
{
Construction.lastPlacementError = "Failed Check: (" + socketMod.FailedPhrase.translated + ")";
}
return(false);
}
}
return(true);
}
private bool TestPlacingThroughRock(
ref Construction.Placement placement,
Construction.Target target)
{
OBB obb;
((OBB) ref obb).\u002Ector(placement.position, Vector3.get_one(), placement.rotation, this.bounds);
Vector3 center = target.player.GetCenter(true);
Vector3 origin = ((Ray) ref target.ray).get_origin();
Vector3 vector3_1 = origin;
if (Physics.Linecast(center, vector3_1, 65536, (QueryTriggerInteraction)1))
{
return(false);
}
RaycastHit raycastHit;
Vector3 vector3_2 = ((OBB) ref obb).Trace(target.ray, ref raycastHit, float.PositiveInfinity) ? ((RaycastHit) ref raycastHit).get_point() : ((OBB) ref obb).ClosestPoint(origin);
return(!Physics.Linecast(origin, vector3_2, 65536, (QueryTriggerInteraction)1));
}
public override bool DoCheck(Construction.Placement place)
{
Vector3 vector3 = place.position + (place.rotation * this.worldPosition);
List <BuildingBlock> list = Pool.GetList <BuildingBlock>();
Vis.Entities <BuildingBlock>(vector3, this.sphereRadius, list, this.layerMask.@value, this.queryTriggers);
bool count = list.Count > 0;
if (count && this.wantsCollide)
{
Pool.FreeList <BuildingBlock>(ref list);
return(true);
}
if (count && !this.wantsCollide)
{
Pool.FreeList <BuildingBlock>(ref list);
return(false);
}
Pool.FreeList <BuildingBlock>(ref list);
return(!this.wantsCollide);
}
public override void ModifyPlacement(Construction.Placement place)
{
Vector3 vector3 = place.position + (place.rotation * this.worldPosition);
List <BaseEntity> list = Pool.GetList <BaseEntity>();
Vis.Entities <BaseEntity>(vector3, this.outerRadius * 2f, list, -1, QueryTriggerInteraction.Collide);
foreach (BaseEntity baseEntity in list)
{
if (baseEntity.isServer != this.isServer)
{
continue;
}
AttractionPoint[] attractionPointArray = this.prefabAttribute.FindAll <AttractionPoint>(baseEntity.prefabID);
if (attractionPointArray == null)
{
continue;
}
AttractionPoint[] attractionPointArray1 = attractionPointArray;
for (int i = 0; i < (int)attractionPointArray1.Length; i++)
{
AttractionPoint attractionPoint = attractionPointArray1[i];
if (attractionPoint.groupName == this.groupName)
{
Vector3 vector31 = baseEntity.transform.position + (baseEntity.transform.rotation * attractionPoint.worldPosition);
Vector3 vector32 = vector31 - vector3;
float single = vector32.magnitude;
if (single <= this.outerRadius)
{
Quaternion quaternion = QuaternionEx.LookRotationWithOffset(this.worldPosition, vector31 - place.position, Vector3.up);
float single1 = Mathf.InverseLerp(this.outerRadius, this.innerRadius, single);
place.rotation = Quaternion.Lerp(place.rotation, quaternion, single1);
vector3 = place.position + (place.rotation * this.worldPosition);
vector32 = vector31 - vector3;
place.position = place.position + (vector32 * single1);
}
}
}
}
Pool.FreeList <BaseEntity>(ref list);
}
public override bool DoCheck(Construction.Placement place)
{
bool flag;
Vector3 vector3 = place.position + (place.rotation * this.worldPosition);
List <BaseEntity> list = Pool.GetList <BaseEntity>();
Vis.Entities <BaseEntity>(vector3, this.sphereRadius, list, this.layerMask.@value, this.queryTriggers);
List <BaseEntity> .Enumerator enumerator = list.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
BaseEntity current = enumerator.Current;
bool flag1 = this.entityTypes.Any <BaseEntity>((BaseEntity x) => x.prefabID == current.prefabID);
if (!flag1 || !this.wantsCollide)
{
if (!flag1 || this.wantsCollide)
{
continue;
}
Pool.FreeList <BaseEntity>(ref list);
flag = false;
return(flag);
}
else
{
Pool.FreeList <BaseEntity>(ref list);
flag = true;
return(flag);
}
}
Pool.FreeList <BaseEntity>(ref list);
return(!this.wantsCollide);
}
finally
{
((IDisposable)enumerator).Dispose();
}
return(flag);
}
public override void ModifyPlacement(Construction.Placement place)
{
Vector3 position = Vector3.op_Addition(place.position, Quaternion.op_Multiply(place.rotation, this.worldPosition));
List <BaseEntity> list = (List <BaseEntity>)Pool.GetList <BaseEntity>();
Vis.Entities <BaseEntity>(position, this.outerRadius * 2f, list, -1, (QueryTriggerInteraction)2);
foreach (BaseEntity baseEntity in list)
{
if (baseEntity.isServer == this.isServer)
{
AttractionPoint[] all = this.prefabAttribute.FindAll <AttractionPoint>(baseEntity.prefabID);
if (all != null)
{
foreach (AttractionPoint attractionPoint in all)
{
if (!(attractionPoint.groupName != this.groupName))
{
Vector3 vector3_1 = Vector3.op_Addition(((Component)baseEntity).get_transform().get_position(), Quaternion.op_Multiply(((Component)baseEntity).get_transform().get_rotation(), attractionPoint.worldPosition));
Vector3 vector3_2 = Vector3.op_Subtraction(vector3_1, position);
float magnitude = ((Vector3) ref vector3_2).get_magnitude();
if ((double)magnitude <= (double)this.outerRadius)
{
Quaternion quaternion = QuaternionEx.LookRotationWithOffset(this.worldPosition, Vector3.op_Subtraction(vector3_1, place.position), Vector3.get_up());
float num = Mathf.InverseLerp(this.outerRadius, this.innerRadius, magnitude);
place.rotation = Quaternion.Lerp(place.rotation, quaternion, num);
position = Vector3.op_Addition(place.position, Quaternion.op_Multiply(place.rotation, this.worldPosition));
Vector3 vector3_3 = Vector3.op_Subtraction(vector3_1, position);
place.position = Vector3.op_Addition(place.position, Vector3.op_Multiply(vector3_3, num));
}
}
}
}
}
}
// ISSUE: cast to a reference type
Pool.FreeList <BaseEntity>((List <M0>&) ref list);
}
private static bool TestPlacingThroughWall(
ref Construction.Placement placement,
Transform transform,
Construction common,
Construction.Target target)
{
Vector3 vector3 = Vector3.op_Subtraction(placement.position, ((Ray) ref target.ray).get_origin());
RaycastHit hit;
if (!Physics.Raycast(((Ray) ref target.ray).get_origin(), ((Vector3) ref vector3).get_normalized(), ref hit, ((Vector3) ref vector3).get_magnitude(), 2097152))
{
return(true);
}
StabilityEntity entity = hit.GetEntity() as StabilityEntity;
if (Object.op_Inequality((Object)entity, (Object)null) && Object.op_Equality((Object)target.entity, (Object)entity) || (double)((Vector3) ref vector3).get_magnitude() - (double)((RaycastHit) ref hit).get_distance() < 0.200000002980232)
{
return(true);
}
Construction.lastPlacementError = "object in placement path";
transform.set_position(((RaycastHit) ref hit).get_point());
transform.set_rotation(placement.rotation);
return(false);
}
public virtual bool CheckSocketMods(Construction.Placement placement)
{
int i;
SocketMod[] socketModArray = this.socketMods;
for (i = 0; i < (int)socketModArray.Length; i++)
{
socketModArray[i].ModifyPlacement(placement);
}
socketModArray = this.socketMods;
for (i = 0; i < (int)socketModArray.Length; i++)
{
SocketMod socketMod = socketModArray[i];
if (!socketMod.DoCheck(placement))
{
if (socketMod.FailedPhrase.IsValid())
{
Construction.lastPlacementError = string.Concat("Failed Check: (", socketMod.FailedPhrase.translated, ")");
}
return(false);
}
}
return(true);
}
private static bool TestPlacingThroughWall(ref Construction.Placement placement, Transform transform, Construction common, Construction.Target target)
{
RaycastHit raycastHit;
Vector3 vector3 = placement.position - target.ray.origin;
if (!Physics.Raycast(target.ray.origin, vector3.normalized, out raycastHit, vector3.magnitude, 2097152))
{
return(true);
}
StabilityEntity entity = raycastHit.GetEntity() as StabilityEntity;
if (entity != null && target.entity == entity)
{
return(true);
}
if (vector3.magnitude - raycastHit.distance < 0.2f)
{
return(true);
}
Construction.lastPlacementError = "object in placement path";
transform.position = raycastHit.point;
transform.rotation = placement.rotation;
return(false);
}
public override bool DoCheck(Construction.Placement place)
{
return(true);
}
public virtual void ModifyPlacement(Construction.Placement place)
{
}
public virtual bool DoCheck(Construction.Placement place)
{
return(false);
}
