Changeset b7b11c8


Ignore:
Timestamp:
Aug 12, 2010, 4:38:52 PM (8 years ago)
Author:
Michael Seifert <mseifert@…>
Branches:
master
Children:
d7753e6
Parents:
d2b3ddf
Message:

WARNING: Revision is not functioning!
Improved debug output for unsupported replays;
Updated MPQParser dependency of the sc2replay module;
Added replay version of SC2Replay files saved by the Starcraft 2 retail version to the list of supported versions of version 2 replays;
Added support for move screen actions of the new replay version

Files:
1 added
9 edited
1 moved

Legend:

Unmodified
Added
Removed
  • core/src/main/java/de/erichseifert/warp/core/DataPresenter.java

    rd2b3ddf rb7b11c8  
    9191                                // Parse replay
    9292                                Replay replay = null;
     93                                String replayVersion = null;
    9394                                for (ReplayParser<?> parser : parsers) {
    9495                                                try {
    95                                                         if (parser.isSupported(replayFile)) {
     96                                                        replayVersion = parser.getVersion(replayFile);
     97                                                        if (parser.isSupported(replayVersion)) {
    9698                                                                replay = parser.getReplay(replayFile);
    9799                                                                break;
     
    104106
    105107                                if (replay == null) {
    106                                         System.err.println("No suitable parser for file "+replayFile.getAbsolutePath());
     108                                        System.err.printf("No suitable parser for file %s (version=\"%s\")", replayFile.getAbsolutePath(), replayVersion);
    107109                                        elementsTotal--;
    108110                                }
  • core/src/main/java/de/erichseifert/warp/core/replay/ReplayParser.java

    rd2b3ddf rb7b11c8  
    3232
    3333        boolean isSupported(File file) throws IOException;
     34        boolean isSupported(String version) throws IOException;
     35
     36        String getVersion(File file) throws IOException;
    3437}
  • sc2replay/pom.xml

    rd2b3ddf rb7b11c8  
    2020      <groupId>de.erichseifert.mpqparser</groupId>
    2121      <artifactId>MPQParser</artifactId>
    22       <version>0.2</version>
     22      <version>0.3-SNAPSHOT</version>
    2323    </dependency>
    2424    <dependency>
  • sc2replay/src/main/java/de/erichseifert/warp/sc2replay/SC2ReplayDetail.java

    rd2b3ddf rb7b11c8  
    2222package de.erichseifert.warp.sc2replay;
    2323
    24 import java.awt.Color;
    2524import java.io.IOException;
    2625import java.nio.ByteBuffer;
     
    2827import java.util.List;
    2928
    30 import de.erichseifert.warp.sc2replay.util.DataBlock;
     29import de.erichseifert.warp.sc2replay.util.DataStruct;
    3130import de.erichseifert.warp.sc2replay.util.SC2ReplayUtil;
    3231
     
    3534
    3635        public SC2ReplayDetail(ByteBuffer src) {
    37                 DataBlock data = null;
     36                DataStruct data = null;
    3837                try {
    39                         data = SC2ReplayUtil.readDataBlock(src);
     38                        data = SC2ReplayUtil.readDataStruct(src);
    4039                } catch (IOException e) {
    4140                        // TODO Auto-generated catch block
     
    4544                players = new LinkedList<SC2Player>();
    4645
    47                 DataBlock playerData = data.getDataBlock(0);
     46                DataStruct playerData = data.getDataStruct(0);
    4847                for (int playerIndex = 0; playerIndex < playerData.size(); playerIndex++) {
    49                         DataBlock playerInfo = playerData.getDataBlock(playerIndex);
    50                         String name = playerInfo.getDataBlock(0).getString();
    51                         DataBlock playerDetails = playerInfo.getDataBlock(1);
    52                         String raceLocalized = playerInfo.getDataBlock(2).getString();
    53                         DataBlock colorMap = playerInfo.getDataBlock(3);
     48                        DataStruct playerInfo = playerData.getDataStruct(playerIndex);
     49                        String name = playerInfo.getDataStruct(0).getString();
     50                        DataStruct playerDetails = playerInfo.getDataStruct(1);
     51                        String raceLocalized = playerInfo.getDataStruct(2).getString();
     52                        DataStruct colorMap = playerInfo.getDataStruct(3);
    5453
    55                         Color color = new Color(
    56                                 colorMap.getDataBlock(1).getInt(),
    57                                 colorMap.getDataBlock(2).getInt(),
    58                                 colorMap.getDataBlock(3).getInt(),
    59                                 colorMap.getDataBlock(0).getInt()
     54                        /*Color color = new Color(
     55                                colorMap.getDataStruct(1).getInt(),
     56                                colorMap.getDataStruct(2).getInt(),
     57                                colorMap.getDataStruct(3).getInt(),
     58                                colorMap.getDataStruct(0).getInt()
    6059                        );
    6160                        if (!name.isEmpty()) {
    6261                                SC2Player player = new SC2Player(name);
    63                                 player.setRealID(playerDetails.getDataBlock(3).getString());
     62                                player.setRealID(playerDetails.getDataStruct(3).getString());
    6463                                player.setRace(raceLocalized);
    6564                                player.setColor(color);
    6665                                players.add(player);
    67                         }
     66                        }*/
    6867                }
    6968        }
  • sc2replay/src/main/java/de/erichseifert/warp/sc2replay/SC2ReplayParser.java

    rd2b3ddf rb7b11c8  
    4141        @Override
    4242        public boolean isSupported(File file) throws IOException {
     43                String version = getVersion(file);
     44                return isSupported(version);
     45        }
     46
     47        @Override
     48        public boolean isSupported(String version) throws IOException {
     49                return isVersionSupported(getClass(), version);
     50        }
     51
     52        @Override
     53        public String getVersion(File file) throws IOException {
    4354                RandomAccessFile raf = new RandomAccessFile(file, "r");
    4455                FileChannel fileChannel = raf.getChannel();
     
    4960                src.position(src.position()+39);
    5061                String version = src.get()+"."+src.get()+"."+src.get()+"."+src.getInt();
    51                 return isVersionSupported(getClass(), version);
     62                fileChannel.close();
     63                raf.close();
     64                return version;
    5265        }
    5366}
  • sc2replay/src/main/java/de/erichseifert/warp/sc2replay/SC2ReplayParser_v2.java

    rd2b3ddf rb7b11c8  
    5151                addVersionSupport(SC2ReplayParser_v2.class, "0.16.0.15580");
    5252                addVersionSupport(SC2ReplayParser_v2.class, "0.17.0.15623");
     53                addVersionSupport(SC2ReplayParser_v2.class, "121.27.49.822215948");
    5354        }
    5455
  • sc2replay/src/main/java/de/erichseifert/warp/sc2replay/actions/SC2ActionFactory.java

    rd2b3ddf rb7b11c8  
    3939        private static final byte CODE_ENTER_GAME = 0x0B;
    4040        private static final byte CODE_MOVE_SCREEN = (byte) 0x81;
     41        private static final byte CODE_MOVE_SCREEN_2 = 0x01;
    4142        private static final byte CODE_UNKNOWN3 = (byte) 0x89;
    4243        private static final byte CODE_SELECT = (byte) 0xAC;
     
    7576                        //System.out.println("Group action: offset="+pos+", length="+(src.position()-pos)+" bytes");
    7677                }
    77                 else if (code == CODE_MOVE_SCREEN) {
     78                /*else if (code == CODE_MOVE_SCREEN) {
    7879                        action = new MoveScreen(timeStamp, eventTypeCode, globalEvent, playerIndex, src);
    7980                        //System.out.println("Move screen action: offset="+pos+", length="+(src.position()-pos)+" bytes");
    80                 }
     81                }*/
    8182                else if (code == CODE_SELECT) {
    8283                        action = new Select(timeStamp, eventTypeCode, globalEvent, playerIndex, src);
     
    118119                        action = new StartGame(timeStamp, eventTypeCode, globalEvent, playerIndex);
    119120                }
     121                else if ((code & 0x0F) == CODE_MOVE_SCREEN_2) {
     122                        action = new MoveScreen_2(timeStamp, eventTypeCode, globalEvent, playerIndex, src);
     123                        //System.out.println("Move screen action: offset="+pos+", length="+(src.position()-pos)+" bytes");
     124                }
    120125                else {
    121126                        System.err.println("Unknown action code: 0x"+Integer.toHexString(code)+" ("+code+"), position: "+src.position());
    122                         System.exit(-1);
    123127                }
    124128                return action;
  • sc2replay/src/main/java/de/erichseifert/warp/sc2replay/util/DataStruct.java

    rd2b3ddf rb7b11c8  
    2424import java.util.Map;
    2525
    26 public class DataBlock {
     26public class DataStruct {
    2727        private Object data;
    2828
    29         protected DataBlock() {
     29        protected DataStruct() {
    3030        }
    3131
     
    4242        }
    4343
    44         public DataBlock getDataBlock(int index) {
     44        public DataStruct getDataStruct(int index) {
    4545                if (data instanceof Map<?, ?>) {
    46                         return ((Map<Integer, DataBlock>)data).get(index);
     46                        return ((Map<Integer, DataStruct>)data).get(index);
    4747                }
    48                 else if (data instanceof DataBlock[]) {
    49                         return ((DataBlock[]) data)[index];
     48                else if (data instanceof DataStruct[]) {
     49                        return ((DataStruct[]) data)[index];
    5050                }
    5151                return null;
     
    7373        public int size() {
    7474                if (data instanceof Map<?, ?>) {
    75                         return ((Map<Integer, DataBlock>)data).size();
     75                        return ((Map<Integer, DataStruct>)data).size();
    7676                }
    77                 else if (data instanceof DataBlock[]) {
    78                         return ((DataBlock[]) data).length;
     77                else if (data instanceof DataStruct[]) {
     78                        return ((DataStruct[]) data).length;
    7979                }
    8080                return 1;
  • sc2replay/src/main/java/de/erichseifert/warp/sc2replay/util/SC2ReplayUtil.java

    rd2b3ddf rb7b11c8  
    8282        }
    8383
    84         public static DataBlock readDataBlock(ByteBuffer src) throws IOException {
    85                 DataBlock block = new DataBlock();
     84        public static DataStruct readDataStruct(ByteBuffer src) throws IOException {
     85                DataStruct block = new DataStruct();
    8686                byte type = src.get();
    8787                if (type == TYPE_BINARY) {
     
    9898                        }
    9999                        int size = (int) readNumber(src);
    100                         DataBlock[] data = new DataBlock[size];
     100                        DataStruct[] data = new DataStruct[size];
    101101                        for (int i = 0; i < data.length; i++) {
    102                                 data[i] = readDataBlock(src);
     102                                data[i] = readDataStruct(src);
    103103                        }
    104104                        block.setData(data);
     
    106106                else if (type == TYPE_MAP) {
    107107                        int size = (int) readNumber(src);
    108                         Map<Integer, DataBlock> data = new LinkedHashMap<Integer, DataBlock>(size);
     108                        Map<Integer, DataStruct> data = new LinkedHashMap<Integer, DataStruct>(size);
    109109                        for (int i = 0; i < size; i++) {
    110110                                int index = (int) readNumber(src);
    111                                 DataBlock element = readDataBlock(src);
     111                                DataStruct element = readDataStruct(src);
    112112                                data.put(index, element);
    113113                        }
     
    132132        }
    133133
    134         public static void dumpData(DataBlock block, DataOutputStream dst) throws IOException {
    135                 dumpData(block, dst, 0);
     134        public static void dumpData(DataStruct struct, DataOutputStream dst) throws IOException {
     135                dumpData(struct, dst, 0);
    136136        }
    137137
    138         private static void dumpData(DataBlock block, DataOutputStream dst, int depthCur) throws IOException {
    139                 Object data = block.getData();
     138        private static void dumpData(DataStruct struct, DataOutputStream dst, int depthCur) throws IOException {
     139                Object data = struct.getData();
    140140                if (data instanceof byte[]) {
    141141                        String dataString = new String((byte[]) data);
     
    147147                        depthCur++;
    148148                        indent(dst, depthCur);
    149                         for (DataBlock elem : ((Map<Integer, DataBlock>) data).values()) {
     149                        for (DataStruct elem : ((Map<Integer, DataStruct>) data).values()) {
    150150                                dumpData(elem, dst, depthCur);
    151151                        }
     
    160160                        depthCur++;
    161161                        indent(dst, depthCur);
    162                         for (DataBlock elem : (DataBlock[]) data) {
     162                        for (DataStruct elem : (DataStruct[]) data) {
    163163                                dumpData(elem, dst, depthCur);
    164164                        }
  • sc2replay/src/test/java/de/erichseifert/warp/sc2replay/util/SC2ReplayUtilTest.java

    rd2b3ddf rb7b11c8  
    6868        public void testReadData() throws IOException {
    6969                ByteBuffer buffer = ByteBuffer.wrap(new byte[] {0x02, 0x04, 0x68, 0x69});
    70                 DataBlock result = SC2ReplayUtil.readDataBlock(buffer);
     70                DataStruct result = SC2ReplayUtil.readDataStruct(buffer);
    7171                assertEquals("hi", result.getString());
    7272
    7373                buffer = ByteBuffer.wrap(new byte[] {0x05, 0x02, 0x00, 0x02, 0x04, 0x68, 0x69});
    74                 result = SC2ReplayUtil.readDataBlock(buffer);
    75                 assertEquals("hi", result.getDataBlock(0).getString());
     74                result = SC2ReplayUtil.readDataStruct(buffer);
     75                assertEquals("hi", result.getDataStruct(0).getString());
    7676
    7777                buffer = ByteBuffer.wrap(new byte[] {0x05, 0x04, 0x00, 0x02, 0x04, 0x68, 0x69, 0x02, 0x02, 0x04, 0x68, 0x69});
    78                 result = SC2ReplayUtil.readDataBlock(buffer);
    79                 assertEquals("hi", result.getDataBlock(0).getString());
    80                 assertEquals("hi", result.getDataBlock(1).getString());
     78                result = SC2ReplayUtil.readDataStruct(buffer);
     79                assertEquals("hi", result.getDataStruct(0).getString());
     80                assertEquals("hi", result.getDataStruct(1).getString());
    8181
    8282                buffer = ByteBuffer.wrap(new byte[] {0x05, 0x06, 0x00, 0x09, 0x02, 0x02, 0x09, 0x04, 0x08, 0x09, 0x06});
    83                 result = SC2ReplayUtil.readDataBlock(buffer);
    84                 assertEquals(1l, result.getDataBlock(0).getLong());
    85                 assertEquals(2l, result.getDataBlock(1).getLong());
    86                 assertEquals(null, result.getDataBlock(2));
    87                 assertEquals(null, result.getDataBlock(3));
    88                 assertEquals(3l, result.getDataBlock(4).getLong());
     83                result = SC2ReplayUtil.readDataStruct(buffer);
     84                assertEquals(1l, result.getDataStruct(0).getLong());
     85                assertEquals(2l, result.getDataStruct(1).getLong());
     86                assertEquals(null, result.getDataStruct(2));
     87                assertEquals(null, result.getDataStruct(3));
     88                assertEquals(3l, result.getDataStruct(4).getLong());
    8989        }
    9090}
Note: See TracChangeset for help on using the changeset viewer.