public GEMenuItem(string id, GEText menuName, List <GEAction> actions, GERequirement requirements, SortedList <string, GEText> texts, bool?isActive, int?maxUseNumber) : this(id, menuName, actions)
{
this.requirements = requirements;
this.texts = texts;
this.maxUseNumber = maxUseNumber ?? 0;
this.isActive = isActive ?? false;
}
private List <GENpc.GEAnswer> ProcessAnswers(List <NPCsTypeNPCConversationLineAnswer> answers, GENpc.GELine line)
{
List <GENpc.GEAnswer> processedAnswers = new List <GENpc.GEAnswer>();
if (answers == null || answers.Count == 0)
{
return(processedAnswers);
}
foreach (NPCsTypeNPCConversationLineAnswer answer in answers)
{
GERequirement requirement = ProcessRequirements(answer.Requirements);
GENpc.GEItemAction action = ProcessActions(answer.Actions, answer.id);
GENpc.GEAnswer newAnser = new GENpc.GEAnswer(answer.id, answer.activeAtStart, line)
{
Requirement = requirement,
Action = action
};
OnReferenceProcessing += delegate(object o, EventArgs e)
{
newAnser.AnswerText = elementManager.GetTextElement(answer.textId);
newAnser.NextLine = elementManager.GetNpcConvLine(answer.nextLineId);
};
processedAnswers.Add(newAnser);
elementManager.AddNpcAnswer(newAnser);
}
return(processedAnswers);
}
private SortedList <string, GENeighbour> ProcessNeighbours(NeighboursType neighbours)
{
SortedList <string, GENeighbour> processedNeighbours = new SortedList <string, GENeighbour>();
if (neighbours == null)
{
return(processedNeighbours);
}
foreach (NeighboursTypeNeighbour neighbour in neighbours.Neighbour)
{
GERequirement requirements = ProcessRequirements(neighbour.Requirements);
OnReferenceProcessing += delegate(object o, EventArgs e)
{
GENeighbour newNeighbour = new GENeighbour(neighbour.id, neighbour.activeAtStart)
{
MenuText = elementManager.GetTextElement(neighbour.nameTextId),
Room = elementManager.GetRoom(neighbour.roomRefId),
Requirements = requirements
};
processedNeighbours.Add(neighbour.id, newNeighbour);
elementManager.AddNeighbour(newNeighbour);
};
}
return(processedNeighbours);
}
private SortedList <string, GEMenuItem> ProcessMenuItems(MenuItemsType menuItems, string parentId)
{
SortedList <string, GEMenuItem> processedMenuItems = new SortedList <string, GEMenuItem>();
if (menuItems == null)
{
return(processedMenuItems);
}
foreach (MenuItemsTypeMenuItem menuItem in menuItems.MenuItem)
{
SortedList <string, GEText> texts = ProcessTexts(menuItem.Texts);
List <GEAction> actionsToAdd = new List <GEAction>();
foreach (ActionsType action in menuItem.Actions)
{
actionsToAdd.Add(ProcessActions(action, parentId));
}
GERequirement requirements = ProcessRequirements(menuItem.Requirements);
GEMenuItem newMenuItem = new GEMenuItem(menuItem.id, null, actionsToAdd, requirements, texts, menuItem.activeAtStart, menuItem.useNumber);
OnReferenceProcessing += delegate(object o, EventArgs e)
{
newMenuItem.MenuName = elementManager.GetTextElement(menuItem.menuTextId);
};
elementManager.AddMenuItem(newMenuItem);
processedMenuItems.Add(menuItem.id, newMenuItem);
}
return(processedMenuItems);
}
private GERequirement ProcessRequirements(RequirementsType requirements)
{
if (requirements == null)
{
return(null);
}
List <GERequirement.GEActivationChecker> activationCheckers = new List <GERequirement.GEActivationChecker>();
foreach (RequirementsTypeIsActive aChecker in requirements.isActive)
{
activationCheckers.Add(new GERequirement.GEActivationChecker(elementManager, aChecker.refId, aChecker.value));
}
List <GERequirement.GEPropertyChecker> propertyCheckers = new List <GERequirement.GEPropertyChecker>();
foreach (RequirementsTypePropertyCondition pChecker in requirements.propertyCondition)
{
PropertyConditionEnum condition = pChecker.condition;
GERequirement.PropertyConditionType cType = GERequirement.PropertyConditionType.EQ;
if (!condition.Equals(PropertyConditionEnum.eq))
{
cType = condition.Equals(PropertyConditionEnum.lt) ? GERequirement.PropertyConditionType.LT : GERequirement.PropertyConditionType.GT;
}
propertyCheckers.Add(new GERequirement.GEPropertyChecker(elementManager, pChecker.refId, cType, pChecker.value));
}
List <GERequirement.GEEquippedChecker> equippedCheckers = new List <GERequirement.GEEquippedChecker>();
foreach (RequirementsTypeIsEquipped aChecker in requirements.isEquipped)
{
equippedCheckers.Add(new GERequirement.GEEquippedChecker(elementManager, aChecker.refId, aChecker.value));
}
GERequirement requirement = new GERequirement(null, activationCheckers, propertyCheckers, equippedCheckers);
OnReferenceProcessing += delegate(object o, EventArgs e)
{
requirement.TextOnFail = elementManager.GetTextElement(requirements.textOnFail);
};
return(requirement);
}
