void SetEffectEntry(EffectEntry entry)
{
if (!IsSetup)
{
return;
}
// Assign effect template based on entry key
EffectTemplate = GameManager.Instance.EntityEffectBroker.GetEffectTemplate(entry.Key);
if (EffectTemplate == null)
{
throw new Exception(string.Format("SetEffectEntry() could not find effect key {0}", entry.Key));
}
// Assign settings to spinners
durationBaseSpinner.Value = entry.Settings.DurationBase;
durationPlusSpinner.Value = entry.Settings.DurationPlus;
durationPerLevelSpinner.Value = entry.Settings.DurationPerLevel;
chanceBaseSpinner.Value = entry.Settings.ChanceBase;
chancePlusSpinner.Value = entry.Settings.ChancePlus;
chancePerLevelSpinner.Value = entry.Settings.ChancePerLevel;
magnitudeBaseMinSpinner.Value = entry.Settings.MagnitudeBaseMin;
magnitudeBaseMaxSpinner.Value = entry.Settings.MagnitudeBaseMax;
magnitudePlusMinSpinner.Value = entry.Settings.MagnitudePlusMin;
magnitudePlusMaxSpinner.Value = entry.Settings.MagnitudePlusMax;
magnitudePerLevelSpinner.Value = entry.Settings.MagnitudePerLevel;
}
void SetDefaults()
{
allowedTargets = defaultTargetFlags;
allowedElements = defaultElementFlags;
selectedIcon = new SpellIcon()
{
index = defaultSpellIcon,
};
editOrDeleteSlot = -1;
for (int i = 0; i < maxEffectsPerSpell; i++)
{
effectEntries[i] = new EffectEntry();
}
if (IsSetup)
{
effect1NameLabel.Text = string.Empty;
effect2NameLabel.Text = string.Empty;
effect3NameLabel.Text = string.Empty;
spellNameLabel.Text = string.Empty;
UpdateAllowedButtons();
SetIcon(selectedIcon);
SetStatusLabels();
}
}
EffectEntry GetEffectEntry()
{
// Must have an effect template set
if (EffectTemplate == null)
{
throw new Exception(noEffectTemplateError);
}
// Create settings for effect
EffectSettings effectSettings = new EffectSettings();
if (IsSetup)
{
// Assign from UI control when setup
effectSettings.DurationBase = durationBaseSpinner.Value;
effectSettings.DurationPlus = durationPlusSpinner.Value;
effectSettings.DurationPerLevel = durationPerLevelSpinner.Value;
effectSettings.ChanceBase = chanceBaseSpinner.Value;
effectSettings.ChancePlus = chancePlusSpinner.Value;
effectSettings.ChancePerLevel = chancePerLevelSpinner.Value;
effectSettings.MagnitudeBaseMin = magnitudeBaseMinSpinner.Value;
effectSettings.MagnitudeBaseMax = magnitudeBaseMaxSpinner.Value;
effectSettings.MagnitudePlusMin = magnitudePlusMinSpinner.Value;
effectSettings.MagnitudePlusMax = magnitudePlusMaxSpinner.Value;
effectSettings.MagnitudePerLevel = magnitudePerLevelSpinner.Value;
}
// Create entry
EffectEntry effectEntry = new EffectEntry();
effectEntry.Key = EffectTemplate.Key;
effectEntry.Settings = effectSettings;
return(effectEntry);
}
private void PopulateStore()
{
List <EffectEntry> effects = new List <EffectEntry>();
foreach (Type i in Registry.EffectTypes)
{
EffectEntry entry = EffectEntry.Create(i);
if (entry != null)
{
effects.Add(entry);
}
}
EffectEntry.Sort(effects);
string category = null;
TreeIter node = TreeIter.Zero;
foreach (EffectEntry i in effects)
{
if (i.Category != category)
{
category = i.Category;
node = this.mEffectStore.AppendValues(new CategoryDivider(category));
}
this.mEffectStore.AppendValues(node, i);
}
}
public void LoadFromItem(EffectEntry effectEntry)
{
loadingInternally = true;
try
{
if (effectEntry.EffectKind == EffectKind.Animation)
{
rbAnimation.IsChecked = true;
LoadFromTarget(effectEntry.AnimationEffect.target);
}
else if (effectEntry.EffectKind == EffectKind.Emitter)
{
rbEmitter.IsChecked = true;
LoadFromTarget(effectEntry.EmitterEffect.target);
}
else if (effectEntry.EffectKind == EffectKind.SoundEffect)
{
rbSoundEffect.IsChecked = true;
}
LoadFromAnimation(effectEntry.AnimationEffect);
LoadFromEmitter(effectEntry.EmitterEffect);
LoadFromSoundEffect(effectEntry.SoundEffect);
}
finally
{
loadingInternally = false;
}
}
public override void LoadXML(XmlNode element, FileVersion version)
{
try {
base.LoadXML(element, version);
ImageName = ReadElement(element, "ImageName");
ItmKind = (ItemKind)Enum.Parse(typeof(ItemKind), ReadElement(element, "Kind"));
string signs = ReadElement(element, "Signs");
Flags = new ItemFlags(signs);
string newSigns = Flags.Signature;
if (!signs.Equals(newSigns))
{
throw new Exception("ItemSigns not equals (" + ImageName + ")");
}
EqKind = (BodypartType)Enum.Parse(typeof(BodypartType), ReadElement(element, "eqKind"));
Frequency = Convert.ToSByte(ReadElement(element, "Frequency"));
Satiety = Convert.ToInt16(ReadElement(element, "Satiety"));
Price = Convert.ToInt16(ReadElement(element, "Price"));
Weight = (float)ConvertHelper.ParseFloat(ReadElement(element, "Weight"), 0.0f, true);
XmlNode ael = element.SelectSingleNode("Attributes");
for (int i = ItemAttribute.ia_First; i <= ItemAttribute.ia_Last; i++)
{
string atSign = dbItemAttributes[i - 1];
Attributes[i - 1] = Convert.ToInt32(ReadElement(ael, atSign));
}
XmlNodeList nl = element.SelectSingleNode("Effects").ChildNodes;
Effects = new EffectEntry[nl.Count];
for (int i = 0; i < nl.Count; i++)
{
XmlNode n = nl[i];
Effects[i] = new EffectEntry();
Effects[i].EffID = (EffectID)Enum.Parse(typeof(EffectID), n.Attributes["EffectID"].InnerText);
Effects[i].ExtData = Convert.ToInt32(n.Attributes["ExtData"].InnerText);
}
nl = element.SelectSingleNode("Contents").ChildNodes;
Contents = new ContentsEntry[nl.Count];
for (int i = 0; i < nl.Count; i++)
{
XmlNode n = nl[i];
Contents[i] = new ContentsEntry();
Contents[i].ItemID = n.Attributes["ItemID"].InnerText;
Contents[i].Chance = Convert.ToInt32(n.Attributes["Chance"].InnerText);
}
Material = (MaterialKind)Enum.Parse(typeof(MaterialKind), ReadElement(element, "Material"));
FramesCount = Convert.ToSByte(ReadElement(element, "FramesCount"));
BonusRange.Min = Convert.ToInt32(ReadElement(element, "BonusRange_Min"));
BonusRange.Max = Convert.ToInt32(ReadElement(element, "BonusRange_Max"));
} catch (Exception ex) {
Logger.Write("ItemEntry.loadXML(): " + ex.Message);
throw ex;
}
}
void InitEffectSlots()
{
effectEntries = new EffectEntry[maxEffectsPerSpell];
for (int i = 0; i < maxEffectsPerSpell; i++)
{
effectEntries[i] = new EffectEntry();
}
}
private bool GetSelectedEffectEntry(out EffectEntry entry) {
entry = null;
TreeIter i;
if (!this.EffectList.Selection.GetSelected(out i))
return false;
entry = this.mEffectStore.GetValue(i, 0) as EffectEntry;
return entry != null;
}
void ClearPendingDeleteEffectSlot()
{
if (editOrDeleteSlot == -1)
{
return;
}
effectEntries[editOrDeleteSlot] = new EffectEntry();
UpdateSlotText(editOrDeleteSlot, string.Empty);
editOrDeleteSlot = -1;
UpdateAllowedButtons();
}
private bool GetSelectedEffectEntry(out EffectEntry entry)
{
entry = null;
TreeIter i;
if (!this.EffectList.Selection.GetSelected(out i))
{
return(false);
}
entry = this.mEffectStore.GetValue(i, 0) as EffectEntry;
return(entry != null);
}
TimeSpan GetEffectDuration(EffectEntry effectEntry)
{
switch (effectEntry.EffectKind)
{
case EffectKind.Animation:
return(GetAnimationDuration(effectEntry.AnimationEffect.spriteName));
case EffectKind.Emitter:
return(GetEmitterDuration(effectEntry.EmitterEffect));;
case EffectKind.SoundEffect:
return(GetSoundFileDuration(effectEntry.SoundEffect.soundFileName));
}
return(TimeSpan.FromSeconds(1));
}
private void EffectBuilder_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (loadingInternally)
{
return;
}
if (!(sender is EffectBuilder effectBuilder))
{
return;
}
EffectEntry effectEntry = effectBuilder.EffectEntry;
if (effectEntry == null)
{
return;
}
SetSelectedColorByEffectType(effectEntry.EffectKind);
if (effectBuilder.EffectKind == EffectKind.SoundEffect)
{
string soundFileName = effectEntry.SoundEffect.soundFileName;
AdjustSelectedEntryDuration(GetSoundFileDuration(soundFileName), true, soundFileName);
}
else if (effectBuilder.EffectKind == EffectKind.Animation)
{
AnimationEffect animationEffect = effectEntry.AnimationEffect;
TimeSpan duration = GetAnimationDuration(animationEffect.spriteName);
if (animationEffect.name != "")
{
AdjustSelectedEntryDuration(duration, false, animationEffect.name);
}
else
{
AdjustSelectedEntryDuration(duration, false, animationEffect.spriteName);
}
}
else if (effectBuilder.EffectKind == EffectKind.Emitter)
{
EmitterEffect emitterEffect = effectEntry.EmitterEffect;
TimeSpan duration = GetEmitterDuration(emitterEffect);
AdjustSelectedEntryDuration(duration, false, null);
}
OnPropertyChanged();
}
private void ResponseFeed(ScPetFeed msg)
{
if (msg == null)
{
return;
}
if (msg.response == 0)
{
ps.PlayUniformAnimToPreview(parentWindow.SelectPetInfo.GetExpProcess(), 1, Refresh);
if (curMatrial.ItemCache != null && curMatrial.ItemCache.num > 0)
{
var maxLimit = CalcLimitMax();
if (maxLimit == 0)
{
moduleGlobal.ShowMessage(9707);
}
ValueInput.SetLimit(1, (int)Mathf.Min(curMatrial.ItemCache.num, maxLimit));
}
else
{
ValueInput.SetLimit(0, 0);
}
ValueInput.SetValue(0);
RefreshFeedState();
var entry = new EffectEntry()
{
levelUp = levelUp
};
levelUp = false;
entry.coroutine = global::Root.instance.StartCoroutine(PlayEffect(entry));
effectEntryList.Add(entry);
}
else
{
moduleGlobal.ShowMessage(9702, msg.response);
Refresh();
}
}
private void CreateNewEffect(EffectKind effectKind)
{
EffectEntry newEffect = new EffectEntry(effectKind, GetEntryName());
TimeLineEntry entry = AddEntry(TimeSpan.Zero, TimeSpan.FromSeconds(1), GetEntryName(), newEffect);
entry.PropertyChanged += Entry_PropertyChanged;
tlEffects.SelectedItem = entry;
SetSelectedColorByEffectType(effectKind);
loadingInternally = true;
try
{
effectBuilder.EffectEntry = newEffect;
}
finally
{
loadingInternally = false;
}
OnPropertyChanged();
}
private IEnumerator PlayEffect(EffectEntry entry)
{
var t = flyEffect.GetChild(matrialDataSource.GetItemIndex(curMatrial.PropItem));
entry.go = PerfectInstantiate(t?.gameObject);
entry.go.SafeSetActive(true);
yield return(new WaitForSeconds(0.9f));
entry.go1 = PerfectInstantiate(feedEffect?.gameObject);
entry.go1.SafeSetActive(true);
if (entry.levelUp)
{
entry.levelUpEffect = PerfectInstantiate(levelUpEffect?.gameObject);
entry.levelUpEffect.SafeSetActive(true);
}
yield return(new WaitForSeconds(3));
entry.Destory();
effectEntryList.Remove(entry);
}
public void SaveToItem(EffectEntry effectEntry, string propertyName)
{
if (rbAnimation.IsChecked ?? false)
{
effectEntry.EffectKind = EffectKind.Animation;
if (propertyName != STR_EffectKind)
{
SaveToTarget(effectEntry.AnimationEffect.target);
}
else
{
LoadFromTarget(effectEntry.AnimationEffect.target);
}
}
if (rbEmitter.IsChecked ?? false)
{
effectEntry.EffectKind = EffectKind.Emitter;
effectEntry.EmitterEffect.effectKind = EffectKind.Emitter;
if (propertyName != STR_EffectKind)
{
SaveToTarget(effectEntry.EmitterEffect.target);
}
else
{
LoadFromTarget(effectEntry.EmitterEffect.target);
}
}
if (rbSoundEffect.IsChecked ?? false)
{
effectEntry.EffectKind = EffectKind.SoundEffect;
}
SaveToSound(effectEntry.SoundEffect);
SaveToAnimation(effectEntry.AnimationEffect);
SaveToEmitter(effectEntry.EmitterEffect);
}
void ClearEffectSlot(int slot)
{
effectEntries[slot] = new EffectEntry();
UpdateSlotText(slot, string.Empty);
UpdateAllowedButtons();
}
private EffectEntry ParseEffect()
{
EffectEntry eff = new EffectEntry();
while (_reader.ReadAttribute())
{
if (_reader.Name.Equals("id", true))
eff._id = (string)_reader.Value;
else if (_reader.Name.Equals("name", true))
eff._name = (string)_reader.Value;
}
while (_reader.BeginElement())
{
//Only common is supported
if (_reader.Name.Equals("profile_COMMON", true))
while (_reader.BeginElement())
{
if (_reader.Name.Equals("newparam", true))
eff._newParams.Add(ParseNewParam());
else if (_reader.Name.Equals("technique", true))
{
while (_reader.BeginElement())
{
if (_reader.Name.Equals("phong", true))
eff._shader = ParseShader(ShaderType.phong);
else if (_reader.Name.Equals("lambert", true))
eff._shader = ParseShader(ShaderType.lambert);
else if (_reader.Name.Equals("blinn", true))
eff._shader = ParseShader(ShaderType.blinn);
_reader.EndElement();
}
}
_reader.EndElement();
}
_reader.EndElement();
}
return eff;
}
public TimeLineEffect AddEntry(TimeSpan start, TimeSpan duration, string name, EffectEntry data)
{
TimeLineEffect timeLineEntry = new TimeLineEffect()
{
Start = start, Duration = duration, Name = name, Effect = data, Index = Entries.Count
};
Entries.Add(timeLineEntry);
return(timeLineEntry);
}
