/// <summary>
/// Constructor
/// </summary>
/// <param name="log"></param>
/// <param name="listExpression"></param>
/// <param name="condition"></param>
/// <param name="expression"></param>
/// <param name="root">the root element for which this expression should be parsed</param>
/// <param name="iteratorVariableName"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public SumExpression(ModelElement root, ModelElement log, Expression listExpression, string iteratorVariableName,
Expression condition, Expression expression, ParsingData parsingData)
: base(root, log, listExpression, iteratorVariableName, condition, expression, parsingData)
{
AccumulatorVariable = CreateBoundVariable("RESULT", null);
ISubDeclaratorUtils.AppendNamable(this, AccumulatorVariable);
if (expression != null)
{
DefinedAccumulator = SetEnclosed(expression);
Accumulator =
SetEnclosed(new BinaryExpression(
Root,
RootLog,
DefinedAccumulator,
BinaryExpression.Operator.Add,
new UnaryExpression(
Root,
RootLog,
new Term(
Root,
RootLog,
new Designator(Root, RootLog, "RESULT", ParsingData.SyntheticElement),
ParsingData.SyntheticElement),
ParsingData.SyntheticElement),
ParsingData.SyntheticElement));
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this element is built</param>
/// <param name="log"></param>
/// <param name="variableIdentification"></param>
/// <param name="expression"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public VariableUpdateStatement(ModelElement root, ModelElement log, Expression variableIdentification,
Expression expression, ParsingData parsingData)
: base(root, log, parsingData)
{
VariableIdentification = SetEnclosed(variableIdentification);
Expression = SetEnclosed(expression);
}
private void Awake()
{
// 아이템 리스트에 대한 각 변수들을 할당
Transform trans = itemContent.transform;
itemSlots = new SlotScript[trans.childCount];
for (int num = 0; num < trans.childCount; num++)
{
itemSlots[num] = trans.GetChild(num).gameObject.GetComponent <SlotScript>();
itemSlots[num].InitSlot(num);
}
// 재료 리스트에 대한 각 변수들을 할당
trans = materialContent.transform;
materialSlots = new SlotScript[trans.childCount];
for (int num = 0; num < trans.childCount; num++)
{
materialSlots[num] = trans.GetChild(num).gameObject.GetComponent <SlotScript>();
materialSlots[num].InitSlot(-1);
}
// All Item List scriptable object 캐싱
allData = Resources.Load("CSVData/All Item List Asset") as ParsingData;
// All Mix List scriptable object 캐싱
allMix = Resources.Load("CSVData/All Mix List Asset") as ParsingData;
// stage1 item 이미지 캐싱
stage1_sprites = Resources.LoadAll <Sprite>("ArtResource/Stage1/Object/");
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this element is built</param>
/// <param name="log"></param>
/// <param name="variableIdentification"></param>
/// <param name="expression"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public VariableUpdateStatement(ModelElement root, ModelElement log, Expression variableIdentification,
Expression expression, ParsingData parsingData)
: base(root, log, parsingData)
{
VariableIdentification = SetEnclosed(variableIdentification);
Expression = SetEnclosed(expression);
}
public static AsicStandardStatsObject WebConvert(string html, ParsingObject parsingObject)
{
AsicStandardStatsObject LasicColumn = new AsicStandardStatsObject();
List <string> listTableStats = ParsingData.ParsTable(html, parsingObject.MainNameTable,
parsingObject.MainTableParsingPattern);
List <string> summaryTable = ParsingData.ParsTable(html, parsingObject.AdditionalNameTable,
parsingObject.AdditionalTableParsingPattern);
if (IsOld(listTableStats[1]))
{
LasicColumn = AsiCparsingMethods.GetOldData(LasicColumn, listTableStats);
}
else
{
LasicColumn = AsiCparsingMethods.GetNewData(LasicColumn, listTableStats);
}
LasicColumn.HashrateAVG = listTableStats[listTableStats.Count - 1];
LasicColumn.DateTime = DateTime.Now.ToString();
LasicColumn.ElapsedTime = summaryTable[8 + 0];
return(LasicColumn);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="log"></param>
/// <param name="listExpression"></param>
/// <param name="condition"></param>
/// <param name="expression"></param>
/// <param name="root">the root element for which this expression should be parsed</param>
/// <param name="iteratorVariableName"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public SumExpression(ModelElement root, ModelElement log, Expression listExpression, string iteratorVariableName,
Expression condition, Expression expression, ParsingData parsingData)
: base(root, log, listExpression, iteratorVariableName, condition, expression, parsingData)
{
AccumulatorVariable = CreateBoundVariable("RESULT", null);
ISubDeclaratorUtils.AppendNamable(this, AccumulatorVariable);
if (expression != null)
{
DefinedAccumulator = SetEnclosed(expression);
Accumulator =
SetEnclosed(new BinaryExpression(
Root,
RootLog,
DefinedAccumulator,
BinaryExpression.Operator.Add,
new UnaryExpression(
Root,
RootLog,
new Term(
Root,
RootLog,
new Designator(Root, RootLog, "RESULT", ParsingData.SyntheticElement),
ParsingData.SyntheticElement),
ParsingData.SyntheticElement),
ParsingData.SyntheticElement));
}
}
public ComputationFactory(GameData gameData)
{
_builderFactories = new Lazy <Task <IBuilderFactories> >(
() => BuilderFactories.CreateAsync(gameData));
_parser = new Lazy <Task <IParser> >(
() => Parser <ParsingStep> .CreateAsync(gameData, _builderFactories.Value,
ParsingData.CreateAsync(gameData, _builderFactories.Value)));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this element is built</param>
/// <param name="log"></param>
/// <param name="value">The value to insert</param>
/// <param name="listExpression">The list to alter</param>
/// <param name="replaceElement">The element to be replaced, if any</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public InsertStatement(ModelElement root, ModelElement log, Expression value, Expression listExpression,
Expression replaceElement, ParsingData parsingData)
: base(root, log, parsingData)
{
Value = SetEnclosed(value);
ListExpression = SetEnclosed(listExpression);
ReplaceElement = SetEnclosed(replaceElement);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this element is built</param>
/// <param name="log"></param>
/// <param name="value">The value to insert</param>
/// <param name="listExpression">The list to alter</param>
/// <param name="replaceElement">The element to be replaced, if any</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public InsertStatement(ModelElement root, ModelElement log, Expression value, Expression listExpression,
Expression replaceElement, ParsingData parsingData)
: base(root, log, parsingData)
{
Value = SetEnclosed(value);
ListExpression = SetEnclosed(listExpression);
ReplaceElement = SetEnclosed(replaceElement);
}
private void Start()
{
ani = GetComponent <Animator>();
playerCtrl = GameObject.FindGameObjectWithTag("Player").GetComponent <PlayerCtrl>();
parsingData = GameObject.Find("ParsingData").GetComponent <ParsingData>();
_audio = GetComponent <AudioSource>();
}
public ComputationFactory(GameData gameData)
{
_calculator = new Lazy <ICalculator>(Calculator.Create);
_builderFactories = new Lazy <Task <IBuilderFactories> >(
() => BuilderFactories.CreateAsync(gameData));
_parser = new Lazy <Task <IParser> >(
async() => await Parser <ParsingStep> .CreateAsync(gameData, _builderFactories.Value,
ParsingData.CreateAsync(gameData, _builderFactories.Value)));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">the root element for which this expression should be parsed</param>
/// <param name="log"></param>
/// <param name="listExpression"></param>
/// <param name="iteratorVariableName"></param>
/// <param name="condition"></param>
/// <param name="function"></param>
/// <param name="initialValue"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public ReduceExpression(ModelElement root, ModelElement log, Expression listExpression,
string iteratorVariableName, Expression condition, Expression function, Expression initialValue, ParsingData parsingData)
: base(root, log, listExpression, iteratorVariableName, condition, function, parsingData)
{
InitialValue = SetEnclosed(initialValue);
AccumulatorVariable = CreateBoundVariable("RESULT", null);
ISubDeclaratorUtils.AppendNamable(this, AccumulatorVariable);
}
public CompositionRoot()
{
_gameData = new Lazy <GameData>(
() => new GameData(PassiveTreeDefinition.CreateKeystoneDefinitions(), true));
_builderFactories = new Lazy <Task <IBuilderFactories> >(
() => Builders.BuilderFactories.CreateAsync(_gameData.Value));
_parser = new Lazy <Task <IParser> >(
() => Parser <ParsingStep> .CreateAsync(_gameData.Value, _builderFactories.Value,
ParsingData.CreateAsync(_gameData.Value, _builderFactories.Value)));
}
public CompositionRoot()
{
_gameData = new Lazy <GameData>(
() => new GameData(PassiveTreeDefinition.CreateKeystoneDefinitions(), true));
_calculator = new Lazy <ICalculator>(Core.Calculator.Create);
_builderFactories = new Lazy <Task <IBuilderFactories> >(
() => Builders.BuilderFactories.CreateAsync(_gameData.Value));
_parser = new Lazy <Task <IParser> >(
async() => await Parser <ParsingStep> .CreateAsync(_gameData.Value, _builderFactories.Value,
ParsingData.CreateAsync(_gameData.Value, _builderFactories.Value)).ConfigureAwait(false));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this element is built</param>
/// <param name="log"></param>
/// <param name="value">The value to insert in the list</param>
/// <param name="listExpression">The list affected by the replace statement</param>
/// <param name="condition">The condition which indicates the value to be replaced</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public ReplaceStatement(ModelElement root, ModelElement log, Expression value, Expression listExpression,
Expression condition, ParsingData parsingData)
: base(root, log, parsingData)
{
Value = SetEnclosed(value);
ListExpression = SetEnclosed(listExpression);
Condition = SetEnclosed(condition);
IteratorVariable = CreateBoundVariable("X", null);
InitDeclaredElements();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this element is built</param>
/// <param name="log"></param>
/// <param name="condition">The corresponding function call designator</param>
/// <param name="position">The position in which the element should be removed</param>
/// <param name="listExpression">The expressions used to compute the parameters</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public RemoveStatement(ModelElement root, ModelElement log, Expression condition, PositionEnum position,
Expression listExpression, ParsingData parsingData)
: base(root, log, parsingData)
{
Condition = SetEnclosed(condition);
Position = position;
ListExpression = SetEnclosed(listExpression);
IteratorVariable = CreateBoundVariable("X", null);
InitDeclaredElements();
}
public void IsValid_TwoElementsTooMuch_False()
{
List <string> testList = new List <string>();
ParsingData parsing = new ParsingData(testList);
string[] singleElemenArray = { "aa", "aa", "4", "bb", "bb", "8", "cc", "cc" };
bool isValidToJson = parsing.IsValid(singleElemenArray);
Assert.IsFalse(isValidToJson);
}
private void _parserController_NewDataReceived(object sender, ParsingData e)
{
if (Enum.TryParse(e.Name, out DataGrid myStatus))
{
_view.BindData(e.Data, myStatus);
}
else
{
_messageService.ShowError("Недоступный тип DataGrid!");
}
}
public static AsicStandardStatsObject ApiConvert(string html)
{
AsicStandardStatsObject asicStandard = new AsicStandardStatsObject();
var Json = ParsingData.ParsAPI(html);
asicStandard = AsiCparsingMethods.GetApiData(asicStandard, Json);
return(asicStandard);
}
public void IsValid_NoData_False()
{
List <string> testList = new List <string>();
ParsingData parsing = new ParsingData(testList);
string[] singleElemenArray = { };
bool isValidToJson = parsing.IsValid(singleElemenArray);
Assert.IsFalse(isValidToJson);
}
public void IsValid_NumberIsString_False()
{
List <string> testList = new List <string>();
ParsingData parsing = new ParsingData(testList);
string[] singleElemenArray = { "aa", "aa", "4", "bb", "bb", "5", "cc", "cc", "wrong" };
bool isValidToJson = parsing.IsValid(singleElemenArray);
Assert.IsFalse(isValidToJson);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this element is built</param>
/// <param name="log"></param>
/// <param name="condition">The corresponding function call designator</param>
/// <param name="position">The position in which the element should be removed</param>
/// <param name="listExpression">The expressions used to compute the parameters</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public RemoveStatement(ModelElement root, ModelElement log, Expression condition, PositionEnum position,
Expression listExpression, ParsingData parsingData)
: base(root, log, parsingData)
{
Condition = SetEnclosed(condition);
Position = position;
ListExpression = SetEnclosed(listExpression);
IteratorVariable = CreateBoundVariable("X", null);
InitDeclaredElements();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">the root element for which this expression should be parsed</param>
/// <param name="log"></param>
/// <param name="listExpression"></param>
/// <param name="iteratorVariableName">The name of the iterator variable</param>
/// <param name="parsingData">Additional information about the parsing process</param>
protected ListOperatorExpression(ModelElement root, ModelElement log, Expression listExpression,
string iteratorVariableName, ParsingData parsingData)
: base(root, log, parsingData)
{
ListExpression = SetEnclosed(listExpression);
IteratorVariable = CreateBoundVariable(iteratorVariableName, null);
PreviousIteratorVariable = CreateBoundVariable("prevX", null);
InitDeclaredElements();
}
public void IsValid_RightInput_True()
{
List <string> testList = new List <string>();
ParsingData parsing = new ParsingData(testList);
string[] singleElemenArray = { "aa", "aa", "4", "bb", "bb", "8" };
bool isValidToJson = parsing.IsValid(singleElemenArray);
Assert.IsTrue(isValidToJson);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">the root element for which this expression should be parsed</param>
/// <param name="log"></param>
/// <param name="listExpression"></param>
/// <param name="iteratorVariableName">The name of the iterator variable</param>
/// <param name="parsingData">Additional information about the parsing process</param>
protected ListOperatorExpression(ModelElement root, ModelElement log, Expression listExpression,
string iteratorVariableName, ParsingData parsingData)
: base(root, log, parsingData)
{
ListExpression = SetEnclosed(listExpression);
IteratorVariable = CreateBoundVariable(iteratorVariableName, null);
PreviousIteratorVariable = CreateBoundVariable("prevX", null);
InitDeclaredElements();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this element is built</param>
/// <param name="log"></param>
/// <param name="value">The value to insert in the list</param>
/// <param name="listExpression">The list affected by the replace statement</param>
/// <param name="condition">The condition which indicates the value to be replaced</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public ReplaceStatement(ModelElement root, ModelElement log, Expression value, Expression listExpression,
Expression condition, ParsingData parsingData)
: base(root, log, parsingData)
{
Value = SetEnclosed(value);
ListExpression = SetEnclosed(listExpression);
Condition = SetEnclosed(condition);
IteratorVariable = CreateBoundVariable("X", null);
InitDeclaredElements();
}
public void SplittingJsonString_HashSignsAdded_StringNoHash()
{
List <string> testList = new List <string>();
ParsingData parsing = new ParsingData(testList);
string inputString = "#sd#dd#23#grr#sdada#3";
string validString = "sddd23grrsdada3";
String[] ArrayNoHash = parsing.SplittingJsonString(inputString);
string outputString = string.Join("", ArrayNoHash);
Assert.AreEqual(validString, outputString);
}
public void SplittingJsonString_DifferentSignsAdded_StringNoDifferentSigns()
{
List <string> testList = new List <string>();
ParsingData parsing = new ParsingData(testList);
string inputString = ":sd:dd :2#3:grr :sd##ada:3#";
string validString = "sddd23grrsdada3";
String[] ArrayNoVariation = parsing.SplittingJsonString(inputString);
string outputString = string.Join("", ArrayNoVariation);
Assert.AreEqual(validString, outputString);
}
public void SplittingJsonString_ColonsAdded_StringNoColon()
{
List <string> testList = new List <string>();
ParsingData parsing = new ParsingData(testList);
string inputString = ":sd:dd:23:grr:sdada:3";
string validString = "sddd23grrsdada3";
String[] ArrayNoColon = parsing.SplittingJsonString(inputString);
string outputString = string.Join("", ArrayNoColon);
Assert.AreEqual(validString, outputString);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this element is built</param>
/// <param name="log"></param>
/// <param name="appliedStatement">The statement to be applied when the condition is satisfied</param>
/// <param name="listExpression">The list to work on</param>
/// <param name="conditionExpression">The condition to apply on the list elements</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public ApplyStatement(ModelElement root, ModelElement log, Statement appliedStatement, Expression listExpression,
Expression conditionExpression, ParsingData parsingData)
: base(root, log, parsingData)
{
DeclaredElements = new Dictionary<string, List<INamable>>();
AppliedStatement = SetEnclosed(appliedStatement);
ListExpression = SetEnclosed(listExpression);
ConditionExpression = SetEnclosed(conditionExpression);
IteratorVariable = CreateBoundVariable("X", null);
InitDeclaredElements();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this element is built</param>
/// <param name="log"></param>
/// <param name="appliedStatement">The statement to be applied when the condition is satisfied</param>
/// <param name="listExpression">The list to work on</param>
/// <param name="conditionExpression">The condition to apply on the list elements</param>
/// <param name="parsingData">Additional information about the parsing process</param>
public ApplyStatement(ModelElement root, ModelElement log, Statement appliedStatement, Expression listExpression,
Expression conditionExpression, ParsingData parsingData)
: base(root, log, parsingData)
{
DeclaredElements = new Dictionary <string, List <INamable> >();
AppliedStatement = SetEnclosed(appliedStatement);
ListExpression = SetEnclosed(listExpression);
ConditionExpression = SetEnclosed(conditionExpression);
IteratorVariable = CreateBoundVariable("X", null);
InitDeclaredElements();
}
internal ParsingData FetchParsingData()
{
ParsingData result = parsingDataCache.Get();
if (result == null)
{
result = new ParsingData();
CurrencySink sink = new CurrencySink(!fallback, CurrencySink.EntrypointTable.TOP);
sink.parsingData = result;
rb.GetAllItemsWithFallback("", sink);
parsingDataCache = new SoftReference <ParsingData>(result);
}
return(result);
}
string ParseDocument(string input)
{
dynamic json;
json = JsonConvert.DeserializeObject(input);
string uri = uriPath((string)json.uri);
if (uri == null)
{
return(null);
}
string content = json.content;
// Get the document.
Document document;
if (documents.ContainsKey(uri))
{
document = documents[uri];
}
else
{
document = new Document(uri);
documents.Add(uri, document);
}
document.Content = content;
// Parse the file.
parserData = ParsingData.GetParser(document.Uri, content);
// Update the document's ruleset.
if (parserData.Rulesets.ContainsKey(uri))
{
document.Ruleset = parserData.Rulesets[uri];
}
if (parserData.Rules != null && !parserData.Diagnostics.ContainsErrors())
{
// Update the document's workshop result.
document.WorkshopResult = Program.RuleArrayToWorkshop(parserData.Rules.ToArray(), parserData.VarCollection);
}
PublishDiagnosticsParams[] diagnostics = parserData.Diagnostics.GetDiagnostics();
return(JsonConvert.SerializeObject(diagnostics));
}
private static void Send(ParsingData data, int clientPort, string uri)
{
string final = Program.RuleArrayToWorkshop(data.Rules.ToArray(), data.VarCollection);
var result = JsonConvert.SerializeObject((code: final, uri: uri));
try
{
using (var wc = new WebClient())
{
wc.Encoding = System.Text.Encoding.UTF8;
wc.UploadString($"http://localhost:{clientPort}/", result);
}
}
catch (WebException ex)
{
Log.Write(LogLevel.Normal, "Failed to upload workshop result: " + ex.Message);
}
}
/// <summary>
/// 새로 시작
/// 파싱 데이터를 적용 시킨다
/// </summary>
/// <returns></returns>
public PlayerData NewData()
{
PlayerData data = new PlayerData();
ParsingData parsingData = GameObject.Find("ParsingData").GetComponent <ParsingData>();
data.id = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].id;
data.charName = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].charName;
data.nHp = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].nHp;
data.nMaxHp = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].nMaxHp;
data.fMana = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].fMana;
data.fMaxMana = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].fMaxMana;
data.fThirst = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].fThirst;
data.fMaxThirst = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].fMaxThirst;
data.fSatiety = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].fSatiety;
data.fMaxSatiety = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].fMaxSatiety;
data.fSpeed = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].fSpeed;
data.nMaxUpgradeHp = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].nMaxUpgradeHp;
data.fMaxUpgradeMana = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].fMaxUpgradeMana;
data.fMaxUpgradeThirst = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].fMaxUpgradeThirst;
data.fMaxUpgradeSatiety = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].fMaxUpgradeSatiety;
data.fWeight = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].fWeight;
data.fMaxWeight = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].fMaxWeight;
data.nAmmo = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].nAmmo;
data.nMaxAmmo = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].nMaxAmmo;
data.nMoney = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].nMoney;
data.nMaterial = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].nMaterial;
data.nPartsMaterial = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].nPartsMaterial;
data.UseSkillMana1 = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].UseSkillMana1;
data.UseSkillMana2 = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].UseSkillMana2;
data.UseSkillMana3 = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].UseSkillMana3;
data.stageClearList = parsingData.PlayerList[GameManager.INSTANCE.CurPlayerIndenx].stageClearList;
return(data);
}
// ============================================================== Public Function =============================================================
public void Init()
{
// 각 slot들 초기화 및 컴포넌트 연결
slots = transform.GetComponentsInChildren <InformationSlot>();
foreach (InformationSlot slot in slots)
{
slot.Init(gameObject.GetComponent <DocumentInformationManager>());
}
clues = transform.GetComponentsInChildren <InformationClue>();
foreach (InformationClue clue in clues)
{
clue.Init(gameObject.GetComponent <DocumentInformationManager>());
}
InfoImage = transform.Find("InfoImage").GetComponent <Image>();
expText = transform.Find("ExpSheet").Find("Viewport").Find("ExpText").GetComponent <Text>();
expRect = expText.GetComponent <RectTransform>();
slotsRect = transform.Find("ScrollBack").Find("Viewport").Find("Content").GetComponent <RectTransform>();
// information 정보를 추출할 csv 파일t 캐싱
allData = Resources.Load("CSVData/All Item List Asset") as ParsingData;
}
/// <summary>
/// Constructor for THERE_IS, FORALL, FIRST, LAST
/// </summary>
/// <param name="root">the root element for which this expression should be parsed</param>
/// <param name="log"></param>
/// <param name="listExpression"></param>
/// <param name="iteratorVariableName"></param>
/// <param name="condition"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
protected ConditionBasedListExpression(ModelElement root, ModelElement log, Expression listExpression,
string iteratorVariableName, Expression condition, ParsingData parsingData)
: base(root, log, listExpression, iteratorVariableName, parsingData)
{
Condition = SetEnclosed(condition);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">The root element for which this element is built</param>
/// <param name="log"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
protected Statement(ModelElement root, ModelElement log, ParsingData parsingData)
: base(root, log, parsingData)
{
}
/// <summary>
/// Constructor for MAP, REDUCE
/// </summary>
/// <param name="root"></param>
/// <param name="log"></param>
/// <param name="listExpression"></param>
/// <param name="iteratorVariableName"></param>
/// <param name="condition">the condition to apply to list elements</param>
/// <param name="iteratorExpression">the expression to be evaluated on each element of the list</param>
/// <param name="parsingData">Additional information about the parsing process</param>
protected ExpressionBasedListExpression(ModelElement root, ModelElement log, Expression listExpression,
string iteratorVariableName, Expression condition, Expression iteratorExpression, ParsingData parsingData)
: base(root, log, listExpression, iteratorVariableName, condition, parsingData)
{
IteratorExpression = SetEnclosed(iteratorExpression);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="root">the root element for which this expression should be parsed</param>
/// <param name="log"></param>
/// <param name="listExpression"></param>
/// <param name="iteratorVariableName"></param>
/// <param name="condition"></param>
/// <param name="parsingData">Additional information about the parsing process</param>
public ThereIsExpression(ModelElement root, ModelElement log, Expression listExpression,
string iteratorVariableName, Expression condition, ParsingData parsingData)
: base(root, log, listExpression, iteratorVariableName, condition, parsingData)
{
}
void OnEnable()
{
// 원본 클래스에 정의되어 있는, 모든 아이템의 정보를 담고 있는 딕셔너리에 접근하기 위한 스크립트 캐싱.
parsingData = (ParsingData)target;
}
