public override void ComposeSensorTargetSet(GameActor gameActor, Reflex reflex)
{
List <Filter> filters = reflex.Filters;
_typeList.Clear();
/// We never fire until we have valid data to base a trigger on.
if (TerrainMaterial.IsValid(OverrideSenseMaterial, false, false))
{
_typeList.AddType(OverrideSenseMaterial);
reflex.targetSet.Param = _typeList;
reflex.targetSet.Action = TestObjectSet(reflex);
}
else if (gameActor.Chassis.TerrainDataValid)
{
gameActor.Chassis.GetTerrainMaterials(_typeList);
reflex.targetSet.Param = _typeList;
reflex.targetSet.Action = TestObjectSet(reflex);
}
else
{
reflex.targetSet.Action = false;
}
} // end of ComposeSensorTargetSet()
public void Load(BinaryReader br, bool use16BitMatIdx)
{
for (int i = 0; i < PixPerMap; ++i)
{
for (int j = 0; j < PixPerMap; ++j)
{
ushort val;
if (use16BitMatIdx)
{
val = br.ReadUInt16();
}
else
{
val = br.ReadByte();
}
// If user was editing terrain with a huge brush and saved before
// all tiles were updated, some of them may be saved with the
// selection flag in place. Obviously this doesn't make sense to
// have on loading, so clear it out just to be sure.
val &= (ushort)~TerrainMaterial.Flags.Selection;
// Is the material we read valid? If not, replace it with empty.
if (!TerrainMaterial.IsValid(val, true, false))
{
Debug.Assert(false, "Why are we reading invalid values from this map?");
val = TerrainMaterial.EmptyMatIdx;
}
map[i, j] = val;
}
}
}
} // end of PlayCollision()
/// <summary>
/// Play audio for actor/terrrain collision
/// </summary>
/// <param name="actor"></param>
/// <param name="material">Material index.</param>
public static void PlayCollision(GameThing actor, ushort material)
{
// Get the proper collision sound from the material index.
if (!TerrainMaterial.IsValid(material, false, false))
{
//Debug.Assert(false, "Why do we have an invalid material here?");
// Why? Well because we sometimes clear the material in the feeler
// collision testing. So it's no longer a valid way to tell what
// terrain we're over. In general, it works when we're on the ground
// but not when jumping. Argh.
collisionMetalSoft.Play(actor);
return;
}
PlayActorCollision(actor);
CollisionSound cs = TerrainMaterial.Get(material).CollisionSound;
switch (cs)
{
case CollisionSound.plasticHard:
collisionPlasticHard.Play(actor);
break;
case CollisionSound.plasticSoft:
collisionPlasticSoft.Play(actor);
break;
case CollisionSound.metalHard:
collisionMetalHard.Play(actor);
break;
case CollisionSound.metalSoft:
collisionMetalSoft.Play(actor);
break;
case CollisionSound.rover:
collisionRover.Play(actor);
break;
case CollisionSound.dirt:
collisionDirt.Play(actor);
break;
case CollisionSound.grass:
collisionGrass.Play(actor);
break;
case CollisionSound.rock:
collisionRock.Play(actor);
break;
default:
break;
}
} // end of PlayCollision()
/// <summary>
/// An assured renderable for each possible material.
/// Will create if it doesn't exist.
/// </summary>
/// <param name="matIdx"></param>
/// <returns></returns>
private Renderable GetOrMakeRenderable(ushort matIdx)
{
Debug.Assert(TerrainMaterial.IsValid(matIdx, false, true)); // There is no reason to fetch a renderable
// for an empty or invalid material.
if (!renderableDict.ContainsKey(matIdx))
{
renderableDict[matIdx] = new Renderable(matIdx);
}
return(renderableDict[matIdx]);
}
/// <summary>
/// Build up renderable geometry for each possible material. Discard empties.
/// </summary>
/// <param name="neighbors"></param>
/// <param name="colorMap"></param>
/// <returns></returns>
private bool MakeRenderables(
VirtualMap.HeightMapNeighbors heightNeighbors,
VirtualMap.ColorMapNeighbors colorNeighbors)
{
var heightMap = heightNeighbors[VirtualMap.HeightMapNeighbors.Dir.Center];
VirtualMap.ColorMap colorMap = colorNeighbors[VirtualMap.ColorMapNeighbors.Dir.Center];
Renderable.PrepareToBuild(heightMap.Size, Min, minLut);
//Dispose();
//renderableDict.Clear();
// Reset number of local vertices in each Renderable
// since we're about to remake the list.
ResetAllVertexCounts();
Vector2 cubeSize = new Vector2(
heightMap.Scale.X / (float)heightMap.Size.X,
heightMap.Scale.Y / (float)heightMap.Size.Y);
Vector2 halfSize = cubeSize * 0.5f;
Point vert = new Point(0, 0);
for (vert.X = 0; vert.X < heightMap.Size.X; vert.X += 1)
{
for (vert.Y = 0; vert.Y < heightMap.Size.Y; vert.Y += 1)
{
float h = heightMap.GetHeightUnsafe(vert.X, vert.Y);
if (h != 0)
{
ushort color = colorMap[vert.X, vert.Y];
//Debug.Assert(TerrainMaterial.IsValid(color, false, true));
if (TerrainMaterial.IsValid(color, false, true))
{
Vector3 pos = new Vector3(
(float)vert.X * cubeSize.X + halfSize.X,
(float)vert.Y * cubeSize.Y + halfSize.Y,
h);
Renderable r = GetOrMakeRenderable(colorMap[vert.X, vert.Y]);
r.AddVertices(pos, halfSize, vert, heightNeighbors, colorNeighbors);
}
}
}
}
return(FinishGeometry(cubeSize, halfSize));
}
public ushort this[int i, int j]
{
get
{
ushort val = map[i, j];
return(val);
}
set
{
Debug.Assert(TerrainMaterial.IsValid(value, allowEmpty: true, allowSelectionFlag: true));
map[i, j] = value;
}
}
} // end of MaterialPicker c'tor
/// <summary>
/// Sample the type under the cursor and translate to a UISlot.
/// Return -1 on no terrain.
/// </summary>
/// <returns></returns>
public int SampleType()
{
Vector2 pos = InGame.inGame.Cursor3D.Position2d;
if (MouseEdit.TriggerSample())
{
Vector3 p = MouseEdit.HitInfo.TerrainPosition;
pos = new Vector2(p.X, p.Y);
}
ushort t = Terrain.GetMaterialType(pos);
return(TerrainMaterial.IsValid(t, false, false) ? Terrain.MaterialIndexToUISlot(t) : -1);
}
public void HandleMouseInput()
{
if (GamePadInput.ActiveMode != GamePadInput.InputMode.KeyboardMouse)
{
return;
}
// In eyedropper mode, show the pointy cursor.
if (KeyboardInput.AltIsPressed)
{
inGame.Cursor3D.Rep = Cursor3D.Visual.Pointy;
inGame.Cursor3D.Hidden = false;
}
else
{
inGame.Cursor3D.Hidden = true;
}
if (KeyboardInput.AltIsPressed)
{
// Sample the current terrain.
if (MouseEdit.TriggerSample())
{
MouseInput.Left.IgnoreUntilReleased = true;
// Prevent terrain from being painted when Alt is being used to select material.
editMode = Terrain.EditMode.Noop;
Vector3 p = MouseEdit.HitInfo.TerrainPosition;
Vector2 pos = new Vector2(p.X, p.Y);
ushort matIdx = Terrain.GetMaterialType(pos);
if (TerrainMaterial.IsValid(matIdx, false, false))
{
Terrain.CurrentMaterialIndex = matIdx;
Foley.PlayCut();
}
}
}
else if (!PickerXInUse && !PickerYInUse)
{
if (DebouncePending)
{
return;
}
if (GamePadInput.ActiveMode == GamePadInput.InputMode.KeyboardMouse)
{
// Set the mode based on whether or not
// option keys are pressed.
if (MouseInput.Left.WasPressed)
{
editMode = Terrain.EditMode.PaintAndAddMaterial;
if (KeyboardInput.ShiftIsPressed)
{
editMode = Terrain.EditMode.PaintMaterial;
}
else if (KeyboardInput.CtrlIsPressed)
{
editMode = Terrain.EditMode.AddAtCenter;
}
}
}
}
}
} // end of ComposeSensorTargetSet()
#endregion Public
#region Internal
/// <summary>
/// See if the terrain types our object is touching match up with our filters.
/// </summary>
/// <param name="reflex"></param>
/// <returns></returns>
public new bool TestObjectSet(Reflex reflex)
{
GameActor gameActor = reflex.Task.GameActor;
List <Filter> filters = reflex.Filters;
bool haveType = false;
bool match = true;
object param;
// Only check all this if we're not jumping. If we are jumping
// we can just skip this.
if (!gameActor.Chassis.Jumping)
{
for (int indexFilter = 0; indexFilter < filters.Count; indexFilter++)
{
Filter filter = filters[indexFilter] as Filter;
if (!(filter is CountFilter))
{
if (filter is TerrainFilter)
{
haveType = true;
}
if (!filter.MatchAction(reflex, out param))
{
match = false;
break;
}
}
}
if (match && !haveType)
{
match = _typeList.HasAnyValid((matIdx) => TerrainMaterial.IsValid((ushort)matIdx, false, false));
}
/// Manually apply the count filters, because they look at the sensorTargetSet.Count,
/// which is always zero for non-object based sensors like this.
for (int indexFilter = 0; indexFilter < filters.Count; indexFilter++)
{
if (filters[indexFilter] is CountFilter)
{
CountFilter countFilter = filters[indexFilter] as CountFilter;
int count = match ? 1 : 0;
match = countFilter.Compare(count);
}
}
}
else
{
// Jumping...
match = false;
}
if (reflex.Data.GetFilterCountByType(typeof(NotFilter)) > 0)
{
match = !match;
}
match = PostProcessAction(match, reflex);
return(match);
}
public int OnGetTerrain()
{
Debug.Assert(TerrainMaterial.IsValid(lastTerrainIndex, false, false), "If this assert fires, set 'lastTerrainIndex's initial value to 'TerrainMaterial.DefaultMatIdx' and fire Daryl. (DZ)");//ToDo(DZ): Is this assert msg ship-able?
return(Terrain.MaterialIndexToUISlot(lastTerrainIndex));
}
public override void Activate()
{
if (state != States.Active)
{
pendingState = States.Active;
BokuGame.objectListDirty = true;
Editor editor = InGame.inGame.Editor;
if (editor.Active)
{
HelpOverlay.Push(@"PieSelectorProgrammingNoSelection");
}
else
{
HelpOverlay.Push(@"PieSelectorAddItemNoSelection");
}
if (SelectWater || SetWater)
{
WaterPicker waterPicker = InGame.inGame.shared.ToolBox.WaterPicker;
holdOnGet = waterPicker.OnGetType;
holdOnSet = waterPicker.OnSetType;
holdOnPick = waterPicker.OnPickType;
waterPicker.OnGetType = OnGetWater;
waterPicker.OnSetType = OnSetWater;
waterPicker.OnPickType = OnPickWater;
typePicker = waterPicker;
if (SetWater)
{
lastWaterIndex = RootData.SetWaterTypeIndex;
}
else
{
lastWaterIndex = RootData.WaterType;
}
if (lastWaterIndex < 0)
{
lastWaterIndex = Water.CurrentType;
}
}
else
{
MaterialPicker matPicker = InGame.inGame.shared.ToolBox.MaterialPicker;
holdOnGet = matPicker.OnGetType;
holdOnSet = matPicker.OnSetType;
holdOnPick = matPicker.OnPickType;
matPicker.OnGetType = OnGetTerrain;
matPicker.OnSetType = OnSetTerrain;
matPicker.OnPickType = OnPickTerrain;
matPicker.UseAltOverlay = true;
typePicker = matPicker;
ushort rootDataMatIdx = (ushort)RootData.MaterialType;
if (TerrainMaterial.IsValid(rootDataMatIdx, false, false))
{
lastTerrainIndex = rootDataMatIdx;
}
else if (!TerrainMaterial.IsValid(lastTerrainIndex, false, false))
{
lastTerrainIndex = Terrain.CurrentMaterialIndex;
}
}
typePicker.Active = true;
typePicker.Hidden = false;
}
}
