private static Grid GenerateSpellableGrid(
bool isTargetingSelf,
Page current,
IButtonable previous,
Character owner,
SpellBook excluded,
IEnumerable <ISpellable> spellCollection,
Action <IPlayable> addPlay,
Sprite sprite,
string name,
string description)
{
Grid grid = GenerateBackableGrid(previous, sprite, name, description);
foreach (ISpellable myS in spellCollection)
{
ISpellable s = myS;
if (!s.Equals(excluded))
{
grid.List.Add(GenerateSpellProcess(current, grid, owner, s, addPlay, isTargetingSelf));
}
}
return(grid);
}
/// <summary>
/// Creates a subgrid containing user's equipment
/// </summary>
/// <param name="previous">supergrid</param>
/// <param name="owner">Owner of the equipment</param>
/// <param name="handlePlayable">Playable handler</param>
/// <param name="isInCombat">If in combat, text is "Equipment", otherwise it's the owner's name</param>
/// <returns></returns>
public static Grid GenerateEquipmentGrid(Page current, IButtonable previous, Character owner, Action <IPlayable> handlePlayable, bool isInCombat)
{
Grid grid = GenerateBackableGrid(
previous,
isInCombat ? EQUIPMENT : owner.Look.Sprite,
isInCombat ? "Equipment" : owner.Look.DisplayName,
string.Format("Manage {0}'s equipment.", owner.Look.DisplayName));
foreach (EquipType myET in EquipType.AllTypes)
{
EquipType et = myET;
IButtonable ib = null;
Equipment eq = owner.Equipment;
if (owner.Equipment.Contains(et))
{
CastUnequipItem unequip = new CastUnequipItem(owner.Inventory, owner.Equipment, eq.PeekItem(et));
ib = GetUnequipProcess(current, unequip, owner, grid, handlePlayable);
}
else
{
ib = GetEquipGrid(current, owner, et, owner.Inventory, grid, handlePlayable);
}
grid.List.Add(ib);
}
return(grid);
}
/// <summary>
/// Creates a subGrid containing all possible targets
/// of spellable
/// </summary>
/// <param name="current">Page that owner is on</param>
/// <param name="previous">supergrid containing a list of possible ISpellables to use</param>
/// <param name="caster">User of the Spellable</param>
/// <param name="spellable">Spellable to use on target</param>
/// <param name="spellHandler">Spell handler</param>
/// <returns></returns>
public static Grid GenerateTargets(Page current, IButtonable previous, Character caster, ISpellable spellable, Sprite sprite, Action <Spell> spellHandler)
{
SpellBook sb = spellable.GetSpellBook();
ICollection <Character> targets = sb.TargetType.GetTargets(caster, current);
Grid grid = GenerateBackableGrid(previous, sb.Icon, sb.Name, sb.CreateDescription(caster));
grid.Icon = sprite;
ICollection <Process> targetProcesses = spellable.GetSpellBook().TargetType.GetTargetProcesses(current, spellable, caster, spellHandler);
foreach (Process targetProcess in targetProcesses)
{
grid.List.Add(targetProcess);
}
Item item = spellable as Item;
if (item != null && item.HasFlag(Items.Flag.OCCUPIES_SPACE))
{
grid.List.Add(
new Process(
string.Format("Drop"),
string.Format("Throw away {0}.", item.Name),
() => {
spellHandler(
caster.Spells.CreateSpell(current, new TossItem(item, caster.Inventory), caster, caster)
);
}
));
}
return(grid);
}
public static Grid GenerateGroupItemsGrid(
Page current,
IButtonable previous,
IEnumerable <Character> party,
Action <Spell> addPlay
)
{
Grid grid = GenerateBackableGrid(previous, INVENTORY, party.FirstOrDefault().Inventory.DetailedName, party.FirstOrDefault().Inventory.DetailedDescription);
foreach (Character partyMember in party)
{
if (partyMember.Stats.State == State.ALIVE)
{
grid.List.Add(
GenerateItemsGrid(
current,
grid,
partyMember,
addPlay,
partyMember.Look.Sprite,
partyMember.Look.DisplayName,
string.Format("{0} will be the item's caster.",
partyMember.Look.DisplayName)));
}
else
{
grid.List.Add(new Process(partyMember.Look.DisplayName, partyMember.Look.Sprite, "This unit is dead and is unable to be a caster for any item."));
}
}
return(grid);
}
/// <summary>
/// Create a Back Process, which is used
/// to leave a subgrid.
/// </summary>
/// <param name="previous"></param>
/// <returns></returns>
public static Process GenerateBack(IButtonable previous)
{
return(new Process(
"Back",
Util.GetSprite("plain-arrow"),
string.Format("Go back to {0}.", previous.ButtonText),
() => previous.Invoke()
));
}
public static IButtonable[] UpdateArray <T>(IButtonable[] currentArray, Tuple tuple)
{
IButtonable[] array = currentArray;
if (currentArray.Length - 1 < tuple.Index)
{
array = new IButtonable[tuple.Index];
Array.Copy(currentArray, array, currentArray.Length);
}
array[tuple.Index] = tuple.Data;
return(array);
}
private static Process GenerateSpellProcess(Page current, IButtonable previous, Character owner, ISpellable spellable, Action <IPlayable> handlePlayable, bool isTargetingSelf)
{
SpellBook sb = spellable.GetSpellBook();
return(new Process(sb.GetDetailedName(owner), sb.Icon, sb.CreateDescription(owner),
() => {
if (sb.IsMeetPreTargetRequirements(owner.Stats))
{
GenerateTargets(current, previous, owner, spellable, handlePlayable, isTargetingSelf).Invoke();
}
}));
}
/// <summary>
/// Creates a Grid asking if the user wants to perform a task.
/// </summary>
/// <param name="current">Page grid is on</param>
/// <param name="previous">Previous buttonable</param>
/// <param name="confirm">Process serving as the confirm button</param>
/// <param name="name">Name of this grid</param>
/// <param name="tooltip">Tooltip of this grid</param>
/// <param name="confirmationQuestion">Question to ask when grid is entered.</param>
/// <returns></returns>
public static Grid GetConfirmationGrid(Page current, IButtonable previous, Process confirm, string name, string tooltip, string confirmationQuestion)
{
Grid g = new Grid(name);
g.Tooltip = tooltip;
g.OnEnter += () => {
current.AddText(confirmationQuestion);
};
g.List.Add(PageUtil.GenerateBack(previous));
g.List.Add(confirm);
return(g);
}
/// <summary>
/// Gets a confirmation page asking if the user is sure they want to do a particular action.
/// </summary>
/// <param name="current">The current.</param>
/// <param name="previous">The previous.</param>
/// <param name="confirm">The confirm.</param>
/// <param name="name">The name.</param>
/// <param name="tooltip">The tooltip.</param>
/// <param name="confirmationQuestion">The confirmation question.</param>
/// <returns></returns>
public static Page GetConfirmationPage(Page current, IButtonable previous, Process confirm, string name, string tooltip, string confirmationQuestion)
{
Page p = new Page(name);
p.Body = confirmationQuestion;
p.Actions = new IButtonable[] {
GenerateBack(previous),
confirm
};
return(p);
}
/// <summary>
/// Create a subgrid that can be left to a main grid.
/// </summary>
/// <param name="previous">Content to go back to</param>
/// <param name="icon">Icon on the Button leading to this submenu</param>
/// <param name="name">Name on the button leading to this submenu</param>
/// <param name="tooltip">Description on the button leading to this submenu</param>
/// <returns></returns>
private static Grid GenerateBackableGrid(IButtonable previous, Sprite icon, string name, string tooltip)
{
Grid grid = new Grid(name);
grid.Icon = icon;
grid.Tooltip = tooltip;
List <IButtonable> buttons = new List <IButtonable>();
buttons.Add(GenerateBack(previous));
grid.List = buttons;
return(grid);
}
/// <summary>
/// Gets a basic page that can return to a previous page.
/// </summary>
/// <param name="index">The index.</param>
/// <param name="previousIndex">Index of the previous.</param>
/// <param name="buttons">The buttons.</param>
/// <returns></returns>
protected Page BasicPage(int index, int previousIndex, params IButtonable[] buttons)
{
Page page = Get(index);
IButtonable[] list = new IButtonable[buttons.Length + 1];
list[0] = PageUtil.GenerateBack(Get(previousIndex));
for (int i = 1; i < list.Length; i++)
{
list[i] = buttons[i - 1];
}
page.Actions = list;
return(page);
}
public static Grid GenerateGroupEquipmentGrid(IButtonable previous, Page current, ICollection <Character> party, Action <IPlayable> handlePlayable, bool isInCombat)
{
Grid grid = new Grid("Equipment");
grid.List.Add(GenerateBack(previous));
foreach (Character partyMember in party)
{
grid.List.Add(GenerateEquipmentGrid(current, grid, partyMember, handlePlayable, isInCombat));
}
return(grid);
}
private Grid SetupShopMenu <T>(IButtonable previous, string name, string spriteLoc, string tooltip, IEnumerable <T> items, Func <T, Action, Process> conversion)
{
Grid grid = new Grid(name);
grid.Icon = Util.GetSprite(spriteLoc);
grid.Tooltip = tooltip;
grid.OnEnter = () => {
grid.List.Clear();
grid.List.Add(PageUtil.GenerateBack(previous));
foreach (T item in items)
{
grid.List.Add(conversion(item, () => grid.Invoke()));
}
;
};
return(grid);
}
private static IButtonable[] GetArray(Tuple[] indices, int smallestAllowedSize = 0)
{
int size = Mathf.Max(indices.Max(t => t.Index) + 1, smallestAllowedSize);
IButtonable[] array = new IButtonable[size];
HashSet <int> indexSet = new HashSet <int>();
foreach (Tuple t in indices)
{
if (indexSet.Contains(t.Index))
{
throw new UnityException(string.Format("Index collision detected at index: {0}. Tried to place {1}, but {2} was already there.", t.Data.ButtonText, array[t.Index].ButtonText));
}
indexSet.Add(t.Index);
array[t.Index] = t.Data;
}
return(array);
}
/// <summary>
/// Generate a Grid containing all SpellBooks
/// in Characters.SpellBooks
/// </summary>
/// <param name="current">Page the Owner is on</param>
/// <param name="previous">Previous IButtonable you want this Grid to go back to</param>
/// <param name="owner">Owner of the SpellBooks</param>
/// <param name="excluded">SpellBook to exclude, typically 'Attack'</param>
/// <param name="spellCollection">SpellBooks owned by Owner</param>
/// <param name="addPlay">Chosen action handler</param>
/// <returns></returns>
public static Grid GenerateSpellBooks(
Page current,
IButtonable previous,
Character owner,
SpellBook excluded,
Action <Spell> addPlay
)
{
return(GenerateSpellableGrid(
current,
previous,
owner,
excluded,
((IEnumerable <ISpellable>)owner.Spells).Where(s => s.GetSpellBook().Costs.Count > 0),
addPlay,
SPELLBOOK,
"Spells",
"Cast a spell."));
}
/// <summary>
/// Generates a grid with inventory items
/// to use
/// </summary>
/// <param name="current">Page the owner is on</param>
/// <param name="previous">Main grid</param>
/// <param name="owner">Owner of the inventory</param>
/// <param name="addPlay">IPlayable handler</param>
/// <param name="isInCombat">If in combat, X will use Y on Z, if out of battle, Z would use Y on themself.</param>
/// <returns></returns>
public static Grid GenerateItemsGrid(
bool isInCombat,
Page current,
IButtonable previous,
Character owner,
Action <IPlayable> addPlay
)
{
return(GenerateSpellableGrid(
!isInCombat,
current,
previous,
owner,
null,
owner.Inventory,
addPlay,
INVENTORY,
string.Format("Items ({0}/{1})", owner.Inventory.TotalOccupiedSpace, owner.Inventory.Capacity),
string.Format("Use an item.\n{0} out of {1} inventory space is occupied.", owner.Inventory.TotalOccupiedSpace, owner.Inventory.Capacity)
));
}
private static Process GenerateTargetProcessHelper(
Page current,
IButtonable previous,
Character owner,
Character target,
SpellBook sb,
Action <IPlayable> handlePlayable,
string name,
Sprite icon)
{
return(new Process(name,
icon,
sb.CreateTargetDescription(owner, target),
() => {
if (sb.IsCastable(owner, target))
{
handlePlayable(owner.Spells.CreateSpell(current, sb, owner, target));
previous.Invoke();
}
}));
}
public static Grid GenerateGroupEquipmentGrid(IButtonable previous, Page current, ICollection <Character> party, Action <Spell> spellHandler)
{
Grid grid = new Grid("Equipment");
grid.Icon = EQUIPMENT;
grid.List.Add(GenerateBack(previous));
foreach (Character partyMember in party)
{
if (partyMember.Stats.State == State.ALIVE)
{
grid.List.Add(GenerateEquipmentGrid(current, grid, partyMember, spellHandler, partyMember.Look.Sprite, partyMember.Look.DisplayName));
}
else
{
grid.List.Add(new Process(partyMember.Look.DisplayName, partyMember.Look.Sprite, "This unit is dead and is unable to manage its equipment."));
}
}
return(grid);
}
/// <summary>
/// Creates a subGrid containing all possible targets
/// of spellable
/// </summary>
/// <param name="current">Page that owner is on</param>
/// <param name="previous">supergrid containing a list of possible ISpellables to use</param>
/// <param name="owner">User of the Spellable</param>
/// <param name="spellable">Spellable to use on target</param>
/// <param name="handlePlayable">Playable handler</param>
/// <param name="isTargetingSelf">If true, the target will attempt to cast the spell on themselves (used for out of combat inventories)</param>
/// <returns></returns>
public static Grid GenerateTargets(Page current, IButtonable previous, Character owner, ISpellable spellable, Sprite sprite, Action <IPlayable> handlePlayable, bool isTargetingSelf)
{
SpellBook sb = spellable.GetSpellBook();
ICollection <Character> targets = sb.TargetType.GetTargets(owner, current);
Grid grid = GenerateBackableGrid(previous, sb.Icon, sb.Name, sb.CreateDescription(owner));
grid.Icon = sprite;
foreach (Character myTarget in targets)
{
Character target = myTarget;
Character spellOwner = null;
if (isTargetingSelf)
{
spellOwner = target;
}
else
{
spellOwner = owner;
}
grid.List.Add(GenerateTargetProcess(current, previous, spellOwner, target, sb, handlePlayable));
}
Item item = spellable as Item;
if (item != null && item.HasFlag(Items.Flag.OCCUPIES_SPACE))
{
grid.List.Add(
new Process(
string.Format("Drop"),
string.Format("Throw away {0}.", item.Name),
() => {
handlePlayable(
owner.Spells.CreateSpell(current, new TossItem(item, owner.Inventory), owner, owner)
);
}
));
}
return(grid);
}
/// <summary>
/// Actions are spells without a cost.
/// </summary>
/// <param name="current">The current page.</param>
/// <param name="previous">The previous page.</param>
/// <param name="owner">The owner of the action.</param>
/// <param name="excluded">The excluded spell.</param>
/// <param name="concat">The spells to add alongside the spellbook's.</param>
/// <param name="playHandler">The play handler.</param>
/// <returns></returns>
public static Grid GenerateActions(
Page current,
IButtonable previous,
Character owner,
SpellBook excluded,
IEnumerable <ISpellable> concat,
Action <Spell> playHandler
)
{
List <SpellBook> spellsThatHaveACost = new List <SpellBook>();
return(GenerateSpellableGrid(
current,
previous,
owner,
excluded,
((IEnumerable <ISpellable>)owner.Spells).Where(s => s.GetSpellBook().Costs.Count <= 0).ToList().Concat(concat),
playHandler,
ACTION,
"Action",
"Perform an action."));
}
/// <summary>
/// Generates a grid with inventory items
/// to use
/// </summary>
/// <param name="current">Page the owner is on</param>
/// <param name="previous">Main grid</param>
/// <param name="owner">Owner of the inventory</param>
/// <param name="addPlay">IPlayable handler</param>
/// <returns></returns>
public static Grid GenerateItemsGrid(
Page current,
IButtonable previous,
Character owner,
Action <Spell> addPlay,
Sprite sprite,
string name,
string description
)
{
return(GenerateSpellableGrid(
current,
previous,
owner,
null,
owner.Inventory,
addPlay,
sprite,
name,
description
));
}
private static Process GetUnequipProcess(Page current, CastUnequipItem unequipSpell, Character owner, IButtonable previous, Action <IPlayable> handlePlayable)
{
return(new Process(unequipSpell.Name, unequipSpell.Icon, unequipSpell.CreateDescription(owner),
() => {
handlePlayable(owner.Spells.CreateSpell(current, unequipSpell, owner, owner));
previous.Invoke();
},
() => unequipSpell.IsCastable(owner, owner)
));
}
private static Grid GetEquipGrid(Page current, Character owner, EquipType et, Inventory inv, IButtonable previous, Action <IPlayable> handlePlayable)
{
Grid grid = GenerateBackableGrid(
previous,
et.Sprite,
Util.ColorString(et.Name, Color.grey),
string.Format("Equip an item in the <color=yellow>{0}</color> slot.", et.Name)
);
foreach (EquippableItem ei in inv as IEnumerable <EquippableItem> )
{
if (ei.Type.Equals(et))
{
grid.List.Add(GenerateTargetProcessHelper(current, previous, owner, owner, new CastEquipItem(ei), handlePlayable, ei.Name, ei.Icon));
}
}
return(grid);
}
/// <summary>
/// Clears the action grid.
/// </summary>
public void ClearActionGrid()
{
Actions = new IButtonable[Grid.DEFAULT_BUTTON_COUNT];
}
private static Process GenerateTargetProcess(Page current, IButtonable previous, Character owner, Character target, SpellBook sb, Action <IPlayable> handlePlayable)
{
return(GenerateTargetProcessHelper(current, previous, owner, target, sb, handlePlayable, CreateDetailedTargetName(owner, target, sb), target.Look.Sprite));
}
public Tuple(int index, IButtonable data)
{
this.Index = index;
this.Data = data;
}
private Grid SetupBuyMenu(IButtonable previous)
{
return(SetupShopMenu <Buy>(previous, "Buy", "buy-card", string.Format("Buy items with {0}s.", MONEY.Name), buys, (b, a) => GetBuyProcess(b, a)));
}
private Grid SetupSellMenu(IButtonable previous)
{
return(SetupShopMenu <Item>(previous, "Sell", "sell-card", string.Format("Sell items for {0}s.", MONEY.Name), party.Shared, (i, a) => GetSellProcess(i, a)));
}
/// <summary>
/// Creates a subGrid containing all possible targets
/// of spellable
/// </summary>
/// <param name="current">Page that owner is on</param>
/// <param name="previous">supergrid containing a list of possible ISpellables to use</param>
/// <param name="owner">User of the Spellable</param>
/// <param name="spellable">Spellable to use on target</param>
/// <param name="handlePlayable">Playable handler</param>
/// <returns></returns>
public static Grid GenerateTargets(Page current, IButtonable previous, Character owner, ISpellable spellable, Action <IPlayable> handlePlayable, bool isTargetingSelf)
{
return(GenerateTargets(current, previous, owner, spellable, spellable.GetSpellBook().Icon, handlePlayable, isTargetingSelf));
}
private Grid SetupTalkMenu(IButtonable previous)
{
return(SetupShopMenu <Talk>(previous, "Talk", "talk", "Talk to the shopkeeper about something.", talks, (t, a) => GetTalkProcess(t, a)));
}
