public void SetupEntityClasses(EntityModel model)
{
var ns = model.App.GetType().Namespace + ".Proxies";
_assemblyInfo = _assemblyInfo ?? DynamicAssemblyInfo.Create(ns);
var attrHandler = new AttributeHandler(addStandardAttributes: true);
foreach (var ent in model.Entities)
{
var className = ns + "." + ent.EntityType.Name.Substring(1); //Cut-off I
var controller = new EntityEmitController(ent, _assemblyInfo, className, attrHandler);
var emitter = new ProxyEmitter(controller);
emitter.ImplementInterface(ent.EntityType);
var classType = emitter.CreateClass();
var factory = emitter.GetProxyFactory <Func <EntityRecord, EntityBase> >();
ent.ClassInfo = new EntityClassInfo()
{
Type = classType, CreateInstance = factory
};
//assign member Clr info
var flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
foreach (var member in ent.Members)
{
member.ClrClassMemberInfo = classType.GetProperty(member.MemberName, flags);
}
}
}
public static InventoryItem HandleItemTrade(Character.Models.Character player, Character.Models.Character character, Items foundItem, Room.Models.Room currentRoom)
{
if (foundItem.InventoryItems.Any())
{
AttributeHandler.UpdatePlayerAttributesFromInventoryItem(player, foundItem.InventoryItems.First(), true);
player.Attributes.CarriedItemsCount -= foundItem.InventoryItems.First().InventorySpaceConsumed;
character.CarriedItems.Add(foundItem.InventoryItems.First());
player.CarriedItems.Remove(foundItem.InventoryItems.First());
if (character.DesiredItem != null &&
player.Attributes.CarriedItemsCount + character.OfferedItem.InventorySpaceConsumed <= player.Attributes.MaximumCarryingCapacity)
{
AttributeHandler.UpdatePlayerAttributesFromInventoryItem(player, character.OfferedItem);
player.Attributes.CarriedItemsCount += character.OfferedItem.InventorySpaceConsumed;
player.CarriedItems.Add(character.OfferedItem);
character.CarriedItems.Remove(character.OfferedItem);
character.DesiredItem = new InventoryItem();
return(character.OfferedItem);
}
}
return(new InventoryItem {
ItemName = ""
});
}
/// <summary>
/// Register handlers that are invoked in "Handle" when an instance has, or is missing,
/// the given attribute type.
/// </summary>
/// <param name="attributeType"></param>
/// <param name="presentHandler"></param>
/// <param name="missingHandler"></param>
public void RegisterHandler(Type attributeType
, AttributeHandler presentHandler
, AttributeHandler missingHandler
, bool inheritable = false)
{
if (registeredAttributes.Contains(attributeType))
{
if (presentHandler != null)
{
attributePresentHandlers[attributeType] += presentHandler;
}
if (missingHandler != null)
{
attributeMissingHandlers[attributeType] += missingHandler;
}
}
else
{
if (presentHandler != null)
{
attributePresentHandlers.Add(attributeType, presentHandler);
}
if (missingHandler != null)
{
attributeMissingHandlers.Add(attributeType, missingHandler);
}
registeredAttributes.Add(attributeType);
}
if (inheritable)
{
registeredInheritableAttributes.Add(attributeType);
}
}
/// <summary>
/// Register handlers that are invoked in "Handle" when an instance has, or is missing,
/// the given attribute type.
/// </summary>
/// <typeparam name="U"></typeparam>
/// <param name="presentHandler"></param>
/// <param name="missingHandler"></param>
public void RegisterHandler <U>(AttributeHandler presentHandler
, AttributeHandler missingHandler
, bool inheritable = false)
where U : Attribute
{
RegisterHandler(typeof(U), presentHandler, missingHandler);
}
/// <summary>
/// Sets the value of the property, or if it has a NamedCollectionOption, adds it to the collection of the property value.
/// </summary>
/// <param name="instance"></param>
/// <param name="value"></param>
public void SetValue(object instance, object?value)
{
if (AttributeHandler.IsCollectionAttribute(Option))
{
if (value == null)
{
throw new InvalidOperationException($"The target value for the property \"{PropertyInfo.Name}\" on \"{PropertyInfo.DeclaringType}\" is null, but it is marked as a collection.");
}
var propertyValue = PropertyInfo.GetValue(instance) ?? throw new InvalidOperationException($"The property \"{PropertyInfo.Name}\" on \"{PropertyInfo.DeclaringType}\" must return an instance.");
//TODO: use ICollection for this case, instead of IList.
//that way we don't demand both IList and ICollection<>
var list = (IList)propertyValue;
list.Clear();
foreach (var element in (IList)value)
{
list.Add(element);
}
}
else
{
PropertyInfo.SetValue(instance, value);
}
}
public static void DropItemInRoom(Character.Models.Character player, Room.Models.Room room,
InventoryItem itemBeingDropped)
{
AttributeHandler.UpdatePlayerAttributesFromInventoryItem(player, itemBeingDropped, true);
player.Attributes.CarriedItemsCount -= itemBeingDropped.InventorySpaceConsumed;
room.RoomItems.InventoryItems.Add(itemBeingDropped);
player.CarriedItems.Remove(itemBeingDropped);
}
public static void DropItemInRoom(Character.Models.Character player, Room.Models.Room room,
InventoryItem itemToDrop)
{
player.Attributes.CarriedItemsCount -= 1;
room.RoomItems.InventoryItems.Add(itemToDrop);
AttributeHandler.UpdatePlayerAttributesFromInventoryItem(player, itemToDrop, true);
player.CarriedItems.Remove(itemToDrop);
}
public void Initialize(AttributeHandler handler){
this.handler = handler;
if (raiseButton != null) {
raiseButton.onClick.AddListener (delegate {
handler.IncreaseAttribute(attribute);
});
}
}
public override void OnResponse(Network.NetState sender, RelayInfo info)
{
if (info.ButtonID >= 1000)
{
AttributeHandler handler = AttributeHandler.Definitions[info.ButtonID - 1000];
Process.BeginUpgrade(handler);
}
}
public static void DropWeaponAndPickupNew(Character.Models.Character player, Room.Models.Room room,
WeaponItem weaponToAddToPlayer)
{
room.RoomItems.WeaponItems.Add(player.WeaponItem);
AttributeHandler.UpdatePlayerAttributesFromWeaponItem(player, player.WeaponItem, true);
AttributeHandler.UpdatePlayerAttributesFromWeaponItem(player, weaponToAddToPlayer);
weaponToAddToPlayer.InOriginalLocation = false;
player.WeaponItem = weaponToAddToPlayer;
room.RoomItems.WeaponItems.Remove(weaponToAddToPlayer);
}
/// <summary>
/// Parses the xml document
/// </summary>
/// <param name="tagfile"></param>
protected void init(string tagfile)
{
try {
AttributeHandler a = new AttributeHandler(this);
a.Parse(tagfile);
}
catch (Exception e) {
throw e;
}
}
/// <summary>
/// Parses the xml document
/// </summary>
/// <param name="tagfile"></param>
protected void Init(XmlDocument xTagfile)
{
try {
AttributeHandler a = new AttributeHandler(this);
a.Parse(xTagfile);
}
catch (Exception e) {
throw e;
}
}
public EnhancementGump(EnhancementStoneProcess process) : base(40, 40)
{
bool MoreAttributesAllowed = true;
Process = process;
if (Process.CurrentAttributeCount >= Process.MaxAttrCount)
{
MoreAttributesAllowed = false;
}
AddBackground(0, 0, 620, 390, 9200);
AddImageTiled(8, 10, 604, 24, 2624);
AddImageTiled(8, 38, 300, 345, 2624);
AddImageTiled(312, 38, 300, 345, 2624);
AddAlphaRegion(8, 10, 604, 373);
AddLabel(224, 12, 0x481, "Equipment Enhancement");
AddLabel(15, 40, 0x481, "Attributes");
AddLabel(184, 40, 0x481, "Cost");
AddLabel(273, 40, 0x481, "Buy");
AddLabel(319, 40, 0x481, "Attributes");
AddLabel(488, 40, 0x481, "Cost");
AddLabel(577, 40, 0x481, "Buy");
int column = 0;
int row = 0;
for (int i = 0; i < AttributeHandler.Definitions.Count; i++)
{
AttributeHandler handler = AttributeHandler.Definitions[i];
if (handler.IsUpgradable(Process.ItemToUpgrade))
{
int currentValue = handler.Upgrade(Process.ItemToUpgrade, true);
if (currentValue > 0 || MoreAttributesAllowed)
{
if (row > 11)
{
row = 0;
column = 1;
}
AddLabel(15 + (304 * column), 65 + (25 * row), 0x481, handler.Description);
AddLabel(184 + (304 * column), 65 + (25 * row), 0x481, Process.GetCostToUpgrade(handler).ToString());
AddButton(270 + (304 * column), 62 + (25 * row), 4023, 4024, 1000 + i, GumpButtonType.Reply, 0);
row++;
}
}
}
}
public override int CalculateModifier(int value)
{
var attributeValue = AttributeHandler.Value(AttributeName);
if ((Above == null || attributeValue > Above) &&
(Below == null || attributeValue < Below))
{
return(value + Value);
}
return(Value);
}
public AttributeParser(AttributeConfiguration configuration, IParameterFormatter parameterFormatter, IValueConverter valueConverter, IHelpPresenter helpPresenter)
{
Configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
_attributeHandler = new AttributeHandler(configuration, parameterFormatter,
(option, value) =>
{
var parameterValueOption = configuration.GetParameterValueOption(option);
return(valueConverter.ConvertFromString(option, parameterValueOption.ParameterInfo, AttributeHandler.GetValueType(parameterValueOption.Option, parameterValueOption.ParameterInfo.ParameterType), value));
},
(option) => configuration.GetParameterValueOption(option).ParameterInfo.ParameterType
);
_helpPresenter = helpPresenter ?? throw new ArgumentNullException(nameof(helpPresenter));
}
public void UpdatePlayerAttributesFromWeaponItem_ShouldRemoveTraitPointToPlayer()
{
var player = MockCharacters.MockPlayerAlbert;
player.Attributes = MockAttributes.MockPlayerAttrBeforeUpdate;
MockAttributes.MockPlayerAttrBeforeUpdate.Dexterity = 6;
var expectedOutput = MockAttributes.MockPlayerAttrAfterRemoveDexterity;
AttributeHandler.UpdatePlayerAttributesFromWeaponItem(player, MockItems.MockItemKatana, true);
Assert.AreEqual(expectedOutput.Dexterity, player.Attributes.Dexterity);
}
public void UpdatePlayerAttributesFromInventoryItem_ShouldRemoveTraitPointToPlayer()
{
var player = MockCharacters.MockPlayerAlbert;
player.Attributes = MockAttributes.MockPlayerAttrBeforeUpdate;
MockAttributes.MockPlayerAttrBeforeUpdate.Luck = 7;
var expectedOutput = MockAttributes.MockPlayerAttrAfterRemoveLuck;
AttributeHandler.UpdatePlayerAttributesFromInventoryItem(player, MockItems.MockItemRabbitsFoot, true);
Assert.AreEqual(expectedOutput.Luck, player.Attributes.Luck);
}
public void IndirectAttributeHandler()
{
AttributeHandler.RemoveHandler <CustomAttributeHandler>();
AttributeHandler.AddHandler <CustomAttributeHandler>();
JsonSchema expected = new JsonSchemaBuilder()
.Type(SchemaValueType.Object)
.Properties(
("MyProperty", new JsonSchemaBuilder().Type(SchemaValueType.String).MaxLength(AttributeWithIndirectHandler.MaxLength))
);
JsonSchema actual = new JsonSchemaBuilder().FromType <TypeWithCustomAttribute2>();
Assert.AreEqual(expected, actual);
}
public override void OnEnter ()
{
if (gameObject.Value == null) {
Debug.Log (this.Root.Name);
}
handler = gameObject.Value.GetComponent<AttributeHandler> ();
attr=handler.GetAttribute(attribute.Value);
if (attr != null) {
attr.OnChange.AddListener(DoGetAttribute);
DoGetAttribute (attr);
}
Finish ();
}
internal AttributeConfiguration(IServiceProvider serviceProvider, IEnumerable <Type> optionTypes, object?instance = null)
{
_serviceProvider = serviceProvider;
foreach (var type in optionTypes)
{
var typeInfo = type.GetTypeInfo();
foreach (var methodVerbPair in typeInfo.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static).Select((x) => new KeyValuePair <MethodInfo, IVerb?>(x, GetVerbFromMethod(x))).Where((x) => x.Value != null))
{
var parameterOptions = new List <IParameterValue>();
foreach (var parameter in methodVerbPair.Key.GetParameters())
{
var option = AttributeHandler.GetOption(this, methodVerbPair.Key.ToString(), parameter);
if (option == null)
{
if (parameter.HasDefaultValue)
{
parameterOptions.Add(new DefaultValueParameter(parameter));
}
else
{
throw new InvalidOperationException($"The parameter \"{parameter.Name}\" on \"{methodVerbPair.Key.DeclaringType.FullName + ":" + methodVerbPair.Key.Name}\" for the verb \"{methodVerbPair.Value.Name}\" has neither an option, nor a default value.");
}
}
else
{
parameterOptions.Add(new ParameterValueOption(parameter, option, methodVerbPair.Key));
}
}
_verbData.Add(methodVerbPair.Value, new VerbData(methodVerbPair.Value, methodVerbPair.Key, () => {
if (instance != null)
{
return(instance);
}
return(AttributeHandler.GetConstructor(typeInfo).Invoke(new object[0]));
}, parameterOptions));
}
}
}
private void Init(string elementName, int elements, long size, SettableAttributes attributes, AttributeHandler onOkClicked)
{
InitializeComponent();
nameTextBox.Text = elementName;
sizeTextBox.Text = size.ToString();
elementsTextBox.Text = elements.ToString();
if (attributes.IsReadOnly)
{
readOnlyChBox.Checked = true;
}
if (attributes.IsHidden)
{
hiddenChBox.Checked = true;
}
if (attributes.IsArchive)
{
archiveChBox.Checked = true;
}
OnOkClicked = onOkClicked;
Show();
}
internal AttributeConfiguration(IServiceProvider serviceProvider, IEnumerable <Type> optionTypes)
{
_serviceProvider = serviceProvider;
foreach (var type in optionTypes)
{
var typeInfo = type.GetTypeInfo();
var verb = GetVerbFromType(type);
//get options
var options = new List <OptionProperty>();
foreach (var property in typeInfo.GetProperties(BindingFlags.Public | BindingFlags.Instance))
{
var option = AttributeHandler.GetOption(this, type.Name, property);
if (option != null)
{
options.Add(new OptionProperty(option, property));
}
}
_verbsData.Add(verb, new VerbData(verb, () => AttributeHandler.GetConstructor(typeInfo).Invoke(new object[0]), options));
}
}
public void SetValue(object?value)
{
if (AttributeHandler.IsCollectionAttribute(Option))
{
if (value == null)
{
throw new InvalidOperationException($"The target value for the property \"{ParameterInfo.Name}\" on \"{MethodName}\" is null, but it is marked as a collection.");
}
//TODO: Create element of the correct type.
if (Value == null)
{
var constructor = ParameterInfo.ParameterType.GetConstructors().FirstOrDefault((x) => x.IsPublic && x.GetParameters().Length == 0);
if (constructor != null)
{
Value = constructor.Invoke(new object[0]);
}
else
{
Value = Activator.CreateInstance(typeof(List <>).MakeGenericType(AttributeHandler.GetValueType(Option, ParameterInfo.ParameterType)));
}
}
var list = (IList)Value;
list.Clear();
foreach (var element in (IList)value)
{
list.Add(element);
}
}
else
{
Value = value;
}
}
public PropertyForm(string elementName, int elements, long size,
SettableAttributes attributes, AttributeHandler onOkClicked)
{
Init(elementName, elements, size, attributes, onOkClicked);
}
public PropertyForm(string elementName, RequestSizeDataHandler onSizeRequested,
TerminationHandler onCalculationTerminated, SettableAttributes attributes, AttributeHandler onOkClicked)
{
RequestSizeData = onSizeRequested;
TerminateCalculation = onCalculationTerminated;
Init(elementName, 0, 0, attributes, onOkClicked);
timer1.Start();
}
/// <summary>
/// Register handlers that are invoked in "Handle" when an instance has the given attribute
/// type.
/// </summary>
/// <typeparam name="U"></typeparam>
/// <param name="presentHandler"></param>
public void RegisterHandler <U>(AttributeHandler presentHandler, bool inheritable = false)
where U : Attribute
{
RegisterHandler(typeof(U), presentHandler, null, inheritable);
}
public IPaging Align(VertialAlign align)
{
styleHandler += new AttributeHandler(() => String.Concat("text-align:", align.ToString().ToLower(), ';'));
return(this);
}
public IPaging Align(HorizontalAlign align)
{
styleHandler += new AttributeHandler(() => String.Concat("vertical-align:", align.ToString().ToLower(), ';'));
return(this);
}
/// <summary>
/// Parses the xml document
/// </summary>
/// <param name="tagfile"></param>
protected void Init(XmlDocument xTagfile)
{
try {
AttributeHandler a = new AttributeHandler(this);
a.Parse(xTagfile);
}
catch (Exception e) {
throw e;
}
}
/// <summary>
/// Parses the xml document
/// </summary>
/// <param name="tagfile"></param>
protected void Init(string tagfile)
{
try {
AttributeHandler a = new AttributeHandler(this);
a.Parse(tagfile);
}
catch (Exception e) {
throw e;
}
}
// This updates the room and/or player when the exchange of an item occurs
public static void HandleItemAddOrRemove(Character.Models.Character player, Room.Models.Room currentRoom,
Items foundItem, bool removeItemFromRoom = false)
{
switch (removeItemFromRoom)
{
// We are removing an item from a room, adding it to player inventory
case true:
if (foundItem?.InventoryItems?.First() != null)
{
var meetsAnyRequirement = false;
var needsToDropSameTypeItemFirst = false;
InventoryItem carriedItemOfSameType = null;
var inventoryItemToAddToPlayer = foundItem.InventoryItems.First();
if (inventoryItemToAddToPlayer?.AttributeRequirementToTake == null)
{
meetsAnyRequirement = true;
}
else if (inventoryItemToAddToPlayer?.AttributeRequirementToTake != null &&
CanPickupItemWithAttributeRequirement(player, inventoryItemToAddToPlayer))
{
meetsAnyRequirement = true;
}
if (inventoryItemToAddToPlayer.TreatItemAs == ItemUseTypes.Bag ||
inventoryItemToAddToPlayer.TreatItemAs == ItemUseTypes.Wearable)
{
foreach (var item in player.CarriedItems)
{
if (item.TreatItemAs == ItemUseTypes.Bag && inventoryItemToAddToPlayer.TreatItemAs == ItemUseTypes.Bag ||
item.WearableType != "" && item.WearableType == inventoryItemToAddToPlayer.WearableType)
{
carriedItemOfSameType = item;
needsToDropSameTypeItemFirst = true;
break;
}
}
}
if (PickupOrDropItemIsOk(player, foundItem) && meetsAnyRequirement)
{
Console.WriteLine();
if (needsToDropSameTypeItemFirst)
{
TypingAnimation.Animate("You need to drop your " + carriedItemOfSameType.ItemName + " before you can take the " + inventoryItemToAddToPlayer?.ItemName + ".\n",
Color.ForestGreen);
}
else
{
AttributeHandler.UpdatePlayerAttributesFromInventoryItem(player, inventoryItemToAddToPlayer);
inventoryItemToAddToPlayer.InOriginalLocation = false;
player.CarriedItems.Add(inventoryItemToAddToPlayer);
player.Attributes.CarriedItemsCount += inventoryItemToAddToPlayer.InventorySpaceConsumed;
currentRoom.RoomItems.InventoryItems.Remove(inventoryItemToAddToPlayer);
TypingAnimation.Animate("You take the " + inventoryItemToAddToPlayer.ItemName + ".\n", Color.ForestGreen);
}
}
else
{
if (meetsAnyRequirement)
{
Console.WriteLine();
TypingAnimation.Animate("Your inventory is full! \n" +
"Drop or use an item to pick up the " + inventoryItemToAddToPlayer?.ItemName + ".\n", Color.DarkOliveGreen);
}
}
}
else
if (foundItem?.WeaponItems != null)
{
var weaponItemToAddToPlayer = foundItem.WeaponItems.First();
if (string.IsNullOrEmpty(player.WeaponItem.WeaponName))
{
AttributeHandler.UpdatePlayerAttributesFromWeaponItem(player, weaponItemToAddToPlayer);
weaponItemToAddToPlayer.InOriginalLocation = false;
player.WeaponItem = weaponItemToAddToPlayer;
currentRoom.RoomItems.WeaponItems.Remove(weaponItemToAddToPlayer);
Console.WriteLine();
TypingAnimation.Animate("You take the " + weaponItemToAddToPlayer?.WeaponName + ".\n", Color.ForestGreen);
}
else
{
var oldWeapon = player.WeaponItem.WeaponName.Clone();
DropWeaponAndPickupNew(player, currentRoom, weaponItemToAddToPlayer);
player.WeaponItem = weaponItemToAddToPlayer;
currentRoom.RoomItems.WeaponItems.Remove(weaponItemToAddToPlayer);
Console.WriteLine();
TypingAnimation.Animate("You drop your " + oldWeapon + " for the " + weaponItemToAddToPlayer?.WeaponName + ".\n",
Color.ForestGreen);
}
}
break;
// We are adding an item to a room, removing/dropping it from player inventory
case false:
if (foundItem?.InventoryItems != null)
{
var inventoryItemToRemoveFromPlayer = foundItem.InventoryItems.First();
DropItemInRoom(player, currentRoom, inventoryItemToRemoveFromPlayer);
Console.WriteLine();
TypingAnimation.Animate("You drop the " + inventoryItemToRemoveFromPlayer?.ItemName + ".\n", Color.ForestGreen);
}
else if (foundItem?.WeaponItems != null)
{
var weaponItemToRemoveFromPlayer = foundItem.WeaponItems.First();
DropWeaponInRoom(player, currentRoom);
Console.WriteLine();
TypingAnimation.Animate("You drop the " + weaponItemToRemoveFromPlayer?.WeaponName + ".\n", Color.ForestGreen);
}
break;
}
}
public static void DropWeaponInRoom(Character.Models.Character player, Room.Models.Room room)
{
room.RoomItems.WeaponItems.Add(player.WeaponItem);
AttributeHandler.UpdatePlayerAttributesFromWeaponItem(player, player.WeaponItem, true);
player.WeaponItem = new WeaponItem();
}
public static bool HandleItemBeingUsed(Character.Models.Character player, Items foundItem, string playerInput)
{
if (foundItem?.WeaponItems?.First() != null)
{
Console.WriteLine();
TypingAnimation.Animate($"You swing your {foundItem.WeaponItems.First().WeaponName} around wildly.\n", Color.ForestGreen);
return(true);
}
if (foundItem?.InventoryItems?.First() != null)
{
var item = foundItem.InventoryItems.First();
if (item.TreatItemAs == ItemUseTypes.Default || item.TreatItemAs == ItemUseTypes.Key)
{
Console.WriteLine();
TypingAnimation.Animate($"You {playerInput} the {item.ItemName} but nothing happens...\n",
Color.ForestGreen);
return(true);
}
if (item.TreatItemAs == ItemUseTypes.Wearable)
{
Console.WriteLine();
TypingAnimation.Animate($"You're already wearing the {item.ItemName}...\n", Color.ForestGreen);
return(true);
}
if (item.TreatItemAs == ItemUseTypes.Document)
{
var traitsAdded = "";
foreach (var trait in item.ItemTraits)
{
if (!string.IsNullOrEmpty(trait.RelevantCharacterAttribute))
{
if (trait.TraitValue > 0)
{
traitsAdded += $"\n\t{trait.RelevantCharacterAttribute} + ({trait.TraitValue})!";
AttributeHandler.AddCharacterAttributesByTrait(player, trait);
trait.TraitName = "";
trait.TraitValue = 0;
}
}
}
Console.WriteLine();
TypingAnimation.Animate($"You read the {item.ItemName}: {traitsAdded}\n \n\n{item.DocumentText}\n",
Color.GhostWhite);
return(true);
}
if (item.TreatItemAs == ItemUseTypes.ConsumableAttribute)
{
var traitsAdded = "";
foreach (var trait in item.ItemTraits)
{
if (!string.IsNullOrEmpty(trait.RelevantCharacterAttribute))
{
traitsAdded += $"\n\t{trait.RelevantCharacterAttribute} + ({trait.TraitValue})!";
AttributeHandler.AddCharacterAttributesByTrait(player, trait);
}
}
player.Attributes.CarriedItemsCount -= item.InventorySpaceConsumed;
player.CarriedItems.Remove(item);
Console.WriteLine();
TypingAnimation.Animate($"You use the {item.ItemName}: \n{traitsAdded}\n", Color.ForestGreen);
return(true);
}
if (item.TreatItemAs == ItemUseTypes.ConsumableBattery)
{
var flashlight = player.CarriedItems.SingleOrDefault(i =>
i.ItemName == Program.ItemCreator.Flashlight.ItemName);
var traitsAdded = "";
foreach (var trait in item.ItemTraits)
{
if (!string.IsNullOrEmpty(flashlight?.ItemName))
{
traitsAdded += $"\n\tFlashlight battery: ({trait.TraitValue}%)!";
FlashlightBatteryUpdate.FlashlightBatteryChange(flashlight,
percentToSet: trait.TraitValue);
}
}
if (!string.IsNullOrEmpty(flashlight?.ItemName))
{
player.Attributes.CarriedItemsCount -= item.InventorySpaceConsumed;
player.CarriedItems.Remove(item);
Console.WriteLine();
TypingAnimation.Animate($"You use the {item.ItemName}: \n{traitsAdded}\n", Color.ForestGreen);
return(true);
}
Console.WriteLine();
TypingAnimation.Animate($"You don't have anything to use the {item.ItemName} on...\n",
Color.DarkOliveGreen);
return(true);
}
if (item.TreatItemAs == ItemUseTypes.ConsumableHealth)
{
var traitsAdded = "";
if (player.HealthPoints < player.MaximumHealthPoints)
{
foreach (var trait in item.ItemTraits)
{
if (string.IsNullOrEmpty(trait.RelevantCharacterAttribute))
{
if (player.HealthPoints + trait.TraitValue > player.MaximumHealthPoints)
{
player.HealthPoints = player.MaximumHealthPoints;
}
else
{
player.HealthPoints += trait.TraitValue;
}
traitsAdded += $"\n\tHealth Points: + ({trait.TraitValue})!";
}
else
{
traitsAdded += trait.TraitValue >= 0 ? $"\n\t{trait.RelevantCharacterAttribute} + ({trait.TraitValue})!" : $"\n\t{trait.RelevantCharacterAttribute} - ({-1 * trait.TraitValue})";
AttributeHandler.AddCharacterAttributesByTrait(player, trait);
}
}
}
if (!string.IsNullOrEmpty(traitsAdded))
{
player.Attributes.CarriedItemsCount -= item.InventorySpaceConsumed;
player.CarriedItems.Remove(item);
Console.WriteLine();
TypingAnimation.Animate($"You consume the {item.ItemName}: \n{traitsAdded}\n",
Color.ForestGreen);
return(true);
}
Console.WriteLine();
TypingAnimation.Animate(
$"You don't need to use the {item.ItemName}, you have full Health Points...\n",
Color.DarkOliveGreen);
return(true);
}
if (item.TreatItemAs == ItemUseTypes.ConsumableAmmo)
{
var traitsAdded = "";
if (!string.IsNullOrEmpty(player.WeaponItem?.WeaponName) &&
!string.IsNullOrEmpty(player.WeaponItem?.AmmunitionType) &&
player.WeaponItem.AmmunitionType == item.AmmunitionType)
{
player.WeaponItem.AmmunitionAmount += item.AmmunitionAmount;
traitsAdded += $"\n\t{player.WeaponItem.WeaponName} Ammo + ({item.AmmunitionAmount}) = ({player.WeaponItem.AmmunitionAmount})!";
player.Attributes.CarriedItemsCount -= item.InventorySpaceConsumed;
player.CarriedItems.Remove(item);
Console.WriteLine();
TypingAnimation.Animate($"You use the {item.ItemName}: \n{traitsAdded}\n", Color.ForestGreen);
return(true);
}
Console.WriteLine();
TypingAnimation.Animate($"You don't have a weapon that uses {item.AmmunitionType}...\n",
Color.DarkOliveGreen);
return(true);
}
}
return(false);
}
public EntityEmitController(EntityInfo entityInfo, DynamicAssemblyInfo asm, string className, AttributeHandler attrHandler) : base(asm, className, typeof(EntityBase), attrHandler)
{
_entityInfo = entityInfo;
if (_targetRef == null)
{
InitMethodRefs();
}
}
