public void Execute(SchemeExecutor executor) { ObjectVariable objectVariable = executor.GetVariableByName(characterName); ObjectVariable numberVariable = executor.FindValueByString(numberName); if (objectVariable == null) { throw SchemeExecutor.CreateException($"Character '{characterName}' not found"); } if (numberVariable.Type != VariableTypes.Number) { throw SchemeExecutor.CreateException($"Number is expected to be of type number"); } int requiredNumber = (int)numberVariable.Value; if (!(objectVariable.Value is Character)) { throw SchemeExecutor.CreateException("Items can only be added to characters"); } Character character = (Character)(objectVariable.Value); ObjectVariable itemVariable = executor.GetVariableByName(itemName); if (!executor.CheckTypeCompatibility(VariableTypes.Object, itemVariable.Type)) { throw SchemeExecutor.CreateException($"Type '{itemVariable.Type}' is not an object type"); } character.AddItem(executor.Game, (Object)itemVariable.Value, requiredNumber); }
public override object VisitParameter_definition([NotNull] scheme_langParser.Parameter_definitionContext context) { //Add parameter to scheme string type = context.variable_type()?.GetText(); string name = context.variable_name()?.GetText(); if (type == null || name == null) { return(base.VisitParameter_definition(context)); } if (CompiledScheme.GetVariableByName(name) != null || CompiledScheme.GetParameterByName(name) != null) { Errors.Add(new ErrorDescriptor($"Variable or parameter '{name}' already exists.", context.variable_name())); } else if (!VariableManager.IsTypeValid(type, Config)) { Errors.Add(new ErrorDescriptor($"Type '{type}' is not recognized.", context.variable_type())); } else { ObjectVariable param = new ObjectVariable(type, name, null); CompiledScheme.AddParameter(param); } return(base.VisitParameter_definition(context)); }
public ObjectVariable AddAbility(string abilityName) { var ability = new ObjectVariable(VariableTypes.Ability, abilityName, 0); Variables.Add(ability); return(ability); }
public void Execute(SchemeExecutor executor) { ObjectVariable @object = executor.GetVariableByName(objectName); ObjectVariable numberVariable = executor.FindValueByString(numberName); if (@object == null) { throw SchemeExecutor.CreateException($"Object '{objectName}' not found"); } if (numberVariable.Type != VariableTypes.Number) { throw SchemeExecutor.CreateException($"Number is expected to be of type number"); } int requiredNumber = (int)numberVariable.Value; if (!(@object.Value is Character)) { throw new SchemeExecutionException($"Object '{objectName}' is not a character"); } Character character = (Character)(@object.Value); int ownedNumber = character.CountItem(itemName); bool owns = ownedNumber >= requiredNumber; executor.SetVariable(targetName, new ObjectVariable(VariableTypes.Logical, "", owns)); }
public void Execute(SchemeExecutor executor) { ObjectVariable property = executor.GetPropertyOf(propertyName, objectName); ObjectVariable value = executor.FindValueByString(valueName); property.Value = value.Value; }
public void Execute(SchemeExecutor executor) { ObjectVariable objectVariable = executor.GetVariableByName(characterName); if (objectVariable == null) { throw SchemeExecutor.CreateException($"Character '{characterName}' not found"); } if (!(objectVariable.Value is Character)) { throw SchemeExecutor.CreateException("Spells can only be added to characters"); } Character character = (Character)(objectVariable.Value); ObjectVariable spellVariable = executor.GetVariableByName(spellName); if (!executor.CheckTypeCompatibility(VariableTypes.Object, spellVariable.Type)) { throw SchemeExecutor.CreateException($"Type '{spellVariable.Type}' is not an object type"); } character.AddSpell((Object)spellVariable.Value); }
public void SetVariable(string variableName, ObjectVariable value) { //Check if variable is a register if (IsRegister(variableName)) { //First we get value, and create register with same type and value Registers[variableName] = new ObjectVariable(value.Type, variableName, value.Value); } else { ObjectVariable variable = GetVariableByName(variableName); if (variable != null) { if (!CheckTypeCompatibility(variable.Type, value.Type, Game.Config)) { throw CreateException("Incompatible types"); } variable.Value = value.Value; } else { throw CreateException($"Unidentifyable variable '{variableName}'"); } } }
private void AddParams(Scheme scheme) { if (scheme?.CompiledScheme == null) { return; } foreach (var param in scheme.CompiledScheme.Parameters) { var value = Object.GetParameterByName(param.Name); if (value == null || value.Type != param.Type) { // if parameter's type changed, we delete the old and create a new if (value != null && value.Type != param.Type) { Object.Parameters.RemoveAll(p => p.Name == param.Name); } value = new ObjectVariable(param.Type, param.Name, null); Object.Parameters.Add(value); } var paramRow = ParameterRowFactory.Create(param, value, Project.Current.Config); paramRow.Margin = new Thickness(5, 5, 5, 5); spParams.Children.Add(paramRow); } }
protected override bool GetResult(ObjectVariable variable1, ObjectVariable variable2) { //In case of numbers and logicals we compare values if (variable1.Type == VariableTypes.Number) { if (variable2.Type != VariableTypes.Number) { throw SchemeExecutor.CreateException("Cannot compare number and non-number"); } int value1_int = (int)variable1.Value; int value2_int = (int)variable2.Value; return(value1_int == value2_int); } if (variable1.Type == VariableTypes.Logical) { if (variable2.Type != VariableTypes.Logical) { throw SchemeExecutor.CreateException("Cannot compare logical and non-logical"); } bool value1_bool = (bool)variable1.Value; bool value2_bool = (bool)variable2.Value; return(value1_bool == value2_bool); } //In case of other types, we compare if they are the same object return(variable1.Value == variable2.Value); }
public UCEParameterRow_StringConst(string paramName, ObjectVariable value) : base(paramName, value) { InitializeComponent(); tbParamName.Text = paramName; textSelector.SelectByTag((Text)value.Value); }
public void Execute(SchemeExecutor executor) { ObjectVariable variable1 = executor.FindValueByString(value1); ObjectVariable variable2 = executor.FindValueByString(value2); bool result = GetResult(variable1, variable2); executor.SetVariable(target, new ObjectVariable(VariableTypes.Logical, "", result)); }
private UCETextListElem CreateSlotElem(ObjectVariable slot) { UCETextListElem elem = new UCETextListElem(); elem.Content = $"{slot.Name} [{slot.Type}]"; elem.Tag = slot; elem.DeleteClicked += SlotElem_DeleteClicked; return(elem); }
public void CreateLocalVariable(string type, string name, object value) { if (GetVariableByName(name) != null) { throw CreateException($"Variable '{name}' already exists"); } ObjectVariable variable = new ObjectVariable(type, name, value); LocalVariables.Add(variable); }
public UCEParameterRow_Logical(string paramName, ObjectVariable value) : base(paramName, value) { InitializeComponent(); tbParamName.Text = paramName; if (value.Value == null) { value.Value = false; } cb.IsChecked = (bool)value.Value; }
public UCEAbilityRow(ObjectVariable ability, AbilityMaxValue abilityMaxValue) { InitializeComponent(); Ability = ability; AbilityMaxValue = abilityMaxValue; tbAbilityName.Text = ability.Name; nbAbilityValue.Value = (int)ability.Value; AbilityMaxValue.RemainingValue -= (int)ability.Value; }
protected override bool GetResult(ObjectVariable variable1, ObjectVariable variable2) { if (variable1.Type != VariableTypes.Number || variable2.Type != VariableTypes.Number) { throw SchemeExecutor.CreateException("Cannot compare non-numbers"); } int value1_int = (int)variable1.Value; int value2_int = (int)variable2.Value; return(value1_int < value2_int); }
public UCEParameterRow_Number(string paramName, ObjectVariable value) : base(paramName, value) { InitializeComponent(); tbParamName.Text = paramName; if (value.Value == null) { value.Value = 0; } iValue.NumValue = Convert.ToInt32(value.Value); }
public void Execute(SchemeExecutor executor) { ObjectVariable objectVariable = executor.GetVariableByName(objectName); if (!executor.CheckTypeCompatibility(VariableTypes.Object, objectVariable.Type)) { throw SchemeExecutor.CreateException($"Object has to be compatible with 'object' (actual type: '{objectVariable.Type}')"); } Object @object = (Object)objectVariable.Value; @object.ForbidAttribute(attributeName); }
protected override bool Evaluate(SchemeExecutor executor) { ObjectVariable variable = executor.FindValueByString(value); if (variable.Type != VariableTypes.Logical) { throw SchemeExecutor.CreateException("Cannot use non-logical value in JF"); } bool value_bool = (bool)variable.Value; return(!value_bool); }
public void Execute(SchemeExecutor executor) { ObjectVariable variable = executor.FindValueByString(value); if (variable.Type != VariableTypes.Logical) { throw SchemeExecutor.CreateException("Cannot invert non-logical"); } bool value_bool = (bool)variable.Value; executor.SetVariable(target, new ObjectVariable(VariableTypes.Logical, "", (!value_bool))); }
public UCEParameterRow_Object(string paramName, ObjectVariable value, Config config) : base(paramName, value) { InitializeComponent(); tbParamName.Text = paramName; if (value.Type != VariableTypes.Object) { Scheme scheme = config.GetSchemeByName(value.Type); objectSelector.SchemeFilter = scheme; } objectSelector.SelectByTag((Object)value.Value); }
//Returns the given property (as reference) of the object identified by objectName public ObjectVariable GetPropertyOf(string propertyName, string objectName) { //First we identify the object Object @object = null; ObjectVariable objectVariable = GetVariableByName(objectName); if (objectVariable == null) { throw CreateException("Object not found"); } @object = (Object)objectVariable.Value; return(@object.GetVariableByName(propertyName, Game.Config)); }
public UCEClassSelector(ClassList classList, ObjectVariable classVariable) { InitializeComponent(); ClassVariable = classVariable; if (classList.ShownName != null) { tbClasslistName.Text = $"{classList.ShownName.Content} ({classList.Name})"; } else { tbClasslistName.Text = classList.Name; } BuildClassSelector(classList); }
public void Execute(SchemeExecutor executor) { ObjectVariable objectVariable = executor.GetVariableByName(objectName); // ObjectVariable property = executor //Uses of 'is': // object has attribute actor is forest_wanderer // class var race of actor is dwarf // -> OF(race, actor, _0) EQUALS(_0, dwarf, _0) // item/spell is the same as... some_item is sword_1 //some_item.Name == "sword_1" /* * 1. Check if object's name equals to propertyName * 2. Check if object has attribute named propertyName */ bool value = false; //If we check class variable if (executor.Game.Config.IsClassType(objectVariable.Type)) { //we search for the required class var c = executor.FindValueByString(propertyName); //then we compare it to the classvar value = objectVariable.Value == c.Value; } else { if (!executor.CheckTypeCompatibility(VariableTypes.Object, objectVariable.Type)) { throw SchemeExecutor.CreateException("Object has to be compatible with 'object'"); } Object @object = (Object)objectVariable.Value; if (@object.Name == propertyName) { value = true; } else if (@object.HasAttribute(propertyName)) { value = true; } } executor.SetVariable(target, new ObjectVariable(VariableTypes.Logical, "", value)); }
private void BuildClassList(Character character) { spClasses.Children.Clear(); foreach (ClassList classList in Config.ClassLists) { ObjectVariable classVariable = character.GetVariableByName(classList.Name, Config); if (classVariable == null) { classVariable = new ObjectVariable(classList.Name, classList.Name, null); character.Variables.Add(classVariable); } UCEClassSelector classSelector = new UCEClassSelector(classList, classVariable); spClasses.Children.Add(classSelector); } }
public void Execute(SchemeExecutor executor) { ObjectVariable variable1 = executor.FindValueByString(value1); ObjectVariable variable2 = executor.FindValueByString(value2); if (variable1.Type != VariableTypes.Logical) { throw new Exception("Cannot do logical operation with non-logical variables"); } bool value1_bool = (bool)variable1.Value; bool value2_bool = (bool)variable2.Value; bool result = GetResult(value1_bool, value2_bool); executor.SetVariable(target, new ObjectVariable(VariableTypes.Logical, "", result)); }
public static ParameterRow Create(ObjectVariable param, ObjectVariable value, Config config) { if (param.Type == VariableTypes.Number || param.Type == VariableTypes.Ability) { return(new UCEParameterRow_Number(param.Name, value)); } if (param.Type == VariableTypes.Logical) { return(new UCEParameterRow_Logical(param.Name, value)); } if (param.Type == VariableTypes.Text) { return(new UCEParameterRow_StringConst(param.Name, value)); } return(new UCEParameterRow_Object(param.Name, value, config)); }
public void Execute(SchemeExecutor executor) { ObjectVariable variable1 = executor.FindValueByString(value1); ObjectVariable variable2 = executor.FindValueByString(value2); if (variable1.Type != VariableTypes.Number) { throw new Exception("Cannot do operation with non-number variables"); } int value1_int = (int)variable1.Value; int value2_int = (int)variable2.Value; int result = GetResult(value1_int, value2_int); executor.SetVariable(target, new ObjectVariable(VariableTypes.Number, "", result)); }
// Finds the type and value represented by the given string (including variables; and constants like 11, 5, true, $STRING etc.) // This method calculates the current value of abilities and return that value (thus cannot be used to change ability values) public ObjectVariable FindValueByString(string s) { //If there is a variable with the name s, we return its value ObjectVariable variable = GetVariableByName(s); if (variable != null) { return(variable); } //If s is a number const we return it as a new number variable int number; bool canConvert = int.TryParse(s, out number); if (canConvert) { return(new ObjectVariable("number", "", number)); } //If s is a logical const, we return it as a new logical variable if (s.ToLower() == "true") { return(new ObjectVariable("logical", "", true)); } if (s.ToLower() == "false") { return(new ObjectVariable("logical", "", false)); } //If s is a string const we return its content as a text variable if (s.Length >= 1 && s[0] == '$') { return(new ObjectVariable("text", "", Game.Config.GetStringConstByName(s))); } //If s is a class variable we return it as class var c = Game.Config.GetClassByName(s); if (c != null) { return(new ObjectVariable(c.Item1.Name, "", c.Item2)); } throw CreateException($"Unidentifyable value '{s}'"); }
private void bAddItem_Click(object sender, RoutedEventArgs e) { if (tbSlotName.Text == null || tbSlotName.Text.Length == 0 || slotSchemeSelector.SelectedTag == null) { return; } string slotType = slotSchemeSelector.SelectedTag.Name; string slotName = tbSlotName.Text; ObjectVariable slot = new ObjectVariable(slotType, slotName, null); Project.Current.Config.CharacterConfig.InventorySlots.Add(slot); var elem = CreateSlotElem(slot); spSlots.Children.Add(elem); }