Mercurial > repos > IBDev-IBBoard.WarFoundry.API
comparison API/Exporters/WarFoundryHtmlExporter.cs @ 481:81f32062c9fa
Re #419: Remove assumptions of a file-based install
* Convert schemas to resources and load them from there
* Remove use of "data" folder relative to exe location from default "Hacks" (GTK/WinForms GUIs can re-add it locally)
author | IBBoard <dev@ibboard.co.uk> |
---|---|
date | Mon, 25 Jun 2012 21:04:02 +0100 |
parents | 6da9db4a9c23 |
children | 55b39514cbf8 |
comparison
equal
deleted
inserted
replaced
480:e0641e0eb86c | 481:81f32062c9fa |
---|---|
10 using System.Xml.Schema; | 10 using System.Xml.Schema; |
11 using IBBoard.Lang; | 11 using IBBoard.Lang; |
12 using IBBoard.Xml; | 12 using IBBoard.Xml; |
13 using IBBoard.WarFoundry.API.Objects; | 13 using IBBoard.WarFoundry.API.Objects; |
14 using IBBoard.WarFoundry.API.Util; | 14 using IBBoard.WarFoundry.API.Util; |
15 using System.Reflection; | |
15 | 16 |
16 namespace IBBoard.WarFoundry.API.Exporters | 17 namespace IBBoard.WarFoundry.API.Exporters |
17 { | 18 { |
18 /// <summary> | 19 /// <summary> |
19 /// Custom exporter that exports an army as a basic HTML file | 20 /// Custom exporter that exports an army as a basic HTML file |
20 /// </summary> | 21 /// </summary> |
21 public class WarFoundryHtmlExporter : IWarFoundryExporter | 22 public class WarFoundryHtmlExporter : IWarFoundryExporter |
22 { | |
23 private static WarFoundryHtmlExporter exporter; | |
24 private delegate string GetStatCellTextDelegate(Stat stat); | |
25 | |
26 public static WarFoundryHtmlExporter GetDefault() | |
27 { | 23 { |
28 if (exporter == null) | 24 private static WarFoundryHtmlExporter exporter; |
29 { | 25 private delegate string GetStatCellTextDelegate(Stat stat); |
30 exporter = new WarFoundryHtmlExporter(); | 26 |
31 } | 27 public static WarFoundryHtmlExporter GetDefault() |
32 | 28 { |
33 return exporter; | 29 if (exporter == null) |
30 { | |
31 exporter = new WarFoundryHtmlExporter(); | |
32 } | |
33 | |
34 return exporter; | |
35 } | |
36 | |
37 private WarFoundryHtmlExporter() | |
38 { | |
39 //Hide constructor | |
40 } | |
41 | |
42 public void ExportArmy(Army army, string path) | |
43 { | |
44 XmlDocument doc = new XmlDocument(); | |
45 XmlResourceResolver resolver = new XmlResourceResolver(Assembly.GetExecutingAssembly()); | |
46 resolver.AddMapping("-//W3C//ENTITIES Latin 1 for XHTML//EN", "IBBoard.API.schemas.xhtml1-lat1.ent"); | |
47 resolver.AddMapping("http://www.w3.org/TR/xhtml1/DTD/xhtml-lat1.ent", "IBBoard.API.schemas.xhtml1-lat1.ent"); | |
48 resolver.AddMapping("-//W3C//ENTITIES Symbols for XHTML//EN", "IBBoard.API.schemas.xhtml1-symbol.ent"); | |
49 resolver.AddMapping("http://www.w3.org/TR/xhtml1/DTD/xhtml-symbol.ent", "IBBoard.API.schemas.xhtml1-symbol.ent"); | |
50 resolver.AddMapping("-//W3C//ENTITIES Special for XHTML//EN", "IBBoard.API.schemas.xhtml1-special.ent"); | |
51 resolver.AddMapping("http://www.w3.org/TR/xhtml1/DTD/xhtml-special.ent", "IBBoard.API.schemas.xhtml1-special.ent"); | |
52 resolver.AddMapping("-//W3C//DTD XHTML 1.0 Strict//EN", "IBBoard.WarFoundry.schemas.xhtml1-strict.dtd"); | |
53 resolver.AddMapping("http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", "IBBoard.WarFoundry.schemas.xhtml1-strict.dtd"); | |
54 doc.XmlResolver = resolver; | |
55 doc.AppendChild(doc.CreateDocumentType("html", "-//W3C//DTD XHTML 1.0 Strict//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", null)); | |
56 XmlElement html = doc.CreateElement("html"); | |
57 doc.AppendChild(html); | |
58 XmlElement head = doc.CreateElement("head"); | |
59 html.AppendChild(head); | |
60 XmlElement title = doc.CreateElement("title"); | |
61 title.InnerXml = army.Name; | |
62 head.AppendChild(title); | |
63 XmlElement metaCharset = doc.CreateElement("meta"); | |
64 metaCharset.SetAttribute("http-equiv", "Content-Type"); | |
65 metaCharset.SetAttribute("content", "text/html;charset=UTF-8"); | |
66 head.AppendChild(metaCharset); | |
67 XmlElement style = doc.CreateElement("style"); | |
68 style.InnerText = "table, th, td { border: 1px solid #000; border-spacing: 0; border-collapse: collapse; margin: 0 }\n" | |
69 + "table table { width: 100%; border-width: 0; margin: -2px }\n" | |
70 + "table table td { border-width:0 1px }"; | |
71 head.AppendChild(style); | |
72 XmlElement body = doc.CreateElement("body"); | |
73 html.AppendChild(body); | |
74 XmlElement header = doc.CreateElement("h1"); | |
75 header.InnerText = Translation.GetTranslation("armyHtmlOutputBodyHeader", "{0} - {1}pts", army.Name, army.Points); | |
76 body.AppendChild(header); | |
77 | |
78 foreach (XmlElement table in CreateTables(army, doc)) | |
79 { | |
80 if (!IsTableOnlyHeader(table)) | |
81 { | |
82 body.AppendChild(table); | |
83 } | |
84 } | |
85 | |
86 File.WriteAllText(path, doc.OuterXml); | |
87 } | |
88 | |
89 private bool IsTableOnlyHeader(XmlElement table) | |
90 { | |
91 return table.ChildNodes.Count == 1; | |
92 } | |
93 | |
94 private XmlElement[] CreateTables(Army army, XmlDocument doc) | |
95 { | |
96 Dictionary<string, XmlElement> tables = new Dictionary<string, XmlElement>(); | |
97 | |
98 foreach (SystemStats statSets in army.GameSystem.SystemStats) | |
99 { | |
100 tables[statSets.ID] = CreateTable(statSets, doc); | |
101 } | |
102 | |
103 foreach (Unit unit in army.GetUnits()) | |
104 { | |
105 CreateUnitRow(unit, tables[GetFirstStatType(unit)]); | |
106 } | |
107 | |
108 return DictionaryUtils.ToArray(tables); | |
109 } | |
110 | |
111 private static string GetFirstStatType(Unit unit) | |
112 { | |
113 string[] unitStatIDs = unit.UnitStatsArrayIDs; | |
114 return GetFirstStatType(unitStatIDs); | |
115 } | |
116 | |
117 public static string GetFirstStatType(string[] unitStatIDs) | |
118 { | |
119 return unitStatIDs[0]; | |
120 } | |
121 | |
122 private XmlElement CreateTable(SystemStats stats, XmlDocument doc) | |
123 { | |
124 XmlElement table = doc.CreateElement("table"); | |
125 XmlElement headerRow = doc.CreateElement("tr"); | |
126 table.AppendChild(headerRow); | |
127 XmlElement name = doc.CreateElement("th"); | |
128 name.InnerText = Translation.GetTranslation("armyHtmlOutputTableHeaderUnitName", "name"); | |
129 headerRow.AppendChild(name); | |
130 | |
131 XmlElement unitTypeName = doc.CreateElement("th"); | |
132 unitTypeName.InnerText = Translation.GetTranslation("armyHtmlOutputTableHeaderUnitTypeName", "type name"); | |
133 headerRow.AppendChild(unitTypeName); | |
134 | |
135 foreach (StatSlot stat in stats.StatSlots) | |
136 { | |
137 XmlElement statHeader = doc.CreateElement("th"); | |
138 statHeader.InnerText = stat.Name; | |
139 headerRow.AppendChild(statHeader); | |
140 } | |
141 | |
142 XmlElement notes = doc.CreateElement("th"); | |
143 notes.InnerText = Translation.GetTranslation("armyHtmlOutputTableHeaderUnitNotes", "name"); | |
144 ; | |
145 headerRow.AppendChild(notes); | |
146 | |
147 XmlElement points = doc.CreateElement("th"); | |
148 points.InnerText = Translation.GetTranslation("armyHtmlOutputTableHeaderUnitPoints", "name"); | |
149 ; | |
150 headerRow.AppendChild(points); | |
151 | |
152 return table; | |
153 } | |
154 | |
155 private XmlElement CreateUnitRow(Unit unit, XmlElement tableElem) | |
156 { | |
157 XmlDocument doc = tableElem.OwnerDocument; | |
158 XmlElement row = doc.CreateElement("tr"); | |
159 tableElem.AppendChild(row); | |
160 Stat[][] memberStats = unit.UnitStatsArraysWithName; | |
161 string[] statTypeIDs = unit.UnitStatsArrayIDs; | |
162 string defaultStatType = GetFirstStatType(statTypeIDs); | |
163 int statRowCount = 0; | |
164 bool hasOther = false; | |
165 | |
166 foreach (string statTypeID in statTypeIDs) | |
167 { | |
168 if (statTypeID.Equals(defaultStatType)) | |
169 { | |
170 statRowCount++; | |
171 } else if (!hasOther) | |
172 { | |
173 statRowCount++; | |
174 hasOther = true; | |
175 } | |
176 } | |
177 | |
178 XmlElement name = doc.CreateElement("td"); | |
179 name.InnerText = unit.Name; | |
180 SetRowSpan(name, statRowCount); | |
181 row.AppendChild(name); | |
182 CreateStatsBlock(row, memberStats, statTypeIDs); | |
183 | |
184 StringBuilder sb = new StringBuilder(); | |
185 UnitEquipmentItem[] unitEquipment = unit.GetEquipment(); | |
186 | |
187 if (unitEquipment.Length > 0) | |
188 { | |
189 bool addSeparator = false; | |
190 | |
191 foreach (UnitEquipmentItem equip in unitEquipment) | |
192 { | |
193 if (!addSeparator) | |
194 { | |
195 addSeparator = true; | |
196 } else | |
197 { | |
198 sb.Append(", "); | |
199 } | |
200 | |
201 string amountString; | |
202 double amount = UnitEquipmentUtil.GetEquipmentAmount(unit, equip); | |
203 | |
204 if (UnitEquipmentUtil.GetEquipmentAmountIsRatio(unit, equip)) | |
205 { | |
206 | |
207 if (amount == 100) | |
208 { | |
209 amountString = GetEquipmentAmountAllTranslation(unit); | |
210 } else | |
211 { | |
212 int number = UnitEquipmentUtil.GetEquipmentAmountTaken(unit, equip); | |
213 amountString = GetEquipmentAmountRatioTranslation(amount, number); | |
214 } | |
215 } else | |
216 { | |
217 if (amount == -1) | |
218 { | |
219 amountString = GetEquipmentAmountAllTranslation(unit); | |
220 } else | |
221 { | |
222 amountString = GetEquipmentAmountNumberTranslation((int)amount); | |
223 } | |
224 } | |
225 | |
226 sb.Append(Translation.GetTranslation("armyHtmlExportEquipAmountRatio", "{0} for {1}", equip.Name, amountString)); | |
227 } | |
228 | |
229 sb.Append(". "); | |
230 } | |
231 | |
232 ICollection<Ability> abilities = unit.Abilities; | |
233 | |
234 if (abilities.Count > 0) | |
235 { | |
236 bool addSeparator = false; | |
237 | |
238 foreach (Ability ability in abilities) | |
239 { | |
240 if (!addSeparator) | |
241 { | |
242 addSeparator = true; | |
243 } else | |
244 { | |
245 sb.Append(", "); | |
246 } | |
247 | |
248 sb.Append(ability.Name); | |
249 } | |
250 | |
251 sb.Append(". "); | |
252 } | |
253 | |
254 XmlElement notes = doc.CreateElement("td"); | |
255 notes.InnerText = sb.ToString(); | |
256 SetRowSpan(notes, statRowCount); | |
257 row.AppendChild(notes); | |
258 | |
259 XmlElement points = doc.CreateElement("td"); | |
260 points.InnerText = unit.Points.ToString(); | |
261 SetRowSpan(points, statRowCount); | |
262 row.AppendChild(points); | |
263 | |
264 return row; | |
265 } | |
266 | |
267 private static void SetRowSpan(XmlElement xmlElement, int statRowCount) | |
268 { | |
269 if (statRowCount > 1) | |
270 { | |
271 xmlElement.SetAttribute("rowspan", statRowCount.ToString()); | |
272 } | |
273 } | |
274 | |
275 private void CreateStatsBlock(XmlElement unitRow, Stat[][] memberStats, string[] statTypeIDs) | |
276 { | |
277 XmlDocument doc = unitRow.OwnerDocument; | |
278 string defaultStatType = GetFirstStatType(statTypeIDs); | |
279 | |
280 Stat[] defaultStatLine = memberStats[0]; | |
281 int defaultStatLineCount = defaultStatLine.Length; | |
282 AddStatCell(defaultStatLine[0].SlotValueString, unitRow); | |
283 | |
284 for (int i = 1; i < defaultStatLineCount; i++) | |
285 { | |
286 string statText = GetDefaultStatCellText(defaultStatLine[i]); | |
287 AddStatCell(statText, unitRow); | |
288 } | |
289 | |
290 int statCount = statTypeIDs.Length; | |
291 | |
292 if (statCount > 1) | |
293 { | |
294 XmlElement unitTable = (XmlElement)unitRow.ParentNode; | |
295 Dictionary<string, XmlElement> statParents = CreateStatsParentElements(statTypeIDs, unitTable); | |
296 | |
297 for (int i = 1; i < statCount; i++) | |
298 { | |
299 Stat[] statLine = memberStats[i]; | |
300 string statTypeID = statTypeIDs[i]; | |
301 XmlElement tableElement = DictionaryUtils.GetValue(statParents, statTypeID); | |
302 int statLineCount = statLine.Length; | |
303 XmlElement statRow = doc.CreateElement("tr"); | |
304 tableElement.AppendChild(statRow); | |
305 GetStatCellTextDelegate statCellTextDelegate = (statTypeID.Equals(defaultStatType) ? new GetStatCellTextDelegate(GetDefaultStatCellText) : new GetStatCellTextDelegate(GetOtherStatCellText)); | |
306 AddStatCell(statLine[0].SlotValueString, statRow); | |
307 | |
308 for (int j = 1; j < statLineCount; j++) | |
309 { | |
310 string statText = statCellTextDelegate(statLine[j]); | |
311 AddStatCell(statText, statRow); | |
312 } | |
313 } | |
314 | |
315 if (statParents.Count > 1) | |
316 { | |
317 AddOtherUnitStatTables(statParents, unitTable, defaultStatLineCount); | |
318 } | |
319 } | |
320 } | |
321 | |
322 private static void AddOtherUnitStatTables(Dictionary<string, XmlElement> statParents, XmlElement unitTable, int defaultStatLineCount) | |
323 { | |
324 XmlDocument doc = unitTable.OwnerDocument; | |
325 XmlElement otherStatsRow = doc.CreateElement("tr"); | |
326 unitTable.AppendChild(otherStatsRow); | |
327 XmlElement otherStatsCell = doc.CreateElement("td"); | |
328 otherStatsCell.SetAttribute("colspan", defaultStatLineCount.ToString()); | |
329 otherStatsRow.AppendChild(otherStatsCell); | |
330 | |
331 foreach (XmlElement tableElem in statParents.Values) | |
332 { | |
333 if (tableElem != unitTable) | |
334 { | |
335 otherStatsCell.AppendChild(tableElem); | |
336 } | |
337 } | |
338 } | |
339 | |
340 private Dictionary<string, XmlElement> CreateStatsParentElements(string[] statTypeIDs, XmlElement parentTable) | |
341 { | |
342 Dictionary<string, XmlElement> statParents = new Dictionary<string, XmlElement>(); | |
343 XmlDocument doc = parentTable.OwnerDocument; | |
344 string defaultStatTypeID = GetFirstStatType(statTypeIDs); | |
345 statParents[defaultStatTypeID] = parentTable; | |
346 | |
347 foreach (string statTypeID in statTypeIDs) | |
348 { | |
349 if (!statParents.ContainsKey(statTypeID)) | |
350 { | |
351 XmlElement tableElement = doc.CreateElement("table"); | |
352 statParents[statTypeID] = tableElement; | |
353 } | |
354 } | |
355 | |
356 return statParents; | |
357 } | |
358 | |
359 private string GetDefaultStatCellText(Stat stat) | |
360 { | |
361 return Translation.GetTranslation("armyHtmlExportDefaultStatCellText", "{0}", stat.SlotValueString, stat.ParentSlotName); | |
362 } | |
363 | |
364 private string GetOtherStatCellText(Stat stat) | |
365 { | |
366 return Translation.GetTranslation("armyHtmlExportOtherStatCellText", "{1}: {0}", stat.SlotValueString, stat.ParentSlotName); | |
367 } | |
368 | |
369 private static void AddStatCell(string statValue, XmlElement row) | |
370 { | |
371 XmlElement statCell = row.OwnerDocument.CreateElement("td"); | |
372 statCell.InnerText = statValue; | |
373 row.AppendChild(statCell); | |
374 } | |
375 | |
376 private string GetEquipmentAmountRatioTranslation(double amount, int number) | |
377 { | |
378 return Translation.GetTranslation("armyHtmlExportEquipAmountPercentage", "{0}% ({1})", amount, number); | |
379 } | |
380 | |
381 private string GetEquipmentAmountNumberTranslation(int amount) | |
382 { | |
383 return Translation.GetTranslation("armyHtmlExportEquipAmountNumber", "{0}", amount); | |
384 } | |
385 | |
386 private string GetEquipmentAmountAllTranslation(Unit unit) | |
387 { | |
388 return Translation.GetTranslation("armyHtmlExportEquipAmountAll", "all ({1})", 100, unit.Size); | |
389 } | |
34 } | 390 } |
35 | |
36 private WarFoundryHtmlExporter() | |
37 { | |
38 //Hide constructor | |
39 } | |
40 | |
41 public void ExportArmy(Army army, string path) | |
42 { | |
43 XmlDocument doc = new XmlDocument(); | |
44 CustomXmlResolver resolver = new CustomXmlResolver(); | |
45 Uri localUri = new Uri("file://" + IBBoard.Constants.ExecutablePath + "/schemas/xhtml1-strict.dtd"); | |
46 resolver.AddMapping("-//W3C//DTD XHTML 1.0 Strict//EN", localUri); | |
47 resolver.AddMapping("http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", localUri); | |
48 doc.XmlResolver = resolver; | |
49 doc.AppendChild(doc.CreateDocumentType("html", "-//W3C//DTD XHTML 1.0 Strict//EN", "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd", null)); | |
50 XmlElement html = doc.CreateElement("html"); | |
51 doc.AppendChild(html); | |
52 XmlElement head = doc.CreateElement("head"); | |
53 html.AppendChild(head); | |
54 XmlElement title = doc.CreateElement("title"); | |
55 title.InnerXml = army.Name; | |
56 head.AppendChild(title); | |
57 XmlElement metaCharset = doc.CreateElement("meta"); | |
58 metaCharset.SetAttribute("http-equiv", "Content-Type"); | |
59 metaCharset.SetAttribute("content", "text/html;charset=UTF-8"); | |
60 head.AppendChild(metaCharset); | |
61 XmlElement style = doc.CreateElement("style"); | |
62 style.InnerText = "table, th, td { border: 1px solid #000; border-spacing: 0; border-collapse: collapse; margin: 0 }\n" | |
63 +"table table { width: 100%; border-width: 0; margin: -2px }\n" | |
64 +"table table td { border-width:0 1px }"; | |
65 head.AppendChild(style); | |
66 XmlElement body = doc.CreateElement("body"); | |
67 html.AppendChild(body); | |
68 XmlElement header = doc.CreateElement("h1"); | |
69 header.InnerText = Translation.GetTranslation("armyHtmlOutputBodyHeader", "{0} - {1}pts", army.Name, army.Points); | |
70 body.AppendChild(header); | |
71 | |
72 foreach (XmlElement table in CreateTables(army, doc)) | |
73 { | |
74 if (!IsTableOnlyHeader(table)) | |
75 { | |
76 body.AppendChild(table); | |
77 } | |
78 } | |
79 | |
80 File.WriteAllText(path, doc.OuterXml); | |
81 } | |
82 | |
83 private bool IsTableOnlyHeader(XmlElement table) | |
84 { | |
85 return table.ChildNodes.Count == 1; | |
86 } | |
87 | |
88 private XmlElement[] CreateTables(Army army, XmlDocument doc) | |
89 { | |
90 Dictionary<string, XmlElement> tables = new Dictionary<string, XmlElement>(); | |
91 | |
92 foreach (SystemStats statSets in army.GameSystem.SystemStats) | |
93 { | |
94 tables[statSets.ID] = CreateTable(statSets, doc); | |
95 } | |
96 | |
97 foreach (Unit unit in army.GetUnits()) | |
98 { | |
99 CreateUnitRow(unit, tables[GetFirstStatType(unit)]); | |
100 } | |
101 | |
102 return DictionaryUtils.ToArray(tables); | |
103 } | |
104 | |
105 private static string GetFirstStatType(Unit unit) | |
106 { | |
107 string[] unitStatIDs = unit.UnitStatsArrayIDs; | |
108 return GetFirstStatType(unitStatIDs); | |
109 } | |
110 | |
111 public static string GetFirstStatType(string[] unitStatIDs) | |
112 { | |
113 return unitStatIDs[0]; | |
114 } | |
115 | |
116 private XmlElement CreateTable(SystemStats stats, XmlDocument doc) | |
117 { | |
118 XmlElement table = doc.CreateElement("table"); | |
119 XmlElement headerRow = doc.CreateElement("tr"); | |
120 table.AppendChild(headerRow); | |
121 XmlElement name = doc.CreateElement("th"); | |
122 name.InnerText = Translation.GetTranslation("armyHtmlOutputTableHeaderUnitName", "name"); | |
123 headerRow.AppendChild(name); | |
124 | |
125 XmlElement unitTypeName = doc.CreateElement("th"); | |
126 unitTypeName.InnerText = Translation.GetTranslation("armyHtmlOutputTableHeaderUnitTypeName", "type name"); | |
127 headerRow.AppendChild(unitTypeName); | |
128 | |
129 foreach (StatSlot stat in stats.StatSlots) | |
130 { | |
131 XmlElement statHeader = doc.CreateElement("th"); | |
132 statHeader.InnerText = stat.Name; | |
133 headerRow.AppendChild(statHeader); | |
134 } | |
135 | |
136 XmlElement notes = doc.CreateElement("th"); | |
137 notes.InnerText = Translation.GetTranslation("armyHtmlOutputTableHeaderUnitNotes", "name");; | |
138 headerRow.AppendChild(notes); | |
139 | |
140 XmlElement points = doc.CreateElement("th"); | |
141 points.InnerText = Translation.GetTranslation("armyHtmlOutputTableHeaderUnitPoints", "name");; | |
142 headerRow.AppendChild(points); | |
143 | |
144 return table; | |
145 } | |
146 | |
147 private XmlElement CreateUnitRow(Unit unit, XmlElement tableElem) | |
148 { | |
149 XmlDocument doc = tableElem.OwnerDocument; | |
150 XmlElement row = doc.CreateElement("tr"); | |
151 tableElem.AppendChild(row); | |
152 Stat[][] memberStats = unit.UnitStatsArraysWithName; | |
153 string[] statTypeIDs = unit.UnitStatsArrayIDs; | |
154 string defaultStatType = GetFirstStatType(statTypeIDs); | |
155 int statRowCount = 0; | |
156 bool hasOther = false; | |
157 | |
158 foreach (string statTypeID in statTypeIDs) | |
159 { | |
160 if (statTypeID.Equals(defaultStatType)) | |
161 { | |
162 statRowCount++; | |
163 } | |
164 else if (!hasOther) | |
165 { | |
166 statRowCount++; | |
167 hasOther = true; | |
168 } | |
169 } | |
170 | |
171 XmlElement name = doc.CreateElement("td"); | |
172 name.InnerText = unit.Name; | |
173 SetRowSpan(name, statRowCount); | |
174 row.AppendChild(name); | |
175 CreateStatsBlock(row, memberStats, statTypeIDs); | |
176 | |
177 StringBuilder sb = new StringBuilder(); | |
178 UnitEquipmentItem[] unitEquipment = unit.GetEquipment(); | |
179 | |
180 if (unitEquipment.Length > 0) | |
181 { | |
182 bool addSeparator = false; | |
183 | |
184 foreach (UnitEquipmentItem equip in unitEquipment) | |
185 { | |
186 if (!addSeparator) | |
187 { | |
188 addSeparator = true; | |
189 } | |
190 else | |
191 { | |
192 sb.Append(", "); | |
193 } | |
194 | |
195 string amountString; | |
196 double amount = UnitEquipmentUtil.GetEquipmentAmount(unit, equip); | |
197 | |
198 if (UnitEquipmentUtil.GetEquipmentAmountIsRatio(unit, equip)) | |
199 { | |
200 | |
201 if (amount == 100) | |
202 { | |
203 amountString = GetEquipmentAmountAllTranslation(unit); | |
204 } | |
205 else | |
206 { | |
207 int number = UnitEquipmentUtil.GetEquipmentAmountTaken(unit, equip); | |
208 amountString = GetEquipmentAmountRatioTranslation(amount, number); | |
209 } | |
210 } | |
211 else | |
212 { | |
213 if (amount == -1) | |
214 { | |
215 amountString = GetEquipmentAmountAllTranslation(unit); | |
216 } | |
217 else | |
218 { | |
219 amountString = GetEquipmentAmountNumberTranslation((int)amount); | |
220 } | |
221 } | |
222 | |
223 sb.Append(Translation.GetTranslation("armyHtmlExportEquipAmountRatio", "{0} for {1}", equip.Name, amountString)); | |
224 } | |
225 | |
226 sb.Append(". "); | |
227 } | |
228 | |
229 ICollection<Ability> abilities = unit.Abilities; | |
230 | |
231 if (abilities.Count > 0) | |
232 { | |
233 bool addSeparator = false; | |
234 | |
235 foreach (Ability ability in abilities) | |
236 { | |
237 if (!addSeparator) | |
238 { | |
239 addSeparator = true; | |
240 } | |
241 else | |
242 { | |
243 sb.Append(", "); | |
244 } | |
245 | |
246 sb.Append(ability.Name); | |
247 } | |
248 | |
249 sb.Append(". "); | |
250 } | |
251 | |
252 XmlElement notes = doc.CreateElement("td"); | |
253 notes.InnerText = sb.ToString(); | |
254 SetRowSpan(notes, statRowCount); | |
255 row.AppendChild(notes); | |
256 | |
257 XmlElement points = doc.CreateElement("td"); | |
258 points.InnerText = unit.Points.ToString(); | |
259 SetRowSpan(points, statRowCount); | |
260 row.AppendChild(points); | |
261 | |
262 return row; | |
263 } | |
264 | |
265 private static void SetRowSpan(XmlElement xmlElement, int statRowCount) | |
266 { | |
267 if (statRowCount > 1) | |
268 { | |
269 xmlElement.SetAttribute("rowspan", statRowCount.ToString()); | |
270 } | |
271 } | |
272 | |
273 private void CreateStatsBlock(XmlElement unitRow, Stat[][] memberStats, string[] statTypeIDs) | |
274 { | |
275 XmlDocument doc = unitRow.OwnerDocument; | |
276 string defaultStatType = GetFirstStatType(statTypeIDs); | |
277 | |
278 Stat[] defaultStatLine = memberStats[0]; | |
279 int defaultStatLineCount = defaultStatLine.Length; | |
280 AddStatCell(defaultStatLine[0].SlotValueString, unitRow); | |
281 | |
282 for (int i = 1; i < defaultStatLineCount; i++) | |
283 { | |
284 string statText = GetDefaultStatCellText(defaultStatLine[i]); | |
285 AddStatCell(statText, unitRow); | |
286 } | |
287 | |
288 int statCount = statTypeIDs.Length; | |
289 | |
290 if (statCount > 1) | |
291 { | |
292 XmlElement unitTable = (XmlElement)unitRow.ParentNode; | |
293 Dictionary<string, XmlElement> statParents = CreateStatsParentElements(statTypeIDs, unitTable); | |
294 | |
295 for (int i = 1; i < statCount; i++) | |
296 { | |
297 Stat[] statLine = memberStats[i]; | |
298 string statTypeID = statTypeIDs[i]; | |
299 XmlElement tableElement = DictionaryUtils.GetValue(statParents, statTypeID); | |
300 int statLineCount = statLine.Length; | |
301 XmlElement statRow = doc.CreateElement("tr"); | |
302 tableElement.AppendChild(statRow); | |
303 GetStatCellTextDelegate statCellTextDelegate = (statTypeID.Equals(defaultStatType) ? new GetStatCellTextDelegate(GetDefaultStatCellText) : new GetStatCellTextDelegate(GetOtherStatCellText)); | |
304 AddStatCell(statLine[0].SlotValueString, statRow); | |
305 | |
306 for (int j = 1; j < statLineCount; j++) | |
307 { | |
308 string statText = statCellTextDelegate(statLine[j]); | |
309 AddStatCell(statText, statRow); | |
310 } | |
311 } | |
312 | |
313 if (statParents.Count > 1) | |
314 { | |
315 AddOtherUnitStatTables(statParents, unitTable, defaultStatLineCount); | |
316 } | |
317 } | |
318 } | |
319 | |
320 private static void AddOtherUnitStatTables(Dictionary<string, XmlElement> statParents, XmlElement unitTable, int defaultStatLineCount) | |
321 { | |
322 XmlDocument doc = unitTable.OwnerDocument; | |
323 XmlElement otherStatsRow = doc.CreateElement("tr"); | |
324 unitTable.AppendChild(otherStatsRow); | |
325 XmlElement otherStatsCell = doc.CreateElement("td"); | |
326 otherStatsCell.SetAttribute("colspan", defaultStatLineCount.ToString()); | |
327 otherStatsRow.AppendChild(otherStatsCell); | |
328 | |
329 foreach (XmlElement tableElem in statParents.Values) | |
330 { | |
331 if (tableElem != unitTable) | |
332 { | |
333 otherStatsCell.AppendChild(tableElem); | |
334 } | |
335 } | |
336 } | |
337 | |
338 private Dictionary<string, XmlElement> CreateStatsParentElements(string[] statTypeIDs, XmlElement parentTable) | |
339 { | |
340 Dictionary<string, XmlElement> statParents = new Dictionary<string, XmlElement>(); | |
341 XmlDocument doc = parentTable.OwnerDocument; | |
342 string defaultStatTypeID = GetFirstStatType(statTypeIDs); | |
343 statParents[defaultStatTypeID] = parentTable; | |
344 | |
345 foreach (string statTypeID in statTypeIDs) | |
346 { | |
347 if (!statParents.ContainsKey(statTypeID)) | |
348 { | |
349 XmlElement tableElement = doc.CreateElement("table"); | |
350 statParents[statTypeID] = tableElement; | |
351 } | |
352 } | |
353 | |
354 return statParents; | |
355 } | |
356 | |
357 private string GetDefaultStatCellText(Stat stat) | |
358 { | |
359 return Translation.GetTranslation("armyHtmlExportDefaultStatCellText", "{0}", stat.SlotValueString, stat.ParentSlotName); | |
360 } | |
361 | |
362 private string GetOtherStatCellText(Stat stat) | |
363 { | |
364 return Translation.GetTranslation("armyHtmlExportOtherStatCellText", "{1}: {0}", stat.SlotValueString, stat.ParentSlotName); | |
365 } | |
366 | |
367 private static void AddStatCell(string statValue, XmlElement row) | |
368 { | |
369 XmlElement statCell = row.OwnerDocument.CreateElement("td"); | |
370 statCell.InnerText = statValue; | |
371 row.AppendChild(statCell); | |
372 } | |
373 | |
374 private string GetEquipmentAmountRatioTranslation (double amount, int number) | |
375 { | |
376 return Translation.GetTranslation ("armyHtmlExportEquipAmountPercentage", "{0}% ({1})", amount, number); | |
377 } | |
378 | |
379 private string GetEquipmentAmountNumberTranslation(int amount) | |
380 { | |
381 return Translation.GetTranslation("armyHtmlExportEquipAmountNumber", "{0}", amount); | |
382 } | |
383 | |
384 private string GetEquipmentAmountAllTranslation(Unit unit) | |
385 { | |
386 return Translation.GetTranslation("armyHtmlExportEquipAmountAll", "all ({1})", 100, unit.Size); | |
387 } | |
388 } | |
389 } | 391 } |