private static IEnumerable<BuildItem> WalkCircularDependency(BuildItem item, IDictionary<BuildItem, List<BuildItem>> scriptsToDependencies, ISet<BuildItem> visitedItems, out bool isCircularPath)
{
if(visitedItems.Contains(item))
{
isCircularPath = true;
return Enumerable.Repeat(item, 1);
}
if (!scriptsToDependencies.ContainsKey(item))
{
isCircularPath = false;
return Enumerable.Empty<BuildItem>();
}
visitedItems.Add(item);
foreach (var d in scriptsToDependencies[item])
{
bool currentIsCircular;
var currentPath = WalkCircularDependency(d, scriptsToDependencies, visitedItems, out currentIsCircular);
if(currentIsCircular)
{
isCircularPath = true;
return Enumerable.Repeat(item, 1).Concat(currentPath);
}
}
isCircularPath = false;
return Enumerable.Empty<BuildItem>();
}
public async Task ExecuteAsync(ScriptFile script, BuildItem.BuildActionType action)
{
string cmdText;
switch (action)
{
case BuildItem.BuildActionType.Drop:
return;
case BuildItem.BuildActionType.Alter:
cmdText = script.Sql.GetAlterScript();
break;
case BuildItem.BuildActionType.Create:
case BuildItem.BuildActionType.DropAndCreate:
cmdText = script.Sql.GetCreateScript();
break;
default:
throw new NotSupportedException(string.Format("Unable to execute a script for build action type {0}.", action));
}
using (var cmd = _connection.CreateCommand())
{
cmd.CommandText = cmdText;
cmd.Transaction = _transaction;
await cmd.ExecuteNonQueryAsync();
}
}
public static void InitBaseData()
{
JSONNode jdNodes = JSONNode.Parse((Resources.Load("GameData/Items",typeof(TextAsset)) as TextAsset).ToString());
for (int i = 0; i < jdNodes.Count; i++) {
JSONNode item = jdNodes[i];
BuildItem buildItem = new BuildItem(item);
AddBuildItemBD(buildItem);
}
}
public async Task ExecuteAsync(ScriptFile script, BuildItem.BuildActionType action)
{
if(action == BuildItem.BuildActionType.Drop || action == BuildItem.BuildActionType.DropAndCreate)
{
string cmdText = string.Format("DROP {0} [{1}].[{2}]", script.ScriptObject.ObjectType.ToString(), script.ScriptObject.SchemaName, script.ScriptObject.ObjectName);
var cmd = new SqlCommand(cmdText, Connection);
await cmd.ExecuteNonQueryAsync();
}
}
private string GetReferenceDllName(BuildItem item)
{
string spec = item.FinalItemSpec;
int commaIndex = spec.IndexOf(CHAR_Comma);
if (commaIndex >= 0)
{
return(spec.Substring(0, commaIndex));
}
return(spec);
}
private string GetAssemblyPathFromHintPath(BuildItem item, string projectDir)
{
string path = item.GetMetadata(STR_HintPath);
path = PathUtilities.GetPath(projectDir, path);
if (File.Exists(path))
{
return(path);
}
return(null);
}
private string GetAssemblyPathFromInclude(BuildItem item, string projectDir)
{
string path = item.Include;
path = PathUtilities.GetPath(projectDir, path);
if (File.Exists(path))
{
return(path);
}
return(null);
}
internal void UpdateDependencies(List <BuildElement> dependencies)
{
if (dependencies.Count == 0)
{
BuildItem.RemoveMetadata(Constants.DependsOn);
}
else
{
BuildItem.SetMetadata(Constants.DependsOn, dependencies.ConvertAll(elem => elem.ToString()).Aggregate("", (a, item) => a + ',' + item).Substring(1));
}
}
/// <summary>
/// If this is a persisted group, removes the XML element corresponding to the given item.
/// If this is not a persisted group, does nothing.
/// </summary>
private void RemoveItemElement(BuildItem item)
{
if (IsPersisted)
{
MustNotBeImported();
MustHaveThisParentElement(item);
MustHaveThisParentGroup(item);
xml.Element.RemoveChild(item.ItemElement);
item.ParentPersistedItemGroup = null;
}
}
public void AddItemEmptyPersistedGroup()
{
XmlDocument doc = new XmlDocument();
XmlElement ig = doc.CreateElement("ItemGroup", XMakeAttributes.defaultXmlNamespace);
BuildItemGroup group = new BuildItemGroup(ig, false, new Project());
BuildItem item = CreatePersistedBuildItem(ig, "i", "i3");
group.AddItem(item);
VerifyPersistedItemPosition(group, item, 0);
}
public void AddItemEmptyNonPersistedGroup()
{
BuildItemGroup group = new BuildItemGroup();
BuildItem item = new BuildItem("i", "i1");
group.AddItem(item);
Assertion.AssertEquals(item, group[0]); // should be last
item = new BuildItem("i", "i0");
group.AddItem(item);
Assertion.AssertEquals(item, group[1]); // should be last again
}
/// <summary>
/// Puts the item into the table.
/// </summary>
private void ImportItemIntoTable(Hashtable table, BuildItem item)
{
BuildItemGroup existing = (BuildItemGroup)table[item.Name];
if (existing == null)
{
existing = new BuildItemGroup();
table.Add(item.Name, existing);
}
existing.AddItem(item);
}
public void CopyMetadataToWithDefaults()
{
BuildItem fromBuildItem = BuildItem_Tests.GetXmlBackedItemWithDefinitionLibrary(); // i1; has m=m1 (default) and n=n1 (regular)
TaskItem from = new TaskItem(fromBuildItem);
TaskItem to = new TaskItem("i2");
from.CopyMetadataTo(to);
Assertion.AssertEquals("n1", to.GetMetadata("n"));
Assertion.AssertEquals("m1", to.GetMetadata("m"));
}
private void RemoveRemovedItem(BuildItem buildItem)
#endif
{
if (_removedItems != null)
{
string key = ORMCustomToolUtility.GetItemInclude(buildItem);
if (_removedItems.ContainsKey(key))
{
_removedItems.Remove(key);
}
}
}
/// <summary>
/// Helper for trying valid item names
/// </summary>
/// <param name="name"></param>
private void TryValidItemName(string name)
{
XmlDocument doc = new XmlDocument();
BuildItem item = new BuildItem(doc, name, "someItemSpec", new ItemDefinitionLibrary(new Project()));
Assertion.AssertEquals(name, item.Name);
Assertion.AssertEquals("someItemSpec", item.FinalItemSpec);
// Try setter
item.Name = name;
Assertion.AssertEquals(name, item.Name);
}
public void ModifyItem()
{
Hashtable table1 = new Hashtable(StringComparer.OrdinalIgnoreCase);
Lookup lookup = LookupHelpers.CreateLookup(table1);
lookup.EnterScope();
// Add an item with m=m1
BuildItem item1 = new BuildItem("i1", "a2");
item1.SetMetadata("m", "m1");
lookup.AddNewItem(item1);
lookup.EnterScope();
// Change the item to be m=m2
Dictionary <string, string> newMetadata = new Dictionary <string, string>();
newMetadata.Add("m", "m2");
BuildItemGroup group = new BuildItemGroup();
group.AddItem(item1);
lookup.ModifyItems(item1.Name, group, newMetadata);
// Now it has m=m2
group = lookup.GetItems("i1");
Assertion.AssertEquals(1, group.Count);
Assertion.AssertEquals("m2", group[0].GetMetadata("m"));
// But the original item hasn't changed yet
Assertion.AssertEquals("m1", item1.GetMetadata("m"));
lookup.LeaveScope();
// It still has m=m2
group = lookup.GetItems("i1");
Assertion.AssertEquals(1, group.Count);
Assertion.AssertEquals("m2", group[0].GetMetadata("m"));
// The original item still hasn't changed
// even though it was added in this scope
Assertion.AssertEquals("m1", item1.GetMetadata("m"));
lookup.LeaveScope();
// It still has m=m2
group = lookup.GetItems("i1");
Assertion.AssertEquals(1, group.Count);
Assertion.AssertEquals("m2", group[0].GetMetadata("m"));
// But now the original item has changed
Assertion.AssertEquals("m2", item1.GetMetadata("m"));
}
public void Removes()
{
// One item in the project
BuildItemGroup group1 = new BuildItemGroup();
BuildItem item1 = new BuildItem("i1", "a1");
group1.AddItem(item1);
Hashtable table1 = new Hashtable(StringComparer.OrdinalIgnoreCase);
table1.Add("i1", group1);
Lookup lookup = LookupHelpers.CreateLookup(table1);
// Start a target
lookup.EnterScope();
// Start a task (eg) and add a new item
lookup.EnterScope();
BuildItem item2 = new BuildItem("i1", "a2");
lookup.AddNewItem(item2);
// Remove one item
lookup.RemoveItem(item1);
// We see one item
Assertion.AssertEquals(1, lookup.GetItems("i1").Count);
Assertion.AssertEquals("a2", lookup.GetItems("i1")[0].FinalItemSpec);
// Remove the other item
lookup.RemoveItem(item2);
// We see no items
Assertion.AssertEquals(0, lookup.GetItems("i1").Count);
// Finish the task
lookup.LeaveScope();
// We still see no items
Assertion.AssertEquals(0, lookup.GetItems("i1").Count);
// But there's still one item in the project
Assertion.AssertEquals("a1", group1[0].FinalItemSpec);
Assertion.AssertEquals(1, group1.Count);
// Finish the target
lookup.LeaveScope();
// We still see no items
Assertion.AssertEquals(0, lookup.GetItems("i1").Count);
// And now there are no items in the project either
Assertion.AssertEquals(0, group1.Count);
}
public IActionResult Post([FromBody]BuildItem value)
{
var build = new BuildItem
{
Id = 2,
Name = "test",
Description = "testin 123"
};
_buildContext.BuildItems.Add(build);
return Json(value); //await _buildContext.Sav
}
public BuildItemViewModel(BuildItem item, Dispatcher dispatcher)
{
Item = item;
Item.StatusChanged += (sender, args) => dispatcher.BeginInvoke((Action)(() =>
{
NotifyPropertyChanged("Status");
NotifyPropertyChanged("Error");
NotifyPropertyChanged("ErrorTitle");
NotifyPropertyChanged("ErrorMessage");
NotifyPropertyChanged("ShowError");
}));
}
public async Task ExecuteAsync(ScriptFile script, BuildItem.BuildActionType action)
{
if(action == BuildItem.BuildActionType.Drop || action == BuildItem.BuildActionType.DropAndCreate)
{
using (var cmd = _connection.CreateCommand())
{
cmd.CommandText = string.Format("DROP {0} [{1}].[{2}]", script.ScriptObject.ObjectType.ToString(), script.ScriptObject.SchemaName, script.ScriptObject.ObjectName);
cmd.Transaction = _transaction;
await cmd.ExecuteNonQueryAsync();
}
}
}
public static void CheckBuildItem (BuildItem item, string name, string [,] metadata, string finalItemSpec, string prefix)
{
Assert.AreEqual (name, item.Name, prefix + "#1");
for (int i = 0; i < metadata.GetLength (0); i ++) {
string key = metadata [i, 0];
string val = metadata [i, 1];
Assert.IsTrue (item.HasMetadata (key), String.Format ("{0}#2: Expected metadata '{1}' not found", prefix, key));
Assert.AreEqual (val, item.GetMetadata (key), String.Format ("{0}#3: Value for metadata {1}", prefix, key));
Assert.AreEqual (val, item.GetEvaluatedMetadata (key), String.Format ("{0}#4: Value for evaluated metadata {1}", prefix, key));
}
Assert.AreEqual (finalItemSpec, item.FinalItemSpec, prefix + "#5");
}
public void TestAddNewItem5()
{
BuildItemGroup big = new BuildItemGroup();
big.AddNewItem("I1", "Value");
BuildItem bi = big.AddNewItem("I2", "@(I1)");
Assert.AreEqual("@(I1)", bi.FinalItemSpec, "A1");
Assert.AreEqual("@(I1)", bi.Include, "A2");
Assert.AreEqual(2, big.Count, "A3");
}
public void RemoveItemPopulatedInLowerScope()
{
Hashtable table1 = new Hashtable(StringComparer.OrdinalIgnoreCase);
Lookup lookup = LookupHelpers.CreateLookup(table1);
BuildItem item1 = new BuildItem("i1", "a2");
// Start a target
lookup.EnterScope();
// There's one item in this batch
lookup.PopulateWithItem(item1);
// We see it
Assertion.AssertEquals(1, lookup.GetItems("i1").Count);
// Make a clone so we can keep an eye on that item
Lookup lookup2 = lookup.Clone();
// We can see the item in the clone
Assertion.AssertEquals(1, lookup2.GetItems("i1").Count);
// Start a task (eg)
lookup.EnterScope();
// We see the item below
Assertion.AssertEquals(1, lookup.GetItems("i1").Count);
// Remove that item
lookup.RemoveItem(item1);
// We see no items
Assertion.AssertEquals(0, lookup.GetItems("i1").Count);
// The clone is unaffected so far
Assertion.AssertEquals(1, lookup2.GetItems("i1").Count);
// Finish the task
lookup.LeaveScope();
// We still see no items
Assertion.AssertEquals(0, lookup.GetItems("i1").Count);
// But now the clone doesn't either
Assertion.AssertEquals(0, lookup2.GetItems("i1").Count);
// Finish the target
lookup.LeaveScope();
// We still see no items
Assertion.AssertEquals(0, lookup.GetItems("i1").Count);
Assertion.AssertEquals(0, lookup2.GetItems("i1").Count);
}
public void ModifyItemPreviouslyModifiedAndGottenThroughGetItem()
{
Hashtable table1 = new Hashtable(StringComparer.OrdinalIgnoreCase);
Lookup lookup = LookupHelpers.CreateLookup(table1);
// Add an item with m=m1 and n=n1
BuildItem item1 = new BuildItem("i1", "a2");
item1.SetMetadata("m", "m1");
lookup.PopulateWithItem(item1);
lookup.EnterScope();
// Make a modification to the item to be m=m2
Dictionary <string, string> newMetadata = new Dictionary <string, string>();
newMetadata.Add("m", "m2");
BuildItemGroup group = new BuildItemGroup();
group.AddItem(item1);
lookup.ModifyItems(item1.Name, group, newMetadata);
// Get the item (under the covers, it cloned it in order to apply the modification)
BuildItemGroup group2 = lookup.GetItems(item1.Name);
Assertion.AssertEquals(1, group2.Count);
BuildItem item1b = group2[0];
// Modify to m=m3
Dictionary <string, string> newMetadata2 = new Dictionary <string, string>();
newMetadata2.Add("m", "m3");
BuildItemGroup group3 = new BuildItemGroup();
group3.AddItem(item1b);
lookup.ModifyItems(item1b.Name, group3, newMetadata2);
// Modifications are visible
BuildItemGroup group4 = lookup.GetItems(item1b.Name);
Assertion.AssertEquals(1, group4.Count);
Assertion.AssertEquals("m3", group4[0].GetMetadata("m"));
// Leave scope
lookup.LeaveScope();
// Still visible
BuildItemGroup group5 = lookup.GetItems(item1b.Name);
Assertion.AssertEquals(1, group5.Count);
Assertion.AssertEquals("m3", group5[0].GetMetadata("m"));
}
private void finishChunk(ChunkData chunkData)
{
GameObject chunkObject = new GameObject();
chunkObject.name = "Chunk PosIJ:" + chunkData.startPosIJ.x + " " + chunkData.startPosIJ.y;
chunkObject.transform.parent = asteroidFieldData.gameObject.transform;
chunkObject.transform.position = new Vector3(chunkData.startPosXY.x, chunkData.startPosXY.y, 0);
ChunkContainer chunkContainer = chunkObject.AddComponent <ChunkContainer>();
chunkData.chunkContainer = chunkContainer;
chunkContainer.chunkData = chunkData;
foreach (Triangle triangle in chunkData.visableTriangle)
{
BuildItem copyItem = triangle.item;
triangle.item = (BuildItem)ScriptableObject.CreateInstance("BuildItem");
triangle.item.name = copyItem.name;
triangle.item.Icon = copyItem.Icon;
triangle.item.discription = copyItem.discription;
triangle.item.player = copyItem.player;
triangle.item.duribility = copyItem.duribility;
triangle.item.maxduribility = copyItem.maxduribility;
triangle.item.UV0s = copyItem.UV0s;
triangle.item.mass = copyItem.mass;
}
chunkData.mesh = new Mesh();
chunkData.mesh.vertices = chunkData.vertices;
chunkData.mesh.triangles = chunkData.indices;
chunkData.mesh.uv = chunkData.uv;
chunkData.mesh.uv2 = chunkData.uv1;
chunkData.mesh.colors = chunkData.colors;
chunkData.meshFilter = chunkObject.AddComponent <MeshFilter>();
chunkData.meshFilter.mesh = chunkData.mesh;
chunkData.meshRenderer = chunkObject.AddComponent <MeshRenderer>();
chunkData.meshRenderer.material = buildMaterial;
chunkData.polygonCollider2D = chunkObject.AddComponent <PolygonCollider2D>();
chunkData.polygonCollider2D.pathCount = chunkData.colliderPaths.Count;
int i = 0;
foreach (Vector2[] path in chunkData.colliderPaths)
{
chunkData.polygonCollider2D.SetPath(i, path);
i++;
}
chunkData.state++;
}
/// <summary>
/// Copy constructor
/// </summary>
internal BuildResult
(BuildResult buildResultToCopy, bool deepCopy)
{
ErrorUtilities.VerifyThrowArgumentNull(buildResultToCopy, "Cannot have a null build result passed in");
this.flags = buildResultToCopy.flags;
this.handleId = buildResultToCopy.handleId;
this.requestId = buildResultToCopy.requestId;
this.projectId = buildResultToCopy.projectId;
this.outputsByTarget = new Hashtable();
this.defaultTargets = buildResultToCopy.defaultTargets;
this.initialTargets = buildResultToCopy.initialTargets;
this.resultByTarget = new Hashtable(buildResultToCopy.resultByTarget, StringComparer.OrdinalIgnoreCase);
if (buildResultToCopy.outputsByTarget == null)
{
return;
}
if (deepCopy)
{
// Copy all the old data
foreach (DictionaryEntry entry in buildResultToCopy.outputsByTarget)
{
// Make deep copies of all the target outputs before
// passing them back
BuildItem[] originalArray = (BuildItem[])entry.Value;
BuildItem[] itemArray = new BuildItem[originalArray.Length];
for (int i = 0; i < originalArray.Length; i++)
{
if (!originalArray[i].IsUninitializedItem)
{
itemArray[i] = originalArray[i].Clone();
itemArray[i].CloneVirtualMetadata();
}
else
{
itemArray[i] = new BuildItem(null, originalArray[i].FinalItemSpecEscaped);
}
}
this.outputsByTarget.Add(entry.Key, itemArray);
}
}
else
{
// Create a new hashtable but point at the same data
foreach (DictionaryEntry entry in buildResultToCopy.outputsByTarget)
{
this.outputsByTarget.Add(entry.Key, entry.Value);
}
}
}
private void CreateItem(kcsapi_createitem item, NameValueCollection req)
{
var logitem = new BuildItem
{
Result = item.api_create_flag == 1 ? KanColleClient.Current.Master.SlotItems[item.api_slot_item.api_slotitem_id].Name : "Penguin",
Fuel = req["api_item1"],
Ammo = req["api_item2"],
Steel = req["api_item3"],
Bauxite = req["api_item4"],
};
Log(logitem);
}
public bool AddReference(string grpCondition, ProjectInfo project)
{
BuildItemGroup grpAdding = FristReferenceGroup(grpCondition);
string file = this.MakeProjectRelativePath(project.FullName);
BuildItem addedItem = grpAdding.AddNewItem("ProjectReference", file);
addedItem.SetMetadata("Project", project.ProjectGuid.ToString().ToUpper());
addedItem.SetMetadata("Name", project.AssemblyName);
_refCache.Add(new ProjectRef(addedItem, GetProjectPath));
return(true);
}
string EvaluateMetadata(BuildItem it, string metadata)
{
var d = it.GetEvaluatedMetadata(metadata);
if (string.IsNullOrEmpty(d))
{
return(null);
}
else
{
return(d);
}
}
public void Clear()
{
XmlElement ig = CreatePersistedItemGroupElement();
BuildItemGroup group = new BuildItemGroup(ig, false, new Project());
BuildItem i1 = group[0];
group.Clear();
Assertion.AssertEquals(0, group.Count);
Assertion.AssertEquals(0, ig.ChildNodes.Count);
Assertion.AssertEquals(null, i1.ParentPersistedItemGroup);
}
public void RegularClone()
{
BuildItem item = GetXmlBackedItemWithDefinitionLibrary();
BuildItem clone = item.Clone();
Assertion.AssertEquals("i", clone.Name);
Assertion.AssertEquals("i1", clone.EvaluatedItemSpec);
Assertion.AssertEquals("i1", clone.FinalItemSpec);
Assertion.AssertEquals("i1", clone.FinalItemSpecEscaped);
// Make sure the itemdefinitionlibrary is cloned, too
Assertion.AssertEquals("m1", clone.GetEvaluatedMetadata("m"));
}
void Tree_DoubleClick(object sender, EventArgs e)
{
System.Windows.Forms.TreeView t = sender as System.Windows.Forms.TreeView;
if (t.SelectedNode != null)
{
BuildItem file = t.SelectedNode.Tag as BuildItem;
if (file != null)
{
ServiceHost.File.BringToFront(current.OpenFile(Path.Combine(current.RootDirectory, file.Include)));
return;
}
}
}
public BuildItem AddGeneratedFileBuildItem(BuildItemGroup buildItemGroup, string sourceFileName, string outputFileName)
{
if (outputFileName == null || outputFileName.Length == 0)
{
outputFileName = GetOutputFileDefaultName(sourceFileName);
}
BuildItem buildItem = buildItemGroup.AddNewItem("None", outputFileName);
buildItem.SetMetadata(ITEMMETADATA_AUTOGEN, "True");
buildItem.SetMetadata(ITEMMETADATA_DEPENDENTUPON, sourceFileName);
buildItem.SetMetadata(ITEMMETADATA_ORMGENERATOR, this.OfficialName);
return(buildItem);
}
protected void AddNewItem(string itemName, string fileName)
{
Project project = GetProject();
if (project == null)
{
return;
}
BuildItem buildItem = project.AddNewItem(itemName, fileName);
project.Save(ProjectFile.FullName);
}
/// <summary>
/// A copy of GetItemParentNode where the path is determined from the Link property
/// rather than the FinalItemSpec.
private HierarchyNode GetItemParentNode(BuildItem item)
{
HierarchyNode currentParent = this;
string strPath = item.GetMetadata("Link");
strPath = Path.GetDirectoryName(strPath);
if (strPath.Length > 0)
{
// Use the relative to verify the folders...
currentParent = this.CreateFolderNodes(strPath);
}
return(currentParent);
}
IEnumerator Build(BuildItem item)
{
float currentMass = 0;
float currentEnergy = 0;
while (currentMass < item.massCost || currentEnergy < item.energyCost)
{
PM.RequestResources(item.massRate * Time.deltaTime, item.energyRate * Time.deltaTime);
yield return null;
}
GameObject unit;
unit = Instantiate(item.item.gameObject);
unit.transform.position = transform.position;
unit.GetComponent<Unit>().TryProcessNextPath();
yield return null;
currentState = UnitState.Stopped;
TryBuildNextItem();
}
/// <summary>
/// Creates an instance of a circular dependency error object.
/// </summary>
/// <param name="item">The affected build item.</param>
/// <param name="scriptsToDependencies">A mapping of build items to their dependencies.</param>
public CircularDependencyError(BuildItem item, IDictionary<BuildItem, List<BuildItem>> scriptsToDependencies)
{
// Traverse circular dependency
bool isCircularPath;
var path = WalkCircularDependency(item, scriptsToDependencies, new HashSet<BuildItem>(), out isCircularPath).ToArray();
if(isCircularPath)
{
StringBuilder sb = new StringBuilder();
for (int index = 0; index < path.Length - 1; index++)
{
sb.Append(path[index].DatabaseObject.ObjectName);
sb.AppendLine(" depends on ");
}
sb.Append(path[path.Length - 1].DatabaseObject.ObjectName);
message = sb.ToString();
}
else
{
message = "Unable to determine the circular dependency path.";
}
}
public void RemoveItem(BuildItem itemToRemove) {}
public void OnModelChange()
{
UIToggle utCur = UIToggle.current;
if(utCur != null && (utCur.value == true)){
if(utCur.name.Contains("tg_create")){
model = EModel.Create;
DataCache dc = utCur.gameObject.GetComponent<DataCache>();
CurBuildItem = dc.data as BuildItem;
}else if(utCur.name.Equals("tg_move")){
model = EModel.Move;
}else if(utCur.name.Equals("tg_rotate")){
model = EModel.Rotate;
}else if(utCur.name.Equals("tg_destroy")){
model = EModel.Destroy;
}
}
}
void InitBuildItemUI()
{
for (int i = 0; i < defaultBuildItemId.Length; i++) {
int id = defaultBuildItemId[i];
BuildItem buildItem = GameResources.GetBuildItemBD(id);
if(buildItem != null){
string iconName = "icon_" + buildItem.resourceName;
GameObject gobjItem = Tools.GetGameObjectInChildByPathSimple(g_GobjBtns, "tg_create_" + i);
UISprite icon = Tools.GetComponentInChildByPath<UISprite>(gobjItem, "icon");
icon.spriteName = iconName;
DataCache dc = gobjItem.AddComponent<DataCache>();
dc.data = buildItem;
UIToggle ut = gobjItem.GetComponent<UIToggle>();
ut.onChange.Add(new EventDelegate(this, "OnModelChange"));
if(ut.startsActive){
CurBuildItem = buildItem;
}
}
}
// 列表初始化
GameObject gobjGridBase = Tools.GetGameObjectInChildByPathSimple(g_GobjBtns, "ui_items/items_base/listview/grid");
UIGrid gridBase = gobjGridBase.GetComponent<UIGrid>();
GameObject gobjGridActive = Tools.GetGameObjectInChildByPathSimple(g_GobjBtns, "ui_items/items_active/listview/grid");
UIGrid gridActive = gobjGridActive.GetComponent<UIGrid>();
foreach (BuildItem item in GameResources.dicItems.Values) {
GameObject gobjparent = null;
if(item.type == EBuildItemType.Base){
gobjparent = gobjGridBase;
}else if(item.type == EBuildItemType.Active){
gobjparent = gobjGridActive;
}
if(gobjparent != null){
GameObject gobjItem = Tools.AddNGUIChild(gobjparent, IPath.UI + "ui_builditem");
UISprite us = Tools.GetComponentInChildByPath<UISprite>(gobjItem, "icon");
us.spriteName = "icon_" + item.resourceName;
UILabel txtName = Tools.GetComponentInChildByPath<UILabel>(gobjItem, "name");
txtName.text = item.name;
DataCache dc = gobjItem.AddComponent<DataCache>();
dc.data = item;
}
}
gridBase.Reposition();
gridActive.Reposition();
}
public void OnBtnPress(GameObject gobjBtn, bool isDown)
{
string btnname = gobjBtn.name;
if("btn_down".Equals(btnname)){
if(isDown){
axisV = -1;
}else{
axisV = 0;
}
}
if("btn_up".Equals(btnname)){
if(isDown){
axisV = 1;
}else{
axisV = 0;
}
}
if("btn_left".Equals(btnname)){
if(isDown){
axisH = -1;
}else{
axisH = 0;
}
}
if("btn_right".Equals(btnname)){
if(isDown){
axisH = 1;
}else{
axisH = 0;
}
}
if(btnname.Contains("ui_builditem")){
DataCache dc = gobjBtn.GetComponent<DataCache>();
BuildItem bi = dc.data as BuildItem;
UIToggle toggleCur = UIToggle.GetActiveToggle(1);
DataCache dcTemp = toggleCur.GetComponent<DataCache>();
if(dcTemp != null){
BuildItem biTemp = dcTemp.data as BuildItem;
CurBuildItem = bi;
dcTemp.data = bi;
UISprite usIcon = Tools.GetComponentInChildByPath<UISprite>(toggleCur.gameObject, "icon");
usIcon.spriteName = "icon_" + bi.resourceName;
}
}
}
private void loadBuildButton_Click(object sender, EventArgs e)
{
// Clear existing
build.Clear();
buildItem = 0;
buildNotes = "";
// Load new
OpenFileDialog d = new OpenFileDialog();
d.Title = "Open Build File";
d.Filter = "Build Files|*.build";
d.InitialDirectory = Application.StartupPath + "\\Builds";
d.CheckFileExists = true;
d.CheckPathExists = true;
d.AddExtension = true;
d.Multiselect = false;
if (d.ShowDialog() != DialogResult.OK)
{
return;
}
// Parse and load file
string line;
int counter = 0;
System.IO.StreamReader r = new System.IO.StreamReader(d.FileName.ToString());
while ((line = r.ReadLine()) != null)
{
if (counter == 0)
{
buildNotes = line;
}
else
{
// Parse comma-separated string
string[] parts = line.Split(',');
if (parts.Length < 3)
continue;
BuildItem tmp = new BuildItem();
tmp.Name = parts[0];
tmp.Category = parts[1];
tmp.Price = Convert.ToInt32(parts[2]);
build.Add(tmp);
}
counter++;
}
r.Close();
buildLoaded = true;
// Display first step
displayBuildItem(0);
}
private static Dictionary<string, BuildVarCanonicalized> GenerateBuildVars(BuildItem root, BuildItem target, string targetName)
{
Dictionary<string, BuildVar> firstPass = new Dictionary<string, BuildVar>();
if (root.Var != null)
{
foreach (BuildVar rootVar in root.Var)
{
if (rootVar.Id == null)
{
throw new InvalidOperationException("Build file contains a <var> without an id attribute.");
}
firstPass.Add(rootVar.Id, rootVar);
}
}
if (target.Var != null)
{
foreach (BuildVar targetVar in target.Var)
{
if (targetVar.Id == null)
{
throw new InvalidOperationException("Build file target contains a <var> without an id attribute.");
}
firstPass[targetVar.Id] = targetVar;
}
}
Dictionary<string, BuildVarCanonicalized> output = new Dictionary<string, BuildVarCanonicalized>();
foreach (BuildVar rawElement in firstPass.Values)
{
string id = rawElement.Id;
string value = rawElement.Value;
int intValue = 0;
double floatValue = 0;
bool boolValue = false;
VarType type = VarType.BOOLEAN;
switch ((rawElement.Type ?? "string").ToLowerInvariant())
{
case "int":
case "integer":
type = VarType.INT;
break;
case "float":
case "double":
type = VarType.FLOAT;
break;
case "bool":
case "boolean":
type = VarType.BOOLEAN;
break;
case "string":
type = VarType.STRING;
break;
default:
throw new InvalidOperationException("Build file variable '" + id + "' contains an unrecognized type: '" + rawElement.Type + "'. Types must be 'string', 'integer', 'boolean', or 'float'.");
}
int score = (rawElement.EnvironmentVarValue != null ? 1 : 0)
+ (rawElement.Value != null ? 1 : 0);
if (score != 1)
{
throw new InvalidOperationException("Build file variable '" + id + "' must contain either a <value> or a <env> content element but not both.");
}
if (value == null)
{
value = System.Environment.GetEnvironmentVariable(rawElement.EnvironmentVarValue);
if (value == null)
{
throw new InvalidOperationException("Build file varaible '" + id + "' references an environment variable that is not set: '" + rawElement.EnvironmentVarValue + "'");
}
value = DoReplacement(targetName, value.Trim());
}
switch (type)
{
case VarType.INT:
if (!int.TryParse(value, out intValue))
{
throw new InvalidOperationException("Build file variable: '" + id + "' contains an invalid integer value.");
}
break;
case VarType.FLOAT:
if (!double.TryParse(value, out floatValue))
{
throw new InvalidOperationException("Build file variable: '" + id + "' contains an invalid float value.");
}
break;
case VarType.BOOLEAN:
switch (value.ToLowerInvariant())
{
case "0":
case "no":
case "false":
case "f":
case "n":
boolValue = false;
break;
case "1":
case "true":
case "t":
case "yes":
case "y":
boolValue = true;
break;
default:
throw new InvalidOperationException("Build file variable: '" + id + "' contains an invalid boolean valud.");
}
break;
case VarType.STRING:
break;
default:
break;
}
output[id] = new BuildVarCanonicalized()
{
ID = id,
Type = type,
StringValue = value,
IntValue = intValue,
FloatValue = floatValue,
BoolValue = boolValue
};
}
return output;
}
public static void AddBuildItemBD(BuildItem item)
{
if(!dicItems.ContainsKey(item.id)){
dicItems.Add(item.id, item);
}
}
public void CopyCustomMetadataTo(BuildItem destinationItem) {}
public void GenerateOutput(BuildItem buildItem, Stream outputStream, IDictionary<string, Stream> inputFormatStreams, string defaultNamespace)
{
outputStream = new UncloseableStream(outputStream);
Stream undeadOial = inputFormatStreams["UndeadOIAL"];
Stream liveOial = inputFormatStreams["LiveOIAL"];
XmlDiff xmlDiff = new XmlDiff(XmlDiffOptions.IgnoreComments | XmlDiffOptions.IgnoreXmlDecl | XmlDiffOptions.IgnorePrefixes);
xmlDiff.Algorithm = XmlDiffAlgorithm.Precise;
bool identical = false;
MemoryStream diffgram = new MemoryStream(8192);
using (XmlWriter diffgramWriter = XmlWriter.Create(diffgram))
{
try
{
using (XmlReader undeadReader = XmlReader.Create(undeadOial, XmlReaderSettings), liveReader = XmlReader.Create(liveOial, XmlReaderSettings))
{
identical = xmlDiff.Compare(undeadReader, liveReader, diffgramWriter);
}
}
finally
{
undeadOial.Seek(0, SeekOrigin.Begin);
liveOial.Seek(0, SeekOrigin.Begin);
}
}
// Files have been compared, and the diff has been written to the diffgramwriter.
TextWriter resultHtml = new StreamWriter(outputStream);
resultHtml.WriteLine("<html><head>");
resultHtml.WriteLine("<style TYPE='text/css' MEDIA='screen'>");
resultHtml.Write("<!-- td { font-family: Courier New; font-size:14; } " +
"th { font-family: Arial; } " +
"p { font-family: Arial; } -->");
resultHtml.WriteLine("</style></head>");
resultHtml.WriteLine("<body><h3 style='font-family:Arial'>XmlDiff view</h3><table border='0'><tr><td><table border='0'>");
resultHtml.WriteLine("<tr><th>Undead OIAL</th><th>Live OIAL</th></tr>" +
"<tr><td colspan=2><hr size=1></td></tr>");
if (identical)
{
resultHtml.WriteLine("<tr><td colspan='2' align='middle'>Files are identical.</td></tr>");
}
else
{
resultHtml.WriteLine("<tr><td colspan='2' align='middle'>Files are different.</td></tr>");
}
diffgram.Seek(0, SeekOrigin.Begin);
XmlDiffView xmlDiffView = new XmlDiffView();
XmlTextReader sourceReader = new XmlTextReader(undeadOial);
sourceReader.XmlResolver = null;
xmlDiffView.Load(sourceReader, new XmlTextReader(diffgram));
xmlDiffView.GetHtml(resultHtml);
resultHtml.WriteLine("</table></table></body></html>");
resultHtml.Flush();
resultHtml.Close();
}
