public Font(final Application APP,String fileName,String filePath,int size,boolean filter)
{
    // ASSIGN ATTRIBUTES
    this.size = size;

    FreetypeFontLoader.FreeTypeFontLoaderParameter parameter = new FreetypeFontLoader.FreeTypeFontLoaderParameter();
    FileHandleResolver resolver = new InternalFileHandleResolver();

    APP.assets.setLoader(FreeTypeFontGenerator.class,new FreeTypeFontGeneratorLoader(resolver));
    APP.assets.setLoader(BitmapFont.class,".otf",new FreetypeFontLoader(resolver));

    // GENERATE FONT
    if (filter) // IF FILTER ENABLED
    {
        parameter.fontParameters.genMipMaps = true;
        parameter.fontParameters.minFilter = Texture.TextureFilter.Linear;
        parameter.fontParameters.magFilter = Texture.TextureFilter.Linear;
    }
    parameter.fontFileName = filePath;
    parameter.fontParameters.size = size;

    APP.assets.load(fileName,BitmapFont.class,parameter);
    APP.assets.finishLoading();

    font = APP.assets.get(fileName,BitmapFont.class);
}

@Override
public FileHandleResolver newResolver (FileType fileType) {
    switch (fileType) {
    case Absolute:
        return new AbsoluteFileHandleResolver();
    case Classpath:
        return new ClasspathFileHandleResolver();
    case External:
        return new ExternalFileHandleResolver();
    case Internal:
        return new InternalFileHandleResolver();
    case Local:
        return new LocalFileHandleResolver();
    }
    return null; // Should never happen
}

/** Loads the specified scene as the current Scene
 * 
 * @param scenestring - the Scene to load */
public void loadState (final String scenestring) {
    String scenePath = getAssetManager().getAssetFileName(RavTech.currentScene);
    RavTech.currentScene.dispose();
    getAssetManager().unload(scenePath);
    getAssetManager().setLoader(Scene.class,new SceneLoader(new FileHandleResolver() {
        @Override
        public FileHandle resolve (String fileName) {
            return new FileHandle() {
                @Override
                public String readString () {
                    return scenestring;
                }
            };
        }
    }));
    loadAsset(scenePath,Scene.class);
    finishLoading();
    RavTech.currentScene = getAsset(scenePath,Scene.class);
    getAssetManager().setLoader(Scene.class,new SceneLoader(getResolver()));
}

/** Creates a new AssetManager with all default loaders. */
public AssetManager (FileHandleResolver resolver) {
    setLoader(BitmapFont.class,new BitmapFontLoader(resolver));
    setLoader(Music.class,new MusicLoader(resolver));
    setLoader(pixmap.class,new pixmapLoader(resolver));
    setLoader(Sound.class,new SoundLoader(resolver));
    setLoader(TextureAtlas.class,new TextureAtlasLoader(resolver));
    setLoader(Texture.class,new TextureLoader(resolver));
    setLoader(Skin.class,new SkinLoader(resolver));
    setLoader(ParticleEffect.class,new ParticleEffectLoader(resolver));
    setLoader(polygonRegion.class,new polygonRegionLoader(resolver));
    setLoader(I18NBundle.class,new I18NBundleLoader(resolver));
    setLoader(Model.class,".g3dj",new G3dModelLoader(new JsonReader(),resolver));
    setLoader(Model.class,".g3db",new G3dModelLoader(new UBJsonReader(),".obj",new ObjLoader(resolver));
    executor = new AsyncExecutor(1);
}

public void load(AssetManager assetManager) {
    background.load(assetManager);
    fish1.load(assetManager);
    fish2.load(assetManager);
    fish3.load(assetManager);
    fish4.load(assetManager);
    fish5.load(assetManager);
    fish6.load(assetManager);
    fish7.load(assetManager);
    fish8.load(assetManager);
    fish9.load(assetManager);
    fish10.load(assetManager);
    assetManager.load(AppConst.EXIT_BUTTON_TEXTURE,Texture.class);
    assetManager.load(AppConst.ADD_FISH_BUTTON_TEXTURE,Texture.class);
    assetManager.load(AppConst.SELECT_FISH_BUTTONS_TEXTURE,Texture.class);
    assetManager.load(AppConst.SELECT_TRAJECTORY_TEXTURE,Texture.class);
    FileHandleResolver resolver = new InternalFileHandleResolver();
    assetManager.setLoader(FreeTypeFontGenerator.class,new FreeTypeFontGeneratorLoader(resolver));
    assetManager.setLoader(BitmapFont.class,".ttf",new FreetypeFontLoader(resolver));
    FreeTypeFontLoaderParameter size1Params = new FreeTypeFontLoaderParameter();
    size1Params.fontFileName = AppConst.DEFAUFT_FONT;
    size1Params.fontParameters.size =  AppConst.KEY_FONT_SIZE;
    assetManager.load(AppConst.KEY_FONT_NAME,size1Params);
}

@Override
public FileHandleResolver newResolver (FileType fileType) {
    switch (fileType) {
    case Absolute:
        return new AbsoluteFileHandleResolver();
    case Classpath:
        return new ClasspathFileHandleResolver();
    case External:
        return new ExternalFileHandleResolver();
    case Internal:
        return new InternalFileHandleResolver();
    case Local:
        return new LocalFileHandleResolver();
    }
    return null; // Should never happen
}

@Override
public void prepareAssets(UiTheme theme,FileHandleResolver fileHandleResolver,AssetManager assetManager) {
    if (theme.isHeadless()) {
        return; 
    }
    super.prepareAssets(theme,fileHandleResolver,assetManager);

    if(sliderBar != null) {
        sliderBarNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(sliderBar)),sliderBarNinePatchLeft,sliderBarNinePatchRight,sliderBarNinePatchTop,sliderBarNinePatchBottom);
    }
    normalTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(normal));
    activeTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(active));
    hoverTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(hover));
    disabledTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(disabled));
}

@Override
public void prepareAssets(UiTheme theme,AssetManager assetManager) {
    if (theme.isHeadless()) {
        return; 
    }

    if(background != null) {
        if(getBackgroundMode().equalsIgnoreCase(BG_REPEAT_MODE)) {
            backgroundNinePatch = new RepeatedninePatch(new TextureRegion(theme.getTextureAtlas().findRegion(background)),getNinePatchLeft(),getNinePatchRight(),getNinePatchTop(),getNinePatchBottom());
        } else {
            backgroundNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(background)),getNinePatchBottom());
        }
    }
}

@Override
public void prepareAssets(UiTheme theme,AssetManager assetManager) {
    if (theme.isHeadless()) {
        return; 
    }

    normalNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(normal)),getPaddingLeft(),getPaddingRight(),getPaddingTop(),getPaddingBottom());
    hoverNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(hover)),getPaddingBottom());
    actionNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(action)),getPaddingBottom());
    disabledninePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(disabled)),getPaddingBottom());
    color = ColorUtils.rgbToColor(textColor);

    UiFont themeFont = theme.getFont(font);
    FreeTypeFontParameter fontParameter = new  FreeTypeFontParameter();
    fontParameter.size = fontSize;
    fontParameter.flip = true;
    if(themeFont.getBorderWidth() > 0) {
        fontParameter.borderWidth = themeFont.getBorderWidth();
        fontParameter.borderColor = themeFont.getFontBorderColor();
    }
    bitmapFont = themeFont.generateFont(fontParameter);
}

@Override
public void prepareAssets(UiTheme theme,AssetManager assetManager) {
    if (theme.isHeadless()) {
        return; 
    }

    super.prepareAssets(theme,assetManager);
    if(textColor != null) {
        color = ColorUtils.rgbToColor(textColor);
    }

    UiFont themeFont = theme.getFont(font);
    FreeTypeFontParameter fontParameter = new  FreeTypeFontParameter();
    fontParameter.size = fontSize;
    fontParameter.flip = true;
    if(themeFont.getBorderWidth() > 0) {
        fontParameter.borderWidth = themeFont.getBorderWidth();
        fontParameter.borderColor = themeFont.getFontBorderColor();
    }
    bitmapFont = themeFont.generateFont(fontParameter);
}

@Override
public void prepareAssets(UiTheme theme,assetManager);
    scrollTrackNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(scrollTrack)),scrollTrackNinePatchLeft,scrollTrackNinePatchRight,scrollTrackNinePatchTop,scrollTrackNinePatchBottom);

    scrollThumbnormalNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(scrollThumbnormal)),scrollThumbNinePatchLeft,scrollThumbNinePatchRight,scrollThumbNinePatchTop,scrollThumbNinePatchBottom);
    scrollThumbHoverNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(scrollThumbHover)),scrollThumbNinePatchBottom);
    scrollThumbActiveNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(scrollThumbAction)),scrollThumbNinePatchBottom);
}

public void init(Nhg nhg) {
    this.nhg = nhg;
    fsm = new DefaultStateMachine<>(this,Assetsstates.IDLE);

    assetManager = new AssetManager();
    syncAssetManager = new AssetManager();

    FileHandleResolver resolver = assetManager.getFileHandleResolver();
    FileHandleResolver syncResolver = syncAssetManager.getFileHandleResolver();

    assetManager.setLoader(Scene.class,new SceneLoader(nhg,resolver));
    assetManager.setLoader(InputProxy.class,new InputLoader(resolver));
    assetManager.setLoader(JsonValue.class,new JsonLoader(resolver));
    assetManager.setLoader(HDRData2.class,new HDRLoader(resolver));
    assetManager.setLoader(Model.class,new NhgG3dModelLoader(this,new UBJsonReader(),resolver));

    syncAssetManager.setLoader(Scene.class,syncResolver));
    syncAssetManager.setLoader(InputProxy.class,new InputLoader(syncResolver));
    syncAssetManager.setLoader(JsonValue.class,new JsonLoader(syncResolver));
    syncAssetManager.setLoader(HDRData2.class,new HDRLoader(syncResolver));
    syncAssetManager.setLoader(Model.class,syncResolver));

    assetManager.setErrorListener(this);
    syncAssetManager.setErrorListener(this);

    assetQueue = new Array<>();
    assetCache = new ArrayMap<>();

    Texture.setAssetManager(assetManager);
}

public Font(final Application APP,Color color,boolean filter)
{
    // ASSIGN ATTRIBUTES
    this.size = size;
    this.color = color;

    FreetypeFontLoader.FreeTypeFontLoaderParameter parameter = new FreetypeFontLoader.FreeTypeFontLoaderParameter();
    FileHandleResolver resolver = new InternalFileHandleResolver();

    APP.assets.setLoader(FreeTypeFontGenerator.class,new FreetypeFontLoader(resolver));

    // GENERATE FONT
    if (filter) // IF FILTER ENABLED
    {
        parameter.fontParameters.genMipMaps = true;
        parameter.fontParameters.minFilter = Texture.TextureFilter.Linear;
        parameter.fontParameters.magFilter = Texture.TextureFilter.Linear;
    }
    parameter.fontFileName = filePath;
    parameter.fontParameters.size = size;
    parameter.fontParameters.color = color;

    APP.assets.load(fileName,BitmapFont.class);
}

public Font(final Application APP,Color borderColor,float borderWidth,new FreetypeFontLoader(resolver));

    // GENERATE FONT
    if (filter) // IF FILTER ENABLED
    {
        parameter.fontParameters.genMipMaps = true;
        parameter.fontParameters.minFilter = Texture.TextureFilter.Linear;
        parameter.fontParameters.magFilter = Texture.TextureFilter.Linear;
    }
    parameter.fontFileName = filePath;
    parameter.fontParameters.size = size;
    parameter.fontParameters.color = color;
    parameter.fontParameters.borderColor = borderColor;
    parameter.fontParameters.borderWidth = borderWidth;

    APP.assets.load(fileName,BitmapFont.class);
}

@SuppressWarnings("rawtypes")
    private BehaviorTreeLibrary (FileHandleResolver resolver,AssetManager assetManager,int parseDebugLevel) {
        this.resolver = resolver;
//      this.assetManager = assetManager;
        this.repository = new ObjectMap<String,BehaviorTree<?>>();
        this.parser = new BehaviorTreeParser(parseDebugLevel);
    }

@Override
public FileHandleResolver newResolver (final FileType fileType) {
    return new FileHandleResolver() {

        @Override
        public FileHandle resolve (String fileName) {
            return new DesktopFileHandle(fileName,fileType);
        }
    };
}

public AnimationControlLoader(FileHandleResolver resolver,Tags tags) {
    super(resolver);

    logger.info("initialize");
    this.resolver = resolver;
    this.tags = tags;
}

public AnimationStateDataLoader(FileHandleResolver resolver) {
    super(resolver);

    logger = new Logger("AnimationStateDataLoader");
    data = null;

    logger.info("initialising");
}

public GdxAssetManager(FileHandleResolver fileHandleResolver) {
    super(fileHandleResolver);

    PremultTextureLoader.register(this);
    ColorTextureLoader.register(this);
    JngTextureLoader.register(this);
    Texture.setAssetManager(this);
}

/** Creates a new {@link InjectingAssetManager} using the {@link InternalFileHandleResolver}. */
public InjectingAssetManager() {
    super(new InternalFileHandleResolver(),true); // Using default loaders.
    final FileHandleResolver resolver = getFileHandleResolver();
    setLoader(I18NBundle.class,new EagerI18NBundleLoader(resolver));
    setLoader(Skin.class,new EagerSkinLoader(resolver));
    setLoader(TextureAtlas.class,new EagerTextureAtlasLoader(resolver));
}

/**
 * Creates a new AnimationLoader
 * 
 * @param resolver file resolver to be used
 */
public SpriteAnimationLoader(FileHandleResolver resolver) {
    super(resolver);

    animationData = null;
    logger = new Logger("Animation",Env.debugLevel);
}

public AnimationStateDataLoader(FileHandleResolver resolver) {
    super(resolver);

    logger = new Logger("AnimationStateDataLoader",Env.debugLevel);
    data = null;

    logger.info("initialising");
}

@Override
public void create () {
    manager = new AssetManager();

    // set the loaders for the generator and the fonts themselves
    FileHandleResolver resolver = new InternalFileHandleResolver();
    manager.setLoader(FreeTypeFontGenerator.class,new FreeTypeFontGeneratorLoader(resolver));
    manager.setLoader(BitmapFont.class,new FreetypeFontLoader(resolver));

    // load to fonts via the generator (implicitely done by the FreetypeFontLoader).
    // Note: you MUST specify a FreetypeFontGenerator defining the ttf font file name and the size
    // of the font to be generated. The names of the fonts are arbitrary and are not pointing
    // to a file on disk!
    FreeTypeFontLoaderParameter size1Params = new FreeTypeFontLoaderParameter();
    size1Params.fontFileName = "data/arial.ttf";
    size1Params.fontParameters.size = 10;
    manager.load("size10.ttf",size1Params);

    FreeTypeFontLoaderParameter size2Params = new FreeTypeFontLoaderParameter();
    size2Params.fontFileName = "data/arial.ttf";
    size2Params.fontParameters.size = 20;
    manager.load("size20.ttf",size2Params);

    // we also load a "normal" font generated via Hiero
    manager.load("data/default.fnt",BitmapFont.class);

    batch = new SpriteBatch();
}

protected EngineAssetManager(FileHandleResolver resolver) {
    super(resolver);

    resResolver = new EngineResolutionFileResolver(resolver);
    setLoader(Texture.class,new TextureLoader(resResolver));
    setLoader(TextureAtlas.class,new TextureAtlasLoader(resResolver));
    setLoader(FreeTypeFontGenerator.class,new FreeTypeFontGeneratorLoader(resolver));
    setLoader(BitmapFont.class,new FreetypeFontLoader(resolver));

    Texture.setAssetManager(this);
}

private Resolution[] getResolutions(FileHandleResolver resolver,int worldWidth,int worldHeight) {
    ArrayList<Resolution> rl = new ArrayList<Resolution>();

    String list[] = null;

    String configRes = Config.getProperty(Config.RESOLUTIONS,null);

    if(configRes != null) {
        list = configRes.split(",");
    } else {
        list = listAssetFiles("ui");
    }

    for (String name : list) {

        try {
            float scale = Float.parseFloat(name);

            EngineLogger.debug("RES FOUND: " + scale);

            Resolution r = new Resolution((int) (worldWidth * scale),(int) (worldHeight * scale),name);

            rl.add(r);
        } catch (NumberFormatException e) {

        }
    }

    Collections.sort(rl,new Comparator<Resolution>() {
        public int compare(Resolution a,Resolution b) {
            return a.portraitWidth - b.portraitWidth;
        }
    });

    return rl.toArray(new Resolution[rl.size()]);
}

public void load(AssetManager assetManager) {
    FileHandleResolver resolver = new InternalFileHandleResolver();
    assetManager.setLoader(FreeTypeFontGenerator.class,new FreetypeFontLoader(resolver));
    FreeTypeFontLoaderParameter size1Params = new FreeTypeFontLoaderParameter();
    size1Params.fontFileName = AppConst.DEFAUFT_FONT;
    size1Params.fontParameters.size =  AppConst.LOADING_FONT_SIZE;
    assetManager.load(AppConst.LOADING_FONT_NAME,size1Params);
}

public VisAssetManager (FileHandleResolver resolver,Batch batch) {
    super(resolver);
    if (batch == null) throw new IllegalStateException("Batch cannot be null");
    sceneLoader = new SceneLoader(resolver,new RuntimeConfiguration());
    sceneLoader.setBatch(batch);
    setLoader(Scene.class,sceneLoader);
    setLoader(ShaderProgram.class,new ShaderLoader());
}

@SuppressWarnings("rawtypes")
    private BehaviorTreeLibrary (FileHandleResolver resolver,BehaviorTree<?>>();
        this.parser = new BehaviorTreeParser(parseDebugLevel);
    }

@Override
public FileHandleResolver newResolver (final FileType fileType) {
    return new FileHandleResolver() {

        @Override
        public FileHandle resolve (String fileName) {
            return new DesktopFileHandle(fileName,fileType);
        }
    };
}

@Override
public void prepareAssets(UiTheme theme,assetManager);

    enabledninePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(enabledBox)),getNinePatchBottom());
    disabledninePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(disabledBox)),getNinePatchBottom());
    enabledCheckTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(enabledCheck));
    disabledCheckTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(disabledCheck));

    if(disabledUncheck != null) {
        disabledUncheckTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(disabledUncheck));
    }
    if(enabledUncheck != null) {
        enabledUncheckTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(enabledUncheck));
    }
    if(hoveredCheck == null) {
        hoveredCheckTextureRegion = enabledCheckTextureRegion;
    } else {
        hoveredCheckTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(hoveredCheck));
    }
    if (hoveredUncheck != null) {
        hoveredUncheckTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(hoveredUncheck));
    }
}

@Override
public void prepareAssets(UiTheme theme,AssetManager assetManager) {
    if (theme.isHeadless()) {
        return; 
    }
    if (background != null) {
        backgroundNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(background)),getBackgroundNinePatchLeft(),getBackgroundNinePatchRight(),getBackgroundNinePatchTop(),getBackgroundNinePatchBottom());
    }
    fillNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(fill)),fillNinePatchLeft,fillNinePatchRight,fillNinePatchTop,fillNinePatchBottom);
}

public void prepareAssets(UiTheme theme,FileHandleResolver fileHandleResolver) {
    if(theme.isHeadless()) {
        return;
    }

    fontGenerator = new FreeTypeFontGenerator(fileHandleResolver.resolve(path));
    if(borderColor != null) {
        fontBorderColor = ColorUtils.rgbToColor(borderColor);
    }
}

@Override
public void prepareAssets(UiTheme theme,assetManager);
    activeTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(active));
    inactiveTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(inactive));
    disabledActiveTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(disabledActive));
    disabledInactiveTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(disabledInactive));

    if(activeHover != null) {
        activeHoverTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(activeHover));
    } else {
        activeHoverTextureRegion = activeTextureRegion;
    }
    if(inactiveHover != null) {
        inactiveHoverTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(inactiveHover));
    } else {
        inactiveHoverTextureRegion = inactiveTextureRegion;
    }
    if(disabledActiveHover != null) {
        disabledActiveHoverTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(disabledActiveHover));
    } else {
        disabledActiveHoverTextureRegion = disabledActiveTextureRegion;
    }
    if(disabledInactiveHover != null) {
        disabledInactiveHoverTextureRegion = new TextureRegion(theme.getTextureAtlas().findRegion(disabledInactiveHover));
    } else {
        disabledInactiveHoverTextureRegion = disabledInactiveTextureRegion;
    }
}

@Override
public void prepareAssets(UiTheme theme,assetManager);
    if(background != null) {
        backgroundNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(background)),getNinePatchBottom());
    }
}

@Override
public void prepareAssets(UiTheme theme,AssetManager assetManager) {
    if (theme.isHeadless()) {
        return; 
    }

    if(normal != null) {
        normalNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(normal)),getNinePatchBottom());
    }
    if(hover != null) {
        hoverNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(hover)),getNinePatchBottom());
    }
    if(action != null) {
        actionNinePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(action)),getNinePatchBottom());
    }
    if(disabled != null) {
        disabledninePatch = new NinePatch(new TextureRegion(theme.getTextureAtlas().findRegion(disabled)),getNinePatchBottom());
    }

    UiFont themeFont = theme.getFont(font);
    FreeTypeFontParameter fontParameter = new  FreeTypeFontParameter();
    fontParameter.size = fontSize;
    fontParameter.flip = true;
    if(themeFont.getBorderWidth() > 0) {
        fontParameter.borderWidth = themeFont.getBorderWidth();
        fontParameter.borderColor = themeFont.getFontBorderColor();
    }
    bitmapFont = themeFont.generateFont(fontParameter);

    if(textColor != null) {
        color = ColorUtils.rgbToColor(textColor);
    }
}

public UiEditor(String directory,String gameThemePath) {
    super();
    this.directory = directory;
    this.gameThemePath = gameThemePath;

    FileHandleResolver fileHandleResolver = new FallbackFileHandleResolver(new ClasspathFileHandleResolver(),new InternalFileHandleResolver());
    assetManager = new AssetManager(fileHandleResolver);
    assetManager.setLoader(UiTheme.class,new UiThemeLoader(fileHandleResolver));
    assetManager.load(UiTheme.DEFAULT_THEME_FILENAME,UiTheme.class);
    assetManager.load(gameThemePath,UiTheme.class);

    uiContainer = new UiContainer(this,assetManager);
}

/**
 * Constructor
 * 
 * @param resolvers
 *            The {@link FileHandleResolver}s in priority order. The first
 *            resolver has the highest priority.
 */
public FallbackFileHandleResolver(FileHandleResolver... resolvers) {
    if (resolvers.length == 0) {
        throw new MdxException(FallbackFileHandleResolver.class.getSimpleName() + " requires at least 1 "
                + FileHandleResolver.class.getSimpleName());
    }

    this.resolvers = new ArrayList<FileHandleResolver>();
    for (int i = 0; i < resolvers.length; i++) {
        this.resolvers.add(resolvers[i]);
    }
}

@Override
public FileHandle resolve(String fileName) {
    for (FileHandleResolver resolver : resolvers) {
        FileHandle result = resolver.resolve(fileName);
        if (result == null) {
            continue;
        }
        if (!result.exists()) {
            continue;
        }
        return result;
    }
    return null;
}

public AssetManager(FileHandleResolver paramFileHandleResolver)
{
  setLoader(BitmapFont.class,new BitmapFontLoader(paramFileHandleResolver));
  setLoader(Music.class,new MusicLoader(paramFileHandleResolver));
  setLoader(pixmap.class,new pixmapLoader(paramFileHandleResolver));
  setLoader(Sound.class,new SoundLoader(paramFileHandleResolver));
  setLoader(TextureAtlas.class,new TextureAtlasLoader(paramFileHandleResolver));
  setLoader(Texture.class,new TextureLoader(paramFileHandleResolver));
  setLoader(Skin.class,new SkinLoader(paramFileHandleResolver));
  setLoader(TileAtlas.class,new TileAtlasLoader(paramFileHandleResolver));
  setLoader(TileMapRenderer.class,new TileMapRendererLoader(paramFileHandleResolver));
  this.threadPool = Executors.newFixedThreadPool(1,new AssetManager.1(this));
}

@Override
public final void create() {
    if (debug)
        Gdx.app.setLogLevel(Gdx.app.LOG_DEBUG);
    else
        Gdx.app.setLogLevel(Gdx.app.LOG_INFO);

    // Initialize sprite batch
    this.batch = new SpriteBatch();

    // Initialize asset manager
    FileHandleResolver resolver = new InternalFileHandleResolver();
    this.assetManager.setLoader(FreeTypeFontGenerator.class,new FreeTypeFontGeneratorLoader(resolver));
    this.assetManager.setLoader(BitmapFont.class,new FreetypeFontLoader(resolver));

    this.viewportWidth = Gdx.graphics.getWidth();
    this.viewportHeight = Gdx.graphics.getHeight();

    // Initialize cameras
    this.uiCamera = new OrthographicCamera(viewportWidth,viewportHeight);
    this.uiCamera.translate(viewportWidth / 2,viewportHeight / 2,0);
    this.uiCamera.update();

    this.gameCamera = new PerspectiveCamera(0,viewportWidth,viewportHeight);
    this.gameCamera.translate(viewportWidth / 2,0);
    // this.camera.update();
    this.batch.setProjectionMatrix(this.gameCamera.combined);

    // Create new cursor manager
    this.cursorManager = new CursorManager();

    // Load game settings
    this.settings = new Settings("projekt-gg");

    // Set input processor
    Gdx.input.setInputProcessor(inputProcessor);

    // Add screens
    addScreen("splash",new SplashScreen());
    addScreen("mainMenu",new MainMenuScreen());
    addScreen("loading",new LoadingScreen());
    addScreen("serverbrowser",new ServerbrowserScreen());
    addScreen("lobby",new LobbyScreen());
    addScreen("lobbyCreation",new LobbyCreationScreen());
    addScreen("map",new GameMapScreen());
    addScreen("house",new GameHouseScreen());
    addScreen("roundEnd",new GameRoundendScreen());

    // Push screen
    if (showSplashscreen)
        pushScreen("splash");
    else
        pushScreen("loading");
}

/**
 * 从搜索队列中找到完整文件路径
 * @param fileName
 * @return
 */
public FullFilePath fullPathForFileName(String fileName) {
    FullFilePath ret = _fullPathCache.get(fileName);
    if(ret != null) {
        return ret;
    }

    for(int i = 0; i < _searchPathArray.size; ++i) {
        FullFilePath curr = _searchPathArray.get(i);
        System.out.println(curr);
        FileHandle fh = Gdx.files.getFileHandle(curr.path + fileName,curr.type);
        if(fh != null && fh.exists()) {
            ret = curr;
            break;
        }
    }

    if(ret == null) {
        ret = _defaultResRootPath;
    }

    _fullPathCache.put(fileName,ret);
    return ret;
}

public static Save createSave(String name,String generatorID,Gamemode gamemode,String seedString) {
  if (name != null) name = name.trim();
  if (name == null || name.isEmpty()) name = "world-" + Integer.toHexString(MathUtils.random.nextInt());
  FileHandle folder = getSavesFolder();
  FileHandle handle = folder.child(name);
  handle.mkdirs();
  Compatibility.get().nomedia(handle);
  Save s = new Save(name,handle);

  SaveOptions options = new SaveOptions();
  options.setWorldSeed(seedString);
  options.worldType = generatorID;
  options.worldGamemode = gamemode;
  s.setSaveOptions(options);

  return s;
}

public static Area read(Save save,int x,int z) {
  FileHandle file = file(save,x,z);

  if (!file.exists()) {
    //Log.warning("Area does not exist");
    return null;
  }

  Inflater inflater = inflaterThreadLocal.get();

  try {
    inflater.reset();
    InputStream inputStream = file.read(8192);
    InflaterInputStream inflaterInputStream = new InflaterInputStream(inputStream,inflater);
    BufferedInputStream bufferedInputStream = new BufferedInputStream(inflaterInputStream);
    DataInputStream dataInputStream = new DataInputStream(bufferedInputStream);
    Area area = new Area(x,z);
    area.read(dataInputStream);
    dataInputStream.close();
    return area;
  } catch (Exception e) {
    Log.error("Failed to read area " + x + "," + z,e);
    return null;
  }
}

private FileHandle convertToDex(FileHandle fileHandle) throws Exception {
  String inputHash = hashFile(fileHandle);

  FileHandle cacheDir = new FileHandle(androidCompatibility.androidLauncher.getCacheDir());
  FileHandle dexDir = cacheDir.child("converted_mod_dex");
  dexDir.mkdirs();
  FileHandle dexFile = dexDir.child(inputHash + ".dex");

  if (!dexFile.exists()) {
    Log.warning("Trying to convert jar to dex: " + fileHandle.file().getAbsolutePath());
    com.android.dx.command.dexer.Main.Arguments arguments = new com.android.dx.command.dexer.Main.Arguments();
    arguments.parse(new String[]{"--output=" + dexFile.file().getAbsolutePath(),fileHandle.file().getAbsolutePath()});
    int result = com.android.dx.command.dexer.Main.run(arguments);
    if (result != 0) throw new CubesException("Failed to convert jar to dex [" + result + "]: " + fileHandle.file().getAbsolutePath());
    Log.warning("Converted jar to dex: " + fileHandle.file().getAbsolutePath());
  }

  return dexFile;
}

public static FileHandle getimageFilePath(String path){
    StringBuilder stringBuilder = new StringBuilder();
    String projectPath = getProjectPath();
    stringBuilder.append(projectPath);
    if (!projectPath.isEmpty()){
        if (!projectPath.endsWith("/")){
            stringBuilder.append("/");
        }
        stringBuilder.append(path==null?"":path);
        String imagePath = stringBuilder.toString();
        FileHandle fileHandle = new FileHandle(imagePath);
        if (fileHandle.exists() && fileHandle.file().isFile()){
            return fileHandle;
        } else{
            return Gdx.files.internal("badlogic.jpg");
        }


    }
    return null;
}

/** A utility method to write the given array of pixmaps to the given output directory,with the specified file name. If the
 * pages array is of length 1,then the resulting file ref will look like: "fileName.png".
 *
 * If the pages array is greater than length 1,the resulting file refs will be appended with "_N",such as "fileName_0.png",* "fileName_1.png","fileName_2.png" etc.
 *
 * The returned string array can then be passed to the <tt>writeFont</tt> method.
 *
 * Note: None of the pixmaps will be disposed.
 *
 * @param pages the pages of pixmap data to write
 * @param outputDir the output directory
 * @param fileName the file names for the output images
 * @return the array of string references to be used with <tt>writeFont</tt> */
public static String[] writepixmaps (pixmap[] pages,FileHandle outputDir,String fileName) {
    if (pages==null || pages.length==0)
        throw new IllegalArgumentException("no pixmaps supplied to BitmapFontWriter.write");

    String[] pageRefs = new String[pages.length];

    for (int i=0; i<pages.length; i++) {
        String ref = pages.length==1 ? (fileName+".png") : (fileName+"_"+i+".png");

        //the ref for this image
        pageRefs[i] = ref;

        //write the PNG in that directory
        pixmapIO.writePNG(outputDir.child(ref),pages[i]);
    }
    return pageRefs;
}

public static Save createSave(String name,handle);

  SaveOptions options = new SaveOptions();
  options.setWorldSeed(seedString);
  options.worldType = generatorID;
  options.worldGamemode = gamemode;
  s.setSaveOptions(options);

  return s;
}

public static void toggleTracking() {
    synchronized (enabled) {
        if (enabled.get()) {
            stopTracking();
            FileHandle dir = Compatibility.get().getBaseFolder().child("performance");
            Compatibility.get().nomedia(dir);
            dir.mkdirs();
            try {
                save(dir.child(System.currentTimeMillis() + ".cbpf").file());
            } catch (IOException e) {
                Debug.crash(e);
            }
        } else {
            clear();
            startTracking();
        }
    }
}

/**
 * Lädt die Map aus der Datei in den Speicher.
 *
 * Wird von {@link #initMap()} aufgerufen.
 */
private void loadMap()
{
    FileHandle mapFile = Gdx.files.internal("data/maps/" + mapName + ".tmx");

    if (!mapFile.exists() || mapFile.isDirectory())
    {
        Gdx.app.error("ERROR","The map file " + mapName + ".tmx doesn't exists!");
        levelManager.exitToMenu();
        return;
    }

    TmxMapLoader.Parameters mapLoaderParameters = new TmxMapLoader.Parameters();
    mapLoaderParameters.textureMagFilter = Texture.TextureFilter.Nearest;
    mapLoaderParameters.textureMinFilter = Texture.TextureFilter.Nearest;

    tileMap = new TmxMapLoader().load(mapFile.path(),mapLoaderParameters);
}

private static Multimap<JsonStage,JsonValue> load(Map<String,FileHandle> map) throws IOException {
 try {
  Multimap<JsonStage,JsonValue> m = new Multimap<JsonStage,JsonValue>();
  for (Map.Entry<String,FileHandle> entry : map.entrySet()) {
    JsonStage stage = null;
    if (entry.getKey().startsWith("block")) {
      stage = JsonStage.BLOCK;
    } else if (entry.getKey().startsWith("item")) {
      stage = JsonStage.ITEM;
    } else if (entry.getKey().startsWith("recipe")) {
      stage = JsonStage.RECIPE;
    } else {
      throw new CubesException("Invalid json file path \"" + entry.getKey() + "\"");
    }

    Reader reader = entry.getValue().reader();

      m.put(stage,Json.parse(reader));
    } 
  }finally {
      reader.close();
    }
  return m;
}

public static boolean read() {
    FileHandle fileHandle = Compatibility.get().getBaseFolder().child("settings.json");

    try {
        Reader reader = fileHandle.reader();
        JsonObject json = Json.parse(reader).asObject();
        reader.close();

        for (Member member : json) {
            Setting setting = set.settings.get(member.getName());
            setting.readJson(member.getValue());
        }

        return true;
    } catch (Exception e) {
        Log.error("Failed to read settings",e);
        fileHandle.delete();
        return false;
    }
}

public static String hashFile(FileHandle fileHandle) throws Exception {
  InputStream inputStream = fileHandle.read();
  try {
    MessageDigest digest = MessageDigest.getInstance("SHA-256");

    byte[] bytesBuffer = new byte[1024];
    int bytesRead;
int n =inputStream.read(bytesBuffer);
    while ((bytesRead = n) != -1) {
      digest.update(bytesBuffer,bytesRead);
      n=inputStream.read(bytesBuffer);
    }

    byte[] hashedBytes = digest.digest();
    return convertByteArrayToHexString(hashedBytes);
  } catch (IOException ex) {
    throw new CubesException("Could not generate hash from file " + fileHandle.path(),ex);
  } finally {
    StreamUtils.closeQuietly(inputStream);
  }
}

public Save(String name,FileHandle fileHandle,boolean readOnly) {
    this.name = name;
    this.fileHandle = fileHandle;
    this.readOnly = readOnly;

    if (!this.readOnly) {
        this.fileHandle.mkdirs();
        Compatibility.get().nomedia(this.fileHandle);

        folderArea().mkdirs();
        Compatibility.get().nomedia(folderArea());

        folderPlayer().mkdirs();
        Compatibility.get().nomedia(folderPlayer());

        folderCave().mkdirs();
        Compatibility.get().nomedia(folderCave());
    }
}

public static void takeScreenshot() {
  pixmap pixmap = ScreenUtils.getFrameBufferpixmap(0,Gdx.graphics.getBackBufferWidth(),Gdx.graphics.getBackBufferHeight());
  FileHandle dir = Compatibility.get().getBaseFolder().child("screenshots");
  dir.mkdirs();
  FileHandle f = dir.child(System.currentTimeMillis() + ".png");
  try {
    pixmapIO.PNG writer = new pixmapIO.PNG((int) (pixmap.getWidth() * pixmap.getHeight() * 1.5f));
    try {
      writer.setFlipY(true);
      writer.write(f,pixmap);
    } finally {
      writer.dispose();
    }
  } catch (IOException ex) {
    throw new CubesException("Error writing PNG: " + f,ex);
  } finally {
    pixmap.dispose();
  }
  Log.info("Took screenshot '" + f.file().getAbsolutePath() + "'");
}

@Override
public ModFile getNextModFile() throws IOException {
    FileHandle file = files.pollFirst();
    if (file != null)
        return new FolderModFile(file);
    FileHandle folder = folders.pollFirst();
    if (folder == null)
        return null;
    for (FileHandle f : folder.list()) {
        if (f.isDirectory()) {
            folders.add(f);
        } else {
            files.add(f);
        }
    }
    return new FolderModFile(folder);
}

public Cave readCave(AreaReference areaReference) {
    if (fileHandle == null)
        return null;
    FileHandle folder = folderCave();
    FileHandle file = folder.child(areaReference.areaX + "_" + areaReference.areaZ);
    if (!file.exists())
        return null;
    try {
        InputStream read = file.read();
        DataInputStream dataInputStream = new DataInputStream(read);
        Cave cave = Cave.read(dataInputStream);
        read.close();
        return cave;
    } catch (IOException e) {
        Log.warning("Failed to read cave",e);
        return null;
    }
}

public boolean isGameSaved(int slotIndex) {
    String saveFileName = getSaveFileName(slotIndex);
    FileHandle handle = Gdx.files.internal(saveFileName);

    if (handle.exists()) {
        try {
            String gameStateJSON = handle.readString();

            return new Gson().fromJson(gameStateJSON,GameState.class) != null;
        } catch (Exception e) {
            e.printstacktrace();
        }
    }

    return false;
}

/**
 * 获取文件实例
 * @param fileName
 * @return
 */
public FileHandle getFileHandle(final String fileName) {
    FullFilePath ffp = fullPathForFileName(fileName);
    if(ffp == null) {
        cclog.engine(TAG,"file not found : " + fileName);
        return null;
    }

    FileHandle fh = Gdx.files.getFileHandle(ffp.path + fileName,ffp.type);

    return fh;
}

public void refresh() {
  FileHandle fileHandle = Gdx.files.absolute(FileLogWriter.file.getAbsolutePath());
  String string = "";
  try {
    string = fileHandle.readString();
  } catch (GdxRuntimeException e) {
    Log.error("Failed to refresh log menu",e);
  }
  label.setText(string);
  resize(Graphics.GUI_WIDTH,Graphics.GUI_HEIGHT);
}

/**
*  Retrieve the file size.
*
*  @note If a relative path was passed in,it will be inserted a default root path at the beginning.
*  @param filepath The path of the file,it Could be a relative or absolute path.
*  @return The file size.
*/
public long getFileSize( String filepath) {
 FileHandle fh = getFileHandle(filepath);
 if(fh != null) {
     if(fh.exists()) {
         return fh.length();
     }
 }
 return 0;
}

public static void load () {
    try {
        FileHandle filehandle = Gdx.files.local(file);

        String[] strings = filehandle.readString().split("\n");

        backForwardEnabled = Boolean.parseBoolean(strings[0]);
        autoMovetoNext = Boolean.parseBoolean(strings[1]);
        bpm = Integer.parseInt(strings[2]);
    } catch (Throwable e) {
        // :( It's ok we have defaults
    }
}

/** 
 * 想缓存中添加纹理 以path为键值
*/
public Texture addImage(String path) {
    Texture t = _textures.get(path);

    if(t == null) {
        FileHandle handle = FileUtils.getInstance().getFileHandle(path);
        t = new Texture(handle);
        _textures.put(path,t);
    }

    return t;
}

public static boolean write(Save save,Area area) {
  if (save.readOnly) return false;
  if (!area.isReady()) return false;

  AreaMap map = area.areaMap();
  DataGroup[] dataGroups;
  if (map == null || map.world == null || map.world.entities == null) {
    dataGroups = new DataGroup[0];
  } else {
    dataGroups = map.world.entities.getEntitiesForSave(area.areaX,area.areaZ);
  }
  if (!area.modifiedSinceSave(dataGroups)) return false;
  area.saveModCount();

  Deflater deflater = deflaterThreadLocal.get();

  FileHandle file = file(save,area.areaX,area.areaZ);
  try {
    deflater.reset();
    OutputStream stream = file.write(false,8192);
    DeflaterOutputStream deflaterStream = new DeflaterOutputStream(stream,deflater);
    bufferedoutputstream bufferedoutputstream = new bufferedoutputstream(deflaterStream);
    DataOutputStream dataOutputStream = new DataOutputStream(bufferedoutputstream);
    area.writeSave(dataOutputStream,dataGroups);
    bufferedoutputstream.flush();
    deflaterStream.finish();
    stream.close();
  } catch (Exception e) {
    Log.error("Failed to write area " + area.areaX + "," + area.areaZ,e);
    return false;
  }

  return true;
}

/** initializes a TMX Tiled Map with a TMX file */
public boolean initWithTMXFile(String tmxFile) {
 if(_tileMap != null) {
  _tileMap.dispose();
 }
 TmxMapLoader newLoader = new TmxMapLoader() {
  public FileHandle resolve(String fileName) {
   return CC.File(fileName);
  }
 };
 _tileMap = newLoader.load(tmxFile);
 _initProperties();
 _tileMapRender = new OrthogonalTiledMapRenderer(_tileMap,1f);
 return true;
}

public static FileHandle file(Save save,int z) {
  FileHandle folderArea = save.folderArea();
  FileHandle xMostSignificant = folderArea.child(Integer.toString(x & 0xFFFF0000));
  FileHandle xLeastSignificant = xMostSignificant.child(Integer.toString(x & 0xFFFF));
  FileHandle zMostSignificant = xLeastSignificant.child(Integer.toString(z & 0xFFFF0000));
  zMostSignificant.mkdirs();
  Compatibility.get().nomedia(zMostSignificant);

  return zMostSignificant.child(Integer.toString(z & 0xFFFF));
}

/**
 * Saves GGVm's current state to a save state file. This is used
 * when the user quits GGVm so they can resume their game where they
 * left off.
 * Todo: Implement for mobile devices.
 */
private void saveState() {
    Gdx.app.log(getClass().getSimpleName(),"saveState()");
    try {
        FileHandle file = Gdx.files.local("state.sav");
        OutputStream outputStream = file.write(false);
        ggvm.saveState(outputStream);
        soundtrackManager.save(outputStream);
    } catch (IOException ex) {
        Gdx.app.error(getClass().getSimpleName(),"Error saving game state.",ex);
    }
}

public void refresh() {
  FileHandle fileHandle = Gdx.files.absolute(FileLogWriter.file.getAbsolutePath());
  String string = "";
  try {
    string = fileHandle.readString();
  } catch (GdxRuntimeException e) {
    Log.error("Failed to refresh log menu",Graphics.GUI_HEIGHT);
}

protected static void generate(FileHandle file,float strength) {
    pixmap blocks = new pixmap(INDIVIDUAL_SIZE * 3,INDIVIDUAL_SIZE * 3,AOTextureGenerator.FORMAT);
    pixmap gaussian = new pixmap(INDIVIDUAL_SIZE,INDIVIDUAL_SIZE,AOTextureGenerator.FORMAT);

    pixmap output = new pixmap(TEXTURE_SIZE,TEXTURE_SIZE,AOTextureGenerator.FORMAT);

    double[][] gwm = AOTextureGenerator.gaussianWeightMatrix(SIGMA);
    int gaussianRadius = (gwm.length - 1) / 2;

    Color blockColor = new Color(strength,strength,1f);

    for (int i = 0; i < TOTAL; i++) {
        String n = name(i);
        System.out.print(n + " ");

        AOTextureGenerator.clearpixmap(blocks);
        AOTextureGenerator.clearpixmap(gaussian);

        AOTextureGenerator.setuppixmap(blocks,i,blockColor);

        AOTextureGenerator.gaussianpixmap(blocks,gaussian,gwm,gaussianRadius);

        // pixmapIO.writePNG(folder.child(n + "_blocks_" + sigma + ".png"),// blocks);
        // pixmapIO.writePNG(folder.child(n + "_gaussian_" + sigma +
        // ".png"),gaussian);

        output.drawpixmap(gaussian,(i % SQRT_TOTAL) * INDIVIDUAL_SIZE,(i / SQRT_TOTAL) * INDIVIDUAL_SIZE,INDIVIDUAL_SIZE);

        if (i % SQRT_TOTAL == SQRT_TOTAL - 1)
            System.out.println();
    }

    pixmapIO.writePNG(file,output);
    output.dispose();
    blocks.dispose();
    gaussian.dispose();
}

private void save() {
    // Only save if the game is not over and the game mode is not the time mode. It
    // makes no sense to save the time game mode since it's supposed to be something quick.
    // Don't save either if the score is 0,which means the player did nothing.
    if (gameOverDone || gameMode != GAME_MODE_score || scorer.getCurrentscore() == 0)
        return;

    final FileHandle handle = Gdx.files.local(SAVE_DAT_FILENAME);
    try {
        BinSerializer.serialize(this,handle.write(false));
    } catch (IOException e) {
        // Should never happen but what else Could be done if the game wasn't saved?
        e.printstacktrace();
    }
}

/** A convenience method to write pixmaps by page; typically returned from a pixmapPacker when used alongside
 * FreeTypeFontGenerator.
 *
 * @param pages the pages containing the pixmaps
 * @param outputDir the output directory
 * @param fileName the file name
 * @return the file refs */
public static String[] writepixmaps (Array<Page> pages,String fileName) {
  pixmap[] pix = new pixmap[pages.size];
  for (int i = 0; i < pages.size; i++) {
    pix[i] = pages.get(i).getpixmap();
  }
  return writepixmaps(pix,outputDir,fileName);
}

private void packpixmaps() {
    for (String directory : getCore().getimagePacks().keys()) {
        for (String name : getCore().getimagePacks().get(directory)) {
            FileHandle file = Gdx.files.local(directory + "/" + name + ".png");
            getCore().getpixmapPacker().pack(file.nameWithoutExtension(),getCore().getAssetManager().get(file.path(),pixmap.class));
        }
    }

    getCore().getpixmapPacker().pack("white",getCore().getAssetManager().get(Core.DATA_PATH + "/gfx/white.png",pixmap.class));

    TextureAtlas atlas = getCore().getpixmapPacker().generateTextureAtlas(Texture.TextureFilter.Linear,Texture.TextureFilter.Linear,false);
    getCore().setAtlas(atlas);
}

void print(){

            System.out.println("\n\n\n\n\n\n");
            int i = 0;
            for(FileHandle file : history){
                i ++;
                if(index == i){
                    System.out.println("[[" + file.toString() + "]]");
                }else{
                    System.out.println("--" + file.toString() + "--");
                }
            }
        }

/**
 * {@inheritDoc}
 */
@Override
public void upload(FileHandle file,String path,UploadCallback callback)
{
    StorageReference dataRef = firebaseStorage().getReference().child(path);
    UploadTask uploadTask = dataRef.putFile(Uri.fromFile(file.file()));
    processupload(uploadTask,callback);
}

public static void cleanBundles(FileHandle file){
    String[] strings = file.readString().split("\n");
    FileHandle out = Gdx.files.absolute("/home/anuke/out.properties");
    out.writeString("",false);
    for(String string : strings){
        if(!string.contains(".description")){
            out.writeString(string + "\n",true);
        }
    }
}

public static void loadCore() {
  AssetManager core = Assets.getCoreAssetManager();
  HashMap<String,FileHandle> map = new HashMap<String,FileHandle>();
  for (Asset j : core.getAssets("json/")) {
    map.put(j.getPath().substring(5),j.getFileHandle());
  }
  try {
    coreMap = load(map);
  } catch (IOException e) {
    throw new CubesException("Failed to load core json",e);
  }
}

/**
 * Bereitet die Credits für die Anzeige vor.
 *
 * Zeilen,die mit # Anfangen werden als Überschriften gehandhabt.
 * Zeilen,die mit !# Anfangen,werden als Haupt-Überschriften gehandhabt.
 *
 * @param creditsFile ein FileHandle auf die Datei mit den Credits
 */
private void prepareCredits(FileHandle creditsFile)
{
    creditLines.clear();

    String credits = creditsFile.readString();

    String[] lines = credits.split("\n");

    for (String line: lines) {
        line = line.trim();
        int header = 0;

        if (line.startsWith("#"))
        {
            header = 1;
            line = line.substring(1).trim();
        }

        if (line.startsWith("!#"))
        {
            header = 2;
            line = line.substring(2).trim();
        }

        creditLines.add(new CreditLine(line,header));
    }
}

public static void loadScene(Group parentGroup,String path){
    if (path==null || parentGroup == null) return;
    FileHandle sceneFile = Gdx.files.internal(path);
    if (sceneFile.exists()){
        try {
            XmlUtils.readFile(parentGroup,sceneFile);
        } catch (IOException e) {
            e.printstacktrace();
        }
    }
}

private static List<FileHandle> getModFiles() {
    FileHandle base = Compatibility.get().getBaseFolder().child("mods");
    base.mkdirs();
    Compatibility.get().nomedia(base);
    ArrayList<FileHandle> fileHandles = new ArrayList<FileHandle>();
    fileHandles.addAll(modManager.extraMods);
    Collections.addAll(fileHandles,base.list(new FileFilter() {
        @Override
        public boolean accept(File pathname) {
            String s = pathname.getName().toLowerCase();
            return s.endsWith(".cm");
        }
    }));
    return fileHandles;
}

public static void encryptToFile(Crypto crypto,File inputFile,File outputFile) {
    FileHandle inputFileHandle = new FileHandle(inputFile);
    byte[] bytes = inputFileHandle.readBytes();
    crypto.decrypt(bytes,true);

    FileHandle outputFileHandle = new FileHandle(outputFile);
    outputFileHandle.writeBytes(bytes,false);
}

public static Texture loadTexture(Crypto crypto,FileHandle file,pixmap.Format format,boolean useMipMaps) {
    try {
        byte[] bytes = file.readBytes();
        if (crypto != null) {
            bytes = crypto.decrypt(bytes,true);
        }
        pixmap pixmap = new pixmap(new Gdx2Dpixmap(bytes,bytes.length,0));
        return new Texture(pixmap,format,useMipMaps);
    } catch (Exception e) {
        throw new GdxRuntimeException("Couldn't load file: " + file,e);
    }
}

public Server(String fileName,boolean restart) {
    super();
    parseServerFile(fileName);
    seatAssignments = new ArrayList<>(nSeats);
    for (int i = 0; i < nSeats; i++)
        seatAssignments.add("");

    log.getParent().removeHandler(log.getParent().getHandlers()[0]);

    try {
        // check if logs dir exists
        File logDir = new File("./logs/"); 
        if( !(logDir.exists()) )
            logDir.mkdir();

        FileHandler fh = new FileHandler("logs/server_log_" + serverID + ".log");
        fh.setFormatter(new SimpleFormatter());
        fh.setLevel(logLevel);
        log.addHandler(fh);

        ConsoleHandler ch = new ConsoleHandler();
        ch.setLevel(logLevel);
        log.addHandler(ch);
        log.setLevel(logLevel);

        log.info("Server initializing...");
        log.info("ServerID = " + serverID);
        log.info("nServers = " + nServers);
        log.info("nSeats = " + nSeats);
        log.info("my tcp port = " + tcpPort);
        for (int i = 0; i < nServers; i++)
            log.info("Server " + i + ": " + servers.get(i) + ":" + ports.get(i));
        log.info("Server init complete");
        log.info("--------------------------------");
        mutex = new LamportMutex(servers,ports,this,restart);
        mutex.init();
    } catch (SecurityException | IOException e) {
        e.printstacktrace();
    }
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.INFO;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

private void doDeadlockConsoleAndStdErr(final ConsoleHandler ch) {
    class H extends Handler implements Runnable {
        public void publish(LogRecord record) {
            try {
                RequestProcessor.getDefault().post(this).waitFinished(100);
            } catch (InterruptedException ex) {
                // ex.printstacktrace();
            }
        }

        public void flush() {
        }

        public void close() throws SecurityException {
        }

        public void run() {
            ch.publish(new LogRecord(Level.WARNING,"run"));
        }
    }
    H handler = new H();
    Logger.getLogger("stderr").addHandler(handler);

    System.err.println("Ahoj");
}

public static void unitLogging()
{
    // Start with a fresh root set at warning
    Logger root = LogManager.getLogManager().getLogger("");
    root.setLevel(Level.WARNING);
    for(Handler handler : root.getHandlers()) { root.removeHandler(handler); }

    //Logger.getLogger("java.util.prefs").setLevel(Level.SEVERE);
    Logger.getLogger("org.postgresql.jdbc").setLevel(Level.OFF);
    Logger.getLogger("org.postgresql.Driver").setLevel(Level.OFF);
    Logger.getLogger("org.wwscc").setLevel(Level.ALL);

    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(Level.ALL);
    ch.setFormatter(new SingleLineFormatter());
    root.addHandler(ch);
}

/**
 * Creates a new logger
 */
private Logger init(final Level level,final String file) {
    final LogSettings logSettings = settingsService.getLogSettings();
    final Logger logger = Logger.getAnonymousLogger();
    logger.setLevel(level);
    logger.setUseParentHandlers(false);
    try {
        final FileUnits units = logSettings.getMaxLengthPerFileUnits();
        final FileHandler fileHandler = new FileHandler(file,units.calculate(logSettings.getMaxLengthPerFile()),logSettings.getMaxFilesPerLog(),true);
        fileHandler.setFormatter(logFormatter);
        fileHandler.setEncoding(settingsService.getLocalSettings().getCharset());
        logger.addHandler(fileHandler);
    } catch (final Exception e) {
        final ConsoleHandler consoleHandler = new ConsoleHandler();
        consoleHandler.setFormatter(logFormatter);
        try {
            consoleHandler.setEncoding(settingsService.getLocalSettings().getCharset());
        } catch (final Exception e1) {
            // Just ignore
        }
        logger.addHandler(consoleHandler);
        logger.log(Level.WARNING,"Unable to create logger for file " + file);
    }
    return logger;
}

/**
 * Main entry point for the OpenOffice.org Bean Test.
 *
 * @param args arguments of the test
 *
 * @author Andreas Bröker
 * @date 21.05.2006
 */
public static void main(String[] args) throws OfficeApplicationException {

   LogManager.getLogManager().reset();
   ConsoleHandler consoleHandler = new ConsoleHandler();
   consoleHandler.setLevel(Level.FInesT);
   LOGGER.addHandler(consoleHandler);
   LOGGER.setLevel(Level.FInesT);

   try {
      FileHandler fileHandler = new FileHandler("log.xml");
      fileHandler.setLevel(Level.FInesT);
      LOGGER.addHandler(fileHandler);
   } catch (Throwable throwable) {
   }
   OfficeBeanTest testOfficeBean = new OfficeBeantest();

   if (args.length == 0) {
      testOfficeBean.test(null);
   }else if (args.length == 1) {
      testOfficeBean.test(args[0]);
   }else if(args.length==4){
      testOfficeBean.remoteTestPDF(new File(args[2]),new File(args[3]),args[0],Integer.valueOf(args[1]));
   }else{
      System.out.println("usage:\nOfficeBeanTest host port source-odt target-pdf\nOfficeBeanTest officeHome");
   }
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.SEVERE;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.SEVERE;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.SEVERE;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.SEVERE;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.SEVERE;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.INFO;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.SEVERE;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.INFO;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.INFO;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.INFO;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.INFO;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.INFO;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

@Before
public void setupLogger() throws Exception {
    Level level = Level.INFO;
    Thread.setDefaultUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {

        @Override
        public void uncaughtException(Thread t,Throwable e) {
            System.err.println("uncaughtException from thread " + t.getName() + ": " + e);
            e.printstacktrace();
        }
    });
    java.util.logging.LogManager.getLogManager().reset();
    ConsoleHandler ch = new ConsoleHandler();
    ch.setLevel(level);
    SimpleFormatter f = new SimpleFormatter();
    ch.setFormatter(f);
    java.util.logging.Logger.getLogger("").setLevel(level);
    java.util.logging.Logger.getLogger("").addHandler(ch);
}

public void testConstructor_InvalidProperties() throws Exception {
    Properties p = new Properties();
    p.put("java.util.logging.ConsoleHandler.level",INVALID_LEVEL);
    p.put("java.util.logging.ConsoleHandler.filter",className);
    p.put("java.util.logging.ConsoleHandler.formatter",className);
    p.put("java.util.logging.ConsoleHandler.encoding","XXXX");
    LogManager.getLogManager().readConfiguration(
            EnvironmentHelper.PropertiesToInputStream(p));

    assertEquals(LogManager.getLogManager().getProperty(
            "java.util.logging.ConsoleHandler.level"),INVALID_LEVEL);
    assertEquals(LogManager.getLogManager().getProperty(
            "java.util.logging.ConsoleHandler.encoding"),"XXXX");
    ConsoleHandler h = new ConsoleHandler();
    assertSame(h.getLevel(),Level.INFO);
    assertTrue(h.getFormatter() instanceof SimpleFormatter);
    assertNull(h.getFilter());
    assertNull(h.getEncoding());
    h.publish(new LogRecord(Level.SEVERE,"test"));
    assertNull(h.getEncoding());
}

public void testPublish_AfterResetSystemErr() throws Exception {
    Properties p = new Properties();
    p.put("java.util.logging.ConsoleHandler.formatter",className
            + "$MockFormatter");
    LogManager.getLogManager().readConfiguration(
            EnvironmentHelper.PropertiesToInputStream(p));
    ConsoleHandler h = new ConsoleHandler();
    h.setFilter(new MockFilter());

    System.setErr(new PrintStream(new ByteArrayOutputStream()));

    LogRecord r = new LogRecord(Level.INFO,"testPublish_WithFilter");
    h.setLevel(Level.INFO);
    h.publish(r);
    assertNull(CallVerificationStack.getInstance().pop());
    assertSame(r,CallVerificationStack.getInstance().pop());
    assertEquals("",this.errSubstituteStream.toString());
}

private void setupLogging() {
    log.setUseParentHandlers(false);

    LogFormatter formatter = new LogFormatter();

    ConsoleHandler ch = new ConsoleHandler();
    ch.setFormatter(formatter);
    if (isDebugging()) {
        log.setLevel(Level.FInesT);
        ch.setLevel(Level.FInesT);
    } else {
        log.setLevel(Level.INFO);
        ch.setLevel(Level.INFO);
    }
    log.addHandler(ch);

    try {
        FileHandler fh = new FileHandler("server.log");
        fh.setFormatter(formatter);
        if (isDebugging()) {
            fh.setLevel(Level.FInesT);
        } else {
            ch.setLevel(Level.INFO);
        }
        log.addHandler(fh);
    } catch (IOException ex) {
        log.log(Level.SEVERE,"Error while adding FileHandler to logger. Logs will not be output to a file.",ex);
    }

}

@Override
public StandardOutputCapture start() {
    super.start();
    boolean shouldReadLoggingConfigFile = System.getProperty(READ_LOGGING_CONfig_FILE_PROPERTY,"true").equals("true");
    if (!shouldReadLoggingConfigFile) {
        SingleMessageLogger.nagUserOfdiscontinuedProperty(READ_LOGGING_CONfig_FILE_PROPERTY,"Change your test to work with your java.util.logging configuration file settings.");
    }
    if (!reset) {
        LogManager.getLogManager().reset();
        if (shouldReadLoggingConfigFile) {
            try {
                LogManager.getLogManager().readConfiguration();
            } catch (IOException error) {
                Logger.getLogger("").addHandler(new ConsoleHandler());
            }
        } else {
            Logger.getLogger("").addHandler(new ConsoleHandler());
        }
        reset = true;
    }
    return this;
}

private static void enableHttp2FrameLogging() {
  frameLogger = Logger.getLogger(Http2.class.getName());
  frameLogger.setLevel(Level.FINE);
  ConsoleHandler handler = new ConsoleHandler();
  handler.setLevel(Level.FINE);
  handler.setFormatter(new SimpleFormatter() {
    @Override public String format(LogRecord record) {
      return Util.format("%s%n",record.getMessage());
    }
  });
  frameLogger.addHandler(handler);
}

public LoggingConfig() {
    try {
        // Load a properties file from class path java.util.logging.config.file
        final LogManager logManager = LogManager.getLogManager();
        URL configURL = getClass().getResource("/logging.properties");
        if (configURL != null) {
            try (InputStream is = configURL.openStream()) {
                logManager.readConfiguration(is);
            }
        } else {
            // Programmatic configuration
            System.setProperty("java.util.logging.SimpleFormatter.format","%1$tY-%1$tm-%1$td %1$tH:%1$tM:%1$tS.%1$tL %4$-7s [%3$s] %5$s %6$s%n");

            final ConsoleHandler consoleHandler = new ConsoleHandler();
            consoleHandler.setLevel(Level.FInesT);
            consoleHandler.setFormatter(new SimpleFormatter());

            final Logger app = Logger.getLogger("app");
            app.setLevel(Level.FInesT);
            app.addHandler(consoleHandler);
        }
    } catch (Exception e) {
        e.printstacktrace();
    }
}

/**
 * Constructor.
 */
public ServerRunner() {
    log.setLevel(Level.ALL); 
    ConsoleHandler handler = new ConsoleHandler();
    handler.setFormatter(new SimpleFormatter());
    handler.setLevel(Level.ALL);
    log.addHandler(handler);

}

public void setUp()
{
    agentId = new TeamedAgentId("Agent01");
    agentId.setTeamId( new TeamId("teamRED"));
    agentLogger = new AgentLogger(agentId);
    LifecycleBus bus = new LifecycleBus(agentLogger);

    Logger sharedLogger = Logger.getLogger("SharedLogger");
    sharedLogger.addHandler( new ConsoleHandler() );
    sharedLogger.setLevel( Level.INFO );
    agentLogger.setLevel(Level.INFO);
    agentLogger.addDefaultConsoleHandler();

    sharedWV = new EventDrivenSharedWorldViewStub( sharedLogger );

    ComponentStub starter = new ComponentStub(agentLogger,bus);

    localWV = new EventDrivenLocalWorldViewStub( new ComponentDependencies( ComponentDependencyType.STARTS_WITH ).add(starter),bus,agentLogger,sharedWV,agentId);

    starter.getController().manualStart("TEST");
    localWV.setCurrentTime( TimeKey.get(0));
}

public static void createShared()
{
    globalLogger = Logger.getLogger("globalLogger");
    ConsoleHandler handler = new ConsoleHandler();
    globalLogger.addHandler(handler);
    handler.setLevel(Level.INFO);
    //LogFormatter formatter = new LogFormatter();
    //handler.setFormatter(formatter);
    globalLogger.setLevel( Level.INFO );
    sharedWV = new EventDrivenSharedWorldViewStub(globalLogger);
}

public static void main(String[] args) {
    Logger log = Logger.getGlobal();
    ConsoleHandler handler = new ConsoleHandler();
    handler.setLevel(Level.ALL);
    log.addHandler(handler);
    log.setLevel(Level.ALL);
    JFrame fra = new JFrame("bitBox");
    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
    BaseConverter baseConverter = new BaseConverter();
    BitCombiner bitCombiner = new BitCombiner();
    BitPainter bitPainter = new BitPainter();
    SwingUtilities.invokelater(() -> {
        fra.setSize(new Dimension(500,screenSize.height));
        fra.setDefaultCloSEOperation(JFrame.EXIT_ON_CLOSE);
        fra.setLayout(new GridLayout(GRID_SIZE,GRID_SIZE));
        fra.setComponentOrientation(ComponentOrientation.LEFT_TO_RIGHT);
        fra.add(baseConverter);
        fra.add(bitCombiner);
        fra.add(bitPainter);
        fra.setVisible(true);
        log.fine("Created GUI");
    });
}

/**
 * Configure Logger
 *
 * @throws IOException
 */
protected void config() throws IOException
{
    if( Boolean.parseBoolean(this.config.get("log_console_status","false")) ){
        consoleHandler = new ConsoleHandler();
        log.addHandler(consoleHandler);
        if( this.config.get("log_console_level","SEVERE").equals("ALL") ){
            consoleHandler.setLevel(Level.ALL);
        }else if( this.config.get("log_console_level","SEVERE").equals("CONfig") ){
            consoleHandler.setLevel(Level.CONfig);
        }else if( this.config.get("log_console_level","SEVERE").equals("FINE") ){
            consoleHandler.setLevel(Level.FINE);
        }else if( this.config.get("log_console_level","SEVERE").equals("FINER") ){
            consoleHandler.setLevel(Level.FINER);
        }else if( this.config.get("log_console_level","SEVERE").equals("FInesT") ){
            consoleHandler.setLevel(Level.FInesT);
        }else if( this.config.get("log_console_level","SEVERE").equals("INFO") ){
            consoleHandler.setLevel(Level.INFO);
        }else if( this.config.get("log_console_level","SEVERE").equals("OFF") ){
            consoleHandler.setLevel(Level.OFF);
        }else if( this.config.get("log_console_level","SEVERE").equals("SEVERE") ){
            consoleHandler.setLevel(Level.SEVERE);
        }else if( this.config.get("log_console_level","SEVERE").equals("WARNING") ){
            consoleHandler.setLevel(Level.WARNING);
        }
    }

    if( Boolean.parseBoolean(this.config.get("log_file_status","false")) ){
        fileHandler  = new FileHandler(this.config.get("log_file_path","src/main/java/resources/app.log"),Integer.parseInt(this.config.get("log_file_limit","1")),Integer.parseInt(this.config.get("log_file_count","200000")),Boolean.parseBoolean(this.config.get("log_file_append","true"))
        );
        log.addHandler(fileHandler);
        if( this.config.get("log_file_level","SEVERE").equals("ALL") ){
            fileHandler.setLevel(Level.ALL);
        }else if( this.config.get("log_file_level","SEVERE").equals("CONfig") ){
            fileHandler.setLevel(Level.CONfig);
        }else if( this.config.get("log_file_level","SEVERE").equals("FINE") ){
            fileHandler.setLevel(Level.FINE);
        }else if( this.config.get("log_file_level","SEVERE").equals("FINER") ){
            fileHandler.setLevel(Level.FINER);
        }else if( this.config.get("log_file_level","SEVERE").equals("FInesT") ){
            fileHandler.setLevel(Level.FInesT);
        }else if( this.config.get("log_file_level","SEVERE").equals("INFO") ){
            fileHandler.setLevel(Level.INFO);
        }else if( this.config.get("log_file_level","SEVERE").equals("OFF") ){
            fileHandler.setLevel(Level.OFF);
        }else if( this.config.get("log_file_level","SEVERE").equals("SEVERE") ){
            fileHandler.setLevel(Level.SEVERE);
        }else if( this.config.get("log_file_level","SEVERE").equals("WARNING") ){
            fileHandler.setLevel(Level.WARNING);
        }
    }
}

/**
 * Initialize the logger
 */
public static void init() {

    ConsoleHandler handler = new ConsoleHandler();
    // PUBLISH this level
    handler.setLevel(Level.FInesT);
    LOGGER.addHandler(handler);
    LOGGER.setLevel(Level.FInesT);
}

private static Logger createMetricUpdateTracer() {
  Logger logger = Logger.getLogger(TracingMetricRegistry.class.getName() + ".metricUpdates");
  ConsoleHandler handler = new ConsoleHandler();
  handler.setFormatter(new Formatter() {
    @Override
    public String format(LogRecord record) {
      return ">>" + record.getMessage() + "\n";
    }
  });
  logger.addHandler(handler);
  logger.setUseParentHandlers(false);
  handler.setLevel(Level.ALL);
  //logger.setLevel(Level.ALL);

  return logger;
}

@Override
    public synchronized void init(ProcessingEnvironment processingEnv) {
        super.init(processingEnv);
        final Optional<String> jtsgenLogLevel = Optional.ofNullable(processingEnv.getoptions().get("jtsgenLogLevel"));
        String packageName = AbstractProcessorWithLogging.class.getPackage().getName();
        final Logger logger = Logger.getLogger(packageName);
        if (jtsgenLogLevel.isPresent()) {
            Level level = jtsgenLogLevel
                    .map(
                            (x) -> {
                                try {
                                    return Level.parse(x.trim().toupperCase());
                                } catch (IllegalArgumentException ex) {
                                    return Level.OFF;
                                }
                            }
                    ).orElse(Level.INFO);
            Formatter oneLineFormatter = new OneLineFormatter();
            ConsoleHandler consoleHandler = new ConsoleHandler();
            consoleHandler.setLevel(level);
            consoleHandler.setFormatter(oneLineFormatter);
            logger.setUseParentHandlers(false);
            logger.setLevel(level);

//        consoleHandler.setFormatter(oneLineFormatter);
            logger.addHandler(consoleHandler);
            LOG.log(Level.FINER,() -> String.format("LogLevel %s = %s ",packageName,level.getName()));
        } else {
            logger.setLevel(Level.OFF);
        }
    }

public void setDebug(boolean debug)
{
    _debug = debug;
    _consumerClient.setDebug(debug);

    if (!debug)
    {
        final Logger parentLogger = Logger.getAnonymousLogger().getParent();

        // disable console logger if debug mode not turned on
        for (Handler handler : parentLogger.getHandlers())
        {
            if ( handler instanceof ConsoleHandler )
                parentLogger.removeHandler(handler);
        }
    }
}

private static void addDefaultConsoleHandler(Logger logger,String errorMessage,String logFilePath) {
  ConsoleHandler consoleHandler = new ConsoleHandler();
  consoleHandler.setFormatter(new GemFireFormatter());
  logger.addHandler(consoleHandler);

  System.err
      .println("ERROR: Could not log to file: " + logFilePath + ". Reason: " + errorMessage);
  System.err.println("Logs will be written on Console.");
  try {
    Thread.sleep(3000); // sleep for 3 secs for the message to appear
  } catch (InterruptedException ignore) {
  }
}

@Override
public void enableConsoleOut(boolean check) {

    if (check == true) {
        if (this.consoleHandler == null) {
            this.consoleHandler = new ConsoleHandler();
            this.consoleHandler.setLevel(this.level);
            this.consoleHandler.setFormatter(new DefaultLogFormatter());
        }
        log.addHandler(this.consoleHandler);
    }
    else {
        if (this.consoleHandler != null) {
            log.removeHandler(this.consoleHandler);
        }
    }
}

public static void initServer() throws Exception {
    String portstring = System.getProperty("port.number");
    port = portstring != null ? Integer.parseInt(portstring) : 0;
    portstring = System.getProperty("port.number1");
    proxyPort = portstring != null ? Integer.parseInt(portstring) : 0;

    Logger logger = Logger.getLogger("com.sun.net.httpserver");
    ConsoleHandler ch = new ConsoleHandler();
    logger.setLevel(Level.ALL);
    ch.setLevel(Level.ALL);
    logger.addHandler(ch);
    String root = System.getProperty ("test.src")+ "/docs";
    InetSocketAddress addr = new InetSocketAddress (port);
    s1 = HttpServer.create (addr,0);
    if (s1 instanceof HttpsServer) {
        throw new RuntimeException ("should not be httpsserver");
    }
    HttpHandler h = new FileServerHandler (root);
    HttpContext c = s1.createContext ("/files",h);

    HttpHandler h1 = new RedirectHandler ("/redirect");
    HttpContext c1 = s1.createContext ("/redirect",h1);

    executor = Executors.newCachedThreadPool();
    s1.setExecutor (executor);
    s1.start();

    if (port == 0)
        port = s1.getAddress().getPort();
    else {
        if (s1.getAddress().getPort() != port)
            throw new RuntimeException("Error wrong port");
        System.out.println("Port was assigned by Driver");
    }
    System.out.println("HTTP server port = " + port);
    httproot = "http://127.0.0.1:" + port + "/files/";
    redirectroot = "http://127.0.0.1:" + port + "/redirect/";
    uri = new URI(httproot);
    fileuri = httproot + "foo.txt";
}

public void start() throws LoginException,InterruptedException,RateLimitedException {
    running = true;

    // init logger
    AnsiConsole.systemInstall();
    log = Logger.getLogger("Kyoko");
    log.setUseParentHandlers(false);
    ColoredFormatter formatter = new ColoredFormatter();
    ConsoleHandler handler = new ConsoleHandler();
    handler.setFormatter(formatter);
    log.addHandler(handler);

    log.info("Kyoko v" + Constants.VERSION + " is starting...");

    i18n.loadMessages();

    JDABuilder builder = new JDABuilder(AccountType.BOT);
    if (settings.getToken() != null) {
        if (settings.getToken().equalsIgnoreCase("Change me")) {
            System.out.println("No token specified,please set it in config.json");
            System.exit(1);
        }
        builder.setToken(settings.getToken());
    }

    boolean gameEnabled = false;
    if (settings.getGame() != null && !settings.getGame().isEmpty()) {
        gameEnabled = true;
        builder.setGame(Game.of("booting..."));
    }

    builder.setAutoReconnect(true);
    builder.setBulkDeleteSplittingEnabled(false);
    builder.addEventListener(eventHandler);
    builder.setAudioEnabled(true);
    builder.setStatus(Onlinestatus.IDLE);
    jda = builder.buildBlocking();

    log.info("Invite link: " + "https://discordapp.com/oauth2/authorize?&client_id=" + jda.getSelfUser().getId() + "&scope=bot&permissions=" + Constants.PERMISSIONS);

    if (gameEnabled) {
        Thread t = new Thread(new Kyoko.BlinkThread());
        t.start();
    }

    registerCommands();
}

/**
 * Do some common setup for all applications at startup
 * @param name the application name used for Java logging and database logging
 */
public static void appSetup(String name)
{
    // Set our platform wide L&F 
    System.setProperty("swing.defaultlaf","javax.swing.plaf.nimbus.NimbusLookAndFeel");
    UIDefaults defaults = UIManager.getLookAndFeelDefaults();
    defaults.put("Table.gridColor",new Color(140,140,140));
    defaults.put("Table.showGrid",true);

    // Set the program name which is used by PostgresqlDatabase to identify the app in logs
    System.setProperty("program.name",name);

    // Start with a fresh root set at warning
    Logger root = LogManager.getLogManager().getLogger("");
    Formatter format = new SingleLineFormatter();

    root.setLevel(Level.WARNING);
    for(Handler handler : root.getHandlers()) {
        root.removeHandler(handler);
    }

    // Set prefs levels before windows preference load barfs useless data on the user
    Logger.getLogger("java.util.prefs").setLevel(Level.SEVERE);
    // postgres JDBC spits out a lot of data even though we catch the exception
    Logger.getLogger("org.postgresql.jdbc").setLevel(Level.OFF);
    Logger.getLogger("org.postgresql.Driver").setLevel(Level.OFF);

    // Add console handler if running in debug mode
    if (Prefs.isDebug()) {
        ConsoleHandler ch = new ConsoleHandler();
        ch.setLevel(Level.ALL);
        ch.setFormatter(format);
        root.addHandler(ch);
    }

    // For our own logs,we can set super fine level or info depending on if debug mode and attach dialogs to those
    Logger applog = Logger.getLogger("org.wwscc");
    applog.setLevel(Prefs.isDebug() ? Level.FInesT : Level.INFO);
    applog.addHandler(new AlertHandler());

    Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
        @Override
        public void uncaughtException(Thread t,Throwable e) {
            applog.log(Level.WARNING,String.format("\bUncaughtException in %s: %s",t,e),e);
        }});

    try {
        File logdir = Prefs.getLogDirectory().toFile();
        if (!logdir.exists())
            if (!logdir.mkdirs())
                throw new IOException("Can't create log directory " + logdir);
        FileHandler fh = new FileHandler(new File(logdir,name+".%g.log").getAbsolutePath(),1000000,10,true);
        fh.setFormatter(format);
        fh.setLevel(Level.ALL);
        root.addHandler(fh);
    } catch (IOException ioe) {
        JOptionPane.showMessageDialog(FocusManager.getCurrentManager().getActiveWindow(),"Unable to enable logging to file: " + ioe,"Log Error",JOptionPane.ERROR_MESSAGE);
    }

    // force the initialization of IdGenerator on another thread so app can start Now without an odd delay later
    new Thread() {
        public void run() {
            IdGenerator.generateId();
        }
    }.start();
}