public void FindMovingBlocksCollisionBoxes(Vector3 position, DynamicArray <CollisionBox> result)
{
Vector3 boxSize = BoxSize;
BoundingBox boundingBox = new BoundingBox(position - new Vector3(boxSize.X / 2f, 0f, boxSize.Z / 2f), position + new Vector3(boxSize.X / 2f, boxSize.Y, boxSize.Z / 2f));
boundingBox.Min -= new Vector3(1f);
boundingBox.Max += new Vector3(1f);
m_movingBlockSets.Clear();
m_subsystemMovingBlocks.FindMovingBlocks(boundingBox, extendToFillCells: false, m_movingBlockSets);
for (int i = 0; i < m_movingBlockSets.Count; i++)
{
IMovingBlockSet movingBlockSet = m_movingBlockSets.Array[i];
for (int j = 0; j < movingBlockSet.Blocks.Count; j++)
{
MovingBlock movingBlock = movingBlockSet.Blocks[j];
int num = Terrain.ExtractContents(movingBlock.Value);
Block block = BlocksManager.Blocks[num];
if (block.IsCollidable)
{
BoundingBox[] customCollisionBoxes = block.GetCustomCollisionBoxes(m_subsystemTerrain, movingBlock.Value);
Vector3 v = new Vector3(movingBlock.Offset) + movingBlockSet.Position;
for (int k = 0; k < customCollisionBoxes.Length; k++)
{
result.Add(new CollisionBox
{
Box = new BoundingBox(v + customCollisionBoxes[k].Min, v + customCollisionBoxes[k].Max),
BlockValue = movingBlock.Value,
BlockVelocity = movingBlockSet.CurrentVelocity
});
}
}
}
}
}
public bool IsBlocked(BoundingBox box)
{
int num = Terrain.ToCell(box.Min.X);
int num2 = MathUtils.Max(Terrain.ToCell(box.Min.Y), 0);
int num3 = Terrain.ToCell(box.Min.Z);
int num4 = Terrain.ToCell(box.Max.X);
int num5 = MathUtils.Min(Terrain.ToCell(box.Max.Y), 255);
int num6 = Terrain.ToCell(box.Max.Z);
for (int i = num; i <= num4; i++)
{
for (int j = num3; j <= num6; j++)
{
TerrainChunk chunkAtCell = SubsystemTerrain.Terrain.GetChunkAtCell(i, j);
if (chunkAtCell == null)
{
continue;
}
int num7 = TerrainChunk.CalculateCellIndex(i & 0xF, num2, j & 0xF);
int num8 = num2;
while (num8 <= num5)
{
int cellValueFast = chunkAtCell.GetCellValueFast(num7);
int num9 = Terrain.ExtractContents(cellValueFast);
if (num9 != 0)
{
Block block = BlocksManager.Blocks[num9];
if (block.ShouldAvoid(cellValueFast))
{
return(true);
}
if (block.IsCollidable)
{
Vector3 v = new Vector3(i, num8, j);
BoundingBox[] customCollisionBoxes = block.GetCustomCollisionBoxes(SubsystemTerrain, cellValueFast);
for (int k = 0; k < customCollisionBoxes.Length; k++)
{
BoundingBox boundingBox = customCollisionBoxes[k];
if (box.Intersection(new BoundingBox(v + boundingBox.Min, v + boundingBox.Max)))
{
return(true);
}
}
}
}
num8++;
num7++;
}
}
}
return(false);
}
public void FindTerrainCollisionBoxes(BoundingBox box, DynamicArray <CollisionBox> result)
{
Point3 point = Terrain.ToCell(box.Min);
Point3 point2 = Terrain.ToCell(box.Max);
point.Y = MathUtils.Max(point.Y, 0);
point2.Y = MathUtils.Min(point2.Y, 255);
if (point.Y > point2.Y)
{
return;
}
for (int i = point.X; i <= point2.X; i++)
{
for (int j = point.Z; j <= point2.Z; j++)
{
TerrainChunk chunkAtCell = m_subsystemTerrain.Terrain.GetChunkAtCell(i, j);
if (chunkAtCell == null)
{
continue;
}
int num = TerrainChunk.CalculateCellIndex(i & 0xF, point.Y, j & 0xF);
int num2 = point.Y;
while (num2 <= point2.Y)
{
int cellValueFast = chunkAtCell.GetCellValueFast(num);
int num3 = Terrain.ExtractContents(cellValueFast);
if (num3 != 0)
{
Block block = BlocksManager.Blocks[num3];
if (block.IsCollidable)
{
BoundingBox[] customCollisionBoxes = block.GetCustomCollisionBoxes(m_subsystemTerrain, cellValueFast);
Vector3 v = new Vector3(i, num2, j);
for (int k = 0; k < customCollisionBoxes.Length; k++)
{
result.Add(new CollisionBox
{
Box = new BoundingBox(v + customCollisionBoxes[k].Min, v + customCollisionBoxes[k].Max),
BlockValue = cellValueFast
});
}
}
}
num2++;
num++;
}
}
}
}
public float GetBlockWalkingHeight(Block block, int value)
{
if (block is DoorBlock || block is FenceGateBlock)
{
return(0f);
}
float num = 0f;
BoundingBox[] customCollisionBoxes = block.GetCustomCollisionBoxes(SubsystemTerrain, value);
for (int i = 0; i < customCollisionBoxes.Length; i++)
{
BoundingBox boundingBox = customCollisionBoxes[i];
num = MathUtils.Max(num, boundingBox.Max.Y);
}
return(num);
}
public void QueueShadow(Camera camera, Vector3 shadowPosition, float shadowDiameter, float alpha)
{
if (!SettingsManager.ObjectsShadowsEnabled)
{
return;
}
float num = Vector3.DistanceSquared(camera.ViewPosition, shadowPosition);
if (!(num <= 1024f))
{
return;
}
float num2 = MathUtils.Sqrt(num);
float num3 = MathUtils.Saturate(4f * (1f - num2 / 32f));
float num4 = shadowDiameter / 2f;
int num5 = Terrain.ToCell(shadowPosition.X - num4);
int num6 = Terrain.ToCell(shadowPosition.Z - num4);
int num7 = Terrain.ToCell(shadowPosition.X + num4);
int num8 = Terrain.ToCell(shadowPosition.Z + num4);
for (int i = num5; i <= num7; i++)
{
for (int j = num6; j <= num8; j++)
{
int num9 = MathUtils.Min(Terrain.ToCell(shadowPosition.Y), 255);
int num10 = MathUtils.Max(num9 - 2, 0);
for (int num11 = num9; num11 >= num10; num11--)
{
int cellValueFast = m_subsystemTerrain.Terrain.GetCellValueFast(i, num11, j);
int num12 = Terrain.ExtractContents(cellValueFast);
Block block = BlocksManager.Blocks[num12];
if (block.ObjectShadowStrength > 0f)
{
BoundingBox[] customCollisionBoxes = block.GetCustomCollisionBoxes(m_subsystemTerrain, cellValueFast);
for (int k = 0; k < customCollisionBoxes.Length; k++)
{
BoundingBox boundingBox = customCollisionBoxes[k];
float num13 = boundingBox.Max.Y + (float)num11;
if (shadowPosition.Y - num13 > -0.5f)
{
float num14 = camera.ViewPosition.Y - num13;
if (num14 > 0f)
{
float num15 = MathUtils.Max(num14 * 0.01f, 0.005f);
float num16 = MathUtils.Saturate(1f - (shadowPosition.Y - num13) / 2f);
Vector3 p = new Vector3(boundingBox.Min.X + (float)i, num13 + num15, boundingBox.Min.Z + (float)j);
Vector3 p2 = new Vector3(boundingBox.Max.X + (float)i, num13 + num15, boundingBox.Min.Z + (float)j);
Vector3 p3 = new Vector3(boundingBox.Max.X + (float)i, num13 + num15, boundingBox.Max.Z + (float)j);
Vector3 p4 = new Vector3(boundingBox.Min.X + (float)i, num13 + num15, boundingBox.Max.Z + (float)j);
DrawShadowOverQuad(p, p2, p3, p4, shadowPosition, shadowDiameter, 0.45f * block.ObjectShadowStrength * alpha * num3 * num16);
}
}
}
break;
}
if (num12 == 18)
{
break;
}
}
}
}
}
public bool Place(TerrainRaycastResult raycastResult, int value)
{
if (Place2 != null)
{
return(Place2(raycastResult, value));
}
int num = Terrain.ExtractContents(value);
if (BlocksManager.Blocks[num].IsPlaceable)
{
Block block = BlocksManager.Blocks[num];
BlockPlacementData placementData = block.GetPlacementValue(m_subsystemTerrain, this, value, raycastResult);
if (placementData.Value != 0)
{
Point3 point = CellFace.FaceToPoint3(placementData.CellFace.Face);
int num2 = placementData.CellFace.X + point.X;
int num3 = placementData.CellFace.Y + point.Y;
int num4 = placementData.CellFace.Z + point.Z;
if (num3 > 0 && num3 < 255 && (IsBlockPlacingAllowed(ComponentCreature.ComponentBody) || m_subsystemGameInfo.WorldSettings.GameMode <= GameMode.Harmless))
{
bool flag = false;
if (block.IsCollidable)
{
BoundingBox boundingBox = ComponentCreature.ComponentBody.BoundingBox;
boundingBox.Min += new Vector3(0.2f);
boundingBox.Max -= new Vector3(0.2f);
BoundingBox[] customCollisionBoxes = block.GetCustomCollisionBoxes(m_subsystemTerrain, placementData.Value);
for (int i = 0; i < customCollisionBoxes.Length; i++)
{
BoundingBox box = customCollisionBoxes[i];
box.Min += new Vector3(num2, num3, num4);
box.Max += new Vector3(num2, num3, num4);
if (boundingBox.Intersection(box))
{
flag = true;
break;
}
}
}
if (!flag)
{
SubsystemBlockBehavior[] blockBehaviors = m_subsystemBlockBehaviors.GetBlockBehaviors(Terrain.ExtractContents(placementData.Value));
for (int i = 0; i < blockBehaviors.Length; i++)
{
blockBehaviors[i].OnItemPlaced(num2, num3, num4, ref placementData, value);
}
m_subsystemTerrain.DestroyCell(0, num2, num3, num4, placementData.Value, noDrop: false, noParticleSystem: false);
m_subsystemAudio.PlaySound("Audio/BlockPlaced", 1f, 0f, new Vector3(placementData.CellFace.X, placementData.CellFace.Y, placementData.CellFace.Z), 5f, autoDelay: false);
Poke(forceRestart: false);
if (ComponentCreature.PlayerStats != null)
{
ComponentCreature.PlayerStats.BlocksPlaced++;
}
return(true);
}
}
}
}
return(false);
}
