所以我去：

Image original = Image.FromStream(myPostedFile.InputStream);
int w=original.Width,h=original.Height;

using(Graphics g = Graphics.FromImage(original))
{
 g.ScaleTransform(0.5f,0.5f); ... // e.g.
 using (Bitmap done = new Bitmap(w,h,g))
 {
  done.Save( Server.MapPath(saveas),ImageFormat.Jpeg );
  //saves blank black,though with correct width and height
 }
}

这节省了处女黑色jpeg我给它的任何文件.
虽然如果我将输入图像流立即带入完成的位图,它会重新压缩并保存它,如：

Image original = Image.FromStream(myPostedFile.InputStream);
using (Bitmap done = new Bitmap(original))
{
 done.Save( Server.MapPath(saveas),ImageFormat.Jpeg );
}

我必须用g制作一些魔法吗？

UPD：
我试过了：

Image original = Image.FromStream(fstream);
int w=original.Width,h=original.Height;
using(Bitmap b = new Bitmap(original)) //also tried new Bitmap(w,h)
 using (Graphics g = Graphics.FromImage(b))
 {
  g.DrawImage(original,w,h); //also tried g.DrawImage(b,h)
  using (Bitmap done = new Bitmap(w,g))
  {
   done.Save( Server.MapPath(saveas),ImageFormat.Jpeg );
  }
 }

相同的故事 – 正确尺寸的纯黑色

您可以使用填充背景到调整大小的区域,而不是使用缩放图像.

看一下这个：

Image img = Image.FromFile(Server.MapPath("a.png"));
int w = img.Width;
int h = img.Height;

//Create an empty bitmap with scaled size,here half
Bitmap bmp = new Bitmap(w / 2,h / 2);
//Create graphics object to draw
Graphics g = Graphics.FromImage(bmp);
//You can also use SmoothingMode,CompositingMode and CompositingQuality
//of Graphics object to preserve saving options for new image.        

//Create drawing area with a rectangle
Rectangle drect = new Rectangle(0,bmp.Width,bmp.Height);
//Draw image into your rectangle area
g.DrawImage(img,drect);
//Save your new image
bmp.Save(Server.MapPath("a2.jpg"),ImageFormat.Jpeg);

希望这可以帮助迈拉

public ChatMessage(String sender,String message) {
        super(skin);
//        debugall();
        FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal("fonts/DroidSans.ttf"));
        FreeTypeFontParameter parameter = new FreeTypeFontParameter();
        parameter.size = 17;
        parameter.minFilter = Texture.TextureFilter.Linear;
        parameter.magFilter = Texture.TextureFilter.Linear;
        final Label.LabelStyle labelStyle = skin.get("chat-sender",Label.LabelStyle.class);
        labelStyle.font = generator.generateFont(parameter);
        this.sender = new Label(sender,labelStyle);
        this.message = new Label(message,skin.get("chat-message",Label.LabelStyle.class));
        this.message.setWrap(true);
        add(this.sender).fillX().expandX();
        row();
        add(this.message).fillX().expandX();

        generator.dispose(); // don't forget to dispose to avoid memory leaks!
    }

public static BitmapFont createFont(String fontPath,int size,Color color,Color borderColor,int borderWidth) {
    // load font
    FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.absolute(fontPath));
    FreeTypeFontGenerator.FreeTypeFontParameter parameter = new FreeTypeFontGenerator.FreeTypeFontParameter();

    // https://github.com/libgdx/libgdx/wiki/Gdx-freetype
    parameter.size = size;
    parameter.borderColor = borderColor;
    parameter.borderWidth = borderWidth;
    parameter.color = color;

    BitmapFont font48 = generator.generateFont(parameter);
    generator.dispose();

    return font48;
}

public static BitmapFont createFont(FileHandle fileHandle,int borderWidth) {
    // load font
    FreeTypeFontGenerator generator = new FreeTypeFontGenerator(fileHandle);
    FreeTypeFontGenerator.FreeTypeFontParameter parameter = new FreeTypeFontGenerator.FreeTypeFontParameter();

    // https://github.com/libgdx/libgdx/wiki/Gdx-freetype
    parameter.size = size;
    parameter.borderColor = borderColor;
    parameter.borderWidth = borderWidth;
    parameter.color = color;

    BitmapFont font48 = generator.generateFont(parameter);
    generator.dispose();

    return font48;
}

private void loadAssets() {
    InternalFileHandleResolver fileHandler = new InternalFileHandleResolver();
    assetManager = new AssetManager(fileHandler);
    assetManager.setLoader(FreeTypeFontGenerator.class,new FreeTypeFontGeneratorLoader(fileHandler));

    assetManager.load(SKIN_PATH,Skin.class);
    assetManager.load(MASTER_PATH,TextureAtlas.class);
    assetManager.load(FONT_norMAL_PATH,FreeTypeFontGenerator.class);
    assetManager.load(FONT_BOLD_PATH,FreeTypeFontGenerator.class);
    assetManager.load(MUSIC_PATH,Music.class);
    assetManager.load(MAIN_MENU_MUSIC_PATH,Music.class);
    assetManager.load(GOOD_PATH,Sound.class);
    assetManager.load(HALF_PATH,Sound.class);
    assetManager.load(BAD_PATH,Sound.class);
    assetManager.finishLoading();
}

private void initUtils() {
    //init camera & viewport
    camera = new OrthographicCamera();
    viewport = new StretchViewport(polymorph.WORLD_WIDTH,polymorph.WORLD_HEIGHT,camera);
    viewport.apply(true);
    camera.update();

    //init sprite batch
    batch = new SpriteBatch();
    batch.setProjectionMatrix(camera.combined);

    //init font
    FreeTypeFontGenerator fontGenerator = polymorph.getAssetManager().get(polymorph.FONT_BOLD_PATH,FreeTypeFontGenerator.class);
    FreeTypeFontParameter fontSettings = new FreeTypeFontParameter();
    fontSettings.size = 80;
    fontSettings.minFilter = TextureFilter.Linear;
    fontSettings.magFilter = TextureFilter.Linear;
    font = fontGenerator.generateFont(fontSettings);
}

private static BitmapFont createFont(int fontSize,Fonts type) {
    FileHandle fontFile = null;
    switch(type){
        case HEMI_HEAD: fontFile = Gdx.files.internal("fonts/HEMIHEAD.TTF"); break;
        case VERA: fontFile = Gdx.files.internal("fonts/Vera.ttf"); break;
        case VERA_BD: fontFile = Gdx.files.internal("fonts/VeraBd.ttf"); break;
default:
    break;
    }
      FreeTypeFontGenerator generator = new FreeTypeFontGenerator(fontFile);
      FreeTypeFontGenerator.FreeTypeFontParameter parameter = new FreeTypeFontGenerator.FreeTypeFontParameter();
      parameter.size = fontSize;

      BitmapFont font = generator.generateFont(parameter);
      generator.dispose();
      return font;
  }

/**
 * 初始游戏字体
 */
private void initFont() {
    FreetypeFontLoader.FreeTypeFontLoaderParameter fontConfig = new FreetypeFontLoader.FreeTypeFontLoaderParameter();
    fontConfig.fontFileName = "font.ttf";
    fontConfig.fontParameters.size = 22;

    FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal("font.ttf"));
    FreeTypeFontGenerator.FreeTypeFontParameter parameters = new FreeTypeFontGenerator.FreeTypeFontParameter();

    parameters.size = 18;
    f18 = generator.generateFont(parameters);
    parameters.size = 22;
    f22 = generator.generateFont(parameters);
    parameters.size = 24;
    f24 = generator.generateFont(parameters);

    generator.dispose();
}

public void create() {
    batch = new SpriteBatch();
    font = new BitmapFont();

    FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal("gfx/fonts/roboto-regular.ttf"));
    FreeTypeFontParameter parameter = new FreeTypeFontParameter();
    parameter.size = 16;
    font = generator.generateFont(parameter); // font size 16 pixels
    generator.dispose();

    music = Gdx.audio.newMusic(Gdx.files.internal("sounds/main.ogg"));
    music.setLooping(true);
    music.play();

    this.setScreen(new MenuScreen(this));
}

private HUD() {
    stage = new Stage(new FitViewport(Gdx.graphics.getWidth(),Gdx.graphics.getHeight()));
    stage.addListener(inputListener = new InputListener(true));
    Gdx.input.setInputProcessor(stage);

    fontGenerator = new FreeTypeFontGenerator(Gdx.files.internal("font.ttf"));
    skin = new Skin(Gdx.files.internal("uiskin.json"));
    createFlashImage();
    createProgressLabel();
    createInfoLabel();
    createLevelCompleteUI();
    hideLevelComplete();

    if (Globals.isMobile()) {
        createMobileButtons();
    }
}

private void createReplayButton() {
    FreeTypeFontGenerator.FreeTypeFontParameter fontParam = new FreeTypeFontGenerator.FreeTypeFontParameter();
    fontParam.size = Gdx.graphics.getWidth() / 8;

    TextButton.TextButtonStyle style = new TextButton.TextButtonStyle();
    style.font = fontGenerator.generateFont(fontParam);
    style.fontColor = Color.WHITE;

    final TextButton playButton = new TextButton("REPLAY?",skin);
    playButton.setSize(Gdx.graphics.getWidth(),Gdx.graphics.getHeight());
    playButton.setPosition(0,0);
    playButton.setStyle(style);
    playButton.addListener(new ClickListener() {
        @Override
        public void touchUp(InputEvent event,float x,float y,int pointer,int button) {
            game.setScreen(new Driver(game));
        }
    });

    stage.addActor(playButton);
}

public Font(String filePath,boolean filter)
{
    // ASSIGN ATTRIBUTES
    this.size = size;
    this.color = color;

    // GENERATE FONT
    generator = new FreeTypeFontGenerator(Gdx.files.internal(filePath));
    if (filter) // IF FILTER ENABLED
    {
        parameter.genMipMaps = true;
        parameter.minFilter = Texture.TextureFilter.Linear;
        parameter.magFilter = Texture.TextureFilter.Linear;
    }
    parameter.size = size;
    parameter.color = color;
    font = generator.generateFont(parameter);
    generator.dispose();
}

private Drawable getFontIcon(FileChooser.FileItem item) {
    FileHandle fileHandle = item.getFile();
    BitmapFont bitmapFont;
    try {
        FreeTypeFontGenerator generator = new FreeTypeFontGenerator(fileHandle);
        FreeTypeFontGenerator.FreeTypeFontParameter parameter = new FreeTypeFontGenerator.FreeTypeFontParameter();
        parameter.size = CB.getScaledInt(50);
        parameter.characters = SkinFont.DEFAULT_CHaraCTER;
        parameter.genMipMaps = true;
        parameter.minFilter = Texture.TextureFilter.MipMapNearestNearest;
        bitmapFont = generator.generateFont(parameter);
    } catch (Exception e) {
        return getimageIcon(item);
    }

    Drawable drawable = new BitmapFontDrawable(bitmapFont,item.getFile().nameWithoutExtension());
    return drawable;
}

public Font(final Application APP,String fileName,String filePath,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);
}

public MenuScreen(TTmath game,OrthoCamera camera,SpriteBatch sb){
        this.camera = camera;
        this.game = game;
        this.sb = sb;
        game.resetscore();
        game.manageScreens(this);
//      game.mainMenuScreen = this;

        createStage();

        FreeTypeFontGenerator TEXT_8BIT = new FreeTypeFontGenerator(Gdx.files.internal("resources/minecraftia-Regular.ttf"));
        font = createFont(TEXT_8BIT,25);
        TEXT_8BIT.dispose();

        createButton();
    }

private void createdisplay() {
    if(created){
        return;
    }

    FreeTypeFontGenerator TEXT_8BIT = new FreeTypeFontGenerator(Gdx.files.internal("resources/minecraftia-Regular.ttf"));
    createFont(TEXT_8BIT,25);
    TEXT_8BIT.dispose();

    createQuestions();
    createStage();
    createLabel();
    createButton();
       createscoreLabel();
       createIncorrectLabel();

    created = true;
    game.problemScreen = this;
}

public GameOverScreen(TTmath game,SpriteBatch sb) {
        this.game = game;
        this.camera = camera;
        this.sb = sb;

//        game.gameOver = this;
        game.setScreen(this);

        Gdx.input.setCatchBackKey(true);


        FreeTypeFontGenerator TEXT_8BIT = new FreeTypeFontGenerator(Gdx.files.internal("resources/minecraftia-Regular.ttf"));
        createFont(TEXT_8BIT,25);
        TEXT_8BIT.dispose();

        createStage();
        createLabel();
        createButton();
    }

public HighscoreScreen(TTmath game,SpriteBatch sb){
    this.game = game;
    this.camera = camera;
    this.sb = sb;
    gamescore = game.getscore();
    jscore = new Jsonscore();
    ArrayList<score> score = jscore.getHighscoreList();

    FreeTypeFontGenerator TEXT_8BIT = new FreeTypeFontGenerator(Gdx.files.internal("resources/minecraftia-Regular.ttf"));
    createFont(TEXT_8BIT,25);
    TEXT_8BIT.dispose();

    createStage();
    createLabel("High scores!",true);
    for(int i = 0; i < score.size(); i++){
        table.row();
        createLabel(score.get(i).getUser(),false);
        createLabel(Integer.toString(score.get(i).getscore()),false);
    }
    createButon();
}

public LevelMenuScreen(TTmath game,SpriteBatch sb){
        this.camera = camera;
        this.game = game;
        this.sb = sb;

        game.manageScreens(this);
//      game.levelMenu = this;
        Gdx.input.setCatchBackKey(true);
        FreeTypeFontGenerator TEXT_8BIT = new FreeTypeFontGenerator(Gdx.files.internal("resources/minecraftia-Regular.ttf"));
        createFont(TEXT_8BIT,25);
        TEXT_8BIT.dispose();

        createStage();
        createLabel();
        createButton();
    }

public void init(){
    table = new Table();
    FreeTypeFontGenerator ftfg = new FreeTypeFontGenerator(Assets.KENPIXEL_BLOCKS);
    FreeTypeFontGenerator.FreeTypeFontParameter ftfp = new FreeTypeFontGenerator.FreeTypeFontParameter();
    ftfp.size = 24; //the size can be changed later
    ftfp.color = new Color(0.42f,0.64f,0.62f,1);
    BitmapFont font = ftfg.generateFont(ftfp);

    Label.LabelStyle style = new Label.LabelStyle();
    style.font=font;

    capacity = new Label("0",style);
    currentFlow = new Label("0",style);

    table.add(currentFlow).padright(2f).center();
    table.add(capacity).padLeft(2f).center();

    table.setPosition(posX*64+32,posY*64+32);
}

static UnderlineMetrics deriveUnderlineMetrics(FreeTypeFontGenerator generator,int size) {
    try {
        // Size metrics aren't publicly accessible (as of 1.9.3). (Ab)use reflection to gain access.
        Field faceField = FreeTypeFontGenerator.class.getDeclaredField("face");
        faceField.setAccessible(true);
        Face face = (Face)faceField.get(generator);

        SizeMetrics sizeMetrics = face.getSize().getMetrics();

        int yScale = sizeMetrics.getYscale(); // 16.16 fixed point
        float position = FreeType.toInt(face.getUnderlinePosition() * yScale >> 16);
        float thickness = FreeType.toInt(face.getUnderlineThickness() * yScale >> 16);
        return new UnderlineMetrics(position,thickness);
    } catch (Exception e) {
        LOG.error("Error fetching FreeType underline metrics",e);
    }

    // Return a reasonable default
    return UnderlineMetrics.defaultInstance(size);
}

private void initFonts() {
    FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal("fonts/roboto.ttf"));

    FreeTypeFontGenerator.FreeTypeFontParameter params = new FreeTypeFontGenerator.FreeTypeFontParameter();
    params.size = 48;
    params.color = new Color(.25f,.25f,.85f,1);
    params.shadowOffsetX = 0;
    params.shadowOffsetY = 0;
    params.shadowColor = Color.BLACK;
    titleFont = generator.generateFont(params);

    params = new FreeTypeFontGenerator.FreeTypeFontParameter();
    params.size = 32;
    params.color = Color.BLACK;
    buttonFont = generator.generateFont(params);
    generator.dispose();
}

public GridMapRenderer() {

        // load font from a .ttf file
        try {
            FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal("data/font/jgfont.ttf"));
            FreeTypeFontParameter fp = new FreeTypeFontParameter();
            fp.size = 9;
            font9 = generator.generateFont(fp);
            generator.dispose();

            shapeRenderer = RTSGame.game.cameraShapeRenderer;
            fontBatch = new SpriteBatch();
        } catch (Exception e) {
            e.printstacktrace();
        }

    }

public QuadTreeRenderer() {

        // load font from a .ttf file
        try {
            FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal("data/font/jgfont.ttf"));
            FreeTypeFontParameter fp = new FreeTypeFontParameter();
            fp.size = 9;
            font9 = generator.generateFont(fp);
            generator.dispose();

            shapeRenderer = RTSGame.game.cameraShapeRenderer;
            fontBatch = new SpriteBatch();
        } catch (Exception e) {
            e.printstacktrace();
        }

    }

@Override
public void create () {
    boolean flip = false;
    batch = new SpriteBatch();
    if (flip) {
        OrthographicCamera cam = new OrthographicCamera();
        cam.setToOrtho(flip);
        cam.update();
        batch.setProjectionMatrix(cam.combined);
    }
    font = new BitmapFont(Gdx.files.internal("data/arial-15.fnt"),flip);
    FileHandle fontFile = Gdx.files.internal("data/arial.ttf");

    FreeTypeFontGenerator generator = new FreeTypeFontGenerator(fontFile);

    FreeTypeFontParameter parameter = new FreeTypeFontParameter();
    parameter.size = 15;
    parameter.flip = flip;
    parameter.genMipMaps = true;

    FreeTypeBitmapFontData fontData = generator.generateData(parameter);
    ftFont = generator.generateFont(parameter);
    generator.dispose();
}

public void render () {
    if (Gdx.input.justTouched()) {
        for (int i = 0; i < 10; i++) {
            if (font != null) {
                font.dispose();
            }
            FileHandle fontFile = Gdx.files.internal("data/arial.ttf");
            FreeTypeFontGenerator generator = new FreeTypeFontGenerator(fontFile);

            FreeTypeFontParameter parameter = new FreeTypeFontParameter();
            parameter.size = 15;

            font = generator.generateFont(parameter);
            generator.dispose();
        }
        for (int i = 0; i < 10; i++)
            System.gc();
        Gdx.app.log("FreeTypedisposeTest","generated 10 fonts");
        Gdx.app.log("FreeTypedisposeTest",Gdx.app.getJavaHeap() + "," + Gdx.app.getNativeHeap());
    }
}

public static void loadFonts(){
    FreeTypeFontGenerator font_gen = new FreeTypeFontGenerator(Gdx.files.internal("font.ttf"));
    FreeTypeFontParameter parameter = new FreeTypeFontParameter();
    parameter.size = 100;
    font100 = font_gen.generateFont(parameter);
    font100.getRegion().getTexture().setFilter(TextureFilter.Linear,TextureFilter.Linear);
    font100.setColor(Color.BLACK);  
    font100.setScale(1,-1);

    parameter.size = 75;
    font75 = font_gen.generateFont(parameter);
    font75.getRegion().getTexture().setFilter(TextureFilter.Linear,TextureFilter.Linear);
    font75.setColor(Color.BLACK);   
    font75.setScale(1,-1);

    parameter.size = 250;   
    font250 = font_gen.generateFont(parameter);
    font250.getRegion().getTexture().setFilter(TextureFilter.Linear,TextureFilter.Linear);
    font250.setColor(Color.BLACK);  
    font250.setScale(1,-1);

    font_gen.dispose();
}

/**
 * Convenience method for generating a font,and then writing the fnt and
 * png files. Writing a generated font to files allows the possibility of
 * only generating the fonts when they are missing,otherwise loading from a
 * prevIoUsly generated file.
 * 
 * @param fontFile
 * @param fontSize
 * @param destiny
 */
private void generateFiles(String fontName,FileHandle fontFile,int fontSize,int pageWidth,int pageHeight,FileHandle destiny) {
    FreeTypeFontGenerator generator = new FreeTypeFontGenerator(fontFile);

    pixmapPacker packer = new pixmapPacker(pageWidth,pageHeight,pixmap.Format.RGBA8888,2,false);
    FreeTypeFontParameter param = new FreeTypeFontParameter();
    param.packer = packer;
    param.characters = FreeTypeFontGenerator.DEFAULT_CHARS;
    param.size = fontSize;
    param.flip = false;

    FreeTypeFontGenerator.FreeTypeBitmapFontData fontData = generator
            .generateData(param);

    saveFontToFile(fontData,fontSize,fontName,packer,destiny);
    generator.dispose();
    packer.dispose();
}

/**
 * Liefert BitmapFont,die gut geeignet sind fuer Ueberschriften.
 * 
 * @param size
 *            vom Typ FontSize umd die Groesse der Schriftart zu definieren
 * @return b BitmapFont
 */
@SuppressWarnings("deprecation")
public static BitmapFont getHeadlineFont(final FontSize size) {
    if (headlineFonts == null){
        headlineFonts = new BitmapFont[FontSize.values().length];
    }

    if (headlineFonts[size.ordinal()] == null) {
        int startIdx = directoryFonts.indexOf(FOLDERNAME_FONTS);
        String relativeFilePath = directoryFonts.substring(startIdx,directoryFonts.length()).replace("\\","/") + FILESEParaTOR + "headlinefont/GetVoIP Grotesque.ttf";

        FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal(relativeFilePath));
        headlineFonts[size.ordinal()] = generator.generateFont(size.getVal());
    }
    headlineFonts[size.ordinal()].setScale(1f);

    return headlineFonts[size.ordinal()];
}

/**
 * Liefert BitmapFont,die gut geeignet sind fuer Texte.
 * 
 * @param size
 *            vom Typ FontSize umd die Groesse der Schriftart zu definieren
 * @return b BitmapFont
 */
@SuppressWarnings("deprecation")
public static BitmapFont getTextFont(final FontSize size) {
    if (textFonts == null){
        textFonts = new BitmapFont[FontSize.values().length];
    }

    if (textFonts[size.ordinal()] == null) {
        int startIdx = directoryFonts.indexOf(FOLDERNAME_FONTS);
        String relativeFilePath = directoryFonts.substring(startIdx,"/") + FILESEParaTOR + "textfont/Grundschrift-Bold.ttf";

        FreeTypeFontGenerator gen = new FreeTypeFontGenerator(Gdx.files.internal(relativeFilePath));
        textFonts[size.ordinal()] = gen.generateFont(size.getVal());
        gen.dispose();
    }
    textFonts[size.ordinal()].setScale(1f);

    return textFonts[size.ordinal()];
}

/**
 * Erzeugt den LadeButtonText.
 */
private void createButton() {
    Drawable drawable = new TextureRegionDrawable((new TextureRegion(new Texture(
            Gdx.files.internal("splashscreen/buttonBackground.png")))));
    FreeTypeFontGenerator gen = new FreeTypeFontGenerator(
            Gdx.files.internal("fonts/textfont/Grundschrift-Bold.ttf"));
    FreeTypeFontParameter frontPara = new FreeTypeFontParameter();
    frontPara.size = 40;

    BitmapFont b = gen.generateFont(frontPara);
    gen.dispose();
    ImageTextButtonStyle imageButtonStyle = new ImageTextButton.ImageTextButtonStyle();
    imageButtonStyle.down = drawable;
    imageButtonStyle.up = drawable;
    imageButtonStyle.font = b;

    imageButtonStyle.fontColor = Color.valueOf("877E6A");

    textContent = new ImageTextButton("Lade... : ",imageButtonStyle);

}

/**
 * Gets a font from the cache if it exists otherwise creates it based on the following arguments
 * @param fontID id of the font,must be in the format: {ttf-file-name}-{size}
 * @param defaultPath path to the ttf file used to create the font if it doesn't exist
 * @return the BitmapFont or null if it doesn't exist and no path is provided
 */
public static BitmapFont getFont(String fontID,String defaultPath) {
    if (fonts.containsKey(fontID)) {
        return fonts.get(fontID);
    }
    else if (defaultPath != null) {
        FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal(defaultPath));
        FreeTypeFontGenerator.FreeTypeFontParameter parameter = new FreeTypeFontGenerator.FreeTypeFontParameter();
        parameter.size = Integer.parseInt(fontID.split("-")[1]);
        BitmapFont font = generator.generateFont(parameter);
        generator.dispose();
        fonts.put(fontID,font);
        return font;
    }
    return null;
}

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);
}

/**
 * Retrieve the desired font and size (may load the font
 * if not cached).
 * 
 * @param alias
 * @param size
 * @return the font
 */
private BitmapFont getFont(String alias,int size) {
    BitmapFont font = null;

    String mask = alias + ":" + size;
    if(this.fonts.containsKey(mask)) {
        font = this.fonts.get(mask);
    }
    else if(this.generators.containsKey(alias)) {
        FreeTypeFontParameter params = new FreeTypeFontParameter();
        params.size = size;
        params.characters = FreeTypeFontGenerator.DEFAULT_CHARS;
        params.flip = true;
        params.magFilter = TextureFilter.Linear;
        params.minFilter = TextureFilter.Linear;

        font = this.generators.get(alias).generateFont(params);
        this.fonts.put(mask,font);
    }

    return font;
}

public Assets()
{
    textureParameter = new TextureLoader.TextureParameter();
    //textureParameter.genMipMaps = true;
    textureParameter.magFilter = Texture.TextureFilter.Linear;
    textureParameter.minFilter = Texture.TextureFilter.Linear;

    resolver = new MaryoFileHandleResolver();
    manager = new AssetManager(resolver);

    particleEffectParameter = new ParticleEffectLoader.ParticleEffectParameter();
    particleEffectParameter.imagesDir = resolver.resolve("data/animation/particles");

    // set the loaders for the generator and the fonts themselves
    manager.setLoader(FreeTypeFontGenerator.class,new FreeTypeFontGeneratorLoader(resolver));
    manager.setLoader(BitmapFont.class,new FreetypeFontLoader(resolver));
    manager.setLoader(ParticleEffect.class,".p",new ParticleEffectLoader(resolver));
    manager.setLoader(Sound.class,".mp3",new SoundLoader(new InternalFileHandleResolver()));
    manager.setLoader(Music.class,new MusicLoader(new InternalFileHandleResolver()));
}

/** Convenience method for generating a font,and then writing the fnt and png files.
 * Writing a generated font to files allows the possibility of only generating the fonts when they are missing,otherwise
 * loading from a prevIoUsly generated file.
 * @param fontFile
 * @param fontSize
 */
private BitmapFont generateFontWriteFiles(String fontName,int pageHeight) {
    FreeTypeFontGenerator generator = new FreeTypeFontGenerator(fontFile);

    pixmapPacker packer = new pixmapPacker(pageWidth,false);
    FreeTypeFontGenerator.FreeTypeBitmapFontData fontData = generator.generateData(fontSize,FreeTypeFontGenerator.DEFAULT_CHARS,false,packer);
    Array<pixmapPacker.Page> pages = packer.getPages();
    TextureRegion[] texRegions = new TextureRegion[pages.size];
    for (int i=0; i<pages.size; i++) {
        pixmapPacker.Page p = pages.get(i);
        Texture tex = new Texture(new pixmapTextureData(p.getpixmap(),p.getpixmap().getFormat(),true)) {
            @Override
            public void dispose () {
                super.dispose();
                getTextureData().consumepixmap().dispose();
            }
        };
        tex.setFilter(Texture.TextureFilter.Nearest,Texture.TextureFilter.Nearest);
        texRegions[i] = new TextureRegion(tex);
    }
    BitmapFont font = new BitmapFont(fontData,texRegions,false);
    saveFontToFile(font,packer);
    generator.dispose();
    packer.dispose();
    return font;
}

@Override
public void show() {
    camera = new OrthographicCamera(Gdx.graphics.getWidth(),Gdx.graphics.getHeight());
    camera.setToOrtho(false);
    camera.position.x = Gdx.graphics.getWidth() / 2;
    camera.position.y = Gdx.graphics.getHeight() / 2;

    //Get the font.
    FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal("mainmenu/new/kenvector_future.ttf"));
    FreeTypeFontParameter parameter = new FreeTypeFontParameter();
    parameter.size = 15;
    font = generator.generateFont(parameter);
    generator.dispose();


    System.gc(); //We no longer need the Main Menu stuff,we should clean it up.
}

public static BitmapFont getFont() {
    if (font == null) {
        FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal("VCROSDMono.ttf"));
        FreeTypeFontGenerator.FreeTypeFontParameter parameter = new FreeTypeFontGenerator.FreeTypeFontParameter();
        parameter.size = 30;
        parameter.borderWidth = 1;
        parameter.color = Color.BLACK;
        parameter.shadowOffsetX = 2;
        parameter.shadowOffsetY = 2;
        parameter.shadowColor = new Color(0,1f,0.5f);
        font = generator.generateFont(parameter);
        generator.dispose();
    }
    return font;
}

private BitmapFont getFont() {
    FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal("fonts/DroidSans.ttf"));
    FreeTypeFontParameter parameter = new FreeTypeFontParameter();
    parameter.size = 20;
    BitmapFont font = generator.generateFont(parameter);
    generator.dispose();
    return font;
}

/**
 * Generate new bitmap font.
 *
 * @param fontDescriptor Descriptor object describing font properties.
 * @return Newly generated bitmap font.
 */
private static BitmapFont generateFont(FontDescriptor fontDescriptor) {

    FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal(fontDescriptor.getFontFilename()));
    FreeTypeFontGenerator.FreeTypeFontParameter parameter = new FreeTypeFontGenerator.FreeTypeFontParameter();
    parameter.color = fontDescriptor.getForegroundColor();
    parameter.size = fontDescriptor.getFontSize();
    parameter.borderWidth = fontDescriptor.getBorderWidth();
    parameter.borderColor = fontDescriptor.getBorderColor();
    parameter.borderStraight = fontDescriptor.isstraightBorderUsed();
    BitmapFont font = generator.generateFont(parameter);
    generator.dispose();

    return font;
}

public StatusScreen(CaramelosGame game,boolean victory,int level)
{
    this.game = game;
    this.victory = victory;
    this.level = level;

    Preferences prefs = Gdx.app.getPreferences("My Preferences");
    flagSound = prefs.getBoolean("sound");
    if(victory)
        mp3Music = Gdx.audio.newMusic(Gdx.files.internal("Music/Victory.mp3"));
    else{
        mp3Music = Gdx.audio.newMusic(Gdx.files.internal("Music/GameOver.mp3"));
    }
    mp3Music.setLooping(true);
    if(flagSound){
        mp3Music.play();
    }

    FreeTypeFontGenerator generator = new FreeTypeFontGenerator(Gdx.files.internal("Vollkorn/Vollkorn-Regular.ttf"));
    FreeTypeFontGenerator.FreeTypeFontParameter parameter = new FreeTypeFontGenerator.FreeTypeFontParameter();
    parameter.size = 24;
    font12 = generator.generateFont(parameter); // font size 12 pixels
    generator.dispose(); // don't forget to dispose to avoid memory leaks!

    FileHandle baseFileHandle = Gdx.files.internal("Messages/menus");
    String localeLanguage =java.util.Locale.getDefault().toString();
    Locale locale = new Locale(localeLanguage);
    I18NBundle myBundle = I18NBundle.createBundle(baseFileHandle,locale,"UTF-8");
    menulevel = myBundle.get("menulevel");
    menuvictory = myBundle.get("menuvictory");
    menuchampion = myBundle.get("menuchampion");
    menucontinue = myBundle.get("menucontinue");
    menugameover = myBundle.get("menugameover");
}

@Override
public void show() 
{
    fpsLogger = new FPSLogger();

    batch = new SpriteBatch();
    camera = new OrthographicCamera(500,800);
    viewport = new FitViewport(500,800,camera);
    player = new Player();
    player.create();

    background = new Background();
    background.create();

    spawningFactory = new SpawningFactory();
    spawningFactory.create();

    spawningEnemy = new SpawningEnemy();
    spawningEnemy.create();

    spawningBullet = new SpawningBullet();
    spawningBullet.create();

    ui = new UI();
    ui.create();
}

/**
 * Zeigt den Namenswahl Bilschirm an
 *
 * @param camera  die aktuelle Kamera
 * @param deltaTime die vergangene Zeit seit dem letztem Frame
 */
public void renderName(OrthographicCamera camera,float deltaTime)
{
    strokeTimer += deltaTime;

    if (strokeTimer > 0.6f)
    {
        strokeTimer = 0f;
        stateSwitch = !stateSwitch;
        playerNamestroke = String.format("%s%s",playerName,stateSwitch ? " " : "|");
    }

    fontLayout.setText(font,localeBundle.get("name_eingeben"),Color.WHITE,camera.viewportWidth,Align.center,false);
    font.draw(batch,fontLayout,-camera.viewportWidth / 2,camera.viewportHeight / 2 - 120);

    fontLayout.setText(font,playerNamestroke,Color.ROYAL,30);

    fontLayout.setText(smallFont,localeBundle.get("enter_bestaetigen"),false);
    smallFont.draw(batch,-camera.viewportHeight / 2 + 70);
}

public GameService(SpriteBatch batch,IGameAsset asset,BaseGameSetting setting,OrthographicCamera camera,ISceneManager sceneManager) {
this.batch = batch;
this.asset = asset;
this.setting = setting;

if (asset == null)
    this.asset = new DefaultGameAsset();
if (setting == null)
    this.setting = new DefaultGameSetting();
this.camera = camera;
this.setChangeScene(sceneManager);
Rectangle.tmp.set(0,getwindowSize().x,getwindowSize().y);

services = new IService[MAX_SERVICES];
   }

public static boolean touchInRectangle(Rectangle r,OrthographicCamera camera) {
if (Gdx.input.isTouched()) {
    Vector3 touchPos = new Vector3();
    touchPos.set(Gdx.input.getX(),Gdx.input.getY(),0);
    camera.unproject(touchPos);
    return r.x <= touchPos.x && r.x + r.width >= touchPos.x
        && r.y <= touchPos.y && r.y + r.height >= touchPos.y;
}
return false;
   }

@Override
public void create() {

        rotationSpeed = 0.5f;
        mesh = new Mesh(true,4,6,new VertexAttribute(VertexAttributes.Usage.Position,3,"attr_Position"),new VertexAttribute(Usage.TextureCoordinates,2,"attr_texCoords"));
        texture = new Texture(Gdx.files.internal("data/Jellyfish.jpg"));
        mesh.setVertices(new float[] { 
                         -1024f,-1024f,1,1024f,0
        });
        mesh.setIndices(new short[] { 0,0 });

        cam = new OrthographicCamera(Gdx.graphics.getWidth(),Gdx.graphics.getHeight());            
        xScale = Gdx.graphics.getWidth()/(float)TARGET_WIDTH;
        yScale = Gdx.graphics.getHeight()/(float)TARGET_HEIGHT;
        font = loadBitmapFont("default.fnt","default.png");
        scale = Math.min(xScale,yScale);
        cam.zoom = 1/scale;
      //  cam.project(start_position);
        cam.position.set(0,0);
        batch = new SpriteBatch();
}

@Override
public void create() {      
    float w = Gdx.graphics.getWidth();
    float h = Gdx.graphics.getHeight();

    camera = new OrthographicCamera(1,h/w);
    batch = new SpriteBatch();

    texture = new Texture(Gdx.files.internal("data/libgdx.png"));
    texture.setFilter(TextureFilter.Linear,TextureFilter.Linear);

    TextureRegion region = new TextureRegion(texture,200,200);

    sprite = new Sprite(region);
    sprite.setSize(1f,sprite.getHeight() / sprite.getWidth());
    sprite.setorigin(sprite.getWidth()/2,sprite.getHeight()/2);
    sprite.setPosition(-.5f,-.5f);

}

public MenuScreen() {
    camera = new OrthographicCamera();
    viewport = new FitViewport(Game.WIDTH,Game.HEIGHT,camera);
    viewport.apply();
    camera.position.set(Game.WIDTH / 2,Game.HEIGHT / 2,0);
    camera.update();
    betaText = new BitmapFont(Gdx.files.internal("score.fnt"),Gdx.files.internal("score.png"),false);
    betaText.getData().setScale(0.35f);
    logo = new Sprite(new Texture("logo.png"));
    Random r = new Random();
    background = new Particle[r.nextInt(55 - 45) + 45];
    for (int i = 0; i < background.length; i++) {
        int size = r.nextInt(4) + 1;
        int x = r.nextInt(Game.WIDTH);
        int y = r.nextInt(Game.HEIGHT);
        background[i] = new Particle(x,y,-1,new Color(207 / 255f,187 / 255f,20 / 255f,1f),size);
    }
    musicMuted = new Sprite(new Texture(Gdx.files.internal("buttons/music_muted.png")));
    musicUnmuted = new Sprite(new Texture(Gdx.files.internal("buttons/music_unmuted.png")));
    play = new CenteredButton(500,"buttons/play.png");
    music = new Button(Game.WIDTH - 130,15,Game.musicMuted() ? musicMuted : musicUnmuted);
    music.setScale(4f);
}

LevelScreen(GftGame game) {
    this.game = game;

    this.guiCam = new OrthographicCamera(800,480);
    this.guiCam.position.set(800 / 2,480 / 2,0);

    this.backBounds = new Rectangle(7,432,48,48);
    this.autoMovetoNextBounds = new Rectangle(0,62);

    this.levelBounds = new ArrayList<Rectangle>();
    int line = 0;
    int column = 0;
    for(int i = 0; i < LEVELS; i++) {
        this.levelBounds.add(i,new Rectangle(370 + 75 * column++,240 - 70 * line,57,57));
        if(column == 5) {
            column = 0;
            line++;
        }
    }

    this.touchPoint = new Vector3();
}

public GameCenter(Chat game){
  this.game = game;

  /*Camera Settings*/
  camera = new OrthographicCamera();
  camera.setToOrtho(false,480,800);
  camera.position.set(480/2,800/2,0);

  /*Button Areas*/
  wordTiles = new Rectangle(480/2-250/2,250,55);
  Arkanoid = new Rectangle(480/2-250/2,800/2-60,55);
  WordCrush = new Rectangle(480/2-250/2,800/2-120,55);
  EndlessRoad = new Rectangle(480/2-250/2,800/2-180,55);
  bottone4 = new Rectangle(480/2-250/2,800/2-240,55);
  buttonTexture = new Texture("green_button00.png");
  touch = new Vector3();
}

public ScreenCombat(GameManager gameManager) {
    this.gameManager = gameManager;
    managerAssets = ManagerAssets.getInstance();
    cam = new OrthographicCamera();
    UpdatedisplayCombat.getInstance().setScreenCombat(this);
    camera = new PerspectiveCamera(40,Gdx.graphics.getWidth(),Gdx.graphics.getHeight());
    camera.position.set(0,350);//initial 180
    camera.lookAt(0,0);
    camera.far = 2500;
    camera.near = 1;
    camera.update();
    centerPlayer = new Integer[7];
    for(int i=0;i<7;i++){
        centerPlayer[i]=-1;
    }
}

private void initUtils() {
    //init camera & viewport
    camera = new OrthographicCamera();
    viewport = new StretchViewport(polymorph.WORLD_WIDTH,polymorph.WORLD_HEIGHT,camera);
    viewport.apply(true);
    camera.update();

    //init sprite batch
    batch = new SpriteBatch();
    batch.setProjectionMatrix(camera.combined);

    //init font
    FreeTypeFontGenerator fontGenerator = polymorph.getAssetManager().get(polymorph.FONT_BOLD_PATH,FreeTypeFontGenerator.class);
    FreeTypeFontParameter fontSettings = new FreeTypeFontParameter();
    fontSettings.size = 80;
    fontSettings.minFilter = TextureFilter.Linear;
    fontSettings.magFilter = TextureFilter.Linear;
    font = fontGenerator.generateFont(fontSettings);
}

public void show() {
    if (!init) {
        loadingScreenAssets = new Assets.LoadingScreenAssets();
        AL.getAssetManager().loadAssetFields(loadingScreenAssets);
        AL.getAssetManager().finishLoading();
        font = new BitmapFont();
        batch = new SpriteBatch();

        cam = new OrthographicCamera();
        viewport = new FitViewport(1920,1080);
        viewport.setCamera(cam);
        stage = new Stage(viewport);
        stage.setViewport(viewport);
        skin = loadingScreenAssets.styles_json;

        loadingScreenBar = new ProgressBar(0,100,false,skin);
        loadingScreenBar.setPosition(25,-10);
        loadingScreenBar.setSize(1890,50);

        stage.addActor(loadingScreenBar);
    }
    init = true;
}

/**
 * Method responsible for initializing the main menu
 * Called when the screen becomes the current screen of the game
 */
@Override
public void show() {
    cam = new OrthographicCamera();
    viewport = new FitViewport(1920,1080);
    viewport.setCamera(cam);
    stage = new Stage(viewport);
    stage.setViewport(viewport);
    skin = settingsAssets.styles_json;
    int x = 1920;
    int y = 1080;
    spriteBatch = new SpriteBatch();
    mainbackground = settingsAssets.testmainscreen;
    BitmapFont font = settingsAssets.bocklin_fnt;
    TextureRegion backgroundTexture = new TextureRegion(settingsAssets.background_textbutton);

    inputTable = new Table();
    keys = IInputConfig.InputKeys.values();
    keyMap = new HashMap<>();

    initInputRows(font,backgroundTexture);
    createBackButton();
    AL.input.setInputProcessor(new InputMultiplexer(stage,this));
}

public void render(OrthographicCamera camera,SpriteBatch batch,int y,MenuEntry activeEntry,SchoolGame game,I18NBundle localeBundle,float deltaTime) {

            Color entryColor = getColor();
            if (this == activeEntry)
            {
                entryColor = getActiveColor();
            }
            if (!isEnabled())
            {
                entryColor = getdisabledColor();
            }

            if (font == null)
                font = game.getDefaultFont();

            if (fontSmall == null)
                fontSmall = game.getLongTextFont();

            fontLayout.setText(font,localeBundle.format(getLabel(),id,used,gender),entryColor,false);
            font.draw(batch,y);

            fontLayout.setText(fontSmall,localeBundle.format(detail,levelName,playTime),false);
            fontSmall.draw(batch,y - 50);
        }

public RenderSystem(DecalBatch decalBatch,AssetManager assetManager,float worldDegree,Assets.LevelAssets assets) {
    super(Aspect.all(RenderComponent.class,PositionComponent.class));
    this.levelAssets = assets;
    decalmap = new ObjectMap<>();
    uiMap = new ObjectMap<>();
    this.decalBatch = decalBatch;
    this.assetManager = assetManager;
    buffers = new ObjectMap<>();

    this.spriteBatch = new SpriteBatch();
    this.font = assets.uifont;
    font.setColor(Color.BLACK);
    this.uiCamera = new OrthographicCamera();

    Viewport viewportUi = new FitViewport(levelAssets.health_bar_gradient.getWidth(),levelAssets.health_bar_gradient.getHeight(),uiCamera);
    viewportUi.update(viewportUi.getScreenWidth(),viewportUi.getScreenHeight(),true);

    stateTime = 0;
    this.worldDegree = worldDegree;

    gradientShader = new ShaderProgram(Shaders.GradientShader.vertexShader,Shaders.GradientShader.fragmentShader);
    if (gradientShader.isCompiled() == false)
        throw new IllegalArgumentException("Couldn't compile shader: " + gradientShader.getLog());
    shaderBatch = new SpriteBatch(10,gradientShader);
}

public UiStage(){
     OrthographicCamera _uiCamera = new OrthographicCamera(Gdx.graphics.getWidth(),Gdx.graphics.getHeight());
     this.setViewport(new ScreenViewport(_uiCamera));
     // create skin


     // root table
     _roottable = createRoottable();
     createErrorMessagePanel();

     uiPanel = new UIPanel(Assets._skin);

     _roottable.add(uiPanel)
             .align(Align.center)
             .fill(true,true)
             .minWidth(uiPanel.getLeftSection().getPrefWidth() + uiPanel.getMidSection().getPrefWidth() + uiPanel.getRightSection().getPrefWidth() + 50);
     // align stuff
     _roottable.align(Align.bottom);
     // add root table to stage
     this.addActor(_roottable);
     _pauseWindow = new PauseWindow("Pause",Assets._skin);
     _pauseWindow.setSize(Gdx.graphics.getWidth(),Gdx.graphics.getHeight());
     this.addActor(_pauseWindow);
     this.resize(Gdx.graphics.getWidth(),Gdx.graphics.getHeight());
}

public Hud(SpriteBatch sb) {
    countKill = 0;
    viewport = new FitViewport(ScreenConf.V_WIDTH,ScreenConf.V_HEIGHT,new OrthographicCamera());

    stage = new Stage(viewport,sb);

    Table table = new Table();
    table.setFillParent(true);
    table.top();

    countKillLabel = new Label(String.format("%03d",countKill),new Label.LabelStyle(new BitmapFont(),Color.WHITE));

    table.add(countKillLabel).expandX().padTop(10);
    table.add().expandX();
    table.add().expandX();
    table.add().expandX();
    stage.addActor(table);

}

TrainingScreen(GftGame game) {
    this.game = game;

    this.guiCam = new OrthographicCamera(800,48);
    this.playPauseBounds = new Rectangle(7,7,48);
    this.restartBounds = new Rectangle(62,48);
    this.backFowardtBounds = new Rectangle(127,48);
    this.soundBounds = new Rectangle(192,48);
    this.minusBounds = new Rectangle(590,48);
    this.plusBounds = new Rectangle(699,48);

    this.touchPoint = new Vector3();

    this.grid = new Grid(this.game);
    this.grid.loadTraining();

    this.bottomBar = new BottomBar(this.game);

    this.firstRun = 3;
    this.lastUpdateTime = TimeUtils.millis();
    this.bpm = MINUTE_IN_MILLIS / SettingsUtil.bpm;
}

/**
 * Create a new SelectionSystem object
 *
 * @param camera    - the world camera
 * @param batch     - the batch to draw to
 * @param commandUI - the command ui system used to remove set commands
 * @param quadtree  - the quadtree containign all selectable entities
 */
public SelectionSystem(OrthographicCamera camera,DrawingBatch batch,CommandUISystem commandUI,SpatialQuadtree<Entity> quadtree) {
    super(4);
    this.camera = camera;
    this.batch = batch;
    this.cmdUI = commandUI;
    this.quadtree = quadtree;
}

public ThirdScreen (Game agame) {
    game = agame;
    batch = new SpriteBatch();
    img = new Texture("aklu.jpg");
    shapeRenderer = new ShapeRenderer();
    centerCircle = new Circle();
    leftCircle = new Circle();
    rightCircle = new Circle();
    myTouch = new Circle();
    camera = new OrthographicCamera();
    camera.setToOrtho(false,400);
    colorChanger = 0;
    counter = 0;
}

@Override
public void show() {
    //Initialize everything
    screenCamera = new OrthographicCamera(Gdx.graphics.getWidth(),Gdx.graphics.getHeight());

    camera = new OrthographicCamera(Gdx.graphics.getWidth(),Gdx.graphics.getHeight());
    camera.position.x = 0;
    camera.position.y = 0;
    batch = new DrawingBatch(1000,ShaderUtil.compileShader(Gdx.files.internal("shaders/basic.vertex.glsl"),Gdx.files
            .internal("shaders/basic.fragment.glsl")),true);
    batch.setBlendFunction(GL20.GL_SRC_ALPHA,GL20.GL_ONE_MINUS_SRC_ALPHA);

    setLevel(level);
}

@Override
public void create () {
    batch = new SpriteBatch();
    img = new Texture("aklu.jpg");
       shapeRenderer = new ShapeRenderer();
       centerCircle = new Circle();
       leftCircle = new Circle();
       rightCircle = new Circle();
       myTouch = new Circle();
       camera = new OrthographicCamera();
       camera.setToOrtho(false,400);
       colorChanger = 0;
}

public void render(SpriteBatch batch,OrthographicCamera screenCamera) {
    batch.setShader(null);
    batch.setProjectionMatrix(screenCamera.combined);
    batch.begin();
    batch.draw(pixelBufferRegion,screenCamera.viewportWidth,screenCamera.viewportHeight);
    batch.end();
}

public GameScreen(SkyCity skyCity) {
    super(skyCity);
    state = InputState.GAME;
    hud = new Hud(skyCity.batch);
    chat = new Chat(skyCity.batch);

    mapCamera = new OrthographicCamera(SCREEN_WIDTH,SCREEN_HEIGHT);
    gamePort = new FitViewport(SCREEN_WIDTH,SCREEN_HEIGHT,mapCamera);

    renderer = new OrthogonalTiledMapRenderer(Assets.getInstance().getTiledMap(),skyCity.batch);

    mapCamera.position.set(SCREEN_WIDTH / 2,SCREEN_HEIGHT / 2,0);
    renderer.setView(mapCamera);

}

public RenderSystem(Batch batch) {
    super(FAMILY);
    this.camera = new OrthographicCamera();
    viewport = new FitViewport(Asteroids.VIRTUAL_WIDTH,Asteroids.VIRTUAL_HEIGHT,camera);
    viewport.apply(true);
    this.batch = batch;
    shapeRenderer = new ShapeRenderer();
    shapeRenderer.setColor(Color.RED);
    font = ServiceLocator.getAppComponent().getAssetService().getSkin(AssetService.SkinAsset.UISKIN).getFont("default-font");
}

public Background(OrthographicCamera camera) {

        this.camera = camera;
        this.texture = new Texture("bg.png");

        this.sprite = new Sprite(texture);
        this.sprite.setSize(texture.getWidth(),texture.getHeight());
        this.sprite.setPosition(0,0);

        this.spriteClone = new Sprite(texture);
        this.spriteClone.setSize(texture.getWidth(),texture.getHeight());
        this.spriteClone.setPosition((FlappyChapa.WIDTH +
                FlappyChapa.WIDTH/2) - 20f,0);

    }

/**
 * Zeigt den Splashscreen an.
 *
 * @param camera  die aktuelle Kamera
 * @param deltaTime die vergangene Zeit seit dem letztem Frame
 */
@Override
public void render(OrthographicCamera camera,float deltaTime) {

    batch.setProjectionMatrix(camera.combined);
    batch.begin();
    screensprite.draw(batch);

    batch.end();
}

public void setupUIManager(String skinFilePath) {
skin = new Skin(Gdx.files.internal(skinFilePath));
uiManager = new UIManager("dialog",skin,getGameService());
uiBatch = uiManager.getSpriteBatch();
uiManager.getCamera().update();
uiBatch.setTransformMatrix(uiManager.getCamera().combined);
// Gdx.graphics.setdisplayMode(Gdx.graphics.getWidth(),// Gdx.graphics.getH,true);
if (isZoomUI()) {
    OrthographicCamera uiCamera = (OrthographicCamera) uiManager
        .getCamera();
    uiCamera.zoom = services.getCamera().zoom;
}
   }

/**
 * @param configuration the {@link ZoompulseEffectConfiguration} which drives the effect
 * @param cameras       the cameras to be manipulated
 */
public ZoompulseEffect(ZoompulseEffectConfiguration configuration,OrthographicCamera... cameras) {
    if (cameras.length == 0) throw new IllegalArgumentException("at least one camera is required");
    this.cameras = Array.with(cameras);
    this.maxZoomTime = configuration.maxZoomTime / 6;
    this.targetZoom = configuration.targetZoom;
}

/**
    * Setup camera at specific zoom and position at map center
    * 
    * @param zoom
    */
   protected void setupCamera(float zoom) {
OrthographicCamera cam = services.getCamera();
cam.zoom = zoom;
cam.position.set(Gdx.graphics.getWidth() / 2f,Gdx.graphics.getHeight() / 2f,0);
   }

public CameraWrapper(OrthographicCamera camera) {
    this.camera = camera;

    this.cameraOffsetX = this.camera.position.x;
    this.cameraOffsetY = this.camera.position.y;

    this.tempCameraParams = new TempCameraParams(0,1);

    // this.sync();

    // add some basic modifications
    this.registerMod(new Shake1CameraModification(),Shake1CameraModification.class);
    this.registerMod(new Shake2CameraModification(),Shake2CameraModification.class);
    this.registerMod(new Shake3CameraModification(),Shake3CameraModification.class);
}

public GameScreen() {
    game.setGameScreen(this);

    createWorld();

    camera = new OrthographicCamera();
    camera.setToOrtho(false,GameCore.SCREEN_WIDTH,GameCore.SCREEN_HEIGHT);
    uiCamera = new OrthographicCamera();
    uiCamera.setToOrtho(false,GameCore.SCREEN_HEIGHT);
}

public SplashScreen() {
    camera = new OrthographicCamera();
    viewport = new FitViewport(Game.WIDTH,0);
    camera.update();
    logo = new Sprite(new Texture(Gdx.files.internal("gussio.png")));
    initiateTime = System.currentTimeMillis();
}

public World(String avatarImage) {
    batch = new SpriteBatch();
    texture = new Texture("images/black.png");
    this.avatarImage = avatarImage;
    Gdx.input.setInputProcessor(this);
    camera = new OrthographicCamera(Gdx.graphics.getWidth(),Gdx.graphics.getHeight());
    music.setLooping(true);
    music.play();
    connectedTiles = new HashMap<Integer,ArrayList<Tile>>();
    block = null;
    blockAlongX = false;
    lastBlockX = -1;
    lastBlockY = -1;
    fadeTime = FADE_TIME / 2.0f;

    level = 1;
    File levelsFolder = new File("levels/");
    if(levelsFolder.exists()) {
        File[] files = levelsFolder.listFiles();
        if(files == null) {
            maxLevels = 0;
        } else {
            maxLevels = files.length;
        }
    } else {
        maxLevels = 0;
    }

    loadLevel("levels/1.txt");
}

public void render(OrthographicCamera camera,float deltaTime) {

            if (font == null)
                font = game.getTitleFont();

            fontLayout.setText(font,localeBundle.get(getLabel()),getColor(),y);
        }

public void render(OrthographicCamera camera,float deltaTime) {

            if (font == null)
                font = game.getDefaultFont();

            fontLayout.setText(font,y);
        }

public ScreenRooms(GameManager gameManager) {
    this.gameManager = gameManager;
    manager = ManagerAssets.getInstance();
    camera = new PerspectiveCamera(40,Gdx.graphics.getHeight()*0.183f);//initial 180
    camera.lookAt(0,0);
    camera.far = 2500;
    camera.near = 1;
    camera.update();
    cam = new OrthographicCamera();
    renderer = new ImmediateModeRenderer20(false,true,1);
}

public void renderCercle(OrthographicCamera camera,float amt,Color c){
    float start = 0f;
    float end = amt * 360f;

    lookup.bind();
    renderer.begin(camera.combined,GL20.GL_TRIANGLE_STRIP);
    Gdx.gl.glEnable(GL20.GL_BLEND);
    Gdx.gl.glBlendFunc(GL20.GL_SRC_ALPHA,GL20.GL_ONE_MINUS_SRC_ALPHA);
    int segs = (int)(24 * Math.cbrt(r));
    end += 90f;
    start += 90f;
    float halfThick = thickness/2f;
    float step = 360f / segs;
    for (float angle=start; angle<(end+step); angle+=step) {
        float tc = 0.5f;
        if (angle==start)
            tc = 0f;
        else if (angle>=end)
            tc = 1f;

        float fx = MathUtils.cosDeg(angle);
        float fy = MathUtils.sinDeg(angle);

        float z = 0f;
        //renderer.
        renderer.color(c.r,c.g,c.b,c.a);
        renderer.texCoord(tc,1f);
        renderer.vertex(cx + fx * (r + halfThick),cy + fy * (r + halfThick),z);

        renderer.color(c.r,0f);
        renderer.vertex(cx + fx * (r + -halfThick),cy + fy * (r + -halfThick),z);
    }
    renderer.end();
}

@Override
public void create() {
    GameWorldEntity gameWorldEntity = mEngine.getFirstEntityOfType(GameWorldEntity.class);
    if (gameWorldEntity == null) {
        // cannot create a camera without a game world
        return;
    }

    mCamera = new OrthographicCamera(gameWorldEntity.getWorldWidth(),gameWorldEntity.getWorldHeight());
    mCamera.position.set(mCamera.viewportWidth / 2f,mCamera.viewportHeight / 2f,0.f);

    PositionComponent positionComponent = getComponentByType(PositionComponent.class);
    positionComponent.position.set(mCamera.viewportWidth / 2f,mCamera.viewportHeight / 2f);
}

@Override
public OrthographicCamera copy (Kryo kryo,OrthographicCamera original) {
    OrthographicCamera camera = new OrthographicCamera();
    camera.position.set(original.position);
    camera.direction.set(original.direction);
    camera.up.set(original.up);
    camera.near = original.near;
    camera.far = original.far;
    camera.viewportWidth = original.viewportWidth;
    camera.viewportHeight = original.viewportHeight;
    camera.zoom = original.zoom;
    camera.update();
    return camera;
}

@Override
public GraphiteSender get() {
    switch (configuration.getProtocol()) {
        case PICKLE:
            return new PickledGraphite(
                    configuration.getAddress(),SocketFactory.getDefault(),configuration.getCharset(),configuration.getPickleBatchSize());
        case TCP:
            return new Graphite(configuration.getAddress(),configuration.getCharset());
        case UDP:
            return new GraphiteUDP(configuration.getAddress());
        default:
            throw new IllegalArgumentException("UnkNown Graphite protocol \"" + configuration.getProtocol() + "\"");
    }
}

private void initialiseMetrics(AdminUsersConfig configuration,Environment environment) {
    GraphiteSender graphiteUDP = new GraphiteUDP(configuration.getGraphiteHost(),Integer.valueOf(configuration.getGraphitePort()));
    GraphiteReporter.forRegistry(environment.metrics())
            .prefixedWith(SERVICE_METRICS_NODE)
            .build(graphiteUDP)
            .start(GRAPHITE_SENDING_PERIOD_SECONDS,TimeUnit.SECONDS);

}

private void initialiseMetrics(CardConfiguration configuration,TimeUnit.SECONDS);

}

@Test
public void getReturnsGraphiteUDP() throws Exception {
    final MetricsGraphiteReporterConfiguration configuration = new MetricsGraphiteReporterConfiguration() {
        @Override
        public GraphiteProtocol getProtocol() {
            return GraphiteProtocol.UDP;
        }
    };
    final GraphiteSenderProvider provider = new GraphiteSenderProvider(configuration);

    final GraphiteSender graphiteSender = provider.get();
    assertTrue(graphiteSender instanceof GraphiteUDP);
    assertFalse(graphiteSender.isConnected());
}

@Test
public void get() throws Exception {
    final MetricsGraphiteReporterConfiguration configuration = new MetricsGraphiteReporterConfiguration();
    final GraphiteSender graphiteSender = new GraphiteUDP("127.0.0.1",12345);
    final MetricRegistry metricRegistry = new MetricRegistry();
    final GraphiteReporterProvider provider = new GraphiteReporterProvider(configuration,graphiteSender,metricRegistry);

    final GraphiteReporter reporter = provider.get();
    assertNotNull(reporter);
}

/**
 * Create reporter bean and tell Spring to call stop() when shutting down.
 * UPD must be enabled in carbon.conf
 * 
 * @return graphite reporter
 */
@Bean(destroyMethod = "stop")
public GraphiteReporter graphiteReporter() {
    final GraphiteSender graphite = new GraphiteUDP(new InetSocketAddress("localhost",2003));
    final GraphiteReporter reporter = GraphiteReporter.forRegistry(metricRegistry).prefixedWith("camel-spring-boot").convertRatesTo(TimeUnit.SECONDS)
        .convertDurationsTo(TimeUnit.MILLISECONDS).filter(MetricFilter.ALL).build(graphite);
    reporter.start(5,TimeUnit.SECONDS);
    return reporter;
}

private void initialiseMetrics(PublicAuthConfiguration configuration,TimeUnit.SECONDS);

}

private void initialiseMetrics(PublicApiConfig configuration,TimeUnit.SECONDS);
}

@Override
public ScheduledReporter getReporter(MetricConfig config) {
    String host = config.getString(ARG_HOST,null);
    int port = config.getInteger(ARG_PORT,-1);

    if (host == null || host.length() == 0 || port < 1) {
        throw new IllegalArgumentException("Invalid host/port configuration. Host: " + host + " Port: " + port);
    }

    String prefix = config.getString(ARG_PREFIX,null);
    String conversionRate = config.getString(ARG_CONVERSION_RATE,null);
    String conversionDuration = config.getString(ARG_CONVERSION_DURATION,null);
    String protocol = config.getString(ARG_PROTOCOL,"TCP");

    com.codahale.metrics.graphite.GraphiteReporter.Builder builder =
        com.codahale.metrics.graphite.GraphiteReporter.forRegistry(registry);

    if (prefix != null) {
        builder.prefixedWith(prefix);
    }

    if (conversionRate != null) {
        builder.convertRatesTo(TimeUnit.valueOf(conversionRate));
    }

    if (conversionDuration != null) {
        builder.convertDurationsTo(TimeUnit.valueOf(conversionDuration));
    }

    Protocol prot;
    try {
        prot = Protocol.valueOf(protocol);
    } catch (IllegalArgumentException iae) {
        log.warn("Invalid protocol configuration: " + protocol + " Expected: TCP or UDP,defaulting to TCP.");
        prot = Protocol.TCP;
    }

    log.info("Configured GraphiteReporter with {host:{},port:{},protocol:{}}",host,port,prot);
    switch(prot) {
        case UDP:
            return builder.build(new GraphiteUDP(host,port));
        case TCP:
        default:
            return builder.build(new Graphite(host,port));
    }
}

@Override public void prepare(Map<String,Object> conf) {
  if (conf.containsKey(GRAPHITE_HOST_OPTION)) {
    graphiteHost = (String) conf.get(GRAPHITE_HOST_OPTION);
  }
  else {
    throw new IllegalArgumentException("Field " + GRAPHITE_HOST_OPTION + " required.");
  }

  if (conf.containsKey(GRAPHITE_PORT_OPTION)) {
    graphitePort = Integer.parseInt((String) conf.get(GRAPHITE_PORT_OPTION));
  }
  else {
    throw new IllegalArgumentException("Field " + GRAPHITE_PORT_OPTION + " required.");
  }

  if (conf.containsKey(GRAPHITE_MIN_CONNECT_ATTEMPT_INTERVAL_SECS_OPTION)) {
    minConnectAttemptIntervalSecs = Integer
        .parseInt((String) conf.get(GRAPHITE_MIN_CONNECT_ATTEMPT_INTERVAL_SECS_OPTION));
  }
  else {
    minConnectAttemptIntervalSecs = DEFAULT_MIN_CONNECT_ATTEMPT_INTERVAL_SECS;
  }

  graphiteSocketAddr = new InetSocketAddress(graphiteHost,graphitePort);

  serverFingerprint = graphiteSocketAddr.getAddress() + ":" + graphiteSocketAddr.getPort();

  if (conf.containsKey(GRAPHITE_PROTOCOL_OPTION) && ((String)conf.get(GRAPHITE_PROTOCOL_OPTION)).equalsIgnoreCase("udp")) {
    // Use UDP client
    this.graphite = new GraphiteUDP(graphiteSocketAddr);
  } else {
    // Default TCP client
    int connectTimeout = DEFAULT_CONNECT_TIMEOUT;
    if (conf.containsKey(GRAPHITE_CONNECT_TIMEOUT)) {
      connectTimeout = Integer.parseInt(conf.get(GRAPHITE_CONNECT_TIMEOUT).toString());
    }

    int readTimeout = DEFAULT_READ_TIMEOUT;
    if (conf.containsKey(GRAPHITE_READ_TIMEOUT)) {
      readTimeout = Integer.parseInt(conf.get(GRAPHITE_READ_TIMEOUT).toString());
    }

    ConfigurableSocketFactory socketFactory = new ConfigurableSocketFactory();
    socketFactory.setConnectTimeout(connectTimeout);
    socketFactory.setReadTimeout(readTimeout);

    this.graphite = new Graphite(graphiteSocketAddr,socketFactory);
  }
  lastConnectAttemptTimestampMs = 0;
  prefix = TagsHelper.getPrefix(conf);
}