public Element(ElementData data, ElementType type)
{
Parent = null;
eType = type;
eData = data;
if(eData != null)
CurrentID = eData.ID.textureID;
Children = new List<Element>();
if (data == null)
return;
Width = eData.ImageData.Size.Width;
Height = eData.ImageData.Size.Height;
if (type == ElementType.Button)
{
ElementProperties OnClickProperty = GetProperty(data.Properties, ElementProperties.PropertyType.OnClick);
Bitmap click_img = null;
TextureID click_id = null;
if (OnClickProperty != null)
{
EventData = new ElementData[1];
EventData[0] = new ElementData(click_img, click_id, data.Properties);
EventData[0].ImageEventType = ElementEventType.MouseOver;
}
OnEvent += Element_OnEvent;
}
}
public static void InitTestSuiteGeneratorWindow(ElementData element,Action<TestSuiteData> onCreate, Func<ElementData, TestSuiteData,String> check )
{
var window = GetWindow(typeof(TestSuiteGeneratorWindow)) as TestSuiteGeneratorWindow;
window._onCreate = onCreate;
window._elementData = element;
window._testSuiteData.Name = element.NameAsController;
window._check = check;
}
private void Spawn()
{
if (owner.Content.Type == ContentType.Empty)
{
var data = new ElementData();
data.capacity = count;
data.kind = kind;
ItemFactory.I.Create(data, owner);
}
}
/// <summary>
/// 转换为数据传输对象。
/// </summary>
/// <param name="ontology"></param>
/// <returns></returns>
public static OntologyData ToOntologyData(this OntologyDescriptor ontology)
{
if (ontology == null)
{
return null;
}
var ontologyData = new OntologyData()
{
Code = ontology.Ontology.Code,
Name = ontology.Ontology.Name,
IsSystem = ontology.Ontology.IsSystem
};
if (ontology.Actions != null && ontology.Actions.Count > 0)
{
foreach (var item in ontology.Actions.Values.OrderBy(a => a.Verb))
{
ontologyData.Actions.Add(new ActionData
{
Verb = item.Verb,
Name = item.Name
});
}
}
if (ontology.Elements != null && ontology.Elements.Count > 0)
{
foreach (var item in ontology.Elements.Values.OrderBy(a => a.Element.SortCode))
{
if (!item.IsRuntimeElement)
{
InfoDicState infoDic = null;
if (item.Element.InfoDicId.HasValue)
{
ontology.Host.NodeHost.InfoDics.TryGetInfoDic(item.Element.InfoDicId.Value, out infoDic);
}
var infoDicCode = infoDic == null ? "" : infoDic.Code;
var infoDicName = infoDic == null ? "" : infoDic.Name;
var serializableElement = new ElementData()
{
Name = item.Element.Name,
Key = item.Element.Code,
Nullable = item.Element.Nullable,
MaxLength = item.Element.MaxLength,
OType = item.Element.OType,
ValueDic = infoDicCode,
IsEnabled = item.Element.IsEnabled
};
ontologyData.Elements.Add(serializableElement);
}
}
}
return ontologyData;
}
public abstract void SetData(ElementData elementData);
//allow moving up and down (but don't alter the team choice selection because it's hard)
public MemberStatsMenu(int teamSlot, bool assembly, bool allowAssembly)
{
Bounds = Rect.FromPoints(new Loc(24, 16), new Loc(296, 224));
this.teamSlot = teamSlot;
this.assembly = assembly;
this.allowAssembly = allowAssembly;
Character player = assembly ? DataManager.Instance.Save.ActiveTeam.Assembly[teamSlot] : DataManager.Instance.Save.ActiveTeam.Players[teamSlot];
//TODO: align the page text properly
Title = new MenuText(Text.FormatKey("MENU_STATS_TITLE") + " (2/3)", Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth + 8, GraphicsManager.MenuBG.TileHeight));
Div = new MenuDivider(Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth, GraphicsManager.MenuBG.TileHeight + LINE_SPACE), Bounds.End.X - Bounds.X - GraphicsManager.MenuBG.TileWidth * 2);
Portrait = new SpeakerPortrait(player.BaseForm, new EmoteStyle(0),
Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2, GraphicsManager.MenuBG.TileHeight + TitledStripMenu.TITLE_OFFSET), false);
string speciesText = player.BaseName + " / " + player.FullFormName;
Name = new MenuText(speciesText, Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 48, GraphicsManager.MenuBG.TileHeight + TitledStripMenu.TITLE_OFFSET));
ElementData element1 = DataManager.Instance.GetElement(player.Element1);
ElementData element2 = DataManager.Instance.GetElement(player.Element2);
string typeString = String.Format("{0}\u2060{1}", element1.Symbol, element1.Name.ToLocal());
if (player.Element2 != 00)
{
typeString += "/" + String.Format("{0}\u2060{1}", element2.Symbol, element2.Name.ToLocal());
}
BaseMonsterForm monsterForm = DataManager.Instance.GetMonster(player.BaseForm.Species).Forms[player.BaseForm.Form];
bool origElements = (player.Element1 == monsterForm.Element1);
origElements &= (player.Element2 == monsterForm.Element2);
Elements = new MenuText(Text.FormatKey("MENU_TEAM_ELEMENT", typeString), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 48, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 1 + TitledStripMenu.TITLE_OFFSET), origElements ? Color.White : Color.Yellow);
Level = new MenuText(Text.FormatKey("MENU_TEAM_LEVEL_SHORT", player.Level), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 48, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 2 + TitledStripMenu.TITLE_OFFSET));
int expToNext = 0;
if (player.Level < DataManager.Instance.MaxLevel)
{
int growth = DataManager.Instance.GetMonster(player.BaseForm.Species).EXPTable;
GrowthData growthData = DataManager.Instance.GetGrowth(growth);
expToNext = growthData.GetExpToNext(player.Level);
}
EXP = new MenuText(Text.FormatKey("MENU_TEAM_EXP", player.EXP, expToNext),
Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 3 + TitledStripMenu.TITLE_OFFSET));
MainDiv = new MenuDivider(Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 5), Bounds.End.X - Bounds.X - GraphicsManager.MenuBG.TileWidth * 2);
StatsTitle = new MenuText(Text.FormatKey("MENU_TEAM_STATS"), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 4 + TitledStripMenu.TITLE_OFFSET));
HPLabel = new MenuText(Text.FormatKey("MENU_LABEL", Data.Stat.HP.ToLocal("tiny")), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 8, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 5 + TitledStripMenu.TITLE_OFFSET));
AttackLabel = new MenuText(Text.FormatKey("MENU_LABEL", Data.Stat.Attack.ToLocal("tiny")), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 8, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 6 + TitledStripMenu.TITLE_OFFSET), player.ProxyAtk > -1 ? Color.Yellow : Color.White);
DefenseLabel = new MenuText(Text.FormatKey("MENU_LABEL", Data.Stat.Defense.ToLocal("tiny")), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 8, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 7 + TitledStripMenu.TITLE_OFFSET), player.ProxyDef > -1 ? Color.Yellow : Color.White);
MAtkLabel = new MenuText(Text.FormatKey("MENU_LABEL", Data.Stat.MAtk.ToLocal("tiny")), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 8, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 8 + TitledStripMenu.TITLE_OFFSET), player.ProxyMAtk > -1 ? Color.Yellow : Color.White);
MDefLabel = new MenuText(Text.FormatKey("MENU_LABEL", Data.Stat.MDef.ToLocal("tiny")), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 8, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 9 + TitledStripMenu.TITLE_OFFSET), player.ProxyMDef > -1 ? Color.Yellow : Color.White);
SpeedLabel = new MenuText(Text.FormatKey("MENU_LABEL", Data.Stat.Speed.ToLocal("tiny")), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 8, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 10 + TitledStripMenu.TITLE_OFFSET), player.ProxySpeed > -1 ? Color.Yellow : Color.White);
HP = new MenuText(player.MaxHP.ToString(), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 72, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 5 + TitledStripMenu.TITLE_OFFSET), DirH.Right);
Attack = new MenuText(player.Atk.ToString(), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 72, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 6 + TitledStripMenu.TITLE_OFFSET), DirV.Up, DirH.Right, player.ProxyAtk > -1 ? Color.Yellow : Color.White);
Defense = new MenuText(player.Def.ToString(), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 72, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 7 + TitledStripMenu.TITLE_OFFSET), DirV.Up, DirH.Right, player.ProxyDef > -1 ? Color.Yellow : Color.White);
MAtk = new MenuText(player.MAtk.ToString(), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 72, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 8 + TitledStripMenu.TITLE_OFFSET), DirV.Up, DirH.Right, player.ProxyMAtk > -1 ? Color.Yellow : Color.White);
MDef = new MenuText(player.MDef.ToString(), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 72, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 9 + TitledStripMenu.TITLE_OFFSET), DirV.Up, DirH.Right, player.ProxyMDef > -1 ? Color.Yellow : Color.White);
Speed = new MenuText(player.Speed.ToString(), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 72, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 10 + TitledStripMenu.TITLE_OFFSET), DirV.Up, DirH.Right, player.ProxySpeed > -1 ? Color.Yellow : Color.White);
int hpLength = calcLength(Stat.HP, monsterForm, player.MaxHP, player.Level);
HPBar = new MenuStatBar(Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 76, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 5 + TitledStripMenu.TITLE_OFFSET), hpLength, calcColor(hpLength));
int atkLength = calcLength(Stat.Attack, monsterForm, player.Atk, player.Level);
AttackBar = new MenuStatBar(Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 76, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 6 + TitledStripMenu.TITLE_OFFSET), atkLength, calcColor(atkLength));
int defLength = calcLength(Stat.Defense, monsterForm, player.Def, player.Level);
DefenseBar = new MenuStatBar(Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 76, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 7 + TitledStripMenu.TITLE_OFFSET), defLength, calcColor(defLength));
int mAtkLength = calcLength(Stat.MAtk, monsterForm, player.MAtk, player.Level);
MAtkBar = new MenuStatBar(Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 76, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 8 + TitledStripMenu.TITLE_OFFSET), mAtkLength, calcColor(mAtkLength));
int mDefLength = calcLength(Stat.MDef, monsterForm, player.MDef, player.Level);
MDefBar = new MenuStatBar(Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 76, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 9 + TitledStripMenu.TITLE_OFFSET), mDefLength, calcColor(mDefLength));
int speedLength = calcLength(Stat.Speed, monsterForm, player.Speed, player.Level);
SpeedBar = new MenuStatBar(Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 76, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 10 + TitledStripMenu.TITLE_OFFSET), speedLength, calcColor(speedLength));
ItemDiv = new MenuDivider(Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 12), Bounds.End.X - Bounds.X - GraphicsManager.MenuBG.TileWidth * 2);
Item = new MenuText(player.EquippedItem.ID > -1 ? Text.FormatKey("MENU_HELD_ITEM", player.EquippedItem.GetName()) : Text.FormatKey("MENU_HELD_NO_ITEM"), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 11 + TitledStripMenu.TITLE_OFFSET));
}
protected override IElement <TTag> Clone(ElementData data) => new WebpagesElement <TTag>(this, data);
public override string GetReqString()
{
ElementData elementEntry = DataManager.Instance.GetElement(PartnerElement);
return(String.Format(new StringKey("EVO_REQ_ALLY_ELEMENT").ToLocal(), elementEntry.GetColoredName()));
}
public void PlayerJoin(EntityBase entity)
{
ConnectionComponent connectComp = entity.GetComp <ConnectionComponent>();
PlayerComponent playerComp = null;
if (!entity.GetExistComp <PlayerComponent>())
{
playerComp = new PlayerComponent();
entity.AddComp(playerComp);
}
else
{
playerComp = entity.GetComp <PlayerComponent>();
}
//将角色ID传入游戏
playerComp.characterID = connectComp.m_session.player.characterID;
playerComp.nickName = connectComp.m_session.player.playerID;
ElementData e1 = new ElementData();
e1.id = 100;
e1.num = 10;
playerComp.elementData.Add(e1);
ElementData e2 = new ElementData();
e2.id = 101;
e2.num = 10;
playerComp.elementData.Add(e2);
ElementData e3 = new ElementData();
e3.id = 102;
e3.num = 10;
playerComp.elementData.Add(e3);
ElementData e4 = new ElementData();
e4.id = 103;
e4.num = 00;
playerComp.elementData.Add(e4);
if (!entity.GetExistComp <CommandComponent>())
{
CommandComponent c = new CommandComponent();
entity.AddComp(c);
}
if (!entity.GetExistComp <TransfromComponent>())
{
TransfromComponent c = new TransfromComponent();
c.pos.FromVector(new Vector3(15, 0, 0));
entity.AddComp(c);
}
if (!entity.GetExistComp <AssetComponent>())
{
AssetComponent c = new AssetComponent();
c.m_assetName = playerComp.CharacterData.m_ModelID;
entity.AddComp(c);
}
if (!entity.GetExistComp <MoveComponent>())
{
MoveComponent c = new MoveComponent();
c.pos.FromVector(new Vector3(15, 0, 0));
entity.AddComp(c);
}
if (!entity.GetExistComp <SkillStatusComponent>())
{
SkillStatusComponent c = new SkillStatusComponent();
DataTable data = DataManager.GetData("SkillData");
for (int i = 0; i < data.TableIDs.Count; i++)
{
c.m_skillList.Add(new SkillData(data.TableIDs[i], i));
}
entity.AddComp(c);
}
if (!entity.GetExistComp <CDComponent>())
{
CDComponent c = new CDComponent();
entity.AddComp(c);
}
if (!entity.GetExistComp <CampComponent>())
{
CampComponent c = new CampComponent();
c.creater = entity.ID;
entity.AddComp(c);
}
if (!entity.GetExistComp <MoveComponent>())
{
MoveComponent c = new MoveComponent();
entity.AddComp(c);
}
if (!entity.GetExistComp <CollisionComponent>())
{
CollisionComponent c = new CollisionComponent();
c.area.areaType = AreaType.Circle;
c.area.radius = 0.5f;
entity.AddComp(c);
}
if (!entity.GetExistComp <LifeComponent>())
{
LifeComponent c = new LifeComponent();
c.maxLife = playerComp.CharacterData.m_hp;
c.life = playerComp.CharacterData.m_hp;
entity.AddComp(c);
}
if (!entity.GetExistComp <BlowFlyComponent>())
{
BlowFlyComponent c = new BlowFlyComponent();
entity.AddComp(c);
}
//预测一个输入
//TODO 放在框架中
if (entity.GetExistComp <ConnectionComponent>())
{
ConnectionComponent cc = entity.GetComp <ConnectionComponent>();
cc.m_lastInputCache = new CommandComponent();
cc.m_defaultInput = new CommandComponent();
}
GameTimeComponent gtc = m_world.GetSingletonComp <GameTimeComponent>();
gtc.GameTime = 10000 * 1000;
}
// Вспомогательная функция добавления элемента в структуру строящегося дерева
private static void AddDPNodeToList(List <DPTreeNode <ElementData> > dpTreeNodeList, ElementData sourceElementData, ElementData targetElementData)
{
// сначала ищем, нет ли уже элемента в структуре
DPTreeNode <ElementData> sourceElementNode = null;
DPTreeNode <ElementData> sourceElementNodeRoot = null;
DPTreeNode <ElementData> targetElementNode = null;
DPTreeNode <ElementData> targetElementNodeRoot = null;
foreach (DPTreeNode <ElementData> curNode in dpTreeNodeList)
{
if (curNode.AllNodes.ContainsKey(sourceElementData.ID))
{
sourceElementNode = curNode.AllNodes[sourceElementData.ID];
sourceElementNodeRoot = curNode;
}
if (curNode.AllNodes.ContainsKey(targetElementData.ID))
{
targetElementNode = curNode.AllNodes[targetElementData.ID];
targetElementNodeRoot = curNode;
}
if (sourceElementNode != null && targetElementNode != null)
{
break;
}
}
// Варианты:
// оба узла найдены и находятся в одной иерархии - ничего делать не надо
if (sourceElementNode != null && targetElementNode != null && sourceElementNodeRoot == targetElementNodeRoot)
{
// Ничего не делаем
}
// оба узла найдены и находятся разных иерархиях - надо объъединить эти ветки
if (sourceElementNode != null && targetElementNode != null && sourceElementNodeRoot != targetElementNodeRoot)
{
targetElementNode.AddChildNode(sourceElementNode);
dpTreeNodeList.Remove(sourceElementNode);
}
// найден только дочерний узел - создаём в этой же ветке родительский и перевешиваем на него дочерний
// такая ситуация возможна только если дочерний дежит на самом верху (временно является рутом данной ветки)
else if (sourceElementNode != null && targetElementNode == null)
{
targetElementNode = new DPTreeNode <ElementData>(targetElementData, true);
targetElementNode.AddChildNode(sourceElementNode);
dpTreeNodeList.Remove(sourceElementNode);
dpTreeNodeList.Add(targetElementNode);
}
// найден только родительский узел - создаём в этой же ветке дочерний
// такая ситуация возможна только если родительский лежит в самом низу ветки (временно является одним из листовых узлов)
else if (sourceElementNode == null && targetElementNode != null)
{
sourceElementNode = new DPTreeNode <ElementData>(sourceElementData, false);
targetElementNode.AddChildNode(sourceElementNode);
}
// оба не найдены - создаём оба узла в новой ветке
else if (sourceElementNode == null && targetElementNode == null)
{
sourceElementNode = new DPTreeNode <ElementData>(sourceElementData, false);
targetElementNode = new DPTreeNode <ElementData>(targetElementData, true);
targetElementNode.AddChildNode(sourceElementNode);
dpTreeNodeList.Add(targetElementNode);
}
}
public Element(ItemBox box, ElementData data)
: base(box)
{
Kind = data.kind;
Count = data.capacity;
}
void GenerateNextEntryOrTomb()
{
//随机获取一个砖块(除玩家所在砖块以外)
GameObject block = blockList [Random.Range (1, blockList.Count)];
float blockPosX = block.transform.position.x;
float blockPosY = block.transform.position.y;
//随机获取一个位置
float pX = Random.Range (blockPosX - blockX * 0.5f + border + entryRadius, blockPosX + blockX * 0.5f - border - entryRadius);
float pY = Random.Range (blockPosY - blockY * 0.5f + border + entryRadius, blockPosY + blockY * 0.5f - border - entryRadius);
ElementData nextEntry = new ElementData (new Vector3 (pX, pY, 0), "NextEntry", new Vector3 (0, 0, 0), 0);
currentSceneInfo.nextEntry = nextEntry;
//测试
// if(gData.currentFloor==1){
// player.position = nextEntry.pos;
// }
}
public MultiplierData(ElementData position, ElementData angles)
{
this.position = position;
this.angles = angles;
}
/// <summary>
/// Parses the section.
/// </summary>
/// <param name="source">The source.</param>
/// <param name="data">The data.</param>
/// <returns>bool - success/fail</returns>
public bool ParseSection(string source, ref IParserData data)
{
Sections sourceData = GetSections(source);
bool hasOptional = false;
bool hasMatched = false;
int dataFound = 0;
if (sourceData.dataFields.Count == 0)
{
return(false);
}
if (sourceData.dataFields.Count > _templateData.minFields)
{
hasOptional = true;
}
int s = 0;
for (int t = 0; t < _templateData.dataFields.Count; t++)
{
DataField templateField = (DataField)_templateData.dataFields[t];
if (templateField.optional)
{
if (!hasOptional)
{
continue;
}
}
if (s < sourceData.dataFields.Count)
{
DataField sourceField = (DataField)sourceData.dataFields[s];
if (!templateField.hasData &&
templateField.htmlTag != null &&
sourceField.htmlTag != null)
{
if (templateField.htmlTag.SameType(sourceField.htmlTag))
{
s++;
}
}
else
{
if (templateField.source != string.Empty &&
templateField.hasData)
{
int index = 0;
for (int i = 0; i < templateField.dataElements.Count; i++)
{
ElementData element = (ElementData)templateField.dataElements[i];
int startPos;
if (index < sourceField.source.Length)
{
if (element.start == string.Empty ||
(startPos = sourceField.source.IndexOf(element.start, index, StringComparison.OrdinalIgnoreCase)) ==
-1)
{
startPos = index;
}
else
{
startPos = startPos + element.start.Length;
}
int endPos;
if (element.end == string.Empty ||
(endPos = sourceField.source.IndexOf(element.end, startPos, StringComparison.OrdinalIgnoreCase)) ==
-1)
{
endPos = sourceField.source.Length;
}
string elementSource = sourceField.source.Substring(startPos, endPos - startPos);
if (elementSource != string.Empty)
{
if (element.name[0] == '*')
{
if (hasMatched && element.name == "*VALUE")
{
data.SetElement(_matchField, elementSource);
hasMatched = false;
}
else
{
if (IsMatch(element.name, elementSource))
{
hasMatched = true;
}
}
}
else
{
data.SetElement(element.name, elementSource);
}
dataFound++;
if (dataFound == _templateData.dataTags)
{
break;
}
}
index = endPos + element.end.Length;
}
}
}
s++;
}
}
}
if (dataFound == 0 && _templateData.dataTags > 0)
{
return(false);
}
return(true);
}
private void AddElementToPeriodicTableList(string newName, int newGroupNumber, string newGroupType, int newAtomNumber, float newMass, float newEn)
{
ElementData newElement = new ElementData(newName, newGroupType, newGroupNumber, newAtomNumber, newMass, newEn);
periodicTableList.Add(newElement);
}
private void Awake()
{
_elementData = this;
DontDestroyOnLoad(gameObject);
}
public TestSuiteCodeGenerator(ElementData elementData, TestSuiteData testSuiteData)
{
_testSuiteData = testSuiteData;
_elementData = elementData;
}
object ParseParameter(DeltinScriptParser.ExprContext context, string methodName, Parameter parameterData)
{
object value = null;
if (context.GetChild(0) is DeltinScriptParser.EnumContext)
{
if (parameterData.ParameterType != ParameterType.Enum)
{
throw new SyntaxErrorException($"Expected value type \"{parameterData.ValueType.ToString()}\" on {methodName}'s parameter \"{parameterData.Name}\"."
, context.start);
}
string type = context.GetText().Split('.').ElementAtOrDefault(0);
string enumValue = context.GetText().Split('.').ElementAtOrDefault(1);
if (type != parameterData.EnumType.Name)
{
throw new SyntaxErrorException($"Expected enum type \"{parameterData.EnumType.ToString()}\" on {methodName}'s parameter \"{parameterData.Name}\"."
, context.start);
}
try
{
value = Enum.Parse(parameterData.EnumType, enumValue);
}
catch (Exception ex) when(ex is ArgumentNullException || ex is ArgumentException || ex is OverflowException)
{
throw new SyntaxErrorException($"The value {enumValue} does not exist in the enum {type}.");
}
if (value == null)
{
throw new SyntaxErrorException($"Could not parse enum parameter {context.GetText()}."
, context.start);
}
}
else
{
if (parameterData.ParameterType != ParameterType.Value)
{
throw new SyntaxErrorException($"Expected enum type \"{parameterData.EnumType.Name}\" on {methodName}'s parameter \"{parameterData.Name}\"."
, context.start);
}
value = ParseExpression(context);
Element element = value as Element;
ElementData elementData = element.GetType().GetCustomAttribute <ElementData>();
if (elementData.ValueType != Elements.ValueType.Any &&
!parameterData.ValueType.HasFlag(elementData.ValueType))
{
throw new SyntaxErrorException($"Expected value type \"{parameterData.ValueType.ToString()}\" on {methodName}'s parameter \"{parameterData.Name}\", got \"{elementData.ValueType.ToString()}\" instead."
, context.start);
}
}
if (value == null)
{
throw new SyntaxErrorException("Could not parse parameter.", context.start);
}
return(value);
}
private CircuitElementControl CreateElementControl(ElementData elementData)
{
switch (elementData.Type)
{
case ElementType.Diode:
return(new DiodeControl {
Designer = this
});
case ElementType.Switch:
return(new SwitchControl {
Designer = this
});
case ElementType.Buffer:
return(new BufferControl {
Designer = this
});
case ElementType.Not:
return(new NotGateControl {
Designer = this
});
case ElementType.And:
return(new AndGateControl {
Designer = this
});
case ElementType.Or:
return(new OrGateControl {
Designer = this
});
case ElementType.Xor:
return(new XorGateControl {
Designer = this
});
case ElementType.Nand:
return(new NandGateControl {
Designer = this
});
case ElementType.Nor:
return(new NorGateControl {
Designer = this
});
case ElementType.Xnor:
return(new XorGateControl {
Designer = this
});
case ElementType.SrLatch:
return(new SrLatchControl {
Designer = this
});
case ElementType.IntegratedCircuit:
return(new IntegratedCircuitControl {
Designer = this
});
case ElementType.FreeInput:
return(new FreeInputControl {
Designer = this
});
case ElementType.FreeOutput:
return(new FreeOutputControl {
Designer = this
});
default:
throw new ArgumentOutOfRangeException();
}
}
void OnGUI()
{
//#if UNITY_EDITOR
// Level bar
GUILayout.Label("Level ID: " + GameManager.Instance.LevelId);
GUILayout.Space(5);
GUILayout.BeginHorizontal();
GUILayout.Label("Load_Start: ");
GUILayout.Space(4);
if (GUILayout.Button("1")) { SwitchLevelStart(1); }
if (GUILayout.Button("2")) { SwitchLevelStart(2); }
if (GUILayout.Button("3")) { SwitchLevelStart(3); }
if (GUILayout.Button("4")) { SwitchLevelStart(4); }
if (GUILayout.Button("5")) { SwitchLevelStart(5); }
if (GUILayout.Button("6")) { SwitchLevelStart(6); }
if (GUILayout.Button("7")) { SwitchLevelStart(7); }
if (GUILayout.Button("8")) { SwitchLevelStart(8); }
if (GUILayout.Button("9")) { SwitchLevelStart(9); }
if (GUILayout.Button("10")) { SwitchLevelStart(10); }
GUILayout.EndHorizontal();
GUILayout.Space(5);
GUILayout.BeginHorizontal();
GUILayout.Label("Load_End : ");
GUILayout.Space(4);
if (GUILayout.Button("1")) { SwitchLevelEnd(1); }
if (GUILayout.Button("2")) { SwitchLevelEnd(2); }
if (GUILayout.Button("3")) { SwitchLevelEnd(3); }
if (GUILayout.Button("4")) { SwitchLevelEnd(4); }
if (GUILayout.Button("5")) { SwitchLevelEnd(5); }
if (GUILayout.Button("6")) { SwitchLevelEnd(6); }
if (GUILayout.Button("7")) { SwitchLevelEnd(7); }
if (GUILayout.Button("8")) { SwitchLevelEnd(8); }
if (GUILayout.Button("9")) { SwitchLevelEnd(9); }
if (GUILayout.Button("10")) { SwitchLevelEnd(10); }
GUILayout.EndHorizontal();
GUILayout.Space(10);
GUILayout.BeginArea(new Rect(0, 80, 90, Screen.height - 80));
if(GUILayout.Button("save_start"))
{
LevelData data = GameManager.Instance.CurLevelData;
data.LevelStart.Clear();
foreach(EleComp eleComp in GameManager.Instance.EleCompList)
{
ElementData eleData = new ElementData();
eleData.Catagory = eleComp.ElementInfo.Catagory;
eleData.Type = eleComp.ElementInfo.Type;
eleData.GridX = (int)eleComp.Grid.x;
eleData.GridY = (int)eleComp.Grid.y;
data.LevelStart.Add(eleData);
}
LevelDataBase.SaveLevelData(GameManager.Instance.LevelId, data);
}
if (GUILayout.Button("save_end"))
{
LevelData data = GameManager.Instance.CurLevelData;
data.LevelEnd.Clear();
foreach (EleComp eleComp in GameManager.Instance.EleCompList)
{
ElementData eleData = new ElementData();
eleData.Catagory = eleComp.ElementInfo.Catagory;
eleData.Type = eleComp.ElementInfo.Type;
eleData.GridX = (int)eleComp.Grid.x;
eleData.GridY = (int)eleComp.Grid.y;
data.LevelEnd.Add(eleData);
}
LevelDataBase.SaveLevelData(GameManager.Instance.LevelId, data);
}
if (GUILayout.Button("c_green"))
{
ElementFactory.SpawnNewElement(2, 0, 0, 6, 10);
}
if (GUILayout.Button("c_red"))
{
ElementFactory.SpawnNewElement(3, 0, 0, 6, 10);
}
if(GUILayout.Button("c_gray_0"))
{
ElementFactory.SpawnNewElement(0, 0, 0, 6, 10);
}
if (GUILayout.Button("c_gray_1"))
{
ElementFactory.SpawnNewElement(0, 1, 0, 6, 10);
}
if (GUILayout.Button("c_gray_2"))
{
ElementFactory.SpawnNewElement(0, 2, 0, 6, 10);
}
if (GUILayout.Button("c_gray_3"))
{
ElementFactory.SpawnNewElement(0, 3, 0, 6, 10);
}
if (GUILayout.Button("c_gray_4"))
{
ElementFactory.SpawnNewElement(0, 4, 0, 6, 10);
}
if (GUILayout.Button("c_gray_5"))
{
ElementFactory.SpawnNewElement(0, 5, 0, 6, 10);
}
if (GUILayout.Button("c_gray_6"))
{
ElementFactory.SpawnNewElement(0, 6, 0, 6, 10);
}
if (GUILayout.Button("c_color_0"))
{
ElementFactory.SpawnNewElement(1, 0, 0, 6, 10);
}
if (GUILayout.Button("c_color_1"))
{
ElementFactory.SpawnNewElement(1, 1, 0, 6, 10);
}
if (GUILayout.Button("c_color_2"))
{
ElementFactory.SpawnNewElement(1, 2, 0, 6, 10);
}
if (GUILayout.Button("c_color_3"))
{
ElementFactory.SpawnNewElement(1, 3, 0, 6, 10);
}
if (GUILayout.Button("c_color_4"))
{
ElementFactory.SpawnNewElement(1, 4, 0, 6, 10);
}
if (GUILayout.Button("c_color_5"))
{
ElementFactory.SpawnNewElement(1, 5, 0, 6, 10);
}
if (GUILayout.Button("c_color_6"))
{
ElementFactory.SpawnNewElement(1, 6, 0, 6, 10);
}
GUILayout.EndArea();
if(GUI.Button(new Rect(Screen.width-80, 0, 80, 20), "delete"))
{
if(GameManager.Instance.LastSelEleComp)
{
GameManager.Instance.EleCompList.Remove(GameManager.Instance.LastSelEleComp);
GameObject.Destroy(GameManager.Instance.LastSelEleComp.gameObject);
GameManager.Instance.LastSelEleComp = null;
}
}
//#endif
}
protected void RegisterHydroElement(FrameworkElement element)
{
var elementData = new ElementData(HydroDocument.GetHydroObject(element));
elementDataDic.Add(element, elementData);
element.RenderTransform = Transform;
drawingCanvas.Children.Add(element);
}
private void SetState(bool state)
{
ElementData elem = GetElementData();
dynamicSprite.sprite = (state ? elem.imageOn : elem.imageOff);
}
/// <summary>
/// Возвращает список элементов ElementData для текущей библиотеки
/// </summary>
/// <returns></returns>
public static Dictionary <int, ElementData> GetCurLibElementData()
{
Dictionary <int, ElementData> result = new Dictionary <int, ElementData>();
string[] args = new string[] { String.Join(",", Context.CurLibPackageIDs) };
XDocument sqlResultSet = SQLHelper.RunSQL("CurLibObjects.sql", args);
IEnumerable <XElement> rowNodes = sqlResultSet.Root.XPathSelectElements("/EADATA/Dataset_0/Data/Row");
foreach (XElement rowNode in rowNodes)
{
ElementData elementData;
int object_id = int.Parse(rowNode.Descendants("object_id").First().Value);
if (result.ContainsKey(object_id))
{
elementData = result[object_id];
}
else
{
elementData = new ElementData();
elementData._ElementID = object_id;
elementData.Name = rowNode.Descendants("name").First().Value;
elementData.EAType = rowNode.Descendants("object_type").First().Value;
elementData.Note = rowNode.Descendants("note").First().Value;
string sClassifierID = rowNode.Descendants("classifier_id").First().Value;
if (sClassifierID != "")
{
elementData.ClassifierID = int.Parse(rowNode.Descendants("classifier_id").First().Value);
elementData.ClassifierName = rowNode.Descendants("classifier_name").First().Value;
elementData.ClassifierEAType = rowNode.Descendants("classifier_type").First().Value;
}
if (elementData.EAType == "Boundary") // тэги для Boundary лежат отдельно, поэтому Boundary инициируем неэкономно и сразу - через COM
{
EA.Element element = EARepository.GetElementByID(elementData._ElementID);
elementData = new ElementData(element);
}
result.Add(object_id, elementData);
}
string tagName = rowNode.Descendants("property").First().Value;
string tagValue = rowNode.Descendants("value").First().Value;
if (tagName == DAConst.DP_LibraryTag)
{
elementData.IsLibrary = true;
}
if (tagName == DAConst.DP_ComponentLevelTag)
{
elementData.ComponentLevel = Enum.Parse(typeof(ComponentLevel), tagValue) as ComponentLevel?;
}
if (tagName == DAConst.DP_NodeGroupsTag)
{
elementData.NodeGroups = tagValue.Split(',');
}
}
return(result);
}
/// <summary>
/// The read element data.
/// </summary>
/// <param name="column">
/// The column.
/// </param>
/// <returns>
/// The StruSoft.Impact.V120.ProjectManager.Core.ProjectBrowserData.ElementData.
/// </returns>
private static ElementData ReadElementData( DbDataReader column )
{
var element = new ElementData
{
ElementMark = column[0].Cast<string>().Trim() ?? string.Empty,
Id = column[1].Cast<int>(),
ElementGuid = column[2].Cast<string>() ?? string.Empty,
ElementType = column[3].Cast<string>() ?? string.Empty,
Building = column[4].Cast<string>().Trim() ?? string.Empty,
FloorId = column[5].Cast<int>(),
Phase = column[6].Cast<string>().Trim() ?? string.Empty,
ElementGrp = column[7].Cast<string>() ?? string.Empty,
DrawingName = column[8].Cast<string>() ?? string.Empty,
DrawingRevision = column[9].Cast<string>() ?? string.Empty,
DrawingDesignedBy = column[10].Cast<string>() ?? string.Empty,
DrawingStatus = column[11].Cast<string>() ?? string.Empty,
Product = column[12].Cast<string>() ?? string.Empty,
Length = column[13].Cast<double>(),
Width = column[14].Cast<double>(),
Height = column[15].Cast<double>(),
GrossArea = column[16].Cast<double>(),
Mass = column[17].Cast<double>(),
ReadyForProduction = column[18].Cast<int>(),
ReadyForProductionDate = column[19].Cast<DateTime?>(),
ProductionDate = column[20].Cast<DateTime?>(),
DeliveryDate = column[21].Cast<DateTime?>(),
ErectionSequenceNo = column[22].Cast<int?>(),
TransportId = column[23].Cast<int?>(),
StackNo = column[24].Cast<int?>(),
StackSequenceNo = column[25].Cast<int?>(),
PlannedDrawingDate = column[26].Cast<DateTime?>(),
PlannedProductionDate = column[27].Cast<DateTime?>(),
PlannedReadyForDeliveryDate = column[28].Cast<DateTime?>(),
PlannedDeliveryDate = column[29].Cast<DateTime?>(),
PlannedErectionDate = column[30].Cast<DateTime?>(),
ElementIdStatus = column[31].Cast<int?>(),
ElevationName = column[32].Cast<string>() ?? string.Empty,
CastId = column[33].Cast<int?>() ?? 0,
BedX = column[34].Cast<double?>() ?? 0.0d,
BedY = column[35].Cast<double?>() ?? 0.0d,
BedZ = column[36].Cast<double?>() ?? 0.0d,
BedRotation = column[37].Cast<double?>() ?? 0.0d,
BedSequenceNo = column[38].Cast<int?>() ?? 0,
Style = column[39].Cast<string>() ?? string.Empty,
Lift = column[40].Cast<string>() ?? string.Empty,
StrandPattern = column[41].Cast<string>() ?? string.Empty,
LockStatus = column[42].Cast<int?>() ?? 0,
Remark = column[43].Cast<string>() ?? string.Empty,
DrawingCheckedBy = column[44].Cast<string>() ?? string.Empty,
ElevationZ = column[45].Cast<double?>() ?? 0.0d,
DrawInModel = column[46].Cast<int?>() ?? 0,
ProductionFactory = column[47].Cast<string>() ?? string.Empty,
DivisionProduction = column[48].Cast<string>() ?? string.Empty,
};
return element;
}
public MemberFeaturesMenu(int teamSlot, bool assembly, bool allowAssembly)
{
Bounds = Rect.FromPoints(new Loc(24, 16), new Loc(296, 224));
this.teamSlot = teamSlot;
this.assembly = assembly;
this.allowAssembly = allowAssembly;
Character player = assembly ? DataManager.Instance.Save.ActiveTeam.Assembly[teamSlot] : DataManager.Instance.Save.ActiveTeam.Players[teamSlot];
//TODO: align this text properly
Title = new MenuText(Text.FormatKey("MENU_TEAM_FEATURES") + " (1/3)", Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth + 8, GraphicsManager.MenuBG.TileHeight));
Div = new MenuDivider(Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth, GraphicsManager.MenuBG.TileHeight + LINE_SPACE), Bounds.End.X - Bounds.X - GraphicsManager.MenuBG.TileWidth * 2);
Portrait = new SpeakerPortrait(player.BaseForm, new EmoteStyle(0),
Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2, GraphicsManager.MenuBG.TileHeight + TitledStripMenu.TITLE_OFFSET), false);
string speciesText = player.BaseName + " / " + player.FullFormName;
Name = new MenuText(speciesText, Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 48, GraphicsManager.MenuBG.TileHeight + TitledStripMenu.TITLE_OFFSET));
ElementData element1 = DataManager.Instance.GetElement(player.Element1);
ElementData element2 = DataManager.Instance.GetElement(player.Element2);
string typeString = String.Format("{0}\u2060{1}", element1.Symbol, element1.Name.ToLocal());
if (player.Element2 != 00)
{
typeString += "/" + String.Format("{0}\u2060{1}", element2.Symbol, element2.Name.ToLocal());
}
bool origElements = (player.Element1 == DataManager.Instance.GetMonster(player.BaseForm.Species).Forms[player.BaseForm.Form].Element1);
origElements &= (player.Element2 == DataManager.Instance.GetMonster(player.BaseForm.Species).Forms[player.BaseForm.Form].Element2);
Elements = new MenuText(Text.FormatKey("MENU_TEAM_ELEMENT", typeString), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 48, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 1 + TitledStripMenu.TITLE_OFFSET), origElements ? Color.White : Color.Yellow);
Level = new MenuText(Text.FormatKey("MENU_TEAM_LEVEL_SHORT", player.Level), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2 + 48, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 2 + TitledStripMenu.TITLE_OFFSET));
HP = new MenuText(Text.FormatKey("MENU_TEAM_HP", player.HP, player.MaxHP), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 3 + TitledStripMenu.TITLE_OFFSET));
Fullness = new MenuText(Text.FormatKey("MENU_TEAM_HUNGER", player.Fullness, player.MaxFullness), Bounds.Start + new Loc((Bounds.End.X - Bounds.X) / 2, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 3 + TitledStripMenu.TITLE_OFFSET));
MainDiv = new MenuDivider(Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 5), Bounds.End.X - Bounds.X - GraphicsManager.MenuBG.TileWidth * 2);
SkillTitle = new MenuText(Text.FormatKey("MENU_TEAM_SKILLS"), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 4 + TitledStripMenu.TITLE_OFFSET));
Skills = new MenuText[CharData.MAX_SKILL_SLOTS * 3];
for (int ii = 0; ii < CharData.MAX_SKILL_SLOTS; ii++)
{
SlotSkill skill = player.BaseSkills[ii];
string skillString = "-----";
string skillCharges = "--";
string totalCharges = "/--";
if (skill.SkillNum > -1)
{
SkillData data = DataManager.Instance.GetSkill(skill.SkillNum);
ElementData element = DataManager.Instance.GetElement(data.Data.Element);
skillString = String.Format("{0}\u2060{1}", element.Symbol, data.Name.ToLocal());
skillCharges = skill.Charges.ToString();
totalCharges = "/" + (data.BaseCharges + player.ChargeBoost);
}
Skills[ii * 3] = new MenuText(skillString, Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * (ii + 5) + TitledStripMenu.TITLE_OFFSET));
Skills[ii * 3 + 1] = new MenuText(skillCharges, new Loc(Bounds.End.X - GraphicsManager.MenuBG.TileWidth * 2 - 16 - GraphicsManager.TextFont.CharSpace, Bounds.Y + GraphicsManager.MenuBG.TileHeight + VERT_SPACE * (ii + 5) + TitledStripMenu.TITLE_OFFSET), DirH.Right);
Skills[ii * 3 + 2] = new MenuText(totalCharges, new Loc(Bounds.End.X - GraphicsManager.MenuBG.TileWidth * 2 - 16, Bounds.Y + GraphicsManager.MenuBG.TileHeight + VERT_SPACE * (ii + 5) + TitledStripMenu.TITLE_OFFSET), DirH.Left);
}
IntrinsicDiv = new MenuDivider(Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 10), Bounds.End.X - Bounds.X - GraphicsManager.MenuBG.TileWidth * 2);
bool origIntrinsic = (player.Intrinsics[0].Element.ID == player.BaseIntrinsics[0]);
IntrinsicData entry = DataManager.Instance.GetIntrinsic(player.Intrinsics[0].Element.ID);
Intrinsic = new MenuText(Text.FormatKey("MENU_TEAM_INTRINSIC", entry.Name.ToLocal()), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 9 + TitledStripMenu.TITLE_OFFSET), origIntrinsic ? Color.White : Color.Yellow);
IntrinsicDesc = new DialogueText(entry.Desc.ToLocal(), Bounds.Start + new Loc(GraphicsManager.MenuBG.TileWidth * 2, GraphicsManager.MenuBG.TileHeight + VERT_SPACE * 10 + TitledStripMenu.TITLE_OFFSET),
Bounds.End.X - GraphicsManager.MenuBG.TileWidth * 3 - Bounds.X, LINE_SPACE, false);
}
public WebpagesElement(Element <TTag> element, ElementData data) : base(element, data)
{
}
/// <summary>
/// Gets the elements.
/// </summary>
/// <param name="source">The source.</param>
/// <returns>array of elements</returns>
private ArrayList GetElements(string source)
{
ArrayList elements = new ArrayList();
//source = HtmlString.ToAscii(source);
Regex elementTag = new Regex(@"<[#*][A-Z][^>]+>");
MatchCollection elementTags = elementTag.Matches(source);
for (int i = 0; i < elementTags.Count; i++)
{
Match tag = elementTags[i];
ElementData element = new ElementData();
element.name = source.Substring(tag.Index, tag.Length);
element.start = string.Empty;
element.end = string.Empty;
int pos;
if ((pos = element.name.IndexOf(":")) != -1)
{
int sepPos;
if ((sepPos = element.name.IndexOf(",")) != -1)
{
element.start = element.name.Substring(pos + 1, sepPos - pos - 1);
element.end = element.name.Substring(sepPos + 1, element.name.Length - sepPos - 2);
}
element.name = element.name.Substring(1, pos - 1);
}
else
{
if (i == 0 && tag.Index > 0)
{
element.start = source.Substring(0, tag.Index);
}
if (i + 1 == elementTags.Count && tag.Index + tag.Length != source.Length)
{
element.end = source.Substring(tag.Index + tag.Length, source.Length - tag.Index - tag.Length);
}
if (i + 1 < elementTags.Count)
{
Match nextTag = elementTags[i + 1];
element.end = source.Substring(tag.Index + tag.Length, nextTag.Index - tag.Index - tag.Length);
}
element.name = element.name.Substring(1, element.name.Length - 2);
}
elements.Add(element);
}
return elements;
}
public override void Load(TagCompound tag)
{
// we store the list as a list<string> since we can't seralize the enum
// but to use effectively at runtime we need a list of list<Element>
List <Element> names = tag.Get <List <string> >("demonNames").ConvertAll(x => ElementData.elementFromString(x));
List <bool> values = tag.Get <List <bool> >("demonValues");
// combine list of Element and bool to form a dictionary<Element, bool>S
soulDemonsDowned = names.Zip(values, (k, v) => new { Key = k, Value = v }).ToDictionary(x => x.Key, x => x.Value);
mod.Logger.Info("Loaded demon values = " + ToPrettyString(soulDemonsDowned));
}
// Document linkedDocument;
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
{
UIApplication uiapp = commandData.Application;
UIDocument uidoc = uiapp.ActiveUIDocument;
Application app = uiapp.Application;
Document doc = uidoc.Document;
Document linkedDocument = null;
foreach (Document item in uiapp.Application.Documents)
{
linkedDocument = item;
}
ProjectData projectData = new ProjectData();
projectData.VersionName = uiapp.Application.VersionName;
projectData.Architecture_Document = doc.ProjectInformation.Author;
projectData.Document_Information = GetDocumentInformation(doc);
List <ElementData> electroDataList = new List <ElementData>();
var electroList = GetElectricalElements(linkedDocument);
foreach (Element device in electroList)
{
ElementData electroData = new ElementData();
electroData = GetElectroData(linkedDocument, device);
var roomList = GetRoomElement(doc);
var wallList = GetWallElement(doc);
foreach (Element room in roomList)
{
if (GetHost(doc, room, device))
{
electroData.Raum = GetRoomData(doc, room);
}
}
foreach (var wall in wallList)
{
if (GetHost(doc, wall, device))
{
electroData.Wand = GetWallData(doc, wall);
}
}
electroDataList.Add(electroData);
}
projectData.elements = electroDataList;
var JSONdata = string.Empty;
string path = @"D:\Test\Schulweg Oberwil.json";
JSONdata = JsonConvert.SerializeObject(projectData);
// TaskDialog.Show("JSON", JSONdata);
System.IO.File.WriteAllText(path, JSONdata);
Process.Start(path);
return(Result.Succeeded);
}
public static void CleverMapGeneration(ElementData[,] map, int min, int max, int requiredCount = 2)
{
List <int> baseGen = new List <int>();
for (int j = 0; j < map.GetLength(1); j++)
{
baseGen.Add(j);
map[0, j] = new ElementData()
{
CurrentNumber = Random.Range(min, max)
};
}
for (int i = 1; i < map.GetLength(0); i++)
{
List <int> places = new List <int>(baseGen);
List <int> placesTaken = new List <int>();
int checkingNumber = Random.Range(1, map.GetLength(1));
for (int k = 0; k < requiredCount; k++)
{
int randomIndex = Random.Range(0, places.Count);
int place = places[randomIndex];
places.RemoveAt(randomIndex);
placesTaken.Add(place);
int prevRowIndex = place + checkingNumber;
if (prevRowIndex >= map.GetLength(1))
{
prevRowIndex = place + checkingNumber - map.GetLength(1);
}
map[i, place] = new ElementData()
{
CurrentNumber = map[i - 1, prevRowIndex].CurrentNumber - 1
};
if (map[i - 1, prevRowIndex].CurrentNumber == min)
{
map[i, place].CurrentNumber = max - 1;
}
}
if (i == map.GetLength(0) - 1)
{
List <int> places2 = new List <int>();
for (int k = 0; k < baseGen.Count; k++)
{
if (!placesTaken.Contains(k))
{
places2.Add(k);
}
}
for (int k = 0; k < requiredCount; k++)
{
int randomIndex = Random.Range(0, places.Count);
int place = places2[randomIndex];
places2.RemoveAt(randomIndex);
placesTaken.Add(place);
int prevRowIndex = place + checkingNumber;
if (prevRowIndex >= map.GetLength(1))
{
prevRowIndex = place + checkingNumber - map.GetLength(1);
}
map[i, place] = new ElementData()
{
CurrentNumber = map[0, prevRowIndex].CurrentNumber + 1
};
map[i, place].CurrentNumber %= 10;
}
}
for (int j = 0; j < map.GetLength(1); j++)
{
if (!placesTaken.Contains(j))
{
map[i, j] = new ElementData()
{
CurrentNumber = Random.Range(min, max)
}
}
;
}
}
}
/// <summary>
/// Функция проверяет, разрешён ли показ коннекторат текущим фильтром
/// </summary>
private bool AllowByFilter(ConnectorData connectorData)
{
bool result = true;
if (lblFlowIDFilter.Tag != null && ((string[])lblFlowIDFilter.Tag).Length > 0)
{
if (!((string[])lblFlowIDFilter.Tag).Contains(connectorData.FlowID))
{
return(false);
}
}
if (lblSourceElementFilter.Tag != null && ((int[])lblSourceElementFilter.Tag).Length != 0)
{
if (!(
((int[])lblSourceElementFilter.Tag).Contains(connectorData.SourceElementID)
||
((int[])lblSourceElementFilter.Tag).Contains(connectorData.TargetElementID)
)
)
{
return(false);
}
}
if (lblLinkTypeFilter.Tag != null && ((LinkType[])lblLinkTypeFilter.Tag).Length != 0)
{
if (!((LinkType[])lblLinkTypeFilter.Tag).Contains(connectorData.LinkType))
{
return(false);
}
}
if (lblSoftwareClassificationFilter1.Tag != null && ((int[])lblSoftwareClassificationFilter1.Tag).Length != 0)
{
bool belongsToSoftware = false;
foreach (int softwareID in (int[])lblSoftwareClassificationFilter1.Tag)
{
ElementData softwareElementData = Context.SoftwareClassification.AllNodes[softwareID].Value;
ElementData sourceElementData = Context.ElementData[connectorData.SourceElementID];
if (SoftwareClassificationHelper.ISBelongsToSoftware(sourceElementData, softwareElementData))
{
belongsToSoftware = true;
break;
}
ElementData targetElementData = Context.ElementData[connectorData.TargetElementID];
if (SoftwareClassificationHelper.ISBelongsToSoftware(targetElementData, softwareElementData))
{
belongsToSoftware = true;
break;
}
}
if (!belongsToSoftware)
{
return(false);
}
}
return(result);
}
// renders the given node to the internal ElementData dictionary. If the given node is
// not a element, will recursively descend until we render its elements.
protected override void RenderNode(ElementNode node)
{
if (!AudioUtilities.AudioLoaded)
{
return;
}
int currentElement = 0;
var nodeCount = 0;
if (Inverted)
{
nodeCount = node.GetLeafEnumerator().Count();
}
foreach (ElementNode elementNode in node.GetLeafEnumerator())
{
// this is probably always going to be a single element for the given node, as
// we have iterated down to leaf nodes in RenderNode() above. May as well do
// it this way, though, in case something changes in future.
if (elementNode == null || elementNode.Element == null)
{
continue;
}
bool discreteColors = ColorModule.isElementNodeDiscreteColored(elementNode);
for (int i = 1; i < (int)(TimeSpan.TotalMilliseconds / Spacing); i++)
{
int startAudioTime;
int endAudioTime;
if (Inverted)
{
startAudioTime = i * Spacing - (nodeCount - currentElement) * ((WaveformData)Data).ScrollSpeed + 1;
endAudioTime = (i + 1) * Spacing - (nodeCount - currentElement) * ((WaveformData)Data).ScrollSpeed;
}
else
{
startAudioTime = i * Spacing - currentElement * ((WaveformData)Data).ScrollSpeed + 1;
endAudioTime = (i + 1) * Spacing - currentElement * ((WaveformData)Data).ScrollSpeed;
}
TimeSpan startTime = TimeSpan.FromMilliseconds(i * Spacing);
if (startAudioTime > 0 && startAudioTime < TimeSpan.TotalMilliseconds && endAudioTime > 0 && endAudioTime < TimeSpan.TotalMilliseconds)
{
double gradientPosition1 = (AudioUtilities.VolumeAtTime(startAudioTime) + Data.Range) / Data.Range;
double gradientPosition2 = (AudioUtilities.VolumeAtTime(endAudioTime) + Data.Range) / Data.Range;
//Some odd corner cases
if (gradientPosition1 <= 0)
{
gradientPosition1 = 0;
}
if (gradientPosition1 >= 1)
{
gradientPosition1 = 1;
}
//Some odd corner cases
if (gradientPosition2 <= 0)
{
gradientPosition2 = 0;
}
if (gradientPosition2 >= 1)
{
gradientPosition2 = 1;
}
ElementData.Add(GenerateEffectIntents(elementNode, WorkingGradient, MeterIntensityCurve, gradientPosition1, gradientPosition2, TimeSpan.FromMilliseconds(Spacing), startTime, discreteColors));
}
}
currentElement++;
}
}
public void UpdateElementValue(ElementData element, float value)
{
element.value = value;
SaveExpressions();
}
private Translate(RuleNode ruleNode, ScopeGroup root, VarCollection varCollection, UserMethod[] userMethods)
{
Root = root;
VarCollection = varCollection;
UserMethods = userMethods;
Rule = new Rule(ruleNode.Name, ruleNode.Event, ruleNode.Team, ruleNode.Player);
IsGlobal = Rule.IsGlobal;
ContinueSkip = new ContinueSkip(IsGlobal, Actions, varCollection);
ParseConditions(ruleNode.Conditions);
ParseBlock(root.Child(), ruleNode.Block, false, null);
Rule.Actions = Actions.ToArray();
Rule.Conditions = Conditions.ToArray();
// Fufill remaining skips
foreach (var skip in ReturnSkips)
{
skip.ParameterValues = new IWorkshopTree[] { new V_Number(Actions.Count - ReturnSkips.IndexOf(skip)) }
}
;
ReturnSkips.Clear();
}
void ParseConditions(IExpressionNode[] expressions)
{
foreach (var expr in expressions)
{
Element parsedIf = ParseExpression(Root, expr);
// If the parsed if is a V_Compare, translate it to a condition.
// Makes "(value1 == value2) == true" to just "value1 == value2"
if (parsedIf is V_Compare)
{
Element left = (Element)parsedIf.ParameterValues[0];
if (!left.ElementData.IsValue)
{
throw SyntaxErrorException.InvalidMethodType(true, left.Name, ((Node)expr).Range);
}
Element right = (Element)parsedIf.ParameterValues[2];
if (!right.ElementData.IsValue)
{
throw SyntaxErrorException.InvalidMethodType(true, right.Name, ((Node)expr).Range);
}
Conditions.Add(
new Condition(
left,
(EnumMember)parsedIf.ParameterValues[1],
right
)
);
}
// If not, just do "parsedIf == true"
else
{
if (!parsedIf.ElementData.IsValue)
{
throw SyntaxErrorException.InvalidMethodType(true, parsedIf.Name, ((Node)expr).Range);
}
Conditions.Add(new Condition(
parsedIf, EnumData.GetEnumValue(Operators.Equal), new V_True()
));
}
}
}
Element ParseExpression(ScopeGroup scope, IExpressionNode expression)
{
switch (expression)
{
// Math and boolean operations.
case OperationNode operationNode:
{
Element left = ParseExpression(scope, operationNode.Left);
Element right = ParseExpression(scope, operationNode.Right);
/*
* if (Constants.BoolOperations.Contains(operationNode.Operation))
* {
* if (left.ElementData.ValueType != Elements.ValueType.Any && left.ElementData.ValueType != Elements.ValueType.Boolean)
* throw new SyntaxErrorException($"Expected boolean, got {left .ElementData.ValueType.ToString()} instead.", ((Node)operationNode.Left).Range);
*
* if (right.ElementData.ValueType != Elements.ValueType.Any && right.ElementData.ValueType != Elements.ValueType.Boolean)
* throw new SyntaxErrorException($"Expected boolean, got {right.ElementData.ValueType.ToString()} instead.", ((Node)operationNode.Right).Range);
* }
*/
switch (operationNode.Operation)
{
// Math: ^, *, %, /, +, -
case "^":
return(Element.Part <V_RaiseToPower>(left, right));
case "*":
return(Element.Part <V_Multiply>(left, right));
case "%":
return(Element.Part <V_Modulo>(left, right));
case "/":
return(Element.Part <V_Divide>(left, right));
case "+":
return(Element.Part <V_Add>(left, right));
case "-":
return(Element.Part <V_Subtract>(left, right));
// BoolCompare: &, |
case "&":
return(Element.Part <V_And>(left, right));
case "|":
return(Element.Part <V_Or>(left, right));
// Compare: <, <=, ==, >=, >, !=
case "<":
return(Element.Part <V_Compare>(left, EnumData.GetEnumValue(Operators.LessThan), right));
case "<=":
return(Element.Part <V_Compare>(left, EnumData.GetEnumValue(Operators.LessThanOrEqual), right));
case "==":
return(Element.Part <V_Compare>(left, EnumData.GetEnumValue(Operators.Equal), right));
case ">=":
return(Element.Part <V_Compare>(left, EnumData.GetEnumValue(Operators.GreaterThanOrEqual), right));
case ">":
return(Element.Part <V_Compare>(left, EnumData.GetEnumValue(Operators.GreaterThan), right));
case "!=":
return(Element.Part <V_Compare>(left, EnumData.GetEnumValue(Operators.NotEqual), right));
}
throw new Exception($"Operation {operationNode.Operation} not implemented.");
}
// Number
case NumberNode numberNode:
return(new V_Number(numberNode.Value));
// Bool
case BooleanNode boolNode:
if (boolNode.Value)
{
return(new V_True());
}
else
{
return(new V_False());
}
// Not operation
case NotNode notNode:
return(Element.Part <V_Not>(ParseExpression(scope, notNode.Value)));
// Strings
case StringNode stringNode:
Element[] stringFormat = new Element[stringNode.Format?.Length ?? 0];
for (int i = 0; i < stringFormat.Length; i++)
{
stringFormat[i] = ParseExpression(scope, stringNode.Format[i]);
}
return(V_String.ParseString(stringNode.Range, stringNode.Value, stringFormat));
// Null
case NullNode nullNode:
return(new V_Null());
// TODO check if groups need to be implemented here
// Methods
case MethodNode methodNode:
return(ParseMethod(scope, methodNode, true));
// Variable
case VariableNode variableNode:
return(scope.GetVar(variableNode.Name, variableNode.Range, Diagnostics)
.GetVariable(variableNode.Target != null ? ParseExpression(scope, variableNode.Target) : null));
// Get value in array
case ValueInArrayNode viaNode:
return(Element.Part <V_ValueInArray>(ParseExpression(scope, viaNode.Value), ParseExpression(scope, viaNode.Index)));
// Create array
case CreateArrayNode createArrayNode:
{
Element prev = null;
Element current = null;
for (int i = 0; i < createArrayNode.Values.Length; i++)
{
current = new V_Append()
{
ParameterValues = new IWorkshopTree[2]
};
if (prev != null)
{
current.ParameterValues[0] = prev;
}
else
{
current.ParameterValues[0] = new V_EmptyArray();
}
current.ParameterValues[1] = ParseExpression(scope, createArrayNode.Values[i]);
prev = current;
}
return(current ?? new V_EmptyArray());
}
case EnumNode enumNode:
return(EnumData.Special(enumNode.EnumMember)
?? throw SyntaxErrorException.EnumCantBeValue(enumNode.Type, enumNode.Range));
// Seperator
}
throw new Exception();
}
Element ParseMethod(ScopeGroup scope, MethodNode methodNode, bool needsToBeValue)
{
methodNode.RelatedScopeGroup = scope;
// Get the kind of method the method is (Method (Overwatch), Custom Method, or User Method.)
var methodType = GetMethodType(UserMethods, methodNode.Name);
// Throw exception if the method does not exist.
if (methodType == null)
{
throw SyntaxErrorException.NonexistentMethod(methodNode.Name, methodNode.Range);
}
Element method;
switch (methodType)
{
case MethodType.Method:
{
Type owMethod = Element.GetMethod(methodNode.Name);
method = (Element)Activator.CreateInstance(owMethod);
Parameter[] parameterData = owMethod.GetCustomAttributes <Parameter>().ToArray();
List <IWorkshopTree> parsedParameters = new List <IWorkshopTree>();
for (int i = 0; i < parameterData.Length; i++)
{
if (methodNode.Parameters.Length > i)
{
// Parse the parameter.
parsedParameters.Add(ParseParameter(scope, methodNode.Parameters[i], methodNode.Name, parameterData[i]));
}
else
{
if (parameterData[i].ParameterType == ParameterType.Value && parameterData[i].DefaultType == null)
{
// Throw exception if there is no default method to fallback on.
throw SyntaxErrorException.MissingParameter(parameterData[i].Name, methodNode.Name, methodNode.Range);
}
else
{
parsedParameters.Add(parameterData[i].GetDefault());
}
}
}
method.ParameterValues = parsedParameters.ToArray();
break;
}
case MethodType.CustomMethod:
{
MethodInfo customMethod = CustomMethods.GetCustomMethod(methodNode.Name);
Parameter[] parameterData = customMethod.GetCustomAttributes <Parameter>().ToArray();
object[] parsedParameters = new Element[parameterData.Length];
for (int i = 0; i < parameterData.Length; i++)
{
if (methodNode.Parameters.Length > i)
{
parsedParameters[i] = ParseParameter(scope, methodNode.Parameters[i], methodNode.Name, parameterData[i]);
}
else
{
// Throw exception if there is no default method to fallback on.
throw SyntaxErrorException.MissingParameter(parameterData[i].Name, methodNode.Name, methodNode.Range);
}
}
MethodResult result = (MethodResult)customMethod.Invoke(null, new object[] { IsGlobal, VarCollection, parsedParameters });
switch (result.MethodType)
{
case CustomMethodType.Action:
if (needsToBeValue)
{
throw SyntaxErrorException.InvalidMethodType(true, methodNode.Name, methodNode.Range);
}
break;
case CustomMethodType.MultiAction_Value:
case CustomMethodType.Value:
if (!needsToBeValue)
{
throw SyntaxErrorException.InvalidMethodType(false, methodNode.Name, methodNode.Range);
}
break;
}
// Some custom methods have extra actions.
if (result.Elements != null)
{
Actions.AddRange(result.Elements);
}
method = result.Result;
break;
}
case MethodType.UserMethod:
{
if (!AllowRecursion)
{
UserMethod userMethod = UserMethod.GetUserMethod(UserMethods, methodNode.Name);
if (MethodStackNoRecursive.Contains(userMethod))
{
throw SyntaxErrorException.RecursionNotAllowed(methodNode.Range);
}
var methodScope = Root.Child();
// Add the parameter variables to the scope.
DefinedVar[] parameterVars = new DefinedVar[userMethod.Parameters.Length];
for (int i = 0; i < parameterVars.Length; i++)
{
if (methodNode.Parameters.Length > i)
{
// Create a new variable using the parameter input.
parameterVars[i] = VarCollection.AssignDefinedVar(methodScope, IsGlobal, userMethod.Parameters[i].Name, methodNode.Range);
Actions.Add(parameterVars[i].SetVariable(ParseExpression(scope, methodNode.Parameters[i])));
}
else
{
throw SyntaxErrorException.MissingParameter(userMethod.Parameters[i].Name, methodNode.Name, methodNode.Range);
}
}
var returns = VarCollection.AssignVar($"{methodNode.Name}: return temp value", IsGlobal);
MethodStackNoRecursive.Add(userMethod);
var userMethodScope = methodScope.Child();
userMethod.Block.RelatedScopeGroup = userMethodScope;
ParseBlock(userMethodScope, userMethod.Block, true, returns);
MethodStackNoRecursive.Remove(userMethod);
// No return value if the method is being used as an action.
if (needsToBeValue)
{
method = returns.GetVariable();
}
else
{
method = null;
}
break;
}
else
{
UserMethod userMethod = UserMethod.GetUserMethod(UserMethods, methodNode.Name);
MethodStack lastMethod = MethodStack.FirstOrDefault(ms => ms.UserMethod == userMethod);
if (lastMethod != null)
{
ContinueSkip.Setup();
for (int i = 0; i < lastMethod.ParameterVars.Length; i++)
{
if (methodNode.Parameters.Length > i)
{
Actions.Add(lastMethod.ParameterVars[i].Push(ParseExpression(scope, methodNode.Parameters[i])));
}
}
// ?--- Multidimensional Array
Actions.Add(
Element.Part <A_SetGlobalVariable>(EnumData.GetEnumValue(Variable.B), lastMethod.ContinueSkipArray.GetVariable())
);
Actions.Add(
Element.Part <A_ModifyGlobalVariable>(EnumData.GetEnumValue(Variable.B), EnumData.GetEnumValue(Operation.AppendToArray), new V_Number(ContinueSkip.GetSkipCount() + 4))
);
Actions.Add(
lastMethod.ContinueSkipArray.SetVariable(Element.Part <V_GlobalVariable>(EnumData.GetEnumValue(Variable.B)))
);
// ?---
ContinueSkip.SetSkipCount(lastMethod.ActionIndex);
Actions.Add(Element.Part <A_Loop>());
if (needsToBeValue)
{
method = lastMethod.Return.GetVariable();
}
else
{
method = null;
}
}
else
{
var methodScope = Root.Child();
// Add the parameter variables to the scope.
ParameterVar[] parameterVars = new ParameterVar[userMethod.Parameters.Length];
for (int i = 0; i < parameterVars.Length; i++)
{
if (methodNode.Parameters.Length > i)
{
// Create a new variable using the parameter input.
parameterVars[i] = VarCollection.AssignParameterVar(Actions, methodScope, IsGlobal, userMethod.Parameters[i].Name, methodNode.Range);
Actions.Add(parameterVars[i].Push(ParseExpression(scope, methodNode.Parameters[i])));
}
else
{
throw SyntaxErrorException.MissingParameter(userMethod.Parameters[i].Name, methodNode.Name, methodNode.Range);
}
}
var returns = VarCollection.AssignVar($"{methodNode.Name}: return temp value", IsGlobal);
Var continueSkipArray = VarCollection.AssignVar($"{methodNode.Name}: continue skip temp value", IsGlobal);
var stack = new MethodStack(userMethod, parameterVars, ContinueSkip.GetSkipCount(), returns, continueSkipArray);
MethodStack.Add(stack);
var userMethodScope = methodScope.Child();
userMethod.Block.RelatedScopeGroup = userMethodScope;
ParseBlock(userMethodScope, userMethod.Block, true, returns);
// No return value if the method is being used as an action.
if (needsToBeValue)
{
method = returns.GetVariable();
}
else
{
method = null;
}
Actions.Add(Element.Part <A_Wait>(new V_Number(Constants.MINIMUM_WAIT)));
for (int i = 0; i < parameterVars.Length; i++)
{
parameterVars[i].Pop();
}
ContinueSkip.Setup();
ContinueSkip.SetSkipCount(Element.Part <V_LastOf>(continueSkipArray.GetVariable()));
// ?--- Multidimensional Array
Actions.Add(
Element.Part <A_SetGlobalVariable>(EnumData.GetEnumValue(Variable.B), continueSkipArray.GetVariable())
);
Actions.Add(
continueSkipArray.SetVariable(
Element.Part <V_ArraySlice>(
Element.Part <V_GlobalVariable>(EnumData.GetEnumValue(Variable.B)),
new V_Number(0),
Element.Part <V_Subtract>(
Element.Part <V_CountOf>(Element.Part <V_GlobalVariable>(EnumData.GetEnumValue(Variable.B))),
new V_Number(1)
)
)
)
);
// ?---
Actions.Add(
Element.Part <A_LoopIf>(
Element.Part <V_Compare>(
Element.Part <V_CountOf>(continueSkipArray.GetVariable()),
EnumData.GetEnumValue(Operators.NotEqual),
new V_Number(0)
)
)
);
ContinueSkip.ResetSkip();
MethodStack.Remove(stack);
}
break;
}
}
default: throw new NotImplementedException();
}
methodNode.RelatedElement = method;
return(method);
}
IWorkshopTree ParseParameter(ScopeGroup scope, IExpressionNode node, string methodName, Parameter parameterData)
{
IWorkshopTree value = null;
switch (node)
{
case EnumNode enumNode:
/*
* if (parameterData.ParameterType != ParameterType.Enum)
* throw SyntaxErrorException.ExpectedType(true, parameterData.ValueType.ToString(), methodName, parameterData.Name, enumNode.Range);
*
* if (enumNode.Type != parameterData.EnumType.Name)
* throw SyntaxErrorException.ExpectedType(false, parameterData.EnumType.ToString(), methodName, parameterData.Name, enumNode.Range);
*/
value = (IWorkshopTree)EnumData.Special(enumNode.EnumMember) ?? (IWorkshopTree)enumNode.EnumMember;
//if (value == null)
// throw SyntaxErrorException.InvalidEnumValue(enumNode.Type, enumNode.Value, enumNode.Range);
break;
default:
if (parameterData.ParameterType != ParameterType.Value)
{
throw SyntaxErrorException.ExpectedType(false, parameterData.EnumType.Name, methodName, parameterData.Name, ((Node)node).Range);
}
value = ParseExpression(scope, node);
Element element = value as Element;
ElementData elementData = element.GetType().GetCustomAttribute <ElementData>();
if (elementData.ValueType != Elements.ValueType.Any &&
!parameterData.ValueType.HasFlag(elementData.ValueType))
{
throw SyntaxErrorException.InvalidType(parameterData.ValueType, elementData.ValueType, ((Node)node).Range);
}
break;
}
if (value == null)
{
throw new Exception("Failed to parse parameter.");
}
return(value);
}
public void GetDataFromTheList(ElementData e)
{
this.LastShellPopulation = e.valence;
symbol.text = e.symbol;
}
public void PlayerJoin(EntityBase entity)
{
PlayerComponent playerComp = null;
if (!entity.GetExistComp <PlayerComponent>())
{
playerComp = new PlayerComponent();
playerComp.characterID = "1";
playerComp.nickName = "Test model";
ElementData e1 = new ElementData();
e1.id = 100;
e1.num = 10;
playerComp.elementData.Add(e1);
ElementData e2 = new ElementData();
e2.id = 101;
e2.num = 10;
playerComp.elementData.Add(e2);
ElementData e3 = new ElementData();
e3.id = 102;
e3.num = 10;
playerComp.elementData.Add(e3);
ElementData e4 = new ElementData();
e4.id = 103;
e4.num = 00;
playerComp.elementData.Add(e4);
entity.AddComp(playerComp);
}
if (!entity.GetExistComp <CommandComponent>())
{
CommandComponent c = new CommandComponent();
entity.AddComp(c);
}
if (!entity.GetExistComp <TransfromComponent>())
{
TransfromComponent c = new TransfromComponent();
entity.AddComp(c);
}
if (!entity.GetExistComp <AssetComponent>())
{
AssetComponent c = new AssetComponent();
c.m_assetName = "famale_01";
entity.AddComp(c);
}
if (!entity.GetExistComp <MoveComponent>())
{
MoveComponent c = new MoveComponent();
c.pos.FromVector(new Vector3(15, 0, 0));
entity.AddComp(c);
}
if (!entity.GetExistComp <SkillStatusComponent>())
{
SkillStatusComponent c = new SkillStatusComponent();
DataTable data = DataManager.GetData("SkillData");
for (int i = 0; i < data.TableIDs.Count; i++)
{
c.m_skillList.Add(new SkillData(data.TableIDs[i], i));
}
entity.AddComp(c);
}
if (!entity.GetExistComp <CDComponent>())
{
CDComponent c = new CDComponent();
entity.AddComp(c);
}
if (!entity.GetExistComp <CampComponent>())
{
CampComponent c = new CampComponent();
c.creater = entity.ID;
entity.AddComp(c);
}
if (!entity.GetExistComp <MoveComponent>())
{
MoveComponent c = new MoveComponent();
entity.AddComp(c);
}
if (!entity.GetExistComp <CollisionComponent>())
{
CollisionComponent c = new CollisionComponent();
c.area.areaType = AreaType.Circle;
c.area.radius = 0.5f;
entity.AddComp(c);
}
if (!entity.GetExistComp <LifeComponent>())
{
LifeComponent c = new LifeComponent();
c.maxLife = playerComp.CharacterData.m_hp;
c.life = playerComp.CharacterData.m_hp;
entity.AddComp(c);
}
if (!entity.GetExistComp <BlowFlyComponent>())
{
BlowFlyComponent c = new BlowFlyComponent();
entity.AddComp(c);
}
}
private void UpdateIcons(Player player)
{
if (!player || player.IsDead())
{
foreach (ElementData elementData in m_elements)
{
Destroy(elementData.m_go);
}
m_elements.Clear();
return;
}
m_items.Clear();
Inventory inv = player.GetInventory();
if (inv.GetItemAt(5, inv.GetHeight() - 1) != null)
{
m_items.Add(inv.GetItemAt(5, inv.GetHeight() - 1));
}
if (inv.GetItemAt(6, inv.GetHeight() - 1) != null)
{
m_items.Add(inv.GetItemAt(6, inv.GetHeight() - 1));
}
if (inv.GetItemAt(7, inv.GetHeight() - 1) != null)
{
m_items.Add(inv.GetItemAt(7, inv.GetHeight() - 1));
}
m_items.Sort((ItemDrop.ItemData x, ItemDrop.ItemData y) => x.m_gridPos.x.CompareTo(y.m_gridPos.x));
int num = 0;
foreach (ItemDrop.ItemData itemData in m_items)
{
if (itemData.m_gridPos.x - 4 > num)
{
num = itemData.m_gridPos.x - 4;
}
}
if (m_elements.Count != num)
{
foreach (ElementData elementData in m_elements)
{
Destroy(elementData.m_go);
}
m_elements.Clear();
for (int i = 0; i < num; i++)
{
ElementData elementData = new ElementData();
elementData.m_go = Instantiate(m_elementPrefab, transform);
elementData.m_go.transform.localPosition = new Vector3(i * m_elementSpace, 0f, 0f);
elementData.m_go.transform.Find("binding").GetComponent <Text>().text = BepInExPlugin.hotkeys[i].Value;
elementData.m_icon = elementData.m_go.transform.transform.Find("icon").GetComponent <Image>();
elementData.m_durability = elementData.m_go.transform.Find("durability").GetComponent <GuiBar>();
elementData.m_amount = elementData.m_go.transform.Find("amount").GetComponent <Text>();
elementData.m_equiped = elementData.m_go.transform.Find("equiped").gameObject;
elementData.m_queued = elementData.m_go.transform.Find("queued").gameObject;
elementData.m_selection = elementData.m_go.transform.Find("selected").gameObject;
m_elements.Add(elementData);
}
}
foreach (ElementData elementData in m_elements)
{
elementData.m_used = false;
}
bool flag = ZInput.IsGamepadActive();
for (int j = 0; j < m_items.Count; j++)
{
ItemDrop.ItemData itemData2 = m_items[j];
ElementData elementData = m_elements[itemData2.m_gridPos.x - 5];
elementData.m_used = true;
elementData.m_icon.gameObject.SetActive(true);
elementData.m_icon.sprite = itemData2.GetIcon();
elementData.m_durability.gameObject.SetActive(itemData2.m_shared.m_useDurability);
if (itemData2.m_shared.m_useDurability)
{
if (itemData2.m_durability <= 0f)
{
elementData.m_durability.SetValue(1f);
elementData.m_durability.SetColor((Mathf.Sin(Time.time * 10f) > 0f) ? Color.red : new Color(0f, 0f, 0f, 0f));
}
else
{
elementData.m_durability.SetValue(itemData2.GetDurabilityPercentage());
elementData.m_durability.ResetColor();
}
}
elementData.m_equiped.SetActive(itemData2.m_equiped);
elementData.m_queued.SetActive(player.IsItemQueued(itemData2));
if (itemData2.m_shared.m_maxStackSize > 1)
{
elementData.m_amount.gameObject.SetActive(true);
elementData.m_amount.text = itemData2.m_stack.ToString() + "/" + itemData2.m_shared.m_maxStackSize.ToString();
}
else
{
elementData.m_amount.gameObject.SetActive(false);
}
}
for (int k = 0; k < m_elements.Count; k++)
{
ElementData elementData = m_elements[k];
elementData.m_selection.SetActive(flag && k == m_selected);
if (!elementData.m_used)
{
elementData.m_icon.gameObject.SetActive(false);
elementData.m_durability.gameObject.SetActive(false);
elementData.m_equiped.SetActive(false);
elementData.m_queued.SetActive(false);
elementData.m_amount.gameObject.SetActive(false);
}
}
}
//记录场景信息
public void RecScene()
{
//场景切换之间不会有变动的数据，只在首次保存层时记录
if (currentSceneInfo.BlockData == null || currentSceneInfo.BlockData.Count == 0) {
for (int i=0; i<blockList.Count; i++) {
GameObject blockO = blockList [i];
ElementData ed = new ElementData (blockO.transform.position, blockO.name, blockO.transform.eulerAngles, blockO.GetComponent<SpriteRenderer> ().sortingOrder);
blockData.Add (ed);
}
currentSceneInfo.BlockData = blockData;
for (int i=0; i<itemList.Count; i++) {
GameObject itemO = itemList [i];
ElementData ed = new ElementData (itemO.transform.position, itemO.name, itemO.transform.eulerAngles, itemO.GetComponent<SpriteRenderer> ().sortingOrder);
itemData.Add (ed);
}
currentSceneInfo.ItemData = itemData;
for (int i=0; i<enemyList.Count; i++) {
GameObject enemyO = enemyList [i];
ElementData ed = new ElementData (enemyO.transform.position, enemyO.name, enemyO.transform.eulerAngles, enemyO.GetComponent<SpriteRenderer> ().sortingOrder);
enemyData.Add (ed);
}
currentSceneInfo.EnemyData = enemyData;
}
//挖掘点数据在从主场景切换到战斗场景的过程中,贴图会发生变动，所以每次记录场景时都要更新
//先清除原数据(由于digList和digData之间没有关联，所以不方便在更新dig贴图时，同时更新digData的数据，这里在保存场景时全部重新保存)
digData.Clear ();
for (int i=0; i<digList.Count; i++) {
GameObject digO = digList [i];
AddNewDigData (digO);
}
currentSceneInfo.DigData = digData;
gData.currentTomb.sceneList [gData.currentFloor - 1] = currentSceneInfo;
}
void ApplyLevel(Level level)
{
// Elements
Dictionary <GameObject, int> elementsToLink = new Dictionary <GameObject, int>();
for (int i = 0; i < level.levelElements.Count; ++i)
{
ElementData ED = level.levelElements[i];
Vector3 pos = new Vector3(ED.posX, ED.posY, ED.posZ);
GameObject go = null;
switch (ED.type)
{
case (int)PuzzleElementPlaceHolder.PuzzleElementType.Puzzle:
go = Instantiate(puzzlePH, pos, puzzlePH.transform.rotation, mainElementsEditor);
break;
case (int)PuzzleElementPlaceHolder.PuzzleElementType.Player:
go = Instantiate(playerPH, pos, playerPH.transform.rotation, mainElementsEditor);
break;
case (int)PuzzleElementPlaceHolder.PuzzleElementType.PlatformBox:
go = Instantiate(platformBoxPH, pos, platformBoxPH.transform.rotation, mainElementsEditor);
break;
case (int)PuzzleElementPlaceHolder.PuzzleElementType.PlatformCircle:
go = Instantiate(platformCirclePH, pos, platformCirclePH.transform.rotation, mainElementsEditor);
break;
case (int)PuzzleElementPlaceHolder.PuzzleElementType.Doors:
go = Instantiate(doorsPH, pos, doorsPH.transform.rotation, mainElementsEditor);
break;
case (int)PuzzleElementPlaceHolder.PuzzleElementType.MovingBox:
go = Instantiate(movingBoxPH, pos, movingBoxPH.transform.rotation, mainElementsEditor);
break;
case (int)PuzzleElementPlaceHolder.PuzzleElementType.VerticalLeftDoors:
go = Instantiate(VLDoorsPH, pos, VLDoorsPH.transform.rotation, mainElementsEditor);
break;
case (int)PuzzleElementPlaceHolder.PuzzleElementType.VerticalRightDoors:
go = Instantiate(VRDoorsPH, pos, VRDoorsPH.transform.rotation, mainElementsEditor);
break;
}
if (go)
{
go.GetComponent <PuzzleElementPlaceHolder>().ChangeState(PuzzleElementPlaceHolder.States.InLevel);
}
LinkElementPlaceholder LEP = go.GetComponent <LinkElementPlaceholder>();
if (LEP)
{
var linkingObjects = PuzzleEditorController.instance.linkingObjects;
if (!linkingObjects.ContainsKey(go))
{
linkingObjects.Add(go, LEP.type);
}
if (ED.elementLinkedPos != -1)
{
foreach (KeyValuePair <GameObject, int> previousElement in elementsToLink)
{
if (i == previousElement.Value)
{
previousElement.Key.GetComponent <LinkElementPlaceholder>().elementLinked = go;
LEP.elementLinked = previousElement.Key;
elementsToLink.Remove(previousElement.Key);
break;
}
}
if (!LEP.elementLinked)
{
elementsToLink.Add(go, ED.elementLinkedPos);
}
}
}
}
// Tiles
AllTiles allTiles = PuzzleEditorController.instance.allTiles;
PuzzleEditorController.instance.SetSize(level.size);
SetCameraSize(level.size);
for (int i = 0; i < level.groundTiles.Count; ++i)
{
TileData TD = level.groundTiles[i];
Vector3Int pos = new Vector3Int(TD.posX, TD.posY, TD.posZ);
PuzzleEditorController.instance.baseTM.SetTile(pos, GetTileFromInt(TD.id, allTiles));
}
for (int i = 0; i < level.collidableTiles.Count; ++i)
{
TileData TD = level.collidableTiles[i];
Vector3Int pos = new Vector3Int(TD.posX, TD.posY, TD.posZ);
PuzzleEditorController.instance.collidable.SetTile(pos, GetTileFromInt(TD.id, allTiles));
}
levelName.text = level.name;
levelDescription.text = level.description;
ApplyLevelInfo(level.name, level.creatorName, level.description);
}
// renders the given node to the internal ElementData dictionary. If the given node is
// not a element, will recursively descend until we render its elements.
protected override void RenderNode(ElementNode node)
{
int currentElement = 0;
int elementCount = node.GetLeafEnumerator().Count();
foreach (ElementNode elementNode in node.GetLeafEnumerator())
{
// this is probably always going to be a single element for the given node, as
// we have iterated down to leaf nodes in RenderNode() above. May as well do
// it this way, though, in case something changes in future.
if (elementNode == null || elementNode.Element == null)
{
continue;
}
if (!AudioUtilities.AudioLoaded)
{
return;
}
bool discreteColors = ColorModule.isElementNodeDiscreteColored(elementNode);
var lastTime = TimeSpan.FromMilliseconds(0);
double gradientPosition = (double)(currentElement) / elementCount;
//Audio max is at 0db. The threshold gets shifted from 0 to 1 to -1 to 0 and then scaled.
double threshold;
if (!((VerticalMeterData)Data).Inverted)
{
threshold = (((double)(elementCount - currentElement)) / elementCount - 1) * Data.Range;
gradientPosition = 1 - gradientPosition;
}
else
{
threshold = (((double)currentElement) / elementCount - 1) * Data.Range;
}
var lastValue = AudioUtilities.VolumeAtTime(0) >= threshold;
TimeSpan start;
for (int i = 1; i < (int)(TimeSpan.TotalMilliseconds / Spacing); i++)
{
//Current time in ms = i*spacing
var currentValue = AudioUtilities.VolumeAtTime(i * Spacing) >= threshold;
if (currentValue != lastValue)
{
start = lastTime;
if (lastValue)
{
var effectIntents = GenerateEffectIntents(elementNode, WorkingGradient, MeterIntensityCurve, gradientPosition,
gradientPosition, TimeSpan.FromMilliseconds(i * Spacing) - lastTime, start, discreteColors);
ElementData.Add(effectIntents);
}
lastTime = TimeSpan.FromMilliseconds(i * Spacing);
lastValue = currentValue;
}
}
if (lastValue)
{
start = lastTime;
var effectIntents = GenerateEffectIntents(elementNode, WorkingGradient, MeterIntensityCurve, gradientPosition,
gradientPosition, TimeSpan - lastTime, start, discreteColors);
ElementData.Add(effectIntents);
}
currentElement++;
}
}
/*
============================================================================
Init functions
============================================================================
*/
public void Init()
{
// first init languages
languages = new LanguageData();
statusValues = new StatusValueData();
elements = new ElementData();
races = new RaceData();
sizes = new SizeData();
areaNames = new AreaNameData();
armors = new ArmorData();
cameraPositions = new CameraPositionData();
attacks = new BaseAttackData();
characters = new CharacterData();
classes = new ClassData();
colors = new ColorData();
dialoguePositions = new DialoguePositionData();
battleAIs = new BattleAIData();
enemies = new EnemyData();
equipParts = new EquipmentPartData();
formulas = new FormulaData();
gameSettings = new GameSettingsData();
items = new ItemData();
itemTypes = new ItemTypeData();
loadSaveHUD = new LoadSaveHUDData();
mainMenu = new MainMenuData();
skillTypes = new SkillTypeData();
effects = new StatusEffectData();
skills = new SkillData();
weapons = new WeaponData();
music = new MusicData();
huds = new HUDData();
recipes = new ItemRecipeData();
fonts = new FontData();
globalEvents = new GlobalEventData();
teleports = new TeleportData();
difficulties = new DifficultyData();
// battle system
battleAnimations = new BattleAnimationData();
battleSystem = new BattleSystemData();
}
