public void GetInteractions()
{
//find all possible interactable objects in range
Collider2D[] possibleInteractions;
possibleInteractions = Physics2D.OverlapCircleAll(myTransform.position, interactionDistance, LayerMaskHandler.instance.interactableLayer);
if (possibleInteractions.Length == 0)
{
myInteractionObject = null; return;
}
//find closest interactable object in range
float distance = 1000f;//start at an impossiblity
int interactionObject = 0;
for (int i = 0; i < possibleInteractions.Length; i++)
{
float newDistance = (possibleInteractions[i].transform.position - myTransform.position).magnitude;
if (newDistance < distance)
{
distance = newDistance; interactionObject = i;
}
}
myInteractionObject = possibleInteractions[interactionObject].gameObject;
InteractionBase myInteraction = myInteractionObject.GetComponent("InteractionBase") as InteractionBase;
myInteraction.Use();
}
public static void SetupTree()
{
if (displayTree == null)
{
return;
}
displayTree.Nodes.Clear();
currentObject = null;
nodeBase.Clear();
text.Visible = false;
save.Visible = false;
foreach (InteractionBase b in interactedObject.InterItems)
{
if (b is InteractionChoice c)
{
TreeNode tn = new TreeNode(c.ToString(), GetTreeArray(c));
displayTree.Nodes.Add(tn);
nodeBase.Add(tn, c);
}
else
{
TreeNode tn = new TreeNode(b.ToString());
displayTree.Nodes.Add(tn);
nodeBase.Add(tn, b);
}
}
}
// Utility
static private void SwapBasicAndHoldInteractions(InteractionActivator activator, ref IInteraction vanillaBasic, ref IInteraction vanillaHold)
{
InteractionBase basic = vanillaBasic as InteractionBase;
InteractionBase hold = vanillaHold as InteractionBase;
if (_swapWaterInteractions && basic.Is <GatherWaterInteraction>() && hold.Is <DrinkWaterInteraction>() ||
_singleHoldsToPresses && activator.CanDoHold && !activator.CanDoBasic && hold.IsNot <InteractionDisassemble>())
{
if (basic != null)
{
basic.SetOverrideHoldLocKey(basic.DefaultPressLocKey);
}
if (hold != null)
{
hold.SetOverridePressLocKey(hold.DefaultHoldLocKey);
}
Utility.Swap(ref vanillaBasic, ref vanillaHold);
InteractionTriggerBase triggerBase = activator.GetComponent <InteractionTriggerBase>();
if (triggerBase != null)
{
Utility.Swap(ref triggerBase.m_basicConditions, ref triggerBase.m_holdConditions);
}
}
}
public void NextNode()
{
elementNum++;
if (elementNum < interactionElements.Count)
{
currentInteraction = interactionElements[elementNum];
currentInteraction.nextNode = NextNode;
currentInteraction.Setup();
}
else
{
Screen.CloseWindow("interaction");
}
}
public void PreviousNode()
{
elementNum--;
if (elementNum >= 0)
{
currentInteraction = interactionElements[elementNum];
currentInteraction.nextNode = NextNode;
currentInteraction.Setup();
}
else
{
Screen.CloseWindow("interaction");
elementNum = 0;
}
}
public static void UpdateNodeData(object sender, TreeNodeMouseClickEventArgs e)
{
if (e.Button != MouseButtons.Left || !nodeBase.ContainsKey(e.Node))
{
return;
}
if (currentObject != null && nodeBase.ContainsValue(currentObject))
{
SaveInteractionData();
}
currentObject = nodeBase[e.Node];
displayTree.SelectedNode = e.Node;
DeleteOnce = false;
del.Text = "Delete Item";
SetupInteractionData();
}
public void ProcessInteraction(ServerGameState fullState, InteractionBase interaction)
{
switch (interaction.Type)
{
case InteractionType.Attack:
attackProcessor.ProcessAttack(fullState, interaction as InteractionAttack);
return;
case InteractionType.PlayCard:
playCardProcessor.ProcessPlayCard(fullState, interaction as InteractionPlayCard);
return;
case InteractionType.EndTurn:
endTurnProcessor.ProcessEndTurn(fullState, interaction as InteractionEndTurn);
return;
}
throw new ArgumentOutOfRangeException("interaction.Type", interaction.Type, "Unsupported interaction type");
}
public HashSet <UIBase> LoadObjects()
{
blob.ClickAction = (x, y) => {
if (currentInteraction is InteractionChoice c)
{
return(c.CheckClick(x, y));
}
else
{
NextNode();
return(true);
}
};
elementNum = 0;
foreach (InteractionBase b in interactionElements)
{
b.nextNode = NextNode;
}
currentInteraction = interactionElements[elementNum];
currentInteraction.Setup();
return(UIObjects);
}
public ValidationResult ValidateInteraction(ClientGameState currentState, InteractionBase interaction)
{
switch (interaction.Type)
{
case InteractionType.Attack:
return(attackProcessor.ValidateAttack(currentState, interaction as InteractionAttack));
case InteractionType.PlayCard:
return(playCardProcessor.ValidatePlayCard(currentState, interaction as InteractionPlayCard));
case InteractionType.EndTurn:
return(endTurnProcessor.ValidateEndTurn(currentState));
}
return(new ValidationResult()
{
IsOk = false,
Messages = new List <string>()
{
$"Unknown Interaction of type {interaction.GetType()} encountered"
}
});
}
// setup the entire interactor object and merton NPC (no gameplay)
private void SetupInteractor(Vector3 pos)
{
// base gameobject
InteractorObj = new GameObject("Horde_Interactor");
InteractorObj.transform.position = pos;
// fire sigil visuals
StartCoroutine(AddItemToInteractor(8000010, Vector3.down * 0.35f, Vector3.zero, false, InteractorObj.transform));
// setup Merton NPC
var merton = SetupBasicNPC(pos, true);
merton.transform.parent = InteractorObj.transform;
// setup auto look
merton.AddComponent <NPCLookFollow>();
// setup character visuals
try { SetupNpcArmor(merton, new List <int> {
3200030, 3200031, 3200032
}); }
catch { }
// animation fix
merton.SetActive(false);
merton.SetActive(true);
// make big
merton.transform.localScale *= 1.6f;
// setup components
InteractionTriggerBase triggerBase = InteractorObj.AddComponent <InteractionTriggerBase>();
InteractionActivator activator = InteractorObj.AddComponent <InteractionActivator>();
//InteractionBase interactBase = InteractorObj.AddComponent(new InteractionBase { OnActivationEvent = new UnityAction(InteractorBeginEvent) });
InteractionBase interactBase = InteractorObj.AddComponent <InteractionBase>();
interactBase.OnActivationEvent = new UnityAction(InteractorBeginEvent);
triggerBase.SetActivator(activator);
At.SetValue("Begin <color=#FF0000>Merton's Challenge</color>", typeof(InteractionActivator), activator, "m_overrideBasicText");
At.SetValue(interactBase, typeof(InteractionActivator), activator, "m_sceneBasicInteraction");
}
public static bool Activate(InteractionBase __instance, Character _character)
{
// Activate > OnActivate > ActivationDone
try
{
//WorkInProgress.Instance.MyLogger.LogDebug("Activate=" + __instance.GetType().Name);
if (__instance.GetType() != typeof(InteractionSleep))
{
return(true);
}
var ds = (__instance as InteractionSleep).Item.GetComponent <CustomDurable>();
if (ds == null)
{
return(true);
}
//WorkInProgress.Instance.MyLogger.LogDebug($"RestrictUsageOfTents[{(__instance as InteractionSleep).Item.name}]={ds.CurrentDurability}");
//var list = Resources.FindObjectsOfTypeAll<GameObject>().Where(g => g.name.StartsWith("5000021_Bedroll_")
// && g.GetComponent<Item>() != null
// && g.GetComponent<Item>().CurrentDurability == 100
// ).ToList();
//foreach (var go in list)
//{
// AccessTools.Field(typeof(Item), "m_currentDurability").SetValue(go.GetComponent<Item>(), 42);
// WorkInProgress.Instance.MyLogger.LogDebug($" > {go.name} ({go.GetComponent<Item>().CurrentDurability})");
//}
if (_character.Inventory.HasABag)
{
_character.CharacterUI.ShowInfoNotification("You must remove your bagpack before sleep!");
return(false);
}
}
catch (Exception ex)
{
WorkInProgress.Instance.MyLogger.LogError("Activate: " + ex.Message);
}
return(true);
}
public override void OnInspectorGUI()
{
InteractionBase interaction = (InteractionBase)target;
GUILayout.Label(interaction.Storage == null ? "Unlinked" : "Linked to " + interaction.Storage.name);
if (GUILayout.Button("Link to closest Storage"))
{
Storage[] s = FindObjectsOfType <Storage>();
int closest = -1;
float dist = float.MaxValue;
for (int i = 0; i < s.Length; i++)
{
float localDist = Vector3.Distance(interaction.transform.position, s[i].transform.position);
if (localDist < dist)
{
closest = i;
dist = localDist;
}
}
if (closest > -1)
{
interaction.Storage = s[closest];
UnityEditor.PrefabUtility.RecordPrefabInstancePropertyModifications(interaction);
}
else
{
Debug.Log("No Storage found.");
}
}
DrawDefaultInspector();
}
private IEnumerator FixReviveInteraction(InteractionBase _base, UnityEngine.Events.UnityAction action)
{
yield return(new WaitForSeconds(0.1f));
_base.OnActivationEvent = action;
}
// usually called from LoadScene. Also by the Sync functions when you join a host.
public IEnumerator SetupBonfireLocal(Vector3 position, string uid)
{
Debug.Log("Setting up bonfire at: " + position.ToString() + ", uid: " + uid);
var bonfire = new GameObject("Bonfire_" + uid);
bonfire.transform.position = position;
var activatedCampfire = ResourcesPrefabManager.Instance.GetItemPrefab(5000101).GetComponent <Deployable>().DeployedStateItemPrefab.VisualPrefab;
var fireVisuals = Instantiate(activatedCampfire.gameObject);
fireVisuals.transform.parent = bonfire.transform;
fireVisuals.transform.position = bonfire.transform.position;
var swordVisuals = Instantiate(ResourcesPrefabManager.Instance.GetItemPrefab(2000151).VisualPrefab.gameObject);
swordVisuals.transform.parent = bonfire.transform;
swordVisuals.transform.position = bonfire.transform.position + Vector3.up;
swordVisuals.transform.rotation = Quaternion.Euler(0, 0, 90);
var sigilVisuals = Instantiate(ResourcesPrefabManager.Instance.GetItemPrefab(8000010).VisualPrefab.gameObject);
sigilVisuals.transform.parent = bonfire.transform;
sigilVisuals.transform.position = bonfire.transform.position;
// interaction gameobject base
GameObject actionHolder = new GameObject("Interaction_Holder");
actionHolder.transform.parent = bonfire.transform;
actionHolder.transform.position = bonfire.transform.position;
// setup components
InteractionTriggerBase triggerBase = actionHolder.AddComponent <InteractionTriggerBase>();
InteractionActivator activator = actionHolder.AddComponent <InteractionActivator>();
InteractionBase interactBase = actionHolder.AddComponent <InteractionBase>();
// setup the trigger base
triggerBase.SetHolderUID(uid);
triggerBase.GenerateColliderIfNone = true;
triggerBase.IsLargeTrigger = true;
triggerBase.DetectionPriority = -9999;
triggerBase.SetActivator(activator);
// setup the interaction activator
activator.SetUID(uid);
At.SetValue("Rest at <color=#fc4e03>Bonfire</color>", typeof(InteractionActivator), activator, "m_overrideBasicText");
At.SetValue(interactBase, typeof(InteractionActivator), activator, "m_sceneBasicInteraction");
// setup the event interaction base
interactBase.OnActivationEvent = BonfireEvent;
// =========== finalize =========== //
bonfire.gameObject.SetActive(true);
yield return(new WaitForSeconds(0.1f));
//activator.Reregister();
foreach (ParticleSystem ps in fireVisuals.GetComponentsInChildren <ParticleSystem>())
{
ps.Play();
var m = ps.main;
m.prewarm = true;
m.playOnAwake = true;
}
foreach (Light light in fireVisuals.GetComponentsInChildren <Light>())
{
light.gameObject.SetActive(true);
}
foreach (SoundPlayer sound in fireVisuals.GetComponentsInChildren <SoundPlayer>())
{
sound.Play(false);
}
}
void MoveVertical()
{
bool isCurrentlyJumping = startedToListen && state.IsJumping();
if (grounded && jumpReady && isCurrentlyJumping)
{
grounded = false;
jumpReady = false;
verticalSpeed = jumpSpeed;
}
if (canAirJump && !grounded && airJumpReady && isCurrentlyJumping)
{
airJumpReady = false;
verticalSpeed = jumpSpeed;
}
float previousVerticalSpeed = verticalSpeed;
verticalSpeed -= gravity * Time.fixedDeltaTime;
float verticalSpeedAirturnMoment = .15f;
if (!airturned &&
(previousVerticalSpeed >= verticalSpeedAirturnMoment) &&
(verticalSpeed <= verticalSpeedAirturnMoment))
{
animator.StartAnimation(Animation.AIRTURN, state.GetDirection(), () =>
{
airJumpReady = true;
airturned = true;
});
}
if (verticalSpeed < maximumVerticalDropSpeed)
{
verticalSpeed = maximumVerticalDropSpeed;
}
Vector2 movementVector = new Vector2(0, verticalSpeed);
RaycastHit2D hit = Physics2D.BoxCast(collider.bounds.center, collider.bounds.size,
0, movementVector, Mathf.Abs(movementVector.y), LayerMask.GetMask(collisionLayers));
bool wasGrounded = grounded;
if (hit.collider != null)
{
bool touchedFloor = false;
float maximumDistance = movementVector.y < 0 ? -hit.distance + safetyRing : hit.distance - safetyRing;
if (hit.distance == 0)
{
movementVector = new Vector2(0, 0);
touchedFloor = true;
}
else if (Mathf.Abs(maximumDistance) < Mathf.Abs(movementVector.y))
{
movementVector = new Vector2(0, maximumDistance);
touchedFloor = true;
}
if (touchedFloor)
{
if (verticalSpeed < 0)
{
grounded = true;
}
verticalSpeed = 0f;
}
else
{
grounded = false;
}
}
else
{
grounded = false;
}
if (grounded && !wasGrounded)
{
if (airturned)
{
airturned = false;
animator.StartAnimation(Animation.LANDING, state.GetDirection());
}
else
{
jumpReady = true;
}
airJumpReady = false;
}
Move(movementVector);
if (grounded)
{
RaycastHit2D[] floorHits = Physics2D.BoxCastAll(collider.bounds.center, collider.bounds.size,
0, Vector2.down, safetyRing, LayerMask.GetMask(collisionLayers));
foreach (RaycastHit2D floorHit in floorHits)
{
if (floorHit.collider != null)
{
if (floorHit.rigidbody != null)
{
InteractionBase interact = floorHit.rigidbody.GetComponent <InteractionBase>();
if (interact != null)
{
Influence(interact.Do());
}
}
}
}
}
}
public void ConfigureAudioSetUp()
{
CheckSoundBanks();
if (AmbiantSound != null && RoomAmbiantType)
{
PlayerDetectionSphereCollider.enabled = false;
PlayerDetectionBoxCollider.enabled = true;
PlayerDetectionBoxCollider.isTrigger = true;
PlayerDetectionBoxCollider.size = new Vector3(maxDistanceToHear + 5f, maxDistanceToHear + 5f, PlayerDetectionBoxCollider.size.z);
AmbiantAudioInit();
}
else if (AmbiantSound != null && ObjectAmbiantType)
{
PlayerDetectionBoxCollider.enabled = false;
PlayerDetectionSphereCollider.enabled = true;
PlayerDetectionSphereCollider.radius = maxDistanceToHear + 5f;
AmbiantAudioInit();
}
else if (PonctualSoundsEnabled && InteractionType)
{
PlayerDetectionBoxCollider.enabled = false;
PlayerDetectionSphereCollider.enabled = true;
PlayerDetectionSphereCollider.radius = maxDistanceToHear + 5f;
audio.loop = false;
audio.playOnAwake = false;
if (this.transform.parent.GetComponent <InteractionBase>() != null)
{
soundInteractionSource = this.transform.parent.GetComponent <InteractionBase>();
}
if (soundInteractionSource.GetComponent <PowerInteraction>() != null)
{
powerInteractionSource = soundInteractionSource.GetComponent <PowerInteraction>();
}
GetSpecificInteractionType();
}
else if (AmbiantSound != null && MixedType)
{
PlayerDetectionBoxCollider.enabled = false;
PlayerDetectionSphereCollider.enabled = true;
PlayerDetectionSphereCollider.radius = maxDistanceToHear + 5f;
AmbiantAudioInit();
if (this.transform.parent.GetComponent <InteractionBase>() != null)
{
soundInteractionSource = this.transform.parent.GetComponent <InteractionBase>();
}
GetSpecificInteractionType();
}
else if (OtherType)
{
PlayerDetectionBoxCollider.enabled = false;
PlayerDetectionSphereCollider.enabled = true;
PlayerDetectionSphereCollider.radius = maxDistanceToHear + 5f;
audio.loop = false;
audio.playOnAwake = false;
}
else if (OtherTypeLoop)
{
PlayerDetectionBoxCollider.enabled = false;
PlayerDetectionSphereCollider.enabled = true;
PlayerDetectionSphereCollider.radius = maxDistanceToHear + 5f;
audio.playOnAwake = false;
if (this.transform.parent.GetComponent <InteractionBase>() != null)
{
soundInteractionSource = this.transform.parent.GetComponent <InteractionBase>();
}
}
else
{
PlayerDetectionBoxCollider.enabled = false;
PlayerDetectionSphereCollider.enabled = true;
PlayerDetectionSphereCollider.radius = maxDistanceToHear + 5f;
audio.mute = true;
audio.Pause();
}
}
void Start()
{
basicAudioEventPlayer.audio.loop = true;
interactionBase = this.transform.parent.GetComponent <InteractionBase>();
interactionBase.Event_Interaction_On.AddListener(SelectStateOfSound);
}
