public void SetSenseEnabled(SenseType sense, bool active)
{
switch(sense) {
case SenseType.Sight:
SightGO.SetActive(active);
OnSightStateChanged(active);
break;
case SenseType.Hearing:
HearingGO.SetActive(active);
WorldAudioManager.Instance.ToggleAudioSource(active);
break;
case SenseType.Scent:
ScentGO.SetActive(active);
break;
case SenseType.Feeling:
FeelingGO.SetActive(active);
if(!active && PlayerController.Instance.carryingObject != null) {
PlayerController.Instance.carryingObject.collider.enabled = true;
PlayerController.Instance.carryingObject.rigidbody.useGravity = true;
PlayerController.Instance.carryingObject.transform.parent = null;
PlayerController.Instance.carryingObject = null;
PlayerController.Instance.isCarrying = false;
}
if (buttonHandler != null) {
buttonHandler.enabled = active;
}
break;
default:
Debug.Log ("SetSenseEnabled: Invalid sense");
break;
}
WorldAudioManager.Instance.PlayLockSense();
}
public Sense(SenseType type, string name, int range, string notes)
{
this.Type = type;
this.Name = name;
this.Range = range;
this.HasNotes = true;
this.Notes = notes;
}
public Sense(SenseType type, string name, int range)
{
this.Type = type;
this.Name = name;
this.Range = range;
this.HasNotes = false;
this.Notes = "";
}
public SenseLink(float time, Signal signal, Awareness awareness, bool firstHand, SenseType senseType)
{
this.TimeLastSensed = time;
this.signal = signal;
this.awarenessLevel = awareness;
this.FirstHand = firstHand;
this.sense = senseType;
}
private void Verify(
GameEntity attacker,
GameEntity victim,
GameEntity sensor,
SenseType attackerSensed,
SenseType victimSensed,
AbilityAction abilityAction,
GameManager manager,
int?damage,
GameEntity weapon = null,
string expectedMessage = "")
{
var languageService = manager.Game.Services.Language;
var appliedEffects = new List <GameEntity>();
if (damage.HasValue)
{
using (var damageEffectEntity = manager.CreateEntity())
{
var entity = damageEffectEntity.Referenced;
var appliedEffect = manager.CreateComponent <EffectComponent>(EntityComponent.Effect);
appliedEffect.Amount = damage.Value;
appliedEffect.EffectType = EffectType.PhysicalDamage;
appliedEffect.AffectedEntityId = victim.Id;
entity.Effect = appliedEffect;
appliedEffects.Add(entity);
}
if (weapon != null)
{
using (var weaponEffectEntity = manager.CreateEntity())
{
var entity = weaponEffectEntity.Referenced;
var appliedEffect = manager.CreateComponent <EffectComponent>(EntityComponent.Effect);
appliedEffect.Amount = damage.Value;
appliedEffect.EffectType = EffectType.Activate;
appliedEffect.TargetEntityId = weapon.Id;
appliedEffect.AffectedEntityId = victim.Id;
entity.Effect = appliedEffect;
appliedEffects.Add(entity);
}
}
}
var attackEvent = new AttackEvent(sensor, attacker, victim, attackerSensed, victimSensed,
appliedEffects, abilityAction, weapon,
ranged: weapon != null && (weapon.Item.Type & ItemType.WeaponRanged) != 0, hit: damage.HasValue);
Assert.Equal(expectedMessage, languageService.GetString(attackEvent));
}
public ItemDropEvent(
GameEntity sensorEntity, GameEntity dropperEntity, GameEntity itemEntity,
int quantity, SenseType dropperSensed, SenseType itemSensed)
{
SensorEntity = sensorEntity;
DropperEntity = dropperEntity;
ItemEntity = itemEntity;
Quantity = quantity;
DropperSensed = dropperSensed;
ItemSensed = itemSensed;
}
public ItemPickUpEvent(
GameEntity sensorEntity, GameEntity pickerEntity, GameEntity itemEntity,
int quantity, SenseType pickerSensed, SenseType itemSensed)
{
SensorEntity = sensorEntity;
PickerEntity = pickerEntity;
ItemEntity = itemEntity;
Quantity = quantity;
PickerSensed = pickerSensed;
ItemSensed = itemSensed;
}
public ItemEquipmentEvent(
GameEntity sensorEntity, GameEntity equipperEntity, GameEntity itemEntity,
SenseType equipperSensed, SenseType itemSensed, EquipmentSlot slot)
{
SensorEntity = sensorEntity;
EquipperEntity = equipperEntity;
ItemEntity = itemEntity;
EquipperSensed = equipperSensed;
ItemSensed = itemSensed;
Slot = slot;
}
public ItemActivationEvent(
GameEntity sensorEntity, GameEntity itemEntity, GameEntity activatorEntity, GameEntity targetEntity,
SenseType itemSensed, SenseType activatorSensed, SenseType targetSensed, bool consumed, bool successful)
{
SensorEntity = sensorEntity;
ItemEntity = itemEntity;
ActivatorEntity = activatorEntity;
TargetEntity = targetEntity;
ItemSensed = itemSensed;
ActivatorSensed = activatorSensed;
TargetSensed = targetSensed;
Consumed = consumed;
Successful = successful;
}
public static void AddToObject(Transform parent, SenseType type, float radius, float angle = 0f)
{
var senseObject = new GameObject(type.ToString());
senseObject.transform.parent = parent;
var col = senseObject.AddComponent <SphereCollider> ();
col.radius = radius;
col.isTrigger = true;
var sense = senseObject.AddComponent <Sense> ();
sense.Angle = angle;
sense.SenseType = type;
senseObject.transform.localPosition = Vector3.zero;
senseObject.transform.localRotation = Quaternion.identity;
}
public AttackEvent(
GameEntity sensorEntity, GameEntity attackerEntity, GameEntity victimEntity,
SenseType attackerSensed, SenseType victimSensed, IReadOnlyList <GameEntity> appliedEffects,
AbilityAction abilityAction, GameEntity weaponEntity, bool ranged, bool hit)
{
SensorEntity = sensorEntity;
AttackerEntity = attackerEntity;
VictimEntity = victimEntity;
AttackerSensed = attackerSensed;
VictimSensed = victimSensed;
AppliedEffects = appliedEffects;
AbilityAction = abilityAction;
WeaponEntity = weaponEntity;
Ranged = ranged;
Hit = hit;
}
public bool GetSenseEnabled(SenseType sense)
{
switch(sense) {
case SenseType.Sight:
return SightGO.activeInHierarchy;
case SenseType.Hearing:
return HearingGO.activeInHierarchy;
case SenseType.Scent:
return ScentGO.activeInHierarchy;
case SenseType.Feeling:
return FeelingGO.activeInHierarchy;
default:
Debug.Log ("GetSenseEnabled: Invalid sense");
return false;
}
}
void ApplyItemStats(Item item, SenseType sense)
{
for (int i = 0, n = item.effectors.Length; i < n; i++)
{
if (item.effectors[i].senseEffected == sense)
{
for (int j = 0, n2 = affectedBy.Count; j < n2; j++)
{
if (affectedBy[j].effector == item.effectors[i])
{
return;
}
}
wants[item.effectors[i].want] += item.effectors[i].value;
affectedBy.Add(new Effect(item.effectors[i], Time.time));
}
}
}
public static List <object> SerializeAttributes(GameEntity itemEntity, SenseType sense, SerializationContext context)
{
var canIdentify = itemEntity != null && sense.CanIdentify();
if (!canIdentify)
{
return(new List <object>());
}
var manager = itemEntity.Manager;
var item = itemEntity.Item;
var template = Item.Loader.Get(item.TemplateName);
var physical = itemEntity.Physical;
var equipableSlots = manager.ItemUsageSystem.GetEquipableSlots(item, context.Observer.Physical.Size)
.GetNonRedundantFlags(removeComposites: true)
.Select(s => Serialize(s, context))
.ToList();
return(new List <object>(13)
{
context.Services.Language.GetString(item, item.GetQuantity(manager), sense),
context.Services.Language.GetDescription(item.TemplateName, DescriptionCategory.Item),
item.Type,
(int)physical.Material,
physical.Size,
physical.Weight,
item.Hindrance,
template.Complexity,
template.RequiredMight,
template.RequiredSpeed,
template.RequiredFocus,
template.RequiredPerception,
equipableSlots,
manager.AbilitiesToAffectableRelationship[itemEntity.Id]
.Where(a => a.Ability.IsUsable &&
a.Ability.Activation != ActivationType.Default &&
a.Ability.Activation != ActivationType.Always &&
a.Ability.Activation != ActivationType.WhilePossessed)
.Select(a => AbilitySnapshot.SerializeAttributes(a, context.Observer, context)).ToList()
});
}
protected virtual string GetString(
GameEntity actorEntity, EnglishPerson person, SenseType sense, bool?definiteDeterminer = false)
{
if (actorEntity == null)
{
return(null);
}
if (person == EnglishPerson.Second)
{
return(EnglishMorphologicalProcessor.GetPronoun(
EnglishPronounForm.Normal, EnglishNumber.Singular, person, gender: null));
}
if (!sense.CanIdentify())
{
return("something");
}
var properName = actorEntity.AI?.ProperName ?? actorEntity.Player?.ProperName;
if (properName != null)
{
return(properName);
}
var name = "";
foreach (var raceEntity in actorEntity.Manager.RacesToBeingRelationship[actorEntity.Id].Values)
{
name += " " + raceEntity.Race.TemplateName;
}
if (definiteDeterminer.HasValue)
{
name = (definiteDeterminer.Value ? "the" : "a") + name;
}
return(name.Trim());
}
public virtual string GetString(ItemComponent item, int quantity, SenseType sense, bool?definiteDeterminer)
{
if (!sense.CanIdentify())
{
return("something");
}
var itemName = item.TemplateName + (item.Name == null ? "" : " named \"" + item.Name + "\"");
if (quantity > 1)
{
return(quantity + " " +
EnglishMorphologicalProcessor.ProcessNoun(itemName, EnglishNounForm.Plural));
}
return((EnglishMorphologicalProcessor.IsPlural(itemName) || definiteDeterminer == null
? ""
: definiteDeterminer.Value
? "the "
: EnglishMorphologicalProcessor.IsVocal(itemName[0])
? "an "
: "a ") + itemName);
}
public Sense(SenseType senseType, int range)
{
SenseType = senseType;
Range = range;
}
public Sense(string s, string r, SenseType st)
{
Sender = s;
Receiver = r;
senseType = st;
}
//Builder methods
public Signal SetSense(SenseType sense)
{
this.Sense = sense;
return(this);
}
public Sense(int s, int r, SenseType st)
{
Sender = s;
Receiver = r;
senseType = st;
}
public DeathEvent(GameEntity sensorEntity, GameEntity deceasedEntity, SenseType deceasedSensed)
{
SensorEntity = sensorEntity;
DeceasedEntity = deceasedEntity;
DeceasedSensed = deceasedSensed;
}
/// <summary>
/// Initialize SensorCore
/// </summary>
/// <param name="rec">Recording instance</param>
/// <param name="type">Sense type</param>
/// <returns>Asynchronous task</returns>
private async Task HandleSensorActivity(Recording rec, SenseType type)
{
if (rec.Recorder == null)
{
if (await CallSensorcoreApiAsync(async() =>
{
switch (type)
{
case SenseType.Activity:
_aMonitor = await ActivityMonitor.GetDefaultAsync();
break;
case SenseType.Places:
_pMonitor = await PlaceMonitor.GetDefaultAsync();
break;
case SenseType.Route:
_rTracker = await TrackPointMonitor.GetDefaultAsync();
break;
case SenseType.Steps:
_sCounter = await StepCounter.GetDefaultAsync();
break;
}
}))
{
Debug.WriteLine("Recorder initialized.");
switch (type)
{
case SenseType.Activity:
rec.Recorder = new SenseRecorder(_aMonitor);
break;
case SenseType.Places:
rec.Recorder = new SenseRecorder(_pMonitor);
break;
case SenseType.Route:
rec.Recorder = new SenseRecorder(_rTracker);
break;
case SenseType.Steps:
rec.Recorder = new SenseRecorder(_sCounter);
break;
}
}
else
{
return;
}
}
if (rec.Recorder == null)
{
return;
}
else
{
await ActivateAsync();
switch (rec.ItemState)
{
case Status.Recording:
await rec.Recorder.StartAsync();
break;
case Status.Stopped:
await rec.Recorder.StopAsync();
break;
case Status.Empty:
await rec.Recorder.GetRecording().SaveAsync();
break;
}
}
}
public Sense2(GameObject s, string r, SenseType st)
{
Sender = s;
Receiver = r;
senseType = st;
}
public static bool CanIdentify(this SenseType sense) => (sense & (SenseType.Sight | SenseType.Telepathy)) != SenseType.None;
/// <summary>
/// Initialize SensorCore
/// </summary>
/// <param name="rec">Recording instance</param>
/// <param name="type">Sense type</param>
/// <returns>Asynchronous task</returns>
private async Task HandleSensorActivity(Recording rec, SenseType type)
{
if (rec.Recorder == null)
{
if (await CallSensorcoreApiAsync(async () =>
{
switch (type)
{
case SenseType.Activity:
_aMonitor = await ActivityMonitor.GetDefaultAsync();
break;
case SenseType.Places:
_pMonitor = await PlaceMonitor.GetDefaultAsync();
break;
case SenseType.Route:
_rTracker = await TrackPointMonitor.GetDefaultAsync();
break;
case SenseType.Steps:
_sCounter = await StepCounter.GetDefaultAsync();
break;
}
}))
{
Debug.WriteLine("Recorder initialized.");
switch (type)
{
case SenseType.Activity:
rec.Recorder = new SenseRecorder(_aMonitor);
break;
case SenseType.Places:
rec.Recorder = new SenseRecorder(_pMonitor);
break;
case SenseType.Route:
rec.Recorder = new SenseRecorder(_rTracker);
break;
case SenseType.Steps:
rec.Recorder = new SenseRecorder(_sCounter);
break;
}
}
else return;
}
if (rec.Recorder == null)
return;
else
{
await ActivateAsync();
switch (rec.ItemState)
{
case Status.Recording:
await rec.Recorder.StartAsync();
break;
case Status.Stopped:
await rec.Recorder.StopAsync();
break;
case Status.Empty:
await rec.Recorder.GetRecording().SaveAsync();
break;
}
}
}
public static List <object> SerializeAttributes(GameEntity actorEntity, SenseType sense, SerializationContext context)
{
var canIdentify = actorEntity != null && sense.CanIdentify();
if (!canIdentify)
{
return(new List <object>());
}
var being = actorEntity.Being;
var sensor = actorEntity.Sensor;
var physical = actorEntity.Physical;
var description = actorEntity.HasComponent(EntityComponent.Player)
? ""
: context.Services.Language.GetDescription(
actorEntity.Manager.RacesToBeingRelationship[actorEntity.Id].Values.First().Race.TemplateName,
DescriptionCategory.Creature);
var result = new List <object>(40)
{
context.Services.Language.GetActorName(actorEntity, sense),
description,
actorEntity.Position.MovementDelay,
physical.Size,
physical.Weight,
sensor.PrimaryFOVQuadrants,
sensor.PrimaryVisionRange,
sensor.TotalFOVQuadrants,
sensor.SecondaryVisionRange,
sensor.Infravision,
sensor.InvisibilityDetection,
physical.Infravisible,
being.Visibility,
being.HitPoints,
being.HitPointMaximum,
being.EnergyPoints,
being.EnergyPointMaximum,
being.Might,
being.Speed,
being.Focus,
being.Perception,
being.Regeneration,
being.EnergyRegeneration,
being.Armor,
being.Deflection,
being.Evasion,
being.PhysicalResistance,
being.MagicResistance,
being.BleedingResistance,
being.AcidResistance,
being.ColdResistance,
being.ElectricityResistance,
being.FireResistance,
being.PsychicResistance,
being.ToxinResistance,
being.VoidResistance,
being.SonicResistance,
being.StunResistance,
being.LightResistance,
being.WaterResistance
};
if (!actorEntity.HasComponent(EntityComponent.Player))
{
result.Add(actorEntity.Manager.AbilitiesToAffectableRelationship[actorEntity.Id]
.Where(a => a.Ability.IsUsable &&
a.Ability.Activation != ActivationType.Default &&
a.Ability.Activation != ActivationType.Always &&
a.Ability.Activation != ActivationType.OnMeleeAttack &&
a.Ability.Activation != ActivationType.OnRangedAttack) // Instead add the effects to the corresponding abilities
.Select(a => AbilitySnapshot.SerializeAttributes(a, actorEntity, context)).ToList());
}
return(result);
}
public Sense(int Sender, int Receiver, SenseType senseType)
{
this.Sender = Sender;
this.Receiver = Receiver;
this.senseType = senseType;
}
// Builder methods
public Sensor SetSense(SenseType sense)
{
this.Sense = sense;
return(this);
}
public string GetActorName(GameEntity actorEntity, SenseType sense) => GetString(actorEntity, EnglishPerson.Third, sense, definiteDeterminer: null);
protected virtual string GetString(GameEntity actorEntity, EnglishPerson person, SenseType sense)
=> GetString(
actorEntity,
person,
sense,
definiteDeterminer: true);
public virtual string GetString(ItemComponent item, int quantity, SenseType sense) => GetString(item, quantity, sense, definiteDeterminer: null);
