project_files/Android-build/SDL-android-project/src/org/hedgewars/hedgeroid/frontlib/Frontlib.java
changeset 8512 d2bca8e68688
parent 7691 55c0a856ecd0
child 10017 de822cd3df3a
equal deleted inserted replaced
8511:4f899fbce66d 8512:d2bca8e68688
    19 
    19 
    20 
    20 
    21 package org.hedgewars.hedgeroid.frontlib;
    21 package org.hedgewars.hedgeroid.frontlib;
    22 import java.io.UnsupportedEncodingException;
    22 import java.io.UnsupportedEncodingException;
    23 import java.util.ArrayList;
    23 import java.util.ArrayList;
       
    24 import java.util.Arrays;
    24 import java.util.HashMap;
    25 import java.util.HashMap;
    25 import java.util.List;
    26 import java.util.List;
    26 import java.util.Map;
    27 import java.util.Map;
    27 
    28 
    28 import org.hedgewars.hedgeroid.Datastructures.Hog;
    29 import org.hedgewars.hedgeroid.Datastructures.Hog;
   348 	}
   349 	}
   349 	
   350 	
   350 	static class HogStruct extends Structure {
   351 	static class HogStruct extends Structure {
   351 		public static class ByVal extends HogStruct implements Structure.ByValue {}
   352 		public static class ByVal extends HogStruct implements Structure.ByValue {}
   352 		public static class ByRef extends HogStruct implements Structure.ByReference {}
   353 		public static class ByRef extends HogStruct implements Structure.ByReference {}
   353 		private static String[] FIELD_ORDER = new String[] {"name", "hat", "rounds", "kills", "deaths", "suicides", "difficulty", "initialHealth", "weaponset"};
   354 
   354 
   355 		public HogStruct() { super(); }
   355 		public HogStruct() { super(); setFieldOrder(FIELD_ORDER); }
   356 		public HogStruct(Pointer ptr) { super(ptr); }
   356 		public HogStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   357 		
       
   358 		@Override
       
   359 		protected List<String> getFieldOrder() {
       
   360 			return Arrays.asList("name", "hat", "rounds", "kills", "deaths", "suicides", "difficulty", "initialHealth", "weaponset");
       
   361 		}
   357 		
   362 		
   358 		public void fillFrom(Hog hog) {
   363 		public void fillFrom(Hog hog) {
   359 			difficulty = hog.level;
   364 			difficulty = hog.level;
   360 			hat = hog.hat;
   365 			hat = hog.hat;
   361 			name = hog.name;
   366 			name = hog.name;
   380 	}
   385 	}
   381 	
   386 	
   382 	static class TeamStruct extends Structure {
   387 	static class TeamStruct extends Structure {
   383 		public static class ByVal extends TeamStruct implements Structure.ByValue {}
   388 		public static class ByVal extends TeamStruct implements Structure.ByValue {}
   384 		public static class ByRef extends TeamStruct implements Structure.ByReference {}
   389 		public static class ByRef extends TeamStruct implements Structure.ByReference {}
   385 		private static String[] FIELD_ORDER = new String[] {"hogs", "name", "grave", "fort", "voicepack", "flag", "bindings", "bindingCount", "rounds", "wins", "campaignProgress", "colorIndex", "hogsInGame", "remoteDriven", "ownerName"};
   390 
   386 
   391 		public TeamStruct() { super(); }
   387 		public TeamStruct() { super(); setFieldOrder(FIELD_ORDER); }
   392 		public TeamStruct(Pointer ptr) { super(ptr); }
   388 		public TeamStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   393 		
       
   394 		@Override
       
   395 		protected List<String> getFieldOrder() {
       
   396 			return Arrays.asList("hogs", "name", "grave", "fort", "voicepack", "flag", "bindings", "bindingCount", "rounds", "wins", "campaignProgress", "colorIndex", "hogsInGame", "remoteDriven", "ownerName");
       
   397 		}
   389 		
   398 		
   390 		public void fillFrom(Team team, TeamIngameAttributes attrs) {
   399 		public void fillFrom(Team team, TeamIngameAttributes attrs) {
   391 			if(team != null) {
   400 			if(team != null) {
   392 				name = team.name;
   401 				name = team.name;
   393 				grave = team.grave;
   402 				grave = team.grave;
   456 	}
   465 	}
   457 	
   466 	
   458 	static class WeaponsetStruct extends Structure {
   467 	static class WeaponsetStruct extends Structure {
   459 		public static class ByVal extends WeaponsetStruct implements Structure.ByValue {}
   468 		public static class ByVal extends WeaponsetStruct implements Structure.ByValue {}
   460 		public static class ByRef extends WeaponsetStruct implements Structure.ByReference {}
   469 		public static class ByRef extends WeaponsetStruct implements Structure.ByReference {}
   461 		private static String[] FIELD_ORDER = new String[] {"loadout", "crateprob", "crateammo", "delay", "name"};
   470 		
   462 		
   471 		public WeaponsetStruct() { super(); }
   463 		public WeaponsetStruct() { super(); setFieldOrder(FIELD_ORDER); }
   472 		public WeaponsetStruct(Pointer ptr) { super(ptr); }
   464 		public WeaponsetStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   473 		
       
   474 		@Override
       
   475 		protected List<String> getFieldOrder() {
       
   476 			return Arrays.asList("loadout", "crateprob", "crateammo", "delay", "name");
       
   477 		}
   465 		
   478 		
   466 		public void fillFrom(Weaponset weaponset) {
   479 		public void fillFrom(Weaponset weaponset) {
   467 			fillWeaponInfo(loadout, weaponset.loadout);
   480 			fillWeaponInfo(loadout, weaponset.loadout);
   468 			fillWeaponInfo(crateprob, weaponset.crateProb);
   481 			fillWeaponInfo(crateprob, weaponset.crateProb);
   469 			fillWeaponInfo(crateammo, weaponset.crateAmmo);
   482 			fillWeaponInfo(crateammo, weaponset.crateAmmo);
   499 	
   512 	
   500 	/**
   513 	/**
   501 	 * Represents a flib_weaponset*, for use as part of a flib_weaponset**
   514 	 * Represents a flib_weaponset*, for use as part of a flib_weaponset**
   502 	 */
   515 	 */
   503 	static class WeaponsetPointerByReference extends Structure implements Structure.ByReference {
   516 	static class WeaponsetPointerByReference extends Structure implements Structure.ByReference {
   504 		private static String[] FIELD_ORDER = new String[] {"weaponset"};
   517 		public WeaponsetPointerByReference() { super(); }
   505 		
   518 		public WeaponsetPointerByReference(Pointer ptr) { super(ptr); }
   506 		public WeaponsetPointerByReference() { super(); setFieldOrder(FIELD_ORDER); }
   519 		
   507 		public WeaponsetPointerByReference(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   520 		@Override
       
   521 		protected List<String> getFieldOrder() {
       
   522 			return Arrays.asList("weaponset");
       
   523 		}
   508 		
   524 		
   509 		public WeaponsetStruct.ByRef weaponset;
   525 		public WeaponsetStruct.ByRef weaponset;
   510 	}
   526 	}
   511 	
   527 	
   512 	static class WeaponsetListStruct extends Structure {
   528 	static class WeaponsetListStruct extends Structure {
   513 		public static class ByVal extends WeaponsetListStruct implements Structure.ByValue {}
   529 		public static class ByVal extends WeaponsetListStruct implements Structure.ByValue {}
   514 		public static class ByRef extends WeaponsetListStruct implements Structure.ByReference {}
   530 		public static class ByRef extends WeaponsetListStruct implements Structure.ByReference {}
   515 		private static String[] FIELD_ORDER = new String[] {"weaponsetCount", "weaponsets"};
   531 		
   516 		
   532 		public WeaponsetListStruct() { super(); }
   517 		public WeaponsetListStruct() { super(); setFieldOrder(FIELD_ORDER); }
   533 		public WeaponsetListStruct(Pointer ptr) { super(ptr); }
   518 		public WeaponsetListStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   534 		
       
   535 		@Override
       
   536 		protected List<String> getFieldOrder() {
       
   537 			return Arrays.asList("weaponsetCount", "weaponsets");
       
   538 		}
   519 		
   539 		
   520 		public void fillFrom(List<Weaponset> list) {
   540 		public void fillFrom(List<Weaponset> list) {
   521 			weaponsetCount = list.size();
   541 			weaponsetCount = list.size();
   522 			if(weaponsetCount<=0) {
   542 			if(weaponsetCount<=0) {
   523 				weaponsets = null;
   543 				weaponsets = null;
   558 	}
   578 	}
   559 	
   579 	
   560 	static class RoomStruct extends Structure {
   580 	static class RoomStruct extends Structure {
   561 		public static class ByVal extends RoomStruct implements Structure.ByValue {}
   581 		public static class ByVal extends RoomStruct implements Structure.ByValue {}
   562 		public static class ByRef extends RoomStruct implements Structure.ByReference {}
   582 		public static class ByRef extends RoomStruct implements Structure.ByReference {}
   563 		private static String[] FIELD_ORDER = new String[] {"inProgress", "name", "playerCount", "teamCount", "owner", "map", "scheme", "weapons"};
   583 		
   564 		
   584 		public RoomStruct() { super(); }
   565 		public RoomStruct() { super(); setFieldOrder(FIELD_ORDER); }
   585 		public RoomStruct(Pointer ptr) { super(ptr); }
   566 		public RoomStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   586 
   567 
   587 		@Override
       
   588 		protected List<String> getFieldOrder() {
       
   589 			return Arrays.asList("inProgress", "name", "playerCount", "teamCount", "owner", "map", "scheme", "weapons");
       
   590 		}
       
   591 		
   568 		public Room toRoomlistRoom() {
   592 		public Room toRoomlistRoom() {
   569 			return new Room(name, map, scheme, weapons, owner, playerCount, teamCount, inProgress);
   593 			return new Room(name, map, scheme, weapons, owner, playerCount, teamCount, inProgress);
   570 		}
   594 		}
   571 		
   595 		
   572 	    public boolean inProgress;
   596 	    public boolean inProgress;
   580 	}
   604 	}
   581 	
   605 	
   582 	static class MapRecipeStruct extends Structure {
   606 	static class MapRecipeStruct extends Structure {
   583 		public static class ByVal extends MapRecipeStruct implements Structure.ByValue {}
   607 		public static class ByVal extends MapRecipeStruct implements Structure.ByValue {}
   584 		public static class ByRef extends MapRecipeStruct implements Structure.ByReference {}
   608 		public static class ByRef extends MapRecipeStruct implements Structure.ByReference {}
   585 		private static String[] FIELD_ORDER = new String[] {"mapgen", "name", "seed", "theme", "drawData", "drawDataSize", "templateFilter", "mazeSize"};
   609 		
   586 		
   610 		public MapRecipeStruct() { super(); }
   587 		public MapRecipeStruct() { super(); setFieldOrder(FIELD_ORDER); }
   611 		public MapRecipeStruct(Pointer ptr) { super(ptr); }
   588 		public MapRecipeStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   612 		
       
   613 		@Override
       
   614 		protected List<String> getFieldOrder() {
       
   615 			return Arrays.asList("mapgen", "name", "seed", "theme", "drawData", "drawDataSize", "templateFilter", "mazeSize");
       
   616 		}
   589 		
   617 		
   590 		public void fillFrom(MapRecipe map) {
   618 		public void fillFrom(MapRecipe map) {
   591 			mapgen = map.mapgen;
   619 			mapgen = map.mapgen;
   592 			name = map.name;
   620 			name = map.name;
   593 			seed = map.seed;
   621 			seed = map.seed;
   594 			theme = map.theme;
   622 			theme = map.theme;
   595 			byte[] buf = map.getDrawData();
   623 			byte[] buf = map.getDrawData();
   596 			if(buf==null || buf.length==0) {
   624 			drawData = ByteArrayPtr.createJavaOwned(buf);
   597 				drawData = null;
       
   598 			} else {
       
   599 				drawData = ByteArrayPtr.createJavaOwned(buf).getPointer();
       
   600 			}
       
   601 			drawDataSize = NativeSizeT.valueOf(buf==null ? 0 : buf.length);
   625 			drawDataSize = NativeSizeT.valueOf(buf==null ? 0 : buf.length);
   602 			templateFilter = map.templateFilter;
   626 			templateFilter = map.templateFilter;
   603 			mazeSize = map.mazeSize;
   627 			mazeSize = map.mazeSize;
   604 		}
   628 		}
   605 		
   629 		
   606 		public MapRecipe toMapRecipe() {
   630 		public MapRecipe toMapRecipe() {
   607 			byte[] buf;
   631 			byte[] buf = ByteArrayPtr.deref(drawData, drawDataSize.intValue());
   608 			int size = drawDataSize.intValue();
       
   609 			if(size>0) {
       
   610 				buf = drawData.getByteArray(0, size);
       
   611 			} else {
       
   612 				buf = null;
       
   613 			}
       
   614 			return new MapRecipe(mapgen, templateFilter, mazeSize, name, seed, theme, buf);
   632 			return new MapRecipe(mapgen, templateFilter, mazeSize, name, seed, theme, buf);
   615 		}
   633 		}
   616 		
   634 		
   617 		public int mapgen;
   635 		public int mapgen;
   618 		public String name;
   636 		public String name;
   619 		public String seed;
   637 		public String seed;
   620 		public String theme;
   638 		public String theme;
   621 		public Pointer drawData;			// We can't use ByteArrayPtr in a struct because JNA will overwrite the value with NULL - probably a bug.
   639 		public ByteArrayPtr drawData;
   622 		public NativeSizeT drawDataSize;
   640 		public NativeSizeT drawDataSize;
   623 		public int templateFilter;
   641 		public int templateFilter;
   624 		public int mazeSize;
   642 		public int mazeSize;
   625 	}
   643 	}
   626 	
   644 	
   627 	static class MetaschemeSettingStruct extends Structure {
   645 	static class MetaschemeSettingStruct extends Structure {
   628 		public static class ByVal extends MetaschemeSettingStruct implements Structure.ByValue {}
   646 		public static class ByVal extends MetaschemeSettingStruct implements Structure.ByValue {}
   629 		public static class ByRef extends MetaschemeSettingStruct implements Structure.ByReference {}
   647 		public static class ByRef extends MetaschemeSettingStruct implements Structure.ByReference {}
   630 		private static String[] FIELD_ORDER = new String[] {"name", "engineCommand", "maxMeansInfinity", "times1000", "min", "max", "def"};
   648 		
   631 		
   649 		public MetaschemeSettingStruct() { super(); }
   632 		public MetaschemeSettingStruct() { super(); setFieldOrder(FIELD_ORDER); }
   650 		public MetaschemeSettingStruct(Pointer ptr) { super(ptr); }
   633 		public MetaschemeSettingStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   651 		
       
   652 		@Override
       
   653 		protected List<String> getFieldOrder() {
       
   654 			return Arrays.asList("name", "engineCommand", "maxMeansInfinity", "times1000", "min", "max", "def");
       
   655 		}
   634 		
   656 		
   635 		public void fillFrom(Setting setting) {
   657 		public void fillFrom(Setting setting) {
   636 			name = setting.name;
   658 			name = setting.name;
   637 			engineCommand = setting.engineCommand;
   659 			engineCommand = setting.engineCommand;
   638 			maxMeansInfinity = setting.maxMeansInfinity;
   660 			maxMeansInfinity = setting.maxMeansInfinity;
   656 	}
   678 	}
   657 	
   679 	
   658 	static class MetaschemeModStruct extends Structure {
   680 	static class MetaschemeModStruct extends Structure {
   659 		public static class ByVal extends MetaschemeModStruct implements Structure.ByValue {}
   681 		public static class ByVal extends MetaschemeModStruct implements Structure.ByValue {}
   660 		public static class ByRef extends MetaschemeModStruct implements Structure.ByReference {}
   682 		public static class ByRef extends MetaschemeModStruct implements Structure.ByReference {}
   661 		private static String[] FIELD_ORDER = new String[] {"name", "bitmaskIndex"};
   683 		
   662 		
   684 		public MetaschemeModStruct() { super(); }
   663 		public MetaschemeModStruct() { super(); setFieldOrder(FIELD_ORDER); }
   685 		public MetaschemeModStruct(Pointer ptr) { super(ptr); }
   664 		public MetaschemeModStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   686 		
       
   687 		@Override
       
   688 		protected List<String> getFieldOrder() {
       
   689 			return Arrays.asList("name", "bitmaskIndex");
       
   690 		}
   665 		
   691 		
   666 		public void fillFrom(Mod mod) {
   692 		public void fillFrom(Mod mod) {
   667 			name = mod.name;
   693 			name = mod.name;
   668 			bitmaskIndex = mod.bitmaskIndex;
   694 			bitmaskIndex = mod.bitmaskIndex;
   669 		}
   695 		}
   679 	
   705 	
   680 	static class MetaschemeStruct extends Structure {
   706 	static class MetaschemeStruct extends Structure {
   681 		public static class ByVal extends MetaschemeStruct implements Structure.ByValue {}
   707 		public static class ByVal extends MetaschemeStruct implements Structure.ByValue {}
   682 		public static class ByRef extends MetaschemeStruct implements Structure.ByReference {}
   708 		public static class ByRef extends MetaschemeStruct implements Structure.ByReference {}
   683 
   709 
   684 		private static String[] FIELD_ORDER = new String[] {"settingCount", "modCount", "settings", "mods"};
   710 		public MetaschemeStruct() { super(); }
   685 		
   711 		public MetaschemeStruct(Pointer ptr) { super(ptr); }
   686 		public MetaschemeStruct() { super(); setFieldOrder(FIELD_ORDER); }
   712 		
   687 		public MetaschemeStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   713 		@Override
       
   714 		protected List<String> getFieldOrder() {
       
   715 			return Arrays.asList("settingCount", "modCount", "settings", "mods");
       
   716 		}
   688 		
   717 		
   689 		/**
   718 		/**
   690 		 * Only use on native-owned structs!
   719 		 * Only use on native-owned structs!
   691 		 * Calling this method on a Java-owned struct could cause garbage collection of referenced
   720 		 * Calling this method on a Java-owned struct could cause garbage collection of referenced
   692 		 * structures.
   721 		 * structures.
   718 	}
   747 	}
   719 	
   748 	
   720 	static class SchemeStruct extends Structure {
   749 	static class SchemeStruct extends Structure {
   721 		public static class ByVal extends SchemeStruct implements Structure.ByValue {}
   750 		public static class ByVal extends SchemeStruct implements Structure.ByValue {}
   722 		public static class ByRef extends SchemeStruct implements Structure.ByReference {}
   751 		public static class ByRef extends SchemeStruct implements Structure.ByReference {}
   723 		private static String[] FIELD_ORDER = new String[] {"name", "settings", "mod"};
   752 		
   724 		
   753 		public SchemeStruct() { super(); }
   725 		public SchemeStruct() { super(); setFieldOrder(FIELD_ORDER); }
   754 		public SchemeStruct(Pointer ptr) { super(ptr); }
   726 		public SchemeStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   755 		
       
   756 		@Override
       
   757 		protected List<String> getFieldOrder() {
       
   758 			return Arrays.asList("name", "settings", "mods");
       
   759 		}
   727 		
   760 		
   728 		public void fillFrom(Scheme scheme) {
   761 		public void fillFrom(Scheme scheme) {
   729 			MetaScheme meta = MetaScheme.INSTANCE;
   762 			MetaScheme meta = MetaScheme.INSTANCE;
   730 			name = scheme.name;
   763 			name = scheme.name;
   731 			settings = new Memory(AndroidTypeMapper.NATIVE_INT_SIZE * meta.settings.size());
   764 			settings = new Memory(AndroidTypeMapper.NATIVE_INT_SIZE * meta.settings.size());
   760 	
   793 	
   761 	/**
   794 	/**
   762 	 * Represents a flib_scheme*, for use as part of a flib_scheme**
   795 	 * Represents a flib_scheme*, for use as part of a flib_scheme**
   763 	 */
   796 	 */
   764 	static class SchemePointerByReference extends Structure implements Structure.ByReference {
   797 	static class SchemePointerByReference extends Structure implements Structure.ByReference {
   765 		private static String[] FIELD_ORDER = new String[] {"scheme"};
   798 		public SchemePointerByReference() { super(); }
   766 		
   799 		public SchemePointerByReference(Pointer ptr) { super(ptr); }
   767 		public SchemePointerByReference() { super(); setFieldOrder(FIELD_ORDER); }
   800 		
   768 		public SchemePointerByReference(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   801 		@Override
       
   802 		protected List<String> getFieldOrder() {
       
   803 			return Arrays.asList("scheme");
       
   804 		}
   769 		
   805 		
   770 		public SchemeStruct.ByRef scheme;
   806 		public SchemeStruct.ByRef scheme;
   771 	}
   807 	}
   772 	
   808 	
   773 	static class SchemelistStruct extends Structure {
   809 	static class SchemelistStruct extends Structure {
   774 		public static class ByVal extends SchemelistStruct implements Structure.ByValue {}
   810 		public static class ByVal extends SchemelistStruct implements Structure.ByValue {}
   775 		public static class ByRef extends SchemelistStruct implements Structure.ByReference {}
   811 		public static class ByRef extends SchemelistStruct implements Structure.ByReference {}
   776 		private static String[] FIELD_ORDER = new String[] {"schemeCount", "schemes"};
   812 		
   777 		
   813 		public SchemelistStruct() { super(); }
   778 		public SchemelistStruct() { super(); setFieldOrder(FIELD_ORDER); }
   814 		public SchemelistStruct(Pointer ptr) { super(ptr); }
   779 		public SchemelistStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   815 		
       
   816 		@Override
       
   817 		protected List<String> getFieldOrder() {
       
   818 			return Arrays.asList("schemeCount", "schemes");
       
   819 		}
   780 		
   820 		
   781 		public void fillFrom(List<Scheme> schemeList) {
   821 		public void fillFrom(List<Scheme> schemeList) {
   782 			schemeCount = schemeList.size();
   822 			schemeCount = schemeList.size();
   783 			if(schemeCount<=0) {
   823 			if(schemeCount<=0) {
   784 				schemes = null;
   824 				schemes = null;
   821 	
   861 	
   822 	/**
   862 	/**
   823 	 * Represents a flib_team*, for use as part of a flib_team**
   863 	 * Represents a flib_team*, for use as part of a flib_team**
   824 	 */
   864 	 */
   825 	static class TeamPointerByReference extends Structure implements Structure.ByReference {
   865 	static class TeamPointerByReference extends Structure implements Structure.ByReference {
   826 		private static String[] FIELD_ORDER = new String[] {"team"};
   866 		public TeamPointerByReference() { super(); }
   827 		
   867 		public TeamPointerByReference(Pointer ptr) { super(ptr); }
   828 		public TeamPointerByReference() { super(); setFieldOrder(FIELD_ORDER); }
   868 		
   829 		public TeamPointerByReference(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   869 		@Override
       
   870 		protected List<String> getFieldOrder() {
       
   871 			return Arrays.asList("team");
       
   872 		}
   830 		
   873 		
   831 		public TeamStruct.ByRef team;
   874 		public TeamStruct.ByRef team;
   832 	}
   875 	}
   833 	
   876 	
   834 	static class TeamlistStruct extends Structure {
   877 	static class TeamlistStruct extends Structure {
   835 		public static class ByVal extends TeamlistStruct implements Structure.ByValue {}
   878 		public static class ByVal extends TeamlistStruct implements Structure.ByValue {}
   836 		public static class ByRef extends TeamlistStruct implements Structure.ByReference {}
   879 		public static class ByRef extends TeamlistStruct implements Structure.ByReference {}
   837 
   880 
   838 		private static String[] FIELD_ORDER = new String[] {"teamCount", "teams"};
   881 		public TeamlistStruct() { super(); }
   839 		
   882 		public TeamlistStruct(Pointer ptr) { super(ptr); }
   840 		public TeamlistStruct() { super(); setFieldOrder(FIELD_ORDER); }
   883 		
   841 		public TeamlistStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   884 		@Override
       
   885 		protected List<String> getFieldOrder() {
       
   886 			return Arrays.asList("teamCount", "teams");
       
   887 		}
   842 		
   888 		
   843 		public void fillFrom(List<TeamInGame> teamList, WeaponsetStruct.ByRef weaponset, int initialHealth) {
   889 		public void fillFrom(List<TeamInGame> teamList, WeaponsetStruct.ByRef weaponset, int initialHealth) {
   844 			teamCount = teamList.size();
   890 			teamCount = teamList.size();
   845 			if(teamCount <= 0) {
   891 			if(teamCount <= 0) {
   846 				teams = null;
   892 				teams = null;
   876 	}
   922 	}
   877 	
   923 	
   878 	static class GameSetupStruct extends Structure {
   924 	static class GameSetupStruct extends Structure {
   879 		public static class ByVal extends GameSetupStruct implements Structure.ByValue {}
   925 		public static class ByVal extends GameSetupStruct implements Structure.ByValue {}
   880 		public static class ByRef extends GameSetupStruct implements Structure.ByReference {}
   926 		public static class ByRef extends GameSetupStruct implements Structure.ByReference {}
   881 		private static String[] FIELD_ORDER = new String[] {"script", "gamescheme", "map", "teamlist"};
   927 		
   882 		
   928 		public GameSetupStruct() { super(); }
   883 		public GameSetupStruct() { super(); setFieldOrder(FIELD_ORDER); }
   929 		public GameSetupStruct(Pointer ptr) { super(ptr); }
   884 		public GameSetupStruct(Pointer ptr) { super(ptr); setFieldOrder(FIELD_ORDER); }
   930 		
       
   931 		@Override
       
   932 		protected List<String> getFieldOrder() {
       
   933 			return Arrays.asList("script", "gamescheme", "map", "teamlist");
       
   934 		}
   885 		
   935 		
   886 		public void fillFrom(GameConfig conf) {
   936 		public void fillFrom(GameConfig conf) {
   887 			script = conf.style;
   937 			script = conf.style;
   888 			gamescheme = new SchemeStruct.ByRef();
   938 			gamescheme = new SchemeStruct.ByRef();
   889 			gamescheme.fillFrom(conf.scheme);
   939 			gamescheme.fillFrom(conf.scheme);