GridTerminalDingsbums.GetSonstnochwas...

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • GridTerminalDingsbums.GetSonstnochwas...

      ... oder wie erstelle ich mir eine Script-Textwüste? ^^

      Tatsächlich eine geschlagene Woche für dieses Script investiert und endlich habe ich fertig.


      Solche Power-Status-Anzeige-Scripts gibt es bereits zu genüge,
      mir war es aber ein Bedürfnis, mich selbst auch mal daran zu versuchen.
      An einigen Stellen habe ich die nötigen Info's natürlich aus dem Netz geholt,
      aber einfach nur abkupfern wollte ich auch wieder nicht.

      Am Ende will ich schon kapiert haben, was so beim ausführen des Codes passiert... :rolleyes:

      Naja egal...

      Durch *ähem* "organisches Wachstum" und durch Vermeidung jeglicher Vereinfachung
      wie etwa die Verwendung von Unterprogrammen etc. (wozu gibts denn Copy 'n Paste ^^)
      ist nun dass hier entstanden:

      C#-Quellcode

      1. void Main () // SimpleScript (Power Status Panel)
      2. // Space Engineers 01-126-007
      3. {
      4. var INFOPANEL = (IMyTextPanel)
      5. GridTerminalSystem.GetBlockWithName ("LCD Panel (Power Status)"); // Bezeichnung des LCD-Panels
      6. double SOLARMAX = 0; // "Max Output" und "Current Output" Variablen
      7. double SOLARUSE = 0;
      8. double BATTERYMAX = 0;
      9. double BATTERYUSE = 0;
      10. double STOREDMAX = 0; // "Max Stored" Variable
      11. double STOREDMIN = 0; // "Stored Power" Variable
      12. double REACTORMAX = 0;
      13. double REACTORUSE = 0;
      14. var SOMAX = "kW"; // Einheiten-Anzeige
      15. var SOUSE = "kW";
      16. var BAMAX = "kW";
      17. var BAUSE = "kW";
      18. var STMAX = "kWh";
      19. var STMIN = "kWh";
      20. var REMAX = "kW";
      21. var REUSE = "kW";
      22. double SOPRO = 0; // Prozentwerte
      23. double BAPRO = 0;
      24. double STPRO = 0;
      25. double REPRO = 0;
      26. var ALLSOLARPANELS = new List <IMyTerminalBlock> ();
      27. GridTerminalSystem.GetBlocksOfType <IMySolarPanel> (ALLSOLARPANELS);
      28. if (ALLSOLARPANELS.Count > 0) // überprüfe alle Solarpanels im Grid
      29. {
      30. for (int Z = 0; Z < ALLSOLARPANELS.Count; Z++)
      31. {
      32. var SOLARPANEL = (IMySolarPanel) ALLSOLARPANELS [Z];
      33. var POWERMAX = Convert.ToDouble // "Max Output" Info's auslesen
      34. (
      35. SOLARPANEL.DetailedInfo.Split ('\n')
      36. [1].Split (' ') [2]
      37. );
      38. var MAX = SOLARPANEL.DetailedInfo.Split ('\n') [1].Split (' ') [3];
      39. if (MAX == "W") // Addition des "Max Output"-Werts in kW
      40. {
      41. SOLARMAX += POWERMAX * 0.001;
      42. }
      43. if (MAX == "kW")
      44. {
      45. SOLARMAX += POWERMAX;
      46. }
      47. if (MAX == "MW")
      48. {
      49. SOLARMAX += POWERMAX * 1000;
      50. }
      51. if (MAX == "GW")
      52. {
      53. SOLARMAX += POWERMAX * 1000000;
      54. }
      55. var POWERUSE = Convert.ToDouble // "Current Output" Info's auslesen
      56. (
      57. SOLARPANEL.DetailedInfo.Split ('\n')
      58. [2].Split (' ') [2]
      59. );
      60. var USE = SOLARPANEL.DetailedInfo.Split ('\n') [2].Split (' ') [3];
      61. if (USE == "W") // Addition des "Current Output"-Werts in kW
      62. {
      63. SOLARUSE += POWERUSE * 0.001;
      64. }
      65. if (USE == "kW")
      66. {
      67. SOLARUSE += POWERUSE;
      68. }
      69. if (USE == "MW")
      70. {
      71. SOLARUSE += POWERUSE * 1000;
      72. }
      73. if (USE == "GW")
      74. {
      75. SOLARUSE += POWERUSE * 1000000;
      76. }
      77. }
      78. if (SOLARMAX != 0) // keine Division durch Null - Prozentwert ermitteln
      79. {
      80. if (SOLARMAX > SOLARUSE) // um zu vermeiden dass während des Sonnenaufgangs
      81. // eine grössere Prozentzahl als 100 % angezeigt wird.
      82. {
      83. SOPRO = Math.Round (SOLARUSE / SOLARMAX * 100, 2);
      84. }
      85. else // ist natürlich etwas getrickst ;-)
      86. {
      87. SOPRO = Math.Round (SOLARMAX / SOLARUSE * 100, 2);
      88. }
      89. }
      90. if (SOLARMAX <= 1) // Einheiten-Anzeige für die aufaddierten Werte anpassen
      91. {
      92. SOLARMAX /= 0.001;
      93. SOMAX = "W";
      94. }
      95. if (SOLARMAX > 1000)
      96. {
      97. SOLARMAX /= 1000;
      98. SOMAX = "MW";
      99. }
      100. if (SOLARMAX > 1000)
      101. {
      102. SOLARMAX /= 1000;
      103. SOMAX = "GW";
      104. }
      105. if (SOLARUSE <= 1)
      106. {
      107. SOLARUSE /= 0.001;
      108. SOUSE = "W";
      109. }
      110. if (SOLARUSE > 1000)
      111. {
      112. SOLARUSE /= 1000;
      113. SOUSE = "MW";
      114. }
      115. if (SOLARUSE > 1000)
      116. {
      117. SOLARUSE /= 1000;
      118. SOUSE = "GW";
      119. }
      120. }
      121. var ALLBATTERIES = new List <IMyTerminalBlock> ();
      122. GridTerminalSystem.GetBlocksOfType <IMyBatteryBlock> (ALLBATTERIES);
      123. if (ALLBATTERIES.Count > 0) // überprüfe alle Batterien im Grid
      124. {
      125. for (int Z = 0; Z < ALLBATTERIES.Count; Z++)
      126. {
      127. var BATTERY = (IMyBatteryBlock) ALLBATTERIES [Z];
      128. var POWERMAX = Convert.ToDouble // "Max Output" Info's auslesen
      129. (
      130. BATTERY.DetailedInfo.Split ('\n')
      131. [1].Split (' ') [2]
      132. );
      133. var MAX = BATTERY.DetailedInfo.Split ('\n') [1].Split (' ') [3];
      134. if (MAX == "W") // Addition des "Max Output"-Werts in kW
      135. {
      136. BATTERYMAX += POWERMAX * 0.001;
      137. }
      138. if (MAX == "kW")
      139. {
      140. BATTERYMAX += POWERMAX;
      141. }
      142. if (MAX == "MW")
      143. {
      144. BATTERYMAX += POWERMAX * 1000;
      145. }
      146. if (MAX == "GW")
      147. {
      148. BATTERYMAX += POWERMAX * 1000000;
      149. }
      150. var POWERUSE = Convert.ToDouble // "Current Output" Info's auslesen
      151. (
      152. BATTERY.DetailedInfo.Split ('\n')
      153. [5].Split (' ') [2]
      154. );
      155. var USE = BATTERY.DetailedInfo.Split ('\n') [5].Split (' ') [3];
      156. if (USE == "W") // Addition des "Current Output"-Werts in kW
      157. {
      158. BATTERYUSE += POWERUSE * 0.001;
      159. }
      160. if (USE == "kW")
      161. {
      162. BATTERYUSE += POWERUSE;
      163. }
      164. if (USE == "MW")
      165. {
      166. BATTERYUSE += POWERUSE * 1000;
      167. }
      168. if (USE == "GW")
      169. {
      170. BATTERYUSE += POWERUSE * 1000000;
      171. }
      172. var STORAGEMAX = Convert.ToDouble // "Max Stored" Info's auslesen
      173. (
      174. BATTERY.DetailedInfo.Split ('\n')
      175. [3].Split (' ') [3]
      176. );
      177. var SMAX = BATTERY.DetailedInfo.Split ('\n') [3].Split (' ') [4];
      178. if (SMAX == "Wh") // Addition des "Max Stored"-Werts in kWh
      179. {
      180. STOREDMAX += STORAGEMAX * 0.001;
      181. }
      182. if (SMAX == "kWh")
      183. {
      184. STOREDMAX += STORAGEMAX;
      185. }
      186. if (SMAX == "MWh")
      187. {
      188. STOREDMAX += STORAGEMAX * 1000;
      189. }
      190. if (SMAX == "GWh")
      191. {
      192. STOREDMAX += STORAGEMAX * 1000000;
      193. }
      194. var STORAGEMIN = Convert.ToDouble // "Stored Power" Info's auslesen
      195. (
      196. BATTERY.DetailedInfo.Split ('\n')
      197. [6].Split (' ') [2]
      198. );
      199. var SMIN = BATTERY.DetailedInfo.Split ('\n') [6].Split (' ') [3];
      200. if (SMIN == "Wh") // Addition des "Stored Power"-Werts in kWh
      201. {
      202. STOREDMIN += STORAGEMIN * 0.001;
      203. }
      204. if (SMIN == "kWh")
      205. {
      206. STOREDMIN += STORAGEMIN;
      207. }
      208. if (SMIN == "MWh")
      209. {
      210. STOREDMIN += STORAGEMIN * 1000;
      211. }
      212. if (SMIN == "GWh")
      213. {
      214. STOREDMIN += STORAGEMIN * 1000000;
      215. }
      216. }
      217. if (BATTERYMAX != 0) // keine Division durch Null - Prozentwert ermitteln
      218. {
      219. BAPRO = Math.Round (BATTERYUSE / BATTERYMAX * 100, 2);
      220. }
      221. if (BATTERYMAX <= 1) // Einheiten-Anzeige für die aufaddierten Werte anpassen
      222. {
      223. BATTERYMAX /= 0.001;
      224. BAMAX = "W";
      225. }
      226. if (BATTERYMAX > 1000)
      227. {
      228. BATTERYMAX /= 1000;
      229. BAMAX = "MW";
      230. }
      231. if (BATTERYMAX > 1000)
      232. {
      233. BATTERYMAX /= 1000;
      234. BAMAX = "GW";
      235. }
      236. if (BATTERYUSE <= 1)
      237. {
      238. BATTERYUSE /= 0.001;
      239. BAUSE = "W";
      240. }
      241. if (BATTERYUSE > 1000)
      242. {
      243. BATTERYUSE /= 1000;
      244. BAUSE = "MW";
      245. }
      246. if (BATTERYUSE > 1000)
      247. {
      248. BATTERYUSE /= 1000;
      249. BAUSE = "GW";
      250. }
      251. if (STOREDMAX != 0) // keine Division durch Null - Prozentwert ermitteln
      252. {
      253. STPRO = Math.Round (STOREDMIN / STOREDMAX * 100, 2);
      254. }
      255. if (STOREDMAX <= 1) // Einheiten-Anzeige für die aufaddierten Werte anpassen
      256. {
      257. STOREDMAX /= 0.001;
      258. STMAX = "Wh";
      259. }
      260. if (STOREDMAX > 1000)
      261. {
      262. STOREDMAX /= 1000;
      263. STMAX = "MWh";
      264. }
      265. if (STOREDMAX > 1000)
      266. {
      267. STOREDMAX /= 1000;
      268. STMAX = "GWh";
      269. }
      270. if (STOREDMIN <= 1)
      271. {
      272. STOREDMIN /= 0.001;
      273. STMIN = "Wh";
      274. }
      275. if (STOREDMIN > 1000)
      276. {
      277. STOREDMIN /= 1000;
      278. STMIN = "MWh";
      279. }
      280. if (STOREDMIN > 1000)
      281. {
      282. STOREDMIN /= 1000;
      283. STMIN = "GWh";
      284. }
      285. }
      286. var ALLREACTORS = new List <IMyTerminalBlock> ();
      287. GridTerminalSystem.GetBlocksOfType <IMyReactor> (ALLREACTORS);
      288. if (ALLREACTORS.Count > 0) // überprüfe alle Reaktoren im Grid
      289. {
      290. for (int Z = 0; Z < ALLREACTORS.Count; Z++)
      291. {
      292. var REACTOR = (IMyReactor) ALLREACTORS [Z];
      293. var POWERMAX = Convert.ToDouble // "Max Output" Info's auslesen
      294. (
      295. REACTOR.DetailedInfo.Split ('\n')
      296. [1].Split (' ') [2]
      297. );
      298. var MAX = REACTOR.DetailedInfo.Split ('\n') [1].Split (' ') [3];
      299. if (MAX == "W") // Addition des "Max Output"-Werts in kW
      300. {
      301. REACTORMAX += POWERMAX * 0.001;
      302. }
      303. if (MAX == "kW")
      304. {
      305. REACTORMAX += POWERMAX;
      306. }
      307. if (MAX == "MW")
      308. {
      309. REACTORMAX += POWERMAX * 1000;
      310. }
      311. if (MAX == "GW")
      312. {
      313. REACTORMAX += POWERMAX * 1000000;
      314. }
      315. var POWERUSE = Convert.ToDouble // "Current Output" Info's auslesen
      316. (
      317. REACTOR.DetailedInfo.Split ('\n')
      318. [2].Split (' ') [2]
      319. );
      320. var USE = REACTOR.DetailedInfo.Split ('\n') [2].Split (' ') [3];
      321. if (USE == "W") // Addition des "Current Output"-Werts in kW
      322. {
      323. REACTORUSE += POWERUSE * 0.001;
      324. }
      325. if (USE == "kW")
      326. {
      327. REACTORUSE += POWERUSE;
      328. }
      329. if (USE == "MW")
      330. {
      331. REACTORUSE += POWERUSE * 1000;
      332. }
      333. if (USE == "GW")
      334. {
      335. REACTORUSE += POWERUSE * 1000000;
      336. }
      337. }
      338. if (REACTORMAX != 0) // keine Division durch Null - Prozentwert ermitteln
      339. {
      340. REPRO = Math.Round (REACTORUSE / REACTORMAX * 100, 2);
      341. }
      342. if (REACTORMAX <= 1) // Einheiten-Anzeige für die aufaddierten Werte anpassen
      343. {
      344. REACTORMAX /= 0.001;
      345. REMAX = "W";
      346. }
      347. if (REACTORMAX > 1000)
      348. {
      349. REACTORMAX /= 1000;
      350. REMAX = "MW";
      351. }
      352. if (REACTORMAX > 1000)
      353. {
      354. REACTORMAX /= 1000;
      355. REMAX = "GW";
      356. }
      357. if (REACTORUSE <= 1)
      358. {
      359. REACTORUSE /= 0.001;
      360. REUSE = "W";
      361. }
      362. if (REACTORUSE > 1000)
      363. {
      364. REACTORUSE /= 1000;
      365. REUSE = "MW";
      366. }
      367. if (REACTORUSE > 1000)
      368. {
      369. REACTORUSE /= 1000;
      370. REUSE = "GW";
      371. }
      372. }
      373. INFOPANEL.SetValue ("FontSize", 1.4f); // ermittelte Info's auf dem LCD-Panel anzeigen
      374. INFOPANEL.WritePublicText
      375. (
      376. "\n" +
      377. " SOLAR: " + SOPRO + " %" + "\n" +
      378. " " + Math.Round (SOLARUSE, 1) + " " + SOUSE + " / " + Math.Round (SOLARMAX, 1) + " " + SOMAX + "\n" +
      379. "\n" +
      380. " BATTERIES: " + BAPRO + " %" + "\n" +
      381. " " + Math.Round (BATTERYUSE, 1) + " " + BAUSE + " / " + Math.Round (BATTERYMAX, 1) + " " + BAMAX + "\n" +
      382. " STORED POWER: " + STPRO + " %" + "\n" +
      383. " " + Math.Round (STOREDMIN, 1) + " " + STMIN + " / " + Math.Round (STOREDMAX, 1) + " " + STMAX + "\n" +
      384. "\n" +
      385. " REACTORS: " + REPRO + " %" + "\n" +
      386. " " + Math.Round (REACTORUSE, 1) + " " + REUSE + " / " + Math.Round (REACTORMAX, 1) + " " + REMAX
      387. );
      388. }
      Alles anzeigen

      Gehe davon aus, man hätte es DEFINITIV eleganter lösen können... :D

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von Stephan(steff) ()

    • OK, ich habe mir das Script einmal angesehen und natürlich fallen mir Doppelungen auf die man in Funktionen setzen und damit den Quellcode reduzieren könnte.
      Aber an sich mal Schön zu sehen das man sich da durchkämpft :D

      Aber auch Respekt bei den Versuch dahinter zu steigen :D !!!!!

      Ich habe Hier noch einiges Verlinkt bei bedarf > Link <

      Dazu noch eine Kleine Funktion die auch helfen könnte die Verdopplung zu vermeiden :P

      C#-Quellcode

      1. // INCOME = Double ; TYP = String (Wh,kWh,MWh,GWh)
      2. // Addition des "INCOME"-Werts in kWh
      3. double dataToKwh(double INCOME, string TYP)
      4. {
      5. if (TYP == "Wh")
      6. {
      7. INCOME += STORAGEMIN * 0.001;
      8. } else if (TYP == "kWh")
      9. {
      10. INCOME += STORAGEMIN;
      11. } else if (TYP == "MWh")
      12. {
      13. INCOME += STORAGEMIN * 1000;
      14. } else if (TYP == "GWh")
      15. {
      16. INCOME += STORAGEMIN * 1000000;
      17. }
      18. return INCOME;
      19. }
      Alles anzeigen
    • Ja, der Link war einer meiner Nachschlagewerke,
      sage ich nachträglich noch Dankeschön dafür, Xeracles.

      Bei der Gelegenheit möchte ich noch auf folgenden Link hinweisen:

      -> Space Engineers · For Some Definition...

      Nicht ganz vollständig, aber relativ aktuell gehalten.
      (soweit ich das sehen konnte)

      War mir ab und an doch eine Hilfe.

      double dataToKwh (double INCOME, string TYP)

      Wenn da jetzt stehen würde...

      var dataToKwh (double INCOME, string TYP)

      ...würde es für mich (vielleicht) noch Sinn machen.
      So aber haut es die Fragezeichen bei mir nur so raus.

      Mir will es einfach nicht in den Kopf,
      dass man wie in dem Beispiel für die Argumente der Funktion erst double deklariert,
      dann aber doch eine weitere Variable des String-Typs reinpacken kann.

      Du hast zufällig genau den Punkt getroffen,
      warum ich Die Verwendung von Funktionen gescheut habe. (Copy and Paste-Effekt^^)

      Die Übergabe von Werten unterschiedlichen Typs war (ist?)
      für mich noch nicht eindeutig geklärt...


      Spcemarine schrieb:

      Bestimmt. Aber dann hätten wir nicht so viel Rätselspaß bei der Fehlersuche! ;P

      Oh wie wahr... ^^

      Die ersten Ausleseversuche von MaxOutput scheiterten unter anderem daran,
      dass ich nichts von den Newline-Zeichen in der Detailed Info wusste...

      Heureka, war das eine Erkenntnis als ich endlich darauf gekommen bin! :D
    • Also wenn schon, Xera, dann aber auch richtig mit switch. :P

      C#-Quellcode

      1. private double DataToKwh(double income, string typ)
      2. {
      3. switch (typ)
      4. {
      5. case "Wh":
      6. income += STORAGEMIN * 0.001;
      7. break;
      8. case "kWh":
      9. income += STORAGEMIN;
      10. break;
      11. case "MWh":
      12. income += STORAGEMIN * 1000;
      13. break;
      14. case "GWh":
      15. income += STORAGEMIN * 1000000;
      16. break;
      17. }
      18. return income;
      19. }
      Alles anzeigen

      Jack, ich könnte dir Feedback geben an welchen Stellen man vllt. etwas verbessern sollte, wenn du möchtest. Ansonsten würde ich dir raten das Parsen der DetailedInfo zu unterlassen und die dafür vorgesehenen Felder zu verwenden, da das Format der DetailedInfo wechseln könnte etc. Es gibt in IMySolarPanel sowohl das Property CurrentOutput, als auch MaxOutput, was floats sind, die man einfach lesen kann. ;) Das selbe gilt für IMyReactor. ^^ So viel mal, um wenigstens dein Wissen die API betreffend zu verbessern. :D
    • JumpinJack schrieb:

      Mir will es einfach nicht in den Kopf,
      dass man wie in dem Beispiel für die Argumente der Funktion erst double deklariert,
      dann aber doch eine weitere Variable des String-Typs reinpacken kann.
      Ups. Du vertauschst da grundlegende Dinge. double MyMethod(double arg1, string arg2) sagt dem Computer, dass die Methode einen double zurück gibt und als Parameter erst einen double und dann einen String erwartet. Nicht mehr, nicht weniger. Sprich, wenn du irgendwo var myDouble = MyMethod(someDouble, someString) aufrufst, wobei someDouble eine Variable vom Typ double ist und someString eine Variable vom Typ string ist, dann speicherst du in myDouble den Rückgabewert der Methode.

      Will heißen, das double am Anfang gibt an, dass der Rückgabewert vom Typ double ist und keine Auswirkung auf die Übergabeparameter hat.
    • Ansonsten würde ich dir raten das Parsen der DetailedInfo zu unterlassen und die dafür vorgesehenen Felder zu verwenden, da das Format der DetailedInfo wechseln könnte etc.
      Also werde ich mir das bei Gelegenheit nochmal anschauen...
      Allerspätestens dann, wenn aus dem Hause Keen dran gedreht wird. :rolleyes:

      -----
      EDIT:
      Es gibt in IMySolarPanel sowohl das Property CurrentOutput, als auch MaxOutput, was floats sind, die man einfach lesen kann.
      Wo liest man die dazugehörigen Einheiten aus?
      Oder werden diese Eigenschaftswerte einheitlich in W bzw. Wh ausgegeben?
      -----

      Ups. Du vertauschst da grundlegende Dinge. double MyMethod(double arg1, string arg2) sagt dem Computer, dass die Methode einen double zurück gibt und als Parameter erst einen double und dann einen String erwartet. Nicht mehr, nicht weniger.

      Mit anderen Worten:

      double und string raus (Argumente in den Klammern) , dafür double retour...
      ...gut, wäre das geklärt.

      Jack, ich könnte dir Feedback geben an welchen Stellen man vllt. etwas verbessern sollte, wenn du möchtest.

      Die Antwort auf folgende Frage(n) würde mir erstmal reichen: ;)


      Wie realisiere ich die Rückgabe von mehreren Werten unterschiedlichen Typs?
      Gibt es dazu verschiedene (wesentliche) Vorgehensweisen?

      Das reicht auch schon, denke ich. :D
      Sonst komme ich vor lauter scripten nicht mehr dazu,
      mich mit SE zu beschäftigen...

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von JumpinJack ()

    • JumpinJack schrieb:

      Wo liest man die dazugehörigen Einheiten aus?
      Oder werden diese Eigenschaftswerte einheitlich in W bzw. Wh ausgegeben?
      Ich hoffe doch, dass die einheitlich modelliert sind. D: Alles andere wäre ziemlich blöd. Auch intern, da man sonst Konsistenz verlieren würde.

      JumpinJack schrieb:

      double und string raus (Argumente in den Klammern)
      Waaaas?! Du brauchst die nicht rausmobben! :D Die dürfen gerne bleiben! :P Wenn du die Argumente in deiner Methode brauchst, kannst du die ja nicht einfach rauswerfen. :x
      Schönes Codebeispiel:

      C#-Quellcode

      1. string GetFormattedString(float watt, bool hours = false)
      2. {
      3. string unit = "W";
      4. if (watt > 1000)
      5. {
      6. unit = "kW";
      7. watt /= 1000;
      8. }
      9. if (watt > 1000)
      10. {
      11. unit = "MW";
      12. watt /= 1000;
      13. }
      14. if (watt > 1000)
      15. {
      16. unit = "GW";
      17. watt /= 1000;
      18. }
      19. if (watt > 1000)
      20. {
      21. unit = "TW";
      22. watt /= 1000;
      23. }
      24. string result = watt.ToString("N") + " " + unit;
      25. if (hours)
      26. result += "h";
      27. return result;
      28. }
      Alles anzeigen
      Für GetFormattedString(15709) wird die Methode den String 15.70 kW zurückgeben. Die nur 2 Nachkommastellen werden durch das .ToString("N") erreicht. Wenn man nun GetFormattedString(15709, true) ausführt, wird hinten an die Einheit noch ein h angehängt, sodass wir Wh, kWh, etc. bekommen. Somit brauchen wir alle Parameter und den Rückgabetyp auch. :P

      JumpinJack schrieb:

      Wie realisiere ich die Rückgabe von mehreren Werten unterschiedlichen Typs?
      Gibt es dazu verschiedene (wesentliche) Vorgehensweisen?
      Puh. Ja, da gäbe es eigentlich eine ganze Reihe von Möglichkeiten. Es kommt nun ganz darauf an was du wie tun möchtest.
      Einerseits gäbe es die Möglichkeit den Typ Dictionary zu verwenden. Dieser hält einen Schlüssel und einen Wert eines beliebigen Typs. Der Schlüssel muss hierbei eindeutig sein. Hat man den Schlüssel, kann man den Wert abfragen. Umgekehrt ist es auch möglich, aber nicht ohne weiteres und die Eindeutigkeit ist auch nicht gegeben.
      Weiterhin könntest du deine eigene Klasse (oder ein struct) definieren. Der Vorteil hier ist, dass du hier direkt definieren kannst, was du brauchst. Gibst du diese irgendwo zurück, können im zurückgegebenen Objekt die Werte ausgelesen werden, die du zuvor in der Methode gesetzt hast.
      Dann gibt es auch noch das out Schlüsselwort, das man bei Methoden verwenden kann. Dieses wird unter anderem gerne beim Parsen verwendet. Beispielsweise geben die TryParse(...) Methoden alle einen bool zurück, der angibt, ob das Parsen gelungen ist. Zusätzlich wird mit out parsedType noch das "Geparste" ausgegeben. Die Variable parsedType muss man aber vorher selbst deklarieren. Im Fehlerfall setzt die Methode sie auf null.
      Ähnlich funktioniert das ref Schlüsselwort. Im Gegensatz zu out wird hier aber erwartet, dass Argumente mit einem solchen Schlüsselwort gekennzeichnet sind, auch einen richtigen Wert haben, der in der Methode benutzt wird. Nach der Ausführung der Methode sollte aber auch hier in der Variable dann etwas stehen.
      Zuletzt möchte ich noch auf die Möglichkeit von "globalen" Variablen aufmerksam machen. Diese werden außerhalb der Main Methode definiert und können dann überall benutzt werden. Außerdem bleiben sie selbst nach der Ausführung der Main Methode bestehen, sodass sie im nächsten Aufruf wieder benutzt werden können. Kleines Beispiel:

      C#-Quellcode

      1. int number;
      2. void Main()
      3. {
      4. number = 1;
      5. Increase();
      6. Decrease();
      7. Echo(number);
      8. }
      9. void Increase()
      10. {
      11. number += 1;
      12. }
      13. void Decrease()
      14. {
      15. number -= 1;
      16. }
      Alles anzeigen
      Dieses Beispiel wird 1 ausgeben, da auf number erst 1 drauf addiert wird und dann wieder 1 abgezogen. Ganz ohne, dass ich Parameter übergebe oder Rückgabewerte habe (void gibt an, dass nichts zurückgegeben wird.


      Wenn du konkreter machst, was du in welchem Kontext zurückgeben willst, kann man dir vielleicht noch besser helfen. ;)

      JumpinJack schrieb:

      Sonst komme ich vor lauter scripten nicht mehr dazu,
      mich mit SE zu beschäftigen...
      Es gibt noch was anderes in SE? D:

      //Edit:

      @Xeracles switch haben sie irgend wann mal hingekriegt, ist aber auch schon länger her. Aber foreach und where (also Generics) gehen glaube ich immer noch nicht.
    • Spcemarine schrieb:

      Waaaas?! Du brauchst die nicht rausmobben! Die dürfen gerne bleiben! Wenn du die Argumente in deiner Methode brauchst, kannst du die ja nicht einfach rauswerfen. :x
      Nix wie raus aus dem Hauptprogramm mit dem Zeugs... 8o

      Thx für den kleinen Überblick, Spcemarine... :thumbupkind:

      Okay, also globale Variablen... wären vielleicht eine bequeme Möglichkeit.
      Muss dann halt darauf achten, ob je nach Verwendungszweck ein Reset nötig ist oder nicht.

      Klasse oder Struct erscheint mir auch interessant.

      Mir schwebt ein Unterprogramm (Methode, Funktion, whatever) vor,
      dem die zu addierenden Werte zusammen mit den Einheiten übergeben wird (double, double, string, string)
      und den aufaddierten Wert mit angepasster Einheit in double und string zurückgibt.

      Würde mein bisheriges Script um gefühlte 70% verkürzen...
      Bei Gelegenheit und Lust und Laune mache ich mich nochmal darüber her.

      P.S. (Eine formatierte Stringvariable oder so möchte ich lieber nicht)
    • JumpinJack schrieb:

      P.S. (Eine formatierte Stringvariable oder so möchte ich lieber nicht)
      Die wäre ja auch zu fast nichts zu gebrauchen. Meine Methode wäre nur zur Ausgabe gut, sobald alles andere abgeschlossen ist. Solltest du mal die Felder CurrentOutput oder MaxOutput verwenden, kannst du ja darauf zurückgreifen, wenn es dir sinnvoll erscheint. :D

      //Edit:
      Wäre dann übrigens auch einfacher mit dem Zusammenrechnen, da du nicht mehr auf Einheiten achten brauchst. ^^ Und am ende gibst du es einfach mit der Formatierungsmethode aus. :P
    • Spcemarine schrieb:

      //Edit:
      Wäre dann übrigens auch einfacher mit dem Zusammenrechnen, da du nicht mehr auf Einheiten achten brauchst. Und am ende gibst du es einfach mit der Formatierungsmethode aus.
      Ob du's glaubst oder nicht, der Gedanke ist mir duchaus schon gekommem :D

      Durchstöbere gerade alle auffindbaren Infos's im Netz bzgl. abrufbare Eigenschaften.
      Hab's noch nicht getestet, aber sieht so aus, als ob die Current-Werte in kW
      und die Max. Output-Werte in MW sind - und nach den Stored Power Eigenschaften
      kratz ich mir zu Zeit die Augen aus, hab' bisher nur einen boolschen Wert
      (zur Abfrage ob überhaupt Energie gespeichert ist) gefunden...

      Also wenn, dann möchte ich die Abfragen schon komplett über Eigenschaftswerte
      abwickeln. Wenn ich trotzdem wieder einige Werte
      aus dem DetailedInfo-String klauben muss, macht das nicht wirklich Sinn...

      Wie schimpfte sich das nochmal?
      IMyPowerProducer (oder so ähnlich, wirst schon wissen was ich meine)
      ist endgültig abgeschafft, oder?

      Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von JumpinJack ()

    • JumpinJack schrieb:

      Wie schimpfte sich das nochmal?
      IMyPowerProducer (oder so ähnlich, wirst schon wissen was ich meine)
      ist endgültig abgeschafft, oder?
      Keine Ahnung, ob es das gab, jedenfalls gibt es sowas meines Wissens nach nicht.
      Ansonsten:


      Quellcode

      1. float CurrentStoredPower { get; }
      2. Member of Sandbox.ModAPI.Ingame.IMyBatteryBlock
      Suchst du das? Ich kann dir nur empfehlen dir Visual Studio zu holen, da die Referenzen einzufügen und dann im Object Browser die jeweiligen Sachen zu suchen. Das vereinfacht den ganzen Prozess um einiges. Dann kannst du beispielsweise sowas suchen und einsehen:

    • Ja, genau das war es, danke.

      Habe gerade erst gelesen,
      dass mit der Installation von Space-Engineers eine entsprechende Dokumentationsdatei
      auf dem eigenen Rechner zu finden ist... und mit den Updates auch aktuell gehalten wird.
      ...na, da hätte ich mir einiges an Gesuche ja sparen können.

      Visual Studio hm... praktisch wäre es schon,
      allerdings für das, was ich an Scripts je machen werde
      kommt es mir doch etwas zuviel des Guten vor.

      Eine einfache, halbwegs übersichtliche Liste tut es für mich auch.
      Ich schau mir diese Doku mal an, vielleicht enthält sie ja sowas...
    • So, hier nun die etwas optimierte Version des Power-Status-Scripts.

      C#-Quellcode

      1. void Main () // SimpleScript (Power Status Panel) V2
      2. // Space Engineers 01-126-007
      3. { // Definition der Variablen
      4. float SOLARMAX = 0; // Solarpanel
      5. float SOLARUSE = 0;
      6. double SOLARPERCENT = 0;
      7. var SOMAX = "MW";
      8. var SOUSE = "MW";
      9. float BATTERYMAX = 0; // Batterien
      10. float BATTERYUSE = 0;
      11. double BATTERYPERCENT = 0;
      12. var BAMAX = "MW";
      13. var BAUSE = "MW";
      14. float STOREDMAX = 0;
      15. float STOREDMIN = 0;
      16. double STOREDPERCENT = 0;
      17. var STMAX = "MWh";
      18. var STMIN = "MWh";
      19. float REACTORMAX = 0; // Reaktoren
      20. float REACTORUSE = 0;
      21. double REACTORPERCENT = 0;
      22. var REMAX = "MW";
      23. var REUSE = "MW";
      24. var INFOPANEL = (IMyTextPanel) GridTerminalSystem.GetBlockWithName
      25. (
      26. "LCD Panel (Power Status)" // Bezeichnung des LCD-Panels
      27. );
      28. var ALLSOLARPANELS = new List <IMyTerminalBlock> ();
      29. GridTerminalSystem.GetBlocksOfType <IMySolarPanel> (ALLSOLARPANELS);
      30. if (ALLSOLARPANELS.Count > 0) // überprüfe alle Solarpanels im Grid
      31. {
      32. for (int Z = 0; Z < ALLSOLARPANELS.Count; Z++)
      33. {
      34. var SOLARPANEL = (IMySolarPanel) ALLSOLARPANELS [Z];
      35. SOLARMAX += SOLARPANEL.MaxOutput; // Addition der Werte in MW
      36. SOLARUSE += SOLARPANEL.CurrentOutput;
      37. }
      38. }
      39. if (SOLARMAX != 0) // keine Division durch Null - Prozentwert ermitteln
      40. {
      41. SOLARPERCENT = Math.Round (SOLARUSE / SOLARMAX * 100, 2);
      42. }
      43. SOMAX = ChangeUnit (SOLARMAX, SOMAX); // Einheiten anpassen
      44. SOUSE = ChangeUnit (SOLARUSE, SOUSE);
      45. SOLARMAX = ChangeValue (SOLARMAX, SOMAX); // Werte entsprechend umrechnen
      46. SOLARUSE = ChangeValue (SOLARUSE, SOUSE);
      47. var ALLBATTERIES = new List <IMyTerminalBlock> ();
      48. GridTerminalSystem.GetBlocksOfType <IMyBatteryBlock> (ALLBATTERIES);
      49. if (ALLBATTERIES.Count > 0) // überprüfe alle Batterien im Grid
      50. {
      51. for (int Z = 0; Z < ALLBATTERIES.Count; Z++)
      52. {
      53. var BATTERY = (IMyBatteryBlock) ALLBATTERIES [Z];
      54. BATTERYMAX += Convert.ToSingle // Addition der Werte in MW
      55. (
      56. BATTERY.DetailedInfo.Split ('\n') [1].Split (' ') [2]
      57. );
      58. BATTERYUSE += BATTERY.CurrentOutput;
      59. STOREDMAX += BATTERY.MaxStoredPower; // Addition der Werte in MWh
      60. STOREDMIN += BATTERY.CurrentStoredPower;
      61. }
      62. }
      63. if (BATTERYMAX != 0) // keine Division durch Null - Prozentwert ermitteln
      64. {
      65. BATTERYPERCENT = Math.Round (BATTERYUSE / BATTERYMAX * 100, 2);
      66. }
      67. BAMAX = ChangeUnit (BATTERYMAX, BAMAX); // Einheiten anpassen
      68. BAUSE = ChangeUnit (BATTERYUSE, BAUSE);
      69. BATTERYMAX = ChangeValue (BATTERYMAX, BAMAX); // Werte entsprechend umrechnen
      70. BATTERYUSE = ChangeValue (BATTERYUSE, BAUSE);
      71. if (STOREDMAX != 0) // keine Division durch Null - Prozentwert ermitteln
      72. {
      73. STOREDPERCENT = Math.Round (STOREDMIN / STOREDMAX * 100, 2);
      74. }
      75. STMAX = ChangeUnit (STOREDMAX, STMAX); // Einheiten anpassen
      76. STMIN = ChangeUnit (STOREDMIN, STMIN);
      77. STOREDMAX = ChangeValue (STOREDMAX, STMAX); // Werte entsprechend umrechnen
      78. STOREDMIN = ChangeValue (STOREDMIN, STMIN);
      79. var ALLREACTORS = new List <IMyTerminalBlock> ();
      80. GridTerminalSystem.GetBlocksOfType <IMyReactor> (ALLREACTORS);
      81. if (ALLREACTORS.Count > 0) // überprüfe alle Reaktoren im Grid
      82. {
      83. for (int Z = 0; Z < ALLREACTORS.Count; Z++)
      84. {
      85. var REACTOR = (IMyReactor) ALLREACTORS [Z];
      86. REACTORMAX += REACTOR.MaxOutput; // Addition der Werte in MW
      87. REACTORUSE += REACTOR.CurrentOutput;
      88. }
      89. }
      90. if (REACTORMAX != 0) // keine Division durch Null - Prozentwert ermitteln
      91. {
      92. REACTORPERCENT = Math.Round (REACTORUSE / REACTORMAX * 100, 2);
      93. }
      94. REMAX = ChangeUnit (REACTORMAX, REMAX); // Einheiten anpassen
      95. REUSE = ChangeUnit (REACTORUSE, REUSE);
      96. REACTORMAX = ChangeValue (REACTORMAX, REMAX); // Werte entsprechend umrechnen
      97. REACTORUSE = ChangeValue (REACTORUSE, REUSE);
      98. INFOPANEL.SetValue ("FontSize", 1.4f); // Info's auf dem LCD-Panel anzeigen
      99. INFOPANEL.WritePublicText
      100. (
      101. "\n" +
      102. " SOLAR: " + SOLARPERCENT + " %" + "\n" +
      103. " " + Math.Round (SOLARUSE, 1) + " " + SOUSE + " / " + Math.Round (SOLARMAX, 1) + " " + SOMAX + "\n" +
      104. "\n" +
      105. " BATTERIES: " + BATTERYPERCENT + " %" + "\n" +
      106. " " + Math.Round (BATTERYUSE, 1) + " " + BAUSE + " / " + Math.Round (BATTERYMAX, 1) + " " + BAMAX + "\n" +
      107. " STORED POWER: " + STOREDPERCENT + " %" + "\n" +
      108. " " + Math.Round (STOREDMIN, 1) + " " + STMIN + " / " + Math.Round (STOREDMAX, 1) + " " + STMAX + "\n" +
      109. "\n" +
      110. " REACTORS: " + REACTORPERCENT + " %" + "\n" +
      111. " " + Math.Round (REACTORUSE, 1) + " " + REUSE + " / " + Math.Round (REACTORMAX, 1) + " " + REMAX
      112. );
      113. }
      114. string ChangeUnit (float VALUE, string UNIT)
      115. { // die Einheiten werden an die Grösse von VALUE angepasst
      116. // UNIT unterscheidet zwischen Leistung und physikalischer Arbeit
      117. string OUTPUT = "MW"; // Default Rückgabewert
      118. if (VALUE >= 1000) // Einheiten anpassen
      119. {
      120. OUTPUT = "GW";
      121. }
      122. if (VALUE < 1)
      123. {
      124. OUTPUT = "kW";
      125. }
      126. if (VALUE < 0.001)
      127. {
      128. OUTPUT = "W";
      129. }
      130. if (UNIT == "MWh") // falls nötig Rückgabewert für die physikalische Arbeit
      131. { // in "Wh", "kWh", "MWh" oder "GWh" ändern
      132. OUTPUT += "h";
      133. }
      134. return OUTPUT;
      135. }
      136. float ChangeValue (float VALUE, string UNIT)
      137. { // UNIT bestimmt den Umrechnungsfaktor für VALUE
      138. char C = UNIT [0];
      139. if (C == 'G')
      140. {
      141. VALUE /= 1000;
      142. }
      143. if (C == 'k')
      144. {
      145. VALUE *= 1000;
      146. }
      147. if (C == 'W')
      148. {
      149. VALUE *= 1000000;
      150. }
      151. return VALUE;
      152. }
      Alles anzeigen

      Eigentlich wollte ich es noch etwas weiter zusammenfassen,
      aber da es - aus welchen Gründen auch immer - keinen Eigenschaftswert
      für MaxOutput bei den Batterien zu geben scheint,
      hätte ich für die geplante Funktion eine Ausnahmebehandlung für's Parsen
      machen müssen - dazu hatte ich einfach keinen Bock mehr... :whistling: