View difference between Paste ID: gQHQv6eV and j1s9rAxE

-package com.digthedipnetonlyclienttest.game.TiledMaps;
+package com.bla.game.TiledMaps;
 
 import com.badlogic.gdx.Gdx;
 import com.badlogic.gdx.assets.loaders.FileHandleResolver;
 import com.badlogic.gdx.files.FileHandle;
 import com.badlogic.gdx.graphics.Texture;
 import com.badlogic.gdx.graphics.g2d.TextureRegion;
 import com.badlogic.gdx.maps.ImageResolver;
 import com.badlogic.gdx.maps.MapProperties;
 import com.badlogic.gdx.maps.tiled.TiledMap;
 import com.badlogic.gdx.maps.tiled.TiledMapTile;
 import com.badlogic.gdx.maps.tiled.TiledMapTileSet;
 import com.badlogic.gdx.maps.tiled.TmxMapLoader;
 import com.badlogic.gdx.maps.tiled.tiles.AnimatedTiledMapTile;
 import com.badlogic.gdx.maps.tiled.tiles.StaticTiledMapTile;
 import com.badlogic.gdx.utils.*;
 
 import java.io.IOException;
 import java.util.StringTokenizer;
 
 /**
  * Created by nooooobz on 29/04/2016.
  */
 public class TmxMapLoaderFromString extends TmxMapLoader
 {
     public TiledMap load (String xmldata)
     {
         return load(xmldata, new TmxMapLoader.Parameters());
     }
 
     public TiledMap load (String xmldata, TmxMapLoader.Parameters parameters) {
         try {
             this.convertObjectToTileSpace = parameters.convertObjectToTileSpace;
             this.flipY = parameters.flipY;
             root = xml.parse(xmldata);
             ObjectMap<String, Texture> textures = new ObjectMap<String, Texture>();
             Array<FileHandle> textureFiles = loadTilesets(root);
             textureFiles.addAll(loadImages(root));
 
             for (FileHandle textureFile : textureFiles) {
                 Texture texture = new Texture(textureFile, parameters.generateMipMaps);
                 texture.setFilter(parameters.textureMinFilter, parameters.textureMagFilter);
                 textures.put(textureFile.path(), texture);
             }
 
             ImageResolver.DirectImageResolver imageResolver = new ImageResolver.DirectImageResolver(textures);
             TiledMap map = loadTilemap(root, null, imageResolver);
             map.setOwnedResources(textures.values().toArray());
             return map;
         } catch (IOException e) {
             throw new GdxRuntimeException("Couldn't load tilemap", e);
         }
     }
 
     protected Array<FileHandle> loadImages (XmlReader.Element root) throws IOException {
         Array<FileHandle> images = new Array<FileHandle>();
 
         for (XmlReader.Element imageLayer : root.getChildrenByName("imagelayer")) {
             XmlReader.Element image = imageLayer.getChildByName("image");
             String source = image.getAttribute("source", null);
 
             if (source != null) {
                 Gdx.app.log("loadImages","source!=null !!");
                 FileHandle handle = getRelativeFileHandle(null, source);
 
                 if (!images.contains(handle, false)) {
                     images.add(handle);
                 }
             }
         }
 
         return images;
     }
 
 
     protected Array<FileHandle> loadTilesets (XmlReader.Element root) throws IOException {
         Array<FileHandle> images = new Array<FileHandle>();
         for (XmlReader.Element tileset : root.getChildrenByName("tileset")) {
             String source = tileset.getAttribute("source", null);
             if (source != null) {
 
                 Gdx.app.log("loadTilesets","source!=null !!");
 
                 FileHandle tsxFile = getRelativeFileHandle(null, source);
                 tileset = xml.parse(tsxFile);
                 XmlReader.Element imageElement = tileset.getChildByName("image");
                 if (imageElement != null) {
                     String imageSource = tileset.getChildByName("image").getAttribute("source");
                     FileHandle image = getRelativeFileHandle(tsxFile, imageSource);
                     images.add(image);
                 } else {
                     for (XmlReader.Element tile : tileset.getChildrenByName("tile")) {
                         String imageSource = tile.getChildByName("image").getAttribute("source");
                         FileHandle image = getRelativeFileHandle(tsxFile, imageSource);
                         images.add(image);
                     }
                 }
             } else {
                 XmlReader.Element imageElement = tileset.getChildByName("image");
                 if (imageElement != null) {
                     String imageSource = tileset.getChildByName("image").getAttribute("source");
                     FileHandle image = Gdx.files.internal(imageSource);;//getRelativeFileHandle(tmxFile, imageSource);
                     images.add(image);
                 } else {
                     Gdx.app.log("loadTilesets","imageElement==null !!");
                     for (XmlReader.Element tile : tileset.getChildrenByName("tile")) {
                         String imageSource = tile.getChildByName("image").getAttribute("source");
                         FileHandle image = getRelativeFileHandle(null, imageSource);
                         images.add(image);
                     }
                 }
             }
         }
         return images;
     }
 
     protected TiledMap loadTilemap (XmlReader.Element root, FileHandle tmxFile, ImageResolver imageResolver) {
         TiledMap map = new TiledMap();
 
         String mapOrientation = root.getAttribute("orientation", null);
         int mapWidth = root.getIntAttribute("width", 0);
         int mapHeight = root.getIntAttribute("height", 0);
         int tileWidth = root.getIntAttribute("tilewidth", 0);
         int tileHeight = root.getIntAttribute("tileheight", 0);
         int hexSideLength = root.getIntAttribute("hexsidelength", 0);
         String staggerAxis = root.getAttribute("staggeraxis", null);
         String staggerIndex = root.getAttribute("staggerindex", null);
         String mapBackgroundColor = root.getAttribute("backgroundcolor", null);
 
         MapProperties mapProperties = map.getProperties();
         if (mapOrientation != null) {
             mapProperties.put("orientation", mapOrientation);
         }
         mapProperties.put("width", mapWidth);
         mapProperties.put("height", mapHeight);
         mapProperties.put("tilewidth", tileWidth);
         mapProperties.put("tileheight", tileHeight);
         mapProperties.put("hexsidelength", hexSideLength);
         if (staggerAxis != null) {
             mapProperties.put("staggeraxis", staggerAxis);
         }
         if (staggerIndex != null) {
             mapProperties.put("staggerindex", staggerIndex);
         }
         if (mapBackgroundColor != null) {
             mapProperties.put("backgroundcolor", mapBackgroundColor);
         }
         mapTileWidth = tileWidth;
         mapTileHeight = tileHeight;
         mapWidthInPixels = mapWidth * tileWidth;
         mapHeightInPixels = mapHeight * tileHeight;
 
         if (mapOrientation != null) {
             if ("staggered".equals(mapOrientation)) {
                 if (mapHeight > 1) {
                     mapWidthInPixels += tileWidth / 2;
                     mapHeightInPixels = mapHeightInPixels / 2 + tileHeight / 2;
                 }
             }
         }
 
         XmlReader.Element properties = root.getChildByName("properties");
         if (properties != null) {
             loadProperties(map.getProperties(), properties);
         }
         Array<XmlReader.Element> tilesets = root.getChildrenByName("tileset");
         for (XmlReader.Element element : tilesets) {
             loadTileSet(map, element, tmxFile, imageResolver);
             root.removeChild(element);
         }
         for (int i = 0, j = root.getChildCount(); i < j; i++) {
             XmlReader.Element element = root.getChild(i);
             String name = element.getName();
             if (name.equals("layer")) {
                 loadTileLayer(map, element);
             } else if (name.equals("objectgroup")) {
                 loadObjectGroup(map, element);
             }
             else if (name.equals("imagelayer")) {
                 loadImageLayer(map, element, tmxFile, imageResolver);
             }
         }
         return map;
     }
 
     protected void loadTileSet (TiledMap map, XmlReader.Element element, FileHandle tmxFile, ImageResolver imageResolver) {
         if (element.getName().equals("tileset")) {
             String name = element.get("name", null);
             int firstgid = element.getIntAttribute("firstgid", 1);
             int tilewidth = element.getIntAttribute("tilewidth", 0);
             int tileheight = element.getIntAttribute("tileheight", 0);
             int spacing = element.getIntAttribute("spacing", 0);
             int margin = element.getIntAttribute("margin", 0);
             String source = element.getAttribute("source", null);
 
             int offsetX = 0;
             int offsetY = 0;
 
             String imageSource = "";
             int imageWidth = 0, imageHeight = 0;
 
             FileHandle image = null;
             if (source != null) {
                 FileHandle tsx = getRelativeFileHandle(tmxFile, source);
                 try {
                     element = xml.parse(tsx);
                     name = element.get("name", null);
                     tilewidth = element.getIntAttribute("tilewidth", 0);
                     tileheight = element.getIntAttribute("tileheight", 0);
                     spacing = element.getIntAttribute("spacing", 0);
                     margin = element.getIntAttribute("margin", 0);
                     XmlReader.Element offset = element.getChildByName("tileoffset");
                     if (offset != null) {
                         offsetX = offset.getIntAttribute("x", 0);
                         offsetY = offset.getIntAttribute("y", 0);
                     }
                     XmlReader.Element imageElement = element.getChildByName("image");
                     if (imageElement != null) {
                         imageSource = imageElement.getAttribute("source");
                         imageWidth = imageElement.getIntAttribute("width", 0);
                         imageHeight = imageElement.getIntAttribute("height", 0);
                         image = getRelativeFileHandle(tsx, imageSource);
                     }
                 } catch (IOException e) {
                     throw new GdxRuntimeException("Error parsing external tileset.");
                 }
             } else {
                 XmlReader.Element offset = element.getChildByName("tileoffset");
                 if (offset != null) {
                     offsetX = offset.getIntAttribute("x", 0);
                     offsetY = offset.getIntAttribute("y", 0);
                 }
                 XmlReader.Element imageElement = element.getChildByName("image");
                 if (imageElement != null) {
                     imageSource = imageElement.getAttribute("source");
                     imageWidth = imageElement.getIntAttribute("width", 0);
                     imageHeight = imageElement.getIntAttribute("height", 0);
                     image = getRelativeFileHandle(tmxFile, imageSource);
                 }
             }
 
             TiledMapTileSet tileset = new TiledMapTileSet();
             tileset.setName(name);
             tileset.getProperties().put("firstgid", firstgid);
             if (image != null) {
                 TextureRegion texture = imageResolver.getImage(image.path());
 
                 MapProperties props = tileset.getProperties();
                 props.put("imagesource", imageSource);
                 props.put("imagewidth", imageWidth);
                 props.put("imageheight", imageHeight);
                 props.put("tilewidth", tilewidth);
                 props.put("tileheight", tileheight);
                 props.put("margin", margin);
                 props.put("spacing", spacing);
 
                 int stopWidth = texture.getRegionWidth() - tilewidth;
                 int stopHeight = texture.getRegionHeight() - tileheight;
 
                 int id = firstgid;
 
                 for (int y = margin; y <= stopHeight; y += tileheight + spacing) {
                     for (int x = margin; x <= stopWidth; x += tilewidth + spacing) {
                         TextureRegion tileRegion = new TextureRegion(texture, x, y, tilewidth, tileheight);
                         TiledMapTile tile = new StaticTiledMapTile(tileRegion);
                         tile.setId(id);
                         tile.setOffsetX(offsetX);
                         tile.setOffsetY(flipY ? -offsetY : offsetY);
                         tileset.putTile(id++, tile);
                     }
                 }
             } else {
                 Array<XmlReader.Element> tileElements = element.getChildrenByName("tile");
                 for (XmlReader.Element tileElement : tileElements) {
                     XmlReader.Element imageElement = tileElement.getChildByName("image");
                     if (imageElement != null) {
                         imageSource = imageElement.getAttribute("source");
                         imageWidth = imageElement.getIntAttribute("width", 0);
                         imageHeight = imageElement.getIntAttribute("height", 0);
                         image = getRelativeFileHandle(tmxFile, imageSource);
                     }
                     TextureRegion texture = imageResolver.getImage(image.path());
                     TiledMapTile tile = new StaticTiledMapTile(texture);
                     tile.setId(firstgid + tileElement.getIntAttribute("id"));
                     tile.setOffsetX(offsetX);
                     tile.setOffsetY(flipY ? -offsetY : offsetY);
                     tileset.putTile(tile.getId(), tile);
                 }
             }
             Array<XmlReader.Element> tileElements = element.getChildrenByName("tile");
 
             Array<AnimatedTiledMapTile> animatedTiles = new Array<AnimatedTiledMapTile>();
 
             for (XmlReader.Element tileElement : tileElements) {
                 int localtid = tileElement.getIntAttribute("id", 0);
                 TiledMapTile tile = tileset.getTile(firstgid + localtid);
                 if (tile != null) {
                     XmlReader.Element animationElement = tileElement.getChildByName("animation");
                     if (animationElement != null) {
 
                         Array<StaticTiledMapTile> staticTiles = new Array<StaticTiledMapTile>();
                         IntArray intervals = new IntArray();
                         for (XmlReader.Element frameElement: animationElement.getChildrenByName("frame")) {
                             staticTiles.add((StaticTiledMapTile) tileset.getTile(firstgid + frameElement.getIntAttribute("tileid")));
                             intervals.add(frameElement.getIntAttribute("duration"));
                         }
 
                         AnimatedTiledMapTile animatedTile = new AnimatedTiledMapTile(intervals, staticTiles);
                         animatedTile.setId(tile.getId());
                         animatedTiles.add(animatedTile);
                         tile = animatedTile;
                     }
 
                     String terrain = tileElement.getAttribute("terrain", null);
                     if (terrain != null) {
                         tile.getProperties().put("terrain", terrain);
                     }
                     String probability = tileElement.getAttribute("probability", null);
                     if (probability != null) {
                         tile.getProperties().put("probability", probability);
                     }
                     XmlReader.Element properties = tileElement.getChildByName("properties");
                     if (properties != null) {
                         loadProperties(tile.getProperties(), properties);
                     }
                 }
             }
 
             for (AnimatedTiledMapTile tile : animatedTiles) {
                 tileset.putTile(tile.getId(), tile);
             }
 
             XmlReader.Element properties = element.getChildByName("properties");
             if (properties != null) {
                 loadProperties(tileset.getProperties(), properties);
             }
             map.getTileSets().addTileSet(tileset);
         }
     }
 
     protected static FileHandle getRelativeFileHandle (FileHandle file, String path)
     {
         FileHandle result = Gdx.files.internal(path);
         return result;
     }
 }