/// <summary>
/// Setups signal delaying
/// </summary>
/// <param name="distancesStat">Distance statistics to be used when synaptic delay method is Distance</param>
/// <param name="rand">Random object to be used when synaptic delay method is Random</param>
public void SetupDelay(BasicStat distancesStat, Random rand)
{
if (_maxDelay > 0)
{
//Set synapse signal delay
if (DelayMethod == SynapticDelayMethod.Distance)
{
double relDistance = (Distance - distancesStat.Min) / distancesStat.Span;
Delay = (int)Math.Round(_maxDelay * relDistance);
}
else
{
Delay = rand.Next(_maxDelay + 1);
}
if (Delay == 0)
{
//No queue will be used
_signalQueue = null;
}
else
{
//Delay queue
_signalQueue = new SimpleQueue <Signal>(Delay + 1);
}
}
return;
}
/// <summary>
/// Recomputes range
/// </summary>
private void RecomputeRange(Interval range, BasicStat stat)
{
double min, max;
if (_standardize)
{
double hi = Math.Max(Math.Abs((stat.Min - stat.ArithAvg) / stat.StdDev), Math.Abs((stat.Max - stat.ArithAvg) / stat.StdDev));
//Following ensures mean at the center of the normalization range but depending on the data
//it can lead to full utilization of only one half of the normalization interval.
min = -hi;
max = hi;
}
else
{
min = stat.Min;
max = stat.Max;
}
if (_keepReserve)
{
double addSpan = ((max - min) / 2d) * RangeReserveCoeff;
min -= addSpan;
max += addSpan;
}
range.Set(min, max);
return;
}
/// <summary>
/// Initializes a new instance of the <see cref="SilverNeedle.Characters.CharacterSkill"/> class.
/// </summary>
/// <param name="baseSkill">Base skill.</param>
/// <param name="baseScore">Base score.</param>
/// <param name="isClassSkill">If set to <c>true</c> is class skill.</param>
public CharacterSkill(Skill baseSkill, AbilityScore baseScore, bool isClassSkill)
{
Skill = baseSkill;
this.baseAbilityScore = baseScore;
this.ClassSkill = isClassSkill;
this.skillStats = new BasicStat(baseSkill.Name);
}
public FieldUser(GameSocket socket)
{
Socket = socket;
Controlled = new List <IFieldControlledObj>();
Owned = new List <IFieldOwnedObj>();
Pets = Character.Pets
.Where(sn => sn > 0)
.Select(sn => Character
.Inventories[ItemInventoryType.Cash].Items.Values
.OfType <ItemSlotPet>()
.FirstOrDefault(i => i.CashItemSN == sn))
.Where(item => item != null)
.Select(item => new FieldUserPet(
this,
item,
(byte)Character.Pets.IndexOf(item.CashItemSN ?? 0)
))
.ToList();
BasicStat = new BasicStat(this);
ForcedStat = new ForcedStat(this);
TemporaryStats = new Dictionary <TemporaryStatType, TemporaryStat>();
ValidateStat();
}
public void StatsTotalUpAdjustments()
{
var stat = new BasicStat("TestStat", 10);
stat.AddModifier(new ValueStatModifier(5));
Assert.Equal(15, stat.TotalValue);
}
//Constructor
/// <summary>
/// Base constructor
/// </summary>
/// <param name="featureType">Feature type</param>
/// <param name="outputRange">Filter's output range</param>
protected FeatureFilterBase(FeatureType featureType, Interval outputRange)
{
Type = featureType;
Stat = new BasicStat();
OutputRange = outputRange.DeepClone();
return;
}
public void StatsTotalUpAdjustments()
{
var stat = new BasicStat(10);
stat.AddModifier(new BasicStatModifier(5, "Foo"));
Assert.AreEqual(15, stat.TotalValue);
}
/// <inheritdoc/>
public double Compute(BasicStat continuousActivationStat,
BasicStat continuousActivationDiffStat,
MovingDataWindow activationMDW,
SimpleQueue <byte> firingMDW,
double activation,
double normalizedActivation,
bool spike
)
{
PredictorActivationDiffStatFigureSettings cfg = (PredictorActivationDiffStatFigureSettings)Cfg;
if (cfg.Window == PredictorActivationDiffStatFigureSettings.NAWindowNum)
{
return(continuousActivationDiffStat.Get(cfg.Figure));
}
else
{
if (activationMDW.UsedCapacity >= cfg.Window)
{
return(activationMDW.GetDataDiffStat(cfg.Window).Get(cfg.Figure));
}
else
{
return(0d);
}
}
}
public WeaponAttack(OffenseStats offense, CharacterSize size, IWeaponAttackStatistics weapon)
{
this.offenseAbilities = offense;
this.size = size;
this.Weapon = weapon;
this.Name = weapon.Name;
this.Range = weapon.Range;
this.DamageType = weapon.DamageType.ToString();
this.CriticalThreat = weapon.CriticalThreat;
this.CriticalModifier = new BasicStat(string.Format("{0} Critical Modifier", weapon.Name), weapon.CriticalModifier);
this.attackBonus = new BasicStat(string.Format("{0} Attack Bonus", weapon.Name), weapon.AttackModifier);
this.attackBonus.AddModifier(new WeaponProficiencyAttackModifier(this.offenseAbilities, this.Weapon));
this.attackBonus.AddModifiers(MultipleAttackBonusModifier.GetConditionalMultipleAttackModifiers());
this.DamageModifier = new BasicStat(string.Format("{0} Damage Modifier", weapon.Name), 0);
foreach (var weaponModifier in offense.WeaponModifiers)
{
if (weaponModifier.WeaponQualifies(weapon))
{
weaponModifier.ApplyModifier(this);
}
}
}
//Constructor
/// <summary>
/// Creates initialized instance
/// </summary>
/// <param name="sourceNeuron">Source neuron</param>
/// <param name="targetNeuron">Target neuron</param>
/// <param name="weight">Synapse initial weight</param>
public BaseSynapse(INeuron sourceNeuron,
INeuron targetNeuron,
double weight
)
{
//Neurons to be connected
SourceNeuron = sourceNeuron;
TargetNeuron = targetNeuron;
//Euclidean distance
Distance = EuclideanDistance.Compute(SourceNeuron.Placement.ReservoirCoordinates, TargetNeuron.Placement.ReservoirCoordinates);
//Weight sign rules
if (SourceNeuron.Role == NeuronCommon.NeuronRole.Input)
{
if (TargetNeuron.TypeOfActivation == ActivationType.Analog)
{
//No change of the weight sign
Weight = weight;
}
else
{
//Target is spiking neuron
//Weight must be always positive
Weight = Math.Abs(weight);
}
}
else
{
//Weight sign is dependent on source neuron role
Weight = Math.Abs(weight) * (SourceNeuron.Role == NeuronCommon.NeuronRole.Excitatory ? 1d : -1d);
}
//Efficacy statistics
EfficacyStat = new BasicStat(false);
return;
}
/// <inheritdoc/>
public double Compute(BasicStat continuousActivationStat,
BasicStat continuousActivationDiffStat,
MovingDataWindow activationMDW,
SimpleQueue <byte> firingMDW,
double activation,
double normalizedActivation,
bool spike
)
{
PredictorFiringTraceSettings cfg = (PredictorFiringTraceSettings)Cfg;
if (cfg.Window == PredictorFiringTraceSettings.NAWindowNum)
{
return(_continuousTrace);
}
else
{
if (firingMDW.Count >= cfg.Window)
{
double trace = 0d;
for (int i = cfg.Window - 1; i >= 0; i--)
{
trace *= (1d - cfg.Fading);
trace += firingMDW.GetElementAt(i, true);
}
return(trace);
}
else
{
return(0d);
}
}
}
public void Initialize(ComponentContainer components)
{
sorcererLevels = components.Get <ClassLevel>();
CriticalModifier = new BasicStat("Elemental Ray Critical Modifier", 2);
elementalType = components.Get <ElementalType>();
charisma = components.Get <AbilityScores>().GetAbility(AbilityScoreTypes.Charisma);
AttackBonus = components.Get <OffenseStats>().RangeAttackBonus;
}
public void FormatNiceStringVersionOfStat()
{
var stat = new BasicStat("TestStat", 20);
IValueStatModifier mod = new ConditionalStatModifier(new ValueStatModifier("Attack Bonus", 3, "bonus"), "vs. Thor");
stat.AddModifier(mod);
Assert.Equal("Fight +20 (+23 vs. Thor)", stat.ToString("Fight"));
}
/// <summary>
/// The deep copy constructor.
/// </summary>
/// <param name="source">The source instance.</param>
public ClusterErrStatistics(ClusterErrStatistics source)
{
ClusterName = source.ClusterName;
NatPrecissionErrStat = new BasicStat(source.NatPrecissionErrStat);
NrmPrecissionErrStat = new BasicStat(source.NrmPrecissionErrStat);
BinaryErrStat = source.BinaryErrStat?.DeepClone();
return;
}
public void FormatNiceStringVersionOfStat()
{
var stat = new BasicStat(20);
BasicStatModifier mod = new ConditionalStatModifier("vs. Thor", "Attack Bonus", 3, "bonus", "Food");
stat.AddModifier(mod);
Assert.AreEqual("Fight +20 (+23 vs. Thor)", stat.ToString("Fight"));
}
public void Initialize(ComponentContainer components)
{
this.usesPerDayStatistic = new BasicStat(this.UsesPerDayStatName());
this.healingDice = new DiceStatistic("Lay On Hands Dice", "1d6");
components.Add(usesPerDayStatistic);
components.Add(healingDice);
paladinLevel = components.Get <ClassLevel>();
}
//Constructor
/// <summary>
/// Creates an initialized instance.
/// </summary>
public StandardStatSet()
{
MinStat = new BasicStat();
MaxStat = new BasicStat();
AvgStat = new BasicStat();
SpanStat = new BasicStat();
return;
}
public void WorksOffOfTheAbilityModifierIfAbilityScoreIsUsed()
{
var ability = new AbilityScore(AbilityScoreTypes.Strength, 18);
var limit = new BasicStat("Foo", 10);
var mod = new LimitStatModifier(ability, limit);
Assert.Equal(mod.Modifier, 4);
}
public void AlwaysRoundDownStats()
{
var stat = new BasicStat("TestStat", 2);
stat.AddModifier(new ValueStatModifier(-1));
stat.AddModifier(new ValueStatModifier(0.667f));
Assert.Equal(-1, stat.SumBasicModifiers());
Assert.Equal(1, stat.TotalValue);
}
//Constructor
/// <summary>
/// Creates an initialized instance
/// </summary>
public NeuronStatistics(Interval neuronStateRange)
{
TStimuliStat = new BasicStat();
RStimuliStat = new BasicStat();
ActivationStateRange = neuronStateRange.DeepClone();
NormalizedActivationStateStat = new BasicStat();
OutputSignalStat = new BasicStat();
return;
}
//Constructor
/// <summary>
/// Creates an initialized instance
/// </summary>
/// <param name="inputFieldIdx">Index of correspondent reservoir input field.</param>
/// <param name="inputRange">
/// Range of input value.
/// It is very recommended to have input values normalized and standardized before
/// they are passed as an input.
/// </param>
public InputAnalogNeuron(int inputFieldIdx, Interval inputRange)
{
Placement = new NeuronPlacement(inputFieldIdx, -1, inputFieldIdx, inputFieldIdx, 0, 0);
_inputRange = inputRange.DeepClone();
StimuliStat = new BasicStat();
TransmissionFreqStat = new BasicStat();
Reset(false);
return;
}
public FieldUser(WvsGameSocket socket, Character character)
{
Socket = socket;
Character = character;
BasicStat = new BasicStat(this);
ForcedStat = new ForcedStat();
ValidateStat();
}
public void AlwaysRoundDownStats()
{
var stat = new BasicStat(2);
stat.AddModifier(new BasicStatModifier(-1, "Food"));
stat.AddModifier(new BasicStatModifier(0.667f, "Because"));
Assert.AreEqual(-1, stat.SumBasicModifiers);
Assert.AreEqual(1, stat.TotalValue);
}
public void StatsCanHaveAMinimumValueThatClampTheResult()
{
var stat = new BasicStat("Stat!");
stat.Minimum = 3;
var mod = new ValueStatModifier(-20);
stat.AddModifier(mod);
Assert.Equal(stat.TotalValue, 3);
}
//Constructor
/// <summary>
/// Creates an initialized instance
/// </summary>
/// <param name="inputFieldIdx">Index of corresponding reservoir input field.</param>
/// <param name="inputRange">
/// Range of input value.
/// It is very recommended to have input values normalized and standardized before
/// they are passed to input neuron.
/// </param>
/// <param name="inputCodingFractions">Number of coding fractions (see SpikeTrainConverter to understand)</param>
public InputSpikingNeuron(int inputFieldIdx, Interval inputRange, int inputCodingFractions)
{
Placement = new NeuronPlacement(inputFieldIdx, -1, inputFieldIdx, inputFieldIdx, 0, 0);
_inputRange = new Interval(inputRange.Min.Bound(), inputRange.Max.Bound());
_signalConverter = new SignalConverter(_inputRange, inputCodingFractions);
StimuliStat = new BasicStat();
TransmissionSignalStat = new BasicStat();
Reset(false);
return;
}
//Constructor
/// <summary>
/// Creates an initialized instance
/// </summary>
public NeuronStatistics()
{
InputStimuliStat = new BasicStat();
ReservoirStimuliStat = new BasicStat();
TotalStimuliStat = new BasicStat();
ActivationStat = new BasicStat();
AnalogSignalStat = new BasicStat();
FiringStat = new BasicStat();
return;
}
public void CastingDoesntBreakConditionalModifiers()
{
var stat = new BasicStat("TestStat", 10);
IValueStatModifier mod = new ConditionalStatModifier(new ValueStatModifier("Attack Bonus", 3, "bonus"), "vs. Thor");
stat.AddModifier(mod);
Assert.Equal(1, stat.GetConditions().Count());
Assert.Equal(10, stat.TotalValue);
Assert.Equal(13, stat.GetConditionalValue("vs. Thor"));
}
public void StatsCanHaveMaximumValuesThatClampTheResult()
{
var stat = new BasicStat("Stat 1");
stat.Maximum = 29;
var mod = new ValueStatModifier(30);
stat.AddModifier(mod);
Assert.Equal(stat.TotalValue, 29);
}
//Constructor
/// <summary>
/// Creates an initialized instance.
/// </summary>
/// <param name="role">The role of the synapses.</param>
public SynapseStat(Synapse.SynRole role)
{
Role = role;
Count = 0;
Distance = new BasicStat();
Delay = new BasicStat();
Weight = new BasicStat();
Efficacy = new StandardStatSet();
return;
}
//Constructors
/// <summary>
/// Creates an uninitialized instance.
/// </summary>
/// <param name="unitCfg">The configuration of the readout unit.</param>
/// <param name="unitIndex">An index of the readout unit within the readout layer.</param>
/// <param name="memberIndex">An index within the "One Takes All" group.</param>
public MemberErrorStat(ReadoutUnitSettings unitCfg, int unitIndex, int memberIndex)
{
UnitCfg = (ReadoutUnitSettings)unitCfg.DeepClone();
UnitIndex = unitIndex;
MemberIndex = memberIndex;
ErrStat = new BasicStat();
NumOfCorrectButBellowBorderSelections = 0;
NumOfOverbeatedAboveBorderRawProbabilities = 0;
return;
}
