//only intended to be used by core if2 classes
public static void SendTileApply(TileApply tileApply, InteractableTiles interactableTiles, TileInteraction tileInteraction, int tileInteractionIndex)
{
//if we are client and the interaction has client prediction, trigger it.
//Note that client prediction is not triggered for server player.
if (!CustomNetworkManager.IsServer)
{
Logger.LogTraceFormat("Predicting TileApply interaction {0}", Category.Interaction, tileApply);
tileInteraction.ClientPredictInteraction(tileApply);
}
if (!tileApply.Performer.Equals(PlayerManager.LocalPlayer))
{
Logger.LogError("Client attempting to perform an interaction on behalf of another player." +
" This is not allowed. Client can only perform an interaction as themselves. Message" +
" will not be sent.", Category.NetMessage);
return;
}
var msg = new RequestInteractMessage()
{
ComponentType = typeof(InteractableTiles),
InteractionType = typeof(TileApply),
ProcessorObject = interactableTiles.GetComponent <NetworkIdentity>().netId,
Intent = tileApply.Intent,
TargetVector = tileApply.TargetVector,
TileInteractionIndex = tileInteractionIndex
};
msg.Send();
}
public void ServerPerformInteraction(PositionalHandApply interaction)
{
//which matrix are we clicking on
var interactableTiles = InteractableTiles.GetAt(interaction.WorldPositionTarget, true);
Vector3Int cellPos = interactableTiles.WorldToCell(interaction.WorldPositionTarget);
var tileAtPosition = interactableTiles.LayerTileAt(interaction.WorldPositionTarget);
//which way are we placing it
foreach (var entry in waysToPlace)
{
//open space
if (tileAtPosition == null && entry.placeableOn == LayerType.None && entry.placeableOnlyOnTile == null)
{
interactableTiles.TileChangeManager.UpdateTile(cellPos, entry.layerTile);
break;
}
// placing on an existing tile
else if (tileAtPosition.LayerType == entry.placeableOn &&
(entry.placeableOnlyOnTile == null || entry.placeableOnlyOnTile == tileAtPosition))
{
interactableTiles.TileChangeManager.UpdateTile(cellPos, entry.layerTile);
break;
}
}
interactableTiles.TileChangeManager.SubsystemManager.UpdateAt(cellPos);
Inventory.ServerConsume(interaction.HandSlot, 1);
}
private void Awake()
{
metaTileMap = GetComponentInChildren <MetaTileMap>();
subsystemManager = GetComponent <SubsystemManager>();
interactableTiles = GetComponent <InteractableTiles>();
networkMatrix = GetComponent <NetworkedMatrix>();
}
//only intended to be used by core if2 classes
public static void SendTileApply(TileApply tileApply, InteractableTiles interactableTiles, TileInteraction tileInteraction)
{
//if we are client and the interaction has client prediction, trigger it.
//Note that client prediction is not triggered for server player.
if (!CustomNetworkManager.IsServer)
{
Logger.LogTraceFormat("Predicting TileApply interaction {0}", Category.Interaction, tileApply);
tileInteraction.ClientPredictInteraction(tileApply);
}
if (!tileApply.Performer.Equals(PlayerManager.LocalPlayer))
{
Logger.LogError("Client attempting to perform an interaction on behalf of another player." +
" This is not allowed. Client can only perform an interaction as themselves. Message" +
" will not be sent.", Category.Exploits);
return;
}
var msg = new NetMessage()
{
ComponentType = typeof(InteractableTiles),
InteractionType = typeof(TileApply),
ProcessorObject = GetNetId(interactableTiles.gameObject),
Intent = tileApply.Intent,
TargetPosition = tileApply.TargetPosition
};
Send(msg);
}
public TileMouseDrop(GameObject performer, GameObject usedObject, Intent intent, Vector2Int targetCellPos,
InteractableTiles targetInteractableTiles, BasicTile basicTile, Vector2 targetVector) : base(performer, usedObject, intent)
{
this.targetCellPos = targetCellPos;
this.targetInteractableTiles = targetInteractableTiles;
this.basicTile = basicTile;
this.targetVector = targetVector;
}
public void ServerPerformInteraction(PositionalHandApply interaction)
{
//which matrix are we clicking on
var interactableTiles = InteractableTiles.GetAt(interaction.WorldPositionTarget, true);
Vector3Int cellPos = interactableTiles.WorldToCell(interaction.WorldPositionTarget);
var tileAtPosition = interactableTiles.LayerTileAt(interaction.WorldPositionTarget, layerTypeSelection);
PlaceableTileEntry placeableTileEntry = null;
int itemAmount = 1;
var stackable = interaction.HandObject.GetComponent <Stackable>();
if (stackable != null)
{
itemAmount = stackable.Amount;
}
// find the first valid way possible to place a tile
foreach (var entry in waysToPlace)
{
//skip what can't be afforded
if (entry.itemCost > itemAmount)
{
continue;
}
//open space
if (tileAtPosition == null && entry.placeableOn == LayerType.None && entry.placeableOnlyOnTile == null)
{
placeableTileEntry = entry;
break;
}
// placing on an existing tile
else if (tileAtPosition.LayerType == entry.placeableOn && (entry.placeableOnlyOnTile == null || entry.placeableOnlyOnTile == tileAtPosition))
{
placeableTileEntry = entry;
break;
}
}
if (placeableTileEntry != null)
{
GameObject performer = interaction.Performer;
Vector2 targetPosition = interaction.WorldPositionTarget;
void ProgressFinishAction()
{
interactableTiles.TileChangeManager.UpdateTile(cellPos, placeableTileEntry.layerTile);
interactableTiles.TileChangeManager.SubsystemManager.UpdateAt(cellPos);
Inventory.ServerConsume(interaction.HandSlot, placeableTileEntry.itemCost);
SoundManager.PlayNetworkedAtPos(placeSound, targetPosition);
}
var bar = StandardProgressAction.Create(ProgressConfig, ProgressFinishAction)
.ServerStartProgress(targetPosition, placeableTileEntry.timeToPlace, performer);
}
}
public override bool Interact(MatrixManager.CustomPhysicsHit hit, InteractableTiles interactableTiles, Vector3 worldPosition)
{
if (base.Interact(hit, interactableTiles, worldPosition) == false)
{
return(true);
}
return(ProcessCount());
}
public override bool Interact(RaycastHit2D hit, InteractableTiles interactableTiles, Vector3 worldPosition)
{
if (base.Interact(hit, interactableTiles, worldPosition) == false)
{
return(true);
}
return(ProcessCount());
}
/// <summary>
///
/// </summary>
/// <param name="performer">performer of the interaction</param>
/// <param name="usedObject">object in hand</param>
/// <param name="intent">intent of the performer</param>
/// <param name="targetCellPos">cell position being targeted on the interactable tiles</param>
/// <param name="targetInteractableTiles">interactable tiles containing the tile being targeted</param>
/// <param name="basicTile">info of the tile being targeted</param>
/// <param name="handSlot">slot being used</param>
/// <param name="targetVector">vector pointing from perform to the targeted position</param>
public TileApply(GameObject performer, GameObject usedObject, Intent intent, Vector2Int targetCellPos,
InteractableTiles targetInteractableTiles, BasicTile basicTile, ItemSlot handSlot, Vector2 targetVector) : base(performer, usedObject, intent)
{
this.targetCellPos = targetCellPos;
this.targetInteractableTiles = targetInteractableTiles;
this.basicTile = basicTile;
this.handSlot = handSlot;
this.targetVector = targetVector;
}
private void ScrewInPlace(HandApply interaction)
{
var interactableTiles = InteractableTiles.GetAt(interaction.TargetObject.TileWorldPosition(), true);
Vector3Int cellPos = interactableTiles.WorldToCell(interaction.TargetObject.TileWorldPosition());
interactableTiles.TileChangeManager.UpdateTile(cellPos, layerTile);
interactableTiles.TileChangeManager.SubsystemManager.UpdateAt(cellPos);
Despawn.ServerSingle(gameObject);
}
private void SpawnTable(HandApply interaction, LayerTile tableToSpawn)
{
var interactableTiles = InteractableTiles.GetAt(interaction.TargetObject.TileWorldPosition(), true);
Vector3Int cellPos = interactableTiles.WorldToCell(interaction.TargetObject.TileWorldPosition());
interaction.HandObject.GetComponent <Stackable>().ServerConsume(2);
interactableTiles.TileChangeManager.UpdateTile(cellPos, tableToSpawn);
interactableTiles.TileChangeManager.SubsystemManager.UpdateAt(cellPos);
_ = Despawn.ServerSingle(gameObject);
}
/// <summary>
///
/// </summary>
/// <param name="performer">performer of the interaction</param>
/// <param name="usedObject">object in hand</param>
/// <param name="intent">intent of the performer</param>
/// <param name="targetCellPos">cell position being targeted on the interactable tiles</param>
/// <param name="targetInteractableTiles">interactable tiles containing the tile being targeted</param>
/// <param name="basicTile">info of the tile being targeted</param>
/// <param name="handSlot">slot being used</param>
/// <param name="targetVector">vector pointing from perform to the targeted position</param>
public TileApply(GameObject performer, GameObject usedObject, Intent intent, Vector2Int targetCellPos,
InteractableTiles targetInteractableTiles, BasicTile basicTile, ItemSlot handSlot, Vector2 targetPosition, ApplyType type = ApplyType.HandApply) : base(performer, usedObject, intent)
{
this.targetCellPos = targetCellPos;
this.targetInteractableTiles = targetInteractableTiles;
this.basicTile = basicTile;
this.handSlot = handSlot;
this.targetPosition = targetPosition;
this.applyType = type;
}
public bool Interact(MatrixManager.CustomPhysicsHit hit, InteractableTiles interactableTiles, Vector3 worldPosition)
{
if (CheckConditions(hit, interactableTiles, worldPosition) == false)
{
return(true);
}
movingProjectile.position = hit.HitWorld;
RotateBullet(GetNewDirection(hit));
return(IsCountReached());
}
public bool Interact(RaycastHit2D hit, InteractableTiles interactableTiles, Vector3 worldPosition)
{
if (CheckConditions(hit, interactableTiles, worldPosition) == false)
{
return(true);
}
movingProjectile.position = hit.point;
RotateBullet(GetNewDirection(hit));
return(IsCountReached());
}
public bool Interact(MatrixManager.CustomPhysicsHit hit, InteractableTiles interactableTiles, Vector3 worldPosition)
{
var layerToHit = GetLayerToHitOrGetNull(interactableTiles.MetaTileMap.DamageableLayers);
if (layerToHit == null)
{
return(false);
}
layerToHit.TilemapDamage.ApplyDamage(damageData.Damage, damageData.AttackType, worldPosition);
return(true);
}
/// <summary>
/// Invokes cached behaviours
/// </summary>
/// <param name="hit"></param>
/// <param name="interactableTile"></param>
/// <param name="bulletHitTarget"></param>
/// <returns> True if at least one behaviour returned true </returns>
private bool TryProcessBehaviours(MatrixManager.CustomPhysicsHit hit, InteractableTiles interactableTile, Vector3 bulletHitTarget)
{
bool isAnyProcessed = false;
foreach (var behaviour in behavioursInteractTile)
{
if (behaviour.Interact(hit, interactableTile, bulletHitTarget))
{
isAnyProcessed = true;
}
}
return(isAnyProcessed);
}
public override bool CheckCondition(RaycastHit2D hit, InteractableTiles interactableTiles, Vector3 worldPosition)
{
var layers = interactableTiles.MetaTileMap.DamageableLayers;
foreach (var layer in layers)
{
if (CheckType(layer.LayerType))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Invokes cached behaviours
/// </summary>
/// <param name="hit"></param>
/// <param name="interactableTile"></param>
/// <param name="bulletHitTarget"></param>
/// <returns> True if at least one behaviour returned true </returns>
private bool TryProcessBehaviours(RaycastHit2D hit, InteractableTiles interactableTile, Vector3 bulletHitTarget)
{
bool isAnyProcessed = false;
foreach (var behaviour in behavioursInteractTile)
{
if (behaviour.Interact(hit, interactableTile, bulletHitTarget))
{
isAnyProcessed = true;
}
}
return(isAnyProcessed);
}
public void ServerPerformInteraction(PositionalHandApply interaction)
{
//which matrix are we clicking on
var matrix = InteractableTiles.TryGetNonSpaceMatrix(interaction.WorldPositionTarget.RoundToInt(), true);
if (matrix.IsSpaceMatrix)
{
matrix = interaction.Performer.RegisterTile().Matrix;
}
var interactableTiles = matrix.TileChangeManager.InteractableTiles;
Vector3Int cellPos = interactableTiles.WorldToCell(interaction.WorldPositionTarget);
var tileAtPosition = interactableTiles.LayerTileAt(interaction.WorldPositionTarget, layerTypeSelection);
PlaceableTileEntry placeableTileEntry = null;
int itemAmount = 1;
var stackable = interaction.HandObject.GetComponent <Stackable>();
if (stackable != null)
{
itemAmount = stackable.Amount;
}
placeableTileEntry = FindValidTile(itemAmount, tileAtPosition);
if (placeableTileEntry != null)
{
GameObject performer = interaction.Performer;
Vector2 targetPosition = interaction.WorldPositionTarget;
void ProgressFinishAction()
{
ProgressFinishActionPriv(interaction, placeableTileEntry, interactableTiles, cellPos, targetPosition);
}
void ProgressInterruptedAction(ActionInterruptionType reason)
{
ProgressInterruptedActionPriv(interaction, reason, placeableTileEntry);
}
var bar = StandardProgressAction.Create(ProgressConfig, ProgressFinishAction, ProgressInterruptedAction)
.ServerStartProgress(targetPosition, placeableTileEntry.timeToPlace, performer);
}
}
public bool Interact(RaycastHit2D hit, InteractableTiles interactableTiles, Vector3 worldPosition)
{
var layerToHit = GetLayerToHitOrGetNull(interactableTiles.MetaTileMap.DamageableLayers);
if (layerToHit == null)
{
return(false);
}
float newDamage = projectileKineticDamage.DamageByPressureModifier(damageData.Damage);
layerToHit.TilemapDamage.ApplyDamage(damageData.Damage, damageData.AttackType, worldPosition);
return(true);
}
private void ProgressFinishActionPriv(PositionalHandApply interaction, PlaceableTileEntry placeableTileEntry,
InteractableTiles interactableTiles, Vector3Int cellPos, Vector2 targetPosition)
{
if (Inventory.ServerConsume(interaction.HandSlot, placeableTileEntry.itemCost))
{
interactableTiles.TileChangeManager.MetaTileMap.SetTile(cellPos, placeableTileEntry.layerTile);
interactableTiles.TileChangeManager.SubsystemManager.UpdateAt(cellPos);
SoundManager.PlayNetworkedAtPos(placeSound, targetPosition);
}
else
{
Chat.AddExamineMsgFromServer(interaction.PerformerPlayerScript.connectedPlayer,
$"You lack the materials to finish placing {placeableTileEntry.layerTile.DisplayName}");
}
}
public bool Interact(MatrixManager.CustomPhysicsHit hit, InteractableTiles interactableTiles, Vector3 worldPosition)
{
var layers = interactableTiles.MetaTileMap.DamageableLayers;
foreach (var layer in layers)
{
if (layerType.CheckType(layer.LayerType) == false)
{
continue;
}
if (layer.TilemapDamage.ApplyDamage(damageData.Damage, damageData.AttackType, worldPosition) <= 0)
{
continue;
}
return(true);
}
return(false);
}
public static void SendTileMouseDrop(TileMouseDrop mouseDrop, InteractableTiles interactableTiles)
{
if (!mouseDrop.Performer.Equals(PlayerManager.LocalPlayer))
{
Logger.LogError("Client attempting to perform an interaction on behalf of another player." +
" This is not allowed. Client can only perform an interaction as themselves. Message" +
" will not be sent.", Category.NetMessage);
return;
}
var msg = new RequestInteractMessage()
{
ComponentType = typeof(InteractableTiles),
InteractionType = typeof(TileMouseDrop),
ProcessorObject = interactableTiles.GetComponent <NetworkIdentity>().netId,
Intent = mouseDrop.Intent,
UsedObject = mouseDrop.UsedObject.NetId(),
TargetVector = mouseDrop.TargetVector
};
msg.Send();
}
public bool WillInteract(PositionalHandApply interaction, NetworkSide side)
{
if (!DefaultWillInteract.Default(interaction, side))
{
return(false);
}
if (interaction.HandObject != gameObject)
{
return(false);
}
//it's annoying to place something when you're trying to pick up instead to add to your current stack,
//so if it's possible to stack what is being targeted with what's in your hand, we will defer to that
if (Validations.CanStack(interaction.HandObject, interaction.TargetObject))
{
return(false);
}
//check if we are clicking a spot we can place a tile on
var interactableTiles = InteractableTiles.GetAt(interaction.WorldPositionTarget, side);
var tileAtPosition = interactableTiles.LayerTileAt(interaction.WorldPositionTarget);
foreach (var entry in waysToPlace)
{
//open space
if (tileAtPosition == null && entry.placeableOn == LayerType.None && entry.placeableOnlyOnTile == null)
{
return(true);
}
// placing on an existing tile
else if (tileAtPosition.LayerType == entry.placeableOn &&
(entry.placeableOnlyOnTile == null || entry.placeableOnlyOnTile == tileAtPosition))
{
return(true);
}
}
return(false);
}
public static void SendTileMouseDrop(TileMouseDrop mouseDrop, InteractableTiles interactableTiles)
{
if (!mouseDrop.Performer.Equals(PlayerManager.LocalPlayer))
{
Logger.LogError("Client attempting to perform an interaction on behalf of another player." +
" This is not allowed. Client can only perform an interaction as themselves. Message" +
" will not be sent.", Category.Exploits);
return;
}
var msg = new NetMessage()
{
ComponentType = typeof(InteractableTiles),
InteractionType = typeof(TileMouseDrop),
ProcessorObject = GetNetId(interactableTiles.gameObject),
Intent = mouseDrop.Intent,
UsedObject = GetNetId(mouseDrop.UsedObject),
TargetVector = mouseDrop.TargetVector
};
Send(msg);
}
private void Start()
{
interactableTiles = GetComponent <InteractableTiles>();
}
public virtual bool Interact(MatrixManager.CustomPhysicsHit hit, InteractableTiles interactableTiles, Vector3 worldPosition)
{
return(interactableTiles.TryMine(worldPosition));
}
private void Start()
{
gameObjectRoot = transform.root.gameObject;
interactableTiles = GetComponent <InteractableTiles>();
}
/// <summary>
/// Really simple check for determining if the wall can reflect bullet
/// Hard coded only to check wall LayerType
/// </summary>
/// <param name="hit"></param>
/// <param name="interactableTiles"></param>
/// <param name="worldPosition"></param>
/// <returns></returns>
public override bool CheckCondition(RaycastHit2D hit, InteractableTiles interactableTiles, Vector3 worldPosition)
{
var tile = interactableTiles.MetaTileMap.GetTileAtWorldPos(worldPosition, LayerType.Walls) as BasicTile;
return(tile != null && tile.DoesReflectBullet);
}
private bool CheckConditions(MatrixManager.CustomPhysicsHit hit, InteractableTiles interactableTiles, Vector3 worldPosition)
{
return(hitInteractTileConditions.Conditions.Any(condition => condition.CheckCondition(hit, interactableTiles, worldPosition)));
}
