private void Test_Add_ChainAdd()
{
var a = new Modifier(); //0, 0
var b = new Modifier(2); //2, 2
var c = new Modifier(always1, rolld4, 1); //2, 3
var d = new Modifier(always1, new List <RollType>()
{
RollType.d12, RollType.d12
}, 3); //5, 7
var e = new Modifier(always1, new List <RollType>()
{
RollType.d20, RollType.d20, RollType.d20
}, 2); //5, 8
IModifier res = null;
Assert.DoesNotThrow(() => res = a.Add(b));
Assert.DoesNotThrow(() => res = res.Add(c));
Assert.DoesNotThrow(() => res = res.Add(d));
Assert.DoesNotThrow(() => res = res.Add(e));
Assert.IsNotNull(res);
Assert.AreEqual(14, res.Get()); //0+2+2+5+5 = 14
Assert.AreEqual(20, res.GetCrit()); //0+2+3+7+8 = 20
}
public override void AddToUI(IModifier m)
{
modifier_ = m as StorableModifier;
if (modifier_ == null)
{
return;
}
var p = modifier_?.Parameter;
if (p == null)
{
parameterUI_ = null;
}
else
{
if (parameterUI_ == null ||
parameterUI_.ParameterType != p.GetFactoryTypeName())
{
parameterUI_ = CreateParameterMonitorUI(p);
}
}
if (parameterUI_ != null)
{
parameterUI_.AddToUI(p);
widgets_.AddToUI(new SmallSpacer(Widget.Right));
}
base.AddToUI(m);
}
/// <summary>
/// Adds an object space modifier to provided node (by handle).
/// </summary>
/// <param name="nodeHandle"> Input the node handle to add the modifier to. </param>
/// <param name="cid"> Input the class id of the modifier add. </param>
/// <returns> Returns 1 if successful or -1 if not. </returns>
static public int AddOsmModifier(uint nodeHandle, IClass_ID cid)
{
try
{
IGlobal global = Autodesk.Max.GlobalInterface.Instance;
IInterface14 ip = global.COREInterface14;
IINode node = ip.GetINodeByHandle(nodeHandle);
IObject obj = node.ObjectRef;
IIDerivedObject dobj = global.CreateDerivedObject(obj);
object objMod = ip.CreateInstance(SClass_ID.Osm, cid as IClass_ID);
IModifier mod = (IModifier)objMod;
dobj.AddModifier(mod, null, 0); // top of stack
node.ObjectRef = dobj;
}
catch (Exception ex)
{
Debug.Print(ex.Message);
return(-1);
}
return(1);
}
public CreateUserHandler(IRepositoryWrapper repositoryWrapper, IMapper mapper,
IServiceWrapper serviceWrapper, IModifier <AppUser, CreateUserCommand> modifier)
: base(repositoryWrapper, mapper, modifier)
{
_serviceWrapper = serviceWrapper;
_modifier = modifier;
}
public void AddModifier(IModifier modifier, double movesCount)
{
if (Modifiers.Contains(modifier))
{
Modifiers[modifier] = (double)movesCount;
}
else
{
Modifiers.Add(modifier, (double)movesCount);
if (modifier is IDamageModifier)
{
_metaUnit.damage = ((IDamageModifier)modifier).ModifyDamage(_metaUnit.damage);
}
if (modifier is IAttackModifier)
{
_metaUnit.attack = ((IAttackModifier)modifier).ModifyAttack(_metaUnit.attack);
}
if (modifier is IDefenseModifier)
{
_metaUnit.defence = ((IDefenseModifier)modifier).ModifyDefense(_metaUnit.defence);
}
if (modifier is IHitPointsModifier)
{
uint newHitPoints = ((IHitPointsModifier)modifier).ModifyHitPoints(_metaUnit.hitPoints);
initHitPoints = newHitPoints * unitsCount;
totalHitPoints = (uint)(Math.Floor((double)totalHitPoints / (double)_metaUnit.hitPoints) * newHitPoints + totalHitPoints % _metaUnit.hitPoints);
_metaUnit.hitPoints = newHitPoints;
}
if (modifier is IInitiativeModifier)
{
_metaUnit.initiative = ((IInitiativeModifier)modifier).ModifyInitiative(_metaUnit.initiative);
}
}
}
private int GetCritDamage(IModifier mod)
{
return(DamageDice.Select(x => Rng.Roll(x) +
Rng.Roll(x)) //x2 because crit!
.Sum() +
mod.GetCrit());
}
public virtual void AddToUI(IModifier m)
{
modifier_ = m;
widgets_.AddToUI(calls_);
if (m?.ModifierSync == null)
{
syncMonitor_ = null;
}
else
{
if (syncMonitor_ == null ||
syncMonitor_.SyncType != m.ModifierSync.GetFactoryTypeName())
{
syncMonitor_ = CreateSyncMonitor(
m?.ModifierSync, Widget.Right);
}
}
if (syncMonitor_ != null)
{
syncMonitor_.AddToUI(m.ModifierSync);
}
widgets_.AddToUI(timeRemaining_);
}
public bool RemoveModifier(IModifier modifier)
{
bool result = false;
List <int> toRemove = new List <int>();
foreach (KeyValuePair <int, List <IModifier> > pair in modifiers)
{
if (pair.Value.Contains(modifier))
{
pair.Value.Remove(modifier);
if (pair.Value.Count == 0)
{
toRemove.Add(pair.Key);
}
result = true;
break;
}
}
foreach (int level in toRemove)
{
modifiers.Remove(level);
}
return(result);
}
public static bool Export_To(string _filepath)
{
List <IINode> nodes = GetSelection();
foreach (IINode _node in nodes)
{
IIDerivedObject _gObject = (IIDerivedObject)_node.ObjectRef;
IClass_ID classID = maxGlobal.Class_ID.Create((uint)BuiltInClassIDA.TRIOBJ_CLASS_ID, 0);
ITriObject _mObject = (ITriObject)_gObject.ObjRef.ConvertToType(0, classID);
IMesh _mMesh = _mObject.Mesh;
_mMesh.BuildNormals();
IIDerivedObject theObj = (IIDerivedObject)_node.ObjectRef;
for (int m = 0; m < theObj.Modifiers.Count; m++)
{
IModifier theModifier = theObj.GetModifier(m);
if (theModifier.ClassName == "Skin")
{
IISkin _skin = (IISkin)theModifier.GetInterface((InterfaceID)(0x00010000));
IISkinContextData _skinContext = _skin.GetContextInterface(_node);
ComputeVertexData(_mMesh, _skinContext, semantic, _filepath);
}
}
}
return(true);
}
private IModifierMonitor CreateModifierMonitor(IModifier m)
{
if (m is RigidbodyModifier)
{
return(new RigidbodyModifierMonitor());
}
else if (m is MorphModifier)
{
return(new MorphModifierMonitor());
}
else if (m is LightModifier)
{
return(new LightModifierMonitor());
}
else if (m is AudioModifier)
{
return(new AudioModifierMonitor());
}
else if (m is EyesModifier)
{
return(new EyesModifierMonitor());
}
else if (m is StorableModifier)
{
return(new StorableModifierMonitor());
}
else if (m is StepExtenderModifier)
{
return(new StepExtenderModifierMonitor());
}
else
{
return(null);
}
}
public AttackSummary Shoot(IEnemy enemy, CombatStats combatStats)
{
ValidateShoot(enemy, combatStats);
int hitRoll = Rng.Roll(RollType.d20);
AttackSummary summary;
if (ShotMisfired(hitRoll))
{
HandleMisfire();
summary = GetMisfireAttackSummary();
}
else
{
IModifier finalHitMod = HitModifier.Add(combatStats.HitModifier);
IModifier finalDmgMod = DamageModifier.Add(combatStats.DamageModifier);
summary = HandleShoot(enemy,
hitRoll,
finalHitMod,
finalDmgMod,
combatStats.CritValue);
}
DecrementCurrentAmmo();
return(summary);
}
public virtual void OnNext(IModifier value)
{
try
{
var scenario = _rules.Advise(value);
_bus.OnNext(scenario);
var postScenario = _rules.PostProcessing();
_bus.OnNext(postScenario);
IInfo gameStatus = _rules.ReportGameStatus();
_infoChannel.OnNext(gameStatus);
}
catch (InvalidOperationException ex)
{
IErrorInfo info = new ErrorInfo();
info.Error = ex;
info.Message = "Invalid move: " + ex.Message;
_infoChannel.OnNext(info);
}
catch (Exception ex)
{
OnError(ex);
}
}
public void AddModifier(IModifier modifier)
{
if (modifier != null)
{
this.modifiers.Add(modifier);
}
}
public override void AddToTopUI(IModifier m)
{
base.AddToTopUI(m);
modifier_ = m as AudioModifier;
if (modifier_ == null)
{
return;
}
delayWidgets_.SetValue(modifier_.Delay);
clips_.Value = modifier_.Clips;
delayCollapsible_.Clear();
delayCollapsible_.Add(delayWidgets_.GetWidgets());
AddAtomWidgets(m);
widgets_.AddToUI(playType_);
playType_.Value = PlayTypeToString(modifier_.PlayType);
delayCollapsible_.AddToUI();
widgets_.AddToUI(new SmallSpacer(Widget.Right));
widgets_.AddToUI(stop_);
widgets_.AddToUI(clips_);
}
public void Remove(IModifiable modifiable, IModifier modifier)
{
ModifierMap modifiers = FindOrCreateModifierDictionary(modifiable);
List <IModifier> modifierList = FindOrCreateModifierList(modifiers, modifier.ModifierType);
modifierList.Remove(modifier);
}
private void ResolveModifier()
{
if (ParentModifier?.ParentStep == null)
{
return;
}
if (modifierIndex_ == -1 && modifier_ != null)
{
modifierIndex_ = ParentModifier.ParentStep.IndexOfModifier(modifier_);
}
else if (modifierIndex_ >= 0 && modifier_ == null)
{
var mods = ParentModifier.ParentStep.Modifiers;
if (modifierIndex_ >= 0 && modifierIndex_ < mods.Count)
{
modifier_ = mods[modifierIndex_].Modifier;
}
}
if (modifier_ == ParentModifier)
{
Synergy.LogError("OtherModifierSyncedModifier: same modifiers");
modifier_ = null;
modifierIndex_ = -1;
}
}
public void AddModifier(TriggerMode mode, IModifier modifier)
{
if (modifier != null)
{
this.modifiers[mode].Add(modifier.Name, modifier);
}
}
public ModifyRecordingForm(IModifier recorder, int bpm)
{
this.recorder = recorder;
this.bpm = bpm;
InitializeComponent();
// set ComboBox elements
shiftSelectorComboBox.Items.AddRange(new string[]
{
"Octave up", "Major seventh up", "Minor seventh up", "Major sixth up", "Minor sixth up",
"Perfect fifth up", "Tritone up", "Perfect fourth up", "Major third up", "Minor third up",
"Major second up", "Minor second up", "Unison", "Minor second down", "Major second down",
"Minor third down", "Major third down", "Perfect fourth down", "Tritone down", "Perfect fifth down",
"Minor sixth down", "Major sixth down", "Minor seventh down", "Major seventh down", "Octave down"
});
majMinSelector.Items.AddRange(new string[] { "Minor", "Major", "N/A" });
scaleSelector.Items.AddRange(new string[]
{
"C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B", "N/A"
});
chordProgSelector.Items.AddRange(new string[]
{
"ii - v - i", "i - iv - v", "i - v - vi - iv", "i - vi - iv - v", "i - v - i - iv", "vi - v - iv - iii", "N/A"
});
}
public void RemoveModifier(IModifier modifier)
{
if (_modifiers.Remove(modifier))
{
OnModifierRemoved?.Invoke(this, modifier);
}
}
public PlayerStatus(Rng rng,
IPlayer player)
{
Assert.IsNotNull(player);
Assert.IsNotNull(rng);
HasMisfireReaction = true;
CurrentSpell = MagicInitiateSpell.None;
NumberOfShots = 0;
NumberOfHits = 0;
NumberOfShotsLostToMisfire = 0;
NumberOfCrits = 0;
NumberOfTurnsPassed = 0;
ActionSurgeAvailable = true;
ActionAvailable = true;
BonusActionAvailable = true;
OffhandAttackAvailable = false;
Rng = rng;
PlayerBase = player;
spellHitMod = null;
spellDmgMod = null;
usedMfReactionThisTurn = false;
MainHand = new GunStatus(Rng, player.MainHand);
OffHands = player.OffHands.Select(x => (IGunStatus)(new GunStatus(Rng, x))).ToList();
CurrentOffHand = OffHands.FirstOrDefault();
}
public void TaskOnFinish(IModifier <T> modifier, T item)
{
if (EndLoopAction != null)
{
EndLoopAction(this);
}
if (loopCount == LOOP_CONTINUE)
{
secondsElapsed = 0;
modifier.Reset();
}
else
{
this.loop++;
if (this.loop >= this.loopCount)
{
this.isFinish = true;
this.finishedCached = true;
this.ModifierFinish(item);
}
else
{
this.secondsElapsed = 0;
this.modifier.Reset();
}
}
}
public override void AddToUI(IModifier m)
{
modifier_ = m as EyesModifier;
if (modifier_ == null)
{
return;
}
widgets_.AddToUI(current_);
widgets_.AddToUI(currentPos_);
widgets_.AddToUI(head_);
widgets_.AddToUI(eyes_);
widgets_.AddToUI(saccade_);
foreach (var w in saccadeTime_.GetWidgets())
{
widgets_.AddToUI(w);
}
widgets_.AddToUI(saccadeMin_);
widgets_.AddToUI(saccadeMax_);
foreach (var w in focusDuration_.GetWidgets())
{
widgets_.AddToUI(w);
}
widgets_.AddToUI(currentfocusDuration_);
widgets_.AddToUI(focusDurationProgress_);
widgets_.AddToUI(minDistance_);
base.AddToUI(m);
}
public override void AddToTopUI(IModifier m)
{
modifier_ = m as LightModifier;
if (modifier_ == null)
{
return;
}
property_.Value = modifier_.Property;
AddAtomWidgets(m);
widgets_.AddToUI(property_);
if (modifier_ != null)
{
var clp = modifier_.Property as ColorLightProperty;
if (clp != null)
{
color1_.Value = clp.Color1;
color2_.Value = clp.Color2;
widgets_.AddToUI(color1_);
widgets_.AddToUI(color2_);
}
}
AddAtomWithMovementWidgets(m);
base.AddToTopUI(m);
}
private void RemoveModifier(IModifier modifier)
{
_doNotUpdate.Value = modifier;
_modifiers.Remove(modifier);
modifier.Owner.RemoveModifier(modifier);
}
public void ApplyModifierChangeToDownward(string targetPlayerName, IModifier m, bool isRemoving, bool isFromSaveData)
{
if (targetPlayerName.ToLower() != "global" && targetPlayerName != OwnPlayer.PlayerName)
{
TileMap.ApplyModifierChangeToTileObjects(targetPlayerName, m, isRemoving, isFromSaveData, null);
return;
}
// Tiled modifier cannot affect the target type itself.
if (m is TiledModifier && m.TargetType == TypeName)
{
TileMap.ApplyModifierChangeToTileObjects(targetPlayerName, m, isRemoving, isFromSaveData, null);
return;
}
if (isRemoving)
{
m.OnRemoved(this);
RemoveTriggerEvent(m.Name);
}
else
{
if (!isFromSaveData)
{
m.OnAdded(this);
}
RegisterTriggerEvent(m.Name, m.GetTriggerEvent(this));
}
TileMap.ApplyModifierChangeToTileObjects(targetPlayerName, m, isRemoving, isFromSaveData, null);
}
public static string GetModifierGUIName(IModifier m)
{
CustomModifier attr =
m.GetType().GetCustomAttributes(typeof(CustomModifier), false).FirstOrDefault() as CustomModifier;
return(attr.Name);
}
private void UpdateModifier(IModifier modifier)
{
VenusParticleEngine.Core.Modifiers.ScaleInterpolator2 currentModifier = (VenusParticleEngine.Core.Modifiers.ScaleInterpolator2)modifier;
Vector initial = new Vector(0, 0);
Vector final = new Vector(0, 0);
if (_inputInitialX.Value != null && !_inputInitialX.Value.Equals("") && !_inputInitialX.Value.Equals("-"))
{
initial.X = float.Parse(_inputInitialX.Value.Replace(".", ","));
}
if (_inputInitialY.Value != null && !_inputInitialY.Value.Equals("") && !_inputInitialY.Value.Equals("-"))
{
initial.Y = float.Parse(_inputInitialY.Value.Replace(".", ","));
}
if (_inputFinalX.Value != null && !_inputFinalX.Value.Equals("") && !_inputFinalX.Value.Equals("-"))
{
final.X = float.Parse(_inputFinalX.Value.Replace(".", ","));
}
if (_inputFinalY.Value != null && !_inputFinalY.Value.Equals("") && !_inputFinalY.Value.Equals("-"))
{
final.Y = float.Parse(_inputFinalY.Value.Replace(".", ","));
}
currentModifier.InitialScale = initial;
currentModifier.FinalScale = final;
_modifiers[key] = currentModifier;
}
public void RemoveModifier(IModifier modifier)
{
if (modifier is IDamageModifier)
{
_metaUnit.damage = ((IDamageModifier)modifier).UnmodifyDamage(_metaUnit.damage);
}
if (modifier is IAttackModifier)
{
_metaUnit.attack = ((IAttackModifier)modifier).UnmodifyAttack(_metaUnit.attack);
}
if (modifier is IDefenseModifier)
{
_metaUnit.defence = ((IDefenseModifier)modifier).UnmodifyDefense(_metaUnit.defence);
}
if (modifier is IHitPointsModifier)
{
uint newHitPoints = ((IHitPointsModifier)modifier).UnmodifyHitPoints(_metaUnit.hitPoints);
initHitPoints = unitsCount * newHitPoints;
totalHitPoints = (uint)(Math.Floor((double)totalHitPoints / (double)_metaUnit.hitPoints) * newHitPoints + totalHitPoints % _metaUnit.hitPoints);
_metaUnit.hitPoints = newHitPoints;
}
if (modifier is IInitiativeModifier)
{
_metaUnit.initiative = ((IInitiativeModifier)modifier).UnmodifyInitiative(_metaUnit.initiative);
}
Modifiers.Remove(modifier);
}
/// <summary>
/// Adds the Shell modifier to the provided node (by handle).
/// </summary>
/// <param name="nodeHandle"> Input the node handle to add the modifier to. </param>
/// <param name="shellAmount"> Input the amount of shell thickness as float. </param>
/// <returns> Returns 1 if successful or -1 if not. </returns>
static public int AddOsmShell(uint nodeHandle, float shellAmount)
{
try
{
IGlobal global = Autodesk.Max.GlobalInterface.Instance;
IInterface14 ip = global.COREInterface14;
IClass_ID cidOsmShell = global.Class_ID.Create(0x3b9b1a16, 0x6d84e8d0);
AddOsmModifier(nodeHandle, cidOsmShell);
IINode node = ip.GetINodeByHandle(nodeHandle);
IModifier mod = GetModifier(node, cidOsmShell);
if (mod != null)
{
IIParamBlock2 pb = mod.GetParamBlock(0);
pb.SetValue(0, 0, shellAmount, 0); // innerAmount parameter is at index zero of the parameter block.
}
}
catch (Exception ex)
{
Debug.Print(ex.Message);
return(-1);
}
return(1);
}
public void AddModifier(IModifier modifier)
{
if (modifier != null)
{
this.modifiers.Add(modifier);
}
}
private AttackSummary HandleShoot(IEnemy enemy,
int hitRoll,
IModifier hitMod,
IModifier dmgMod,
int critValue)
{
int attackResult = hitRoll + hitMod.Get();
bool crit = Crit(critValue, hitRoll);
int damageDone = 0;
bool hit = false;
if (crit)
{
enemy.CritHit();
damageDone = GetCritDamage(dmgMod);
enemy.TakeDamage(damageDone);
hit = true;
}
else
{
if (enemy.TryHit(attackResult))
{
damageDone = GetDamage(dmgMod);
enemy.TakeDamage(damageDone);
hit = true;
}
}
return(new AttackSummary(attackResult, damageDone, hit, crit));
}
private int GetDamage(IModifier mod)
{
int dmgDieResult = DamageDice.Select(x => Rng.Roll(x))
.Sum();
int x = mod.Get();
return(dmgDieResult + x);
}
public void RemoveModifier(IModifier modifier)
{
if (modifier == null)
{
return;
}
this.modifiers.Remove(modifier);
}
public void AddModifer(IModifier modifier)
{
if (modifier == null)
{
throw new ArgumentNullException(nameof(modifier), "You can not provide a null modifier to this race.");
}
if (this.modifiers.Contains(modifier))
{
return;
}
this.modifiers.Add(modifier);
}
public void RemoveModifier(IModifier modifier)
{
if (modifier == null)
{
throw new ArgumentNullException(nameof(modifier), "Modifier argument can not be null.");
}
if (this.Modifiers == null)
{
this.Modifiers = new List<IModifier>();
}
this.Modifiers.Remove(modifier);
}
public ParticleEmitter(int capacity, TimeSpan term, Profile profile)
{
if (profile == null)
throw new ArgumentNullException(nameof(profile));
_term = (float)term.TotalSeconds;
Buffer = new ParticleBuffer(capacity);
Offset = new Vector2();
Profile = profile;
Modifiers = new IModifier[0];
ModifierExecutionStrategy = ParticleModifierExecutionStrategy.Serial;
Parameters = new ParticleReleaseParameters();
}
public void AddModifer(IModifier modifier)
{
if (modifier == null)
{
throw new ArgumentNullException(nameof(modifier), "Modifier argument can not be null.");
}
if (this.Modifiers == null)
{
this.Modifiers = new List<IModifier>();
}
if (this.Modifiers.Contains(modifier))
{
return;
}
this.Modifiers.Add(modifier);
}
public IScenario Advise(IModifier modifier)
{
if (_judge.ContainsKey(modifier.GetType()))
{
return _judge[modifier.GetType()](modifier);
}
else
{
throw new InvalidOperationException("Not supported modifier {modifier}.");
}
}
void IModifiable.RemoveModifier(IModifier modifier)
{
RemoveModifier((IPlayerModifier)modifier);
}
void IModifiable.RemoveModifier(IModifier modifier)
{
RemoveModifier((ICardModifier)modifier);
}
// ===========================================================
// Getter & Setter
// ===========================================================
// ===========================================================
// Methods for/from SuperClass/Interfaces
// ===========================================================
public /* override */ virtual void AddBackgroundModifier(IModifier<IBackground> pBackgroundModifier)
{
this.mBackgroundModifiers.Add(pBackgroundModifier);
}
private IModifier[] ParseModifiers()
{
IModifier[] result = new IModifier[MODIFIERS_COUNT];
m_parser.AssertNextTokenTypeAndConsume(JsonParser.TokenType.ArrayStart);
for (int i = 0; i < MODIFIERS_COUNT; ++i)
{
result[i] = ParseModifier(m_parser.GetNextStringValue());
}
m_parser.AssertNextTokenTypeAndConsume(JsonParser.TokenType.ArrayEnd);
return result;
}
public bool RemoveModifier(IModifier modifier)
{
bool removed = false;
if (modifier != null)
{
foreach (var mode in this.modifiers.Keys)
{
if (this.modifiers[mode].ContainsValue(modifier))
{
this.modifiers[mode].Remove(modifier.Name);
removed = true;
}
}
}
return removed;
}
public static string GetModifierGUIName(IModifier m)
{
CustomModifier attr =
m.GetType().GetCustomAttributes(typeof(CustomModifier), false).FirstOrDefault() as CustomModifier;
return attr.Name;
}
public void AddModifier(IModifier<ICharacter> modifier)
{
//TODO : Check that this still works.
//if (!_modifiers.Exists(i => i.Name == modifier.Name))
//{
modifier.Apply(this);
_modifiers.Add(modifier);
//}
}
public void AcceptOnLevel(IModifier<ICharacter> modifier)
{
if (Experience.Level <= Experience.MaxLevel) {
modifier.ModifyOnLevel(this);
} else {
throw new InvalidOperationException("The character must be able to level to be modified by ModifyOnLevel");
}
}
public void AcceptOnCreation(IModifier<ICharacter> modifier)
{
if (IsNew) {
modifier.ModifyOnCreation(this);
} else {
throw new InvalidOperationException("Only a new character can be modified with ModifyOnCreation");
}
}
public void OnNext(IModifier value)
{
value.Modify();
}
private void DoInspectorModifierGUI(NodeGUI node)
{
EditorGUILayout.HelpBox("Modifier: Modify asset settings.", MessageType.Info);
UpdateNodeName(node);
GUILayout.Space(10f);
using (new EditorGUILayout.VerticalScope(GUI.skin.box)) {
Type incomingType = FindIncomingAssetType(node.Data.InputPoints[0]);
if(incomingType == null) {
// if there is no asset input to determine incomingType,
// retrieve from assigned Modifier.
incomingType = ModifierUtility.GetModifierTargetType(node.Data.ScriptClassName);
if(incomingType == null) {
EditorGUILayout.HelpBox("Modifier needs a single type of incoming assets.", MessageType.Info);
return;
}
}
var map = ModifierUtility.GetAttributeClassNameMap(incomingType);
if(map.Count > 0) {
using(new GUILayout.HorizontalScope()) {
GUILayout.Label("Modifier");
var guiName = ModifierUtility.GetModifierGUIName(node.Data.ScriptClassName);
if (GUILayout.Button(guiName, "Popup", GUILayout.MinWidth(150f))) {
var builders = map.Keys.ToList();
if(builders.Count > 0) {
NodeGUI.ShowTypeNamesMenu(guiName, builders, (string selectedGUIName) =>
{
using(new RecordUndoScope("Change Modifier class", node, true)) {
m_modifier = ModifierUtility.CreateModifier(selectedGUIName, incomingType);
if(m_modifier != null) {
node.Data.ScriptClassName = ModifierUtility.GUINameToClassName(selectedGUIName, incomingType);
node.Data.InstanceData[currentEditingGroup] = m_modifier.Serialize();
}
}
}
);
}
}
}
} else {
string[] menuNames = AssetBundleGraphSettings.GUI_TEXT_MENU_GENERATE_MODIFIER.Split('/');
EditorGUILayout.HelpBox(
string.Format(
"No CustomModifier found for {3} type. \n" +
"You need to create at least one Modifier script to select script for Modifier. " +
"To start, select {0}>{1}>{2} menu and create a new script.",
menuNames[1],menuNames[2], menuNames[3], incomingType.FullName
), MessageType.Info);
}
GUILayout.Space(10f);
if(DrawPlatformSelector(node)) {
// if platform tab is changed, renew modifierModifierInstance for that tab.
m_modifier = null;
}
using (new EditorGUILayout.VerticalScope()) {
var disabledScope = DrawOverrideTargetToggle(node, node.Data.InstanceData.ContainsValueOf(currentEditingGroup), (bool enabled) => {
if(enabled) {
node.Data.InstanceData[currentEditingGroup] = node.Data.InstanceData.DefaultValue;
} else {
node.Data.InstanceData.Remove(currentEditingGroup);
}
m_modifier = null;
});
using (disabledScope) {
//reload modifierModifier instance from saved modifierModifier data.
if (m_modifier == null) {
m_modifier = ModifierUtility.CreateModifier(node.Data, currentEditingGroup);
if(m_modifier != null) {
node.Data.ScriptClassName = m_modifier.GetType().FullName;
if(node.Data.InstanceData.ContainsValueOf(currentEditingGroup)) {
node.Data.InstanceData[currentEditingGroup] = m_modifier.Serialize();
}
}
}
if (m_modifier != null) {
Action onChangedAction = () => {
using(new RecordUndoScope("Change Modifier Setting", node)) {
node.Data.ScriptClassName = m_modifier.GetType().FullName;
if(node.Data.InstanceData.ContainsValueOf(currentEditingGroup)) {
node.Data.InstanceData[currentEditingGroup] = m_modifier.Serialize();
}
}
};
m_modifier.OnInspectorGUI(onChangedAction);
}
}
}
}
}
public void OnNext(IModifier value)
{
_broadcaster.OnNext(value);
}
public /* override */ virtual bool RemoveBackgroundModifier(IModifier<IBackground> pBackgroundModifier)
{
return this.mBackgroundModifiers.Remove(pBackgroundModifier);
}
public ParticleEffect2DFactory AddModifier(IModifier modifier)
{
particleEffect.Modifiers.Add(modifier);
return this;
}
public static Type GetModifierTargetType(IModifier m)
{
CustomModifier attr =
m.GetType().GetCustomAttributes(typeof(CustomModifier), false).FirstOrDefault() as CustomModifier;
UnityEngine.Assertions.Assert.IsNotNull(attr);
return attr.For;
}
public void AddModifier(IModifier modifier)
{
}
public void AddModifier(TriggerMode mode, IModifier modifier)
{
if (modifier != null)
{
this.modifiers[mode].Add(modifier.Name, modifier);
}
}
public void RemoveModifier(IModifier modifier)
{
}
public virtual void LoadModifier(IModifier modifier)
{
Modifier = modifier;
FireRate *= Modifier.FireRateMod;
cost *= Modifier.CostMod;
}
public PermanentModifiedEvent(Card card, IModifier modifier)
{
Card = card;
Modifier = modifier;
}
internal Modifier(IModifier x) : base(x) { }
private string DoModifier(IModifier modifier)
{
return modifier.ApplyModifier(Crafter.TheCrafter, Craft.TheCraft) + Environment.NewLine;
}
