将 2D libgdx 游戏移植到 MonoGame

package com.rengelbert.froggergdx;

import com.rengelbert.froggergdx.data.GameData;
import com.rengelbert.froggergdx.screens.Screen;

public class Game implements ApplicationListener {
}

using System;
using FruitCatcher.Text;
using FruitCatcher.Models;

namespace FruitCatcher
{
    public class FruitCatcherGame : ScreensGame
    {
    }
}

public class Game implements ApplicationListener {}

public class MyGame extends BaseGame {}

public class Game : ApplicationListener

public class MyGame : BaseGame

boolean

Integer.parseInt("12");

List<Integer> list = new ArrayList<integer>();
</integer>

bool

int.Parse("12");

List<int> list = new List<int>();
</int>

在 C# 中，您需要使用 `bool` 类型而不是 `boolean`。Java 中的其他原始类型在 C# 中具有相同的名称。然而，在 C# 中，没有原始类型的概念。所有类型都是对象。这使得您的生活更轻松，尤其是在集合中。

public static final int GAME_STATE_PLAY = 0;
private final int ANIMATION_DURATION = 100;

public const int GAME_STATE_PLAY = 0;
private readonly int ANIMATION_DURATION = 100;

在 C# 中，`final` 关键字映射到 `const` 或 `readonly`。这不是一对一的关系。您可以在这里阅读完整的讨论。对于大多数情况，上面两个例子就足够了。

public class MyExceptionClass extends Exception
{
  public MyExceptionClass(string msg, string extrainfo)
  {
    super(msg);
  }
}

public class MyExceptionClass : Exception
{
  public MyExceptionClass(string msg, string extrainfo)
                  : base(msg)
  {
  }
}

您使用 `base` 而不是 `super` 来访问父类方法。构造函数语法不同。

class TimePeriod
{
    private double seconds;

    public double getHours() { 
        return seconds / 3600; 
    }
    
    public void setHours(double hours){
        seconds = hours * 3600;
    }
}

class TimePeriod
{
    private double seconds;

    public double Hours
    {
        get { return seconds / 3600; }
        set { seconds = value * 3600; }
    }
}

Java 使用 getter 和 setter 在类之间传递值。C# 使用属性。您无需修改代码来使用属性，因为 getter 和 setter 模式在 C# 中也能很好地工作。但是，您绝对需要理解属性概念，因为它被系统库和 MonoGame 框架大量使用。

import com.google.gson.annotations.SerializedName;

public class PurchaseOrder
{
    @SerializedName("purchaseId")
    private int poId_value;
}

[DataContract]
public class PurchaseOrder
{
    private int poId_value;

    [DataMember]
    public int PurchaseOrderId
    {
        get { return poId_value; }
        set { poId_value = value; }
    }
}

Java 注解的等价物是 C# 属性。语法不同，但理念相同。您通过注解类或字段来添加所需的行为。另一个区别是 `@Override` 注解，它在 C# 中被 `override` 和 `virtual` 关键字取代。

public class A {
    public void methodName() {
    }
}

line.trim().length() 
list.size()
list.add(item)

public class A 
{
    public void MethodName()
    {
    }
}

line.Trim().Length
list.Count // Property
list.add(item)

Java 和 C# 使用不同的编码风格。C# 鼓励每个大括号都另起一行。此外，大小写风格略有不同。也许最重要的区别是 C# 中的方法名使用帕斯卡命名法（首字母大写）。在移植代码时，您无需遵循这些约定。但是，这些信息将帮助您理解系统和框架库。

List<String> l = new ArrayList<string>();
Map<string,> m = new HashMap<string,>();

l.size()
l.add(item), l.remove(item)
l.get(i)
</string,>

List<String> l = new List<string>();
Dictionary<string,> m = new Dictionary<string,>();

l.Count  // Property
l.Add(item), l.Remove(item)
l[i]       // Operation overloading
</string,>

在 C# 中，我们通常不使用接口来定义集合。通用接口（IEnumerable、ICollection）确实存在。List 映射到 C# 中的 List，Map 映射到 Dictionary。大多数方法在 C# 中具有相同的名称，唯一的区别是首字母大写。这将使您的移植更容易。C# 支持运算符重载，因此您可以使用数组语法 `[i]` 来检索项目，而不是 `get(i)`。

for(String s: list) {
}

foreach(String s in list)
{
}

在 C# 中，您使用 `foreach` 语句来实现 for-each 循环。

public enum Planet {
    MERCURY (3.303e+23, 2.4397e6),
    VENUS   (4.869e+24, 6.0518e6),
    EARTH   (5.976e+24, 6.37814e6),
    MARS    (6.421e+23, 3.3972e6),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7);

    private final double mass;   // in kilograms
    private final double radius; // in meters
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    private double mass() { return mass; }
    private double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    public static final double G = 6.67300E-11;

    double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
    public static void main(String[] args) {
        if (args.length != 1) {
            System.err.println(
        "Usage: java Planet <earth_weight>");
            System.exit(-1);
        }
        double earthWeight = Double.parseDouble(args[0]);
        double mass = earthWeight/EARTH.surfaceGravity();
        for (Planet p : Planet.values())
           System.out.printf(
               "Your weight on %s is %f%n",
               p, p.surfaceWeight(mass));
    }
}

public enum Planet {
    MERCURY = 0,
    VENUS,
    EARTH,
    MARS,
    JUPITER,
    SATURN,
    URANUS,
    NEPTUNE
}

public static class PlanetExtensions {
    private static double [] masses = {
        3.303e+23, 4.869e+24, 5.976e+24, 6.421e+23,
        1.9e+27, 5.688e+26, 8.686e+25, 1.024e+26};
        
    private static double [] radii = {
        2.4397e6, 6.0518e6, 6.37814e6, 3.3972e6,
        7.1492e7, 6.0268e7, 2.5559e7, 2.4746e7};    

    public static double Mass(this Planet planet)
    {
        return masses[(int) planet];
    }
    
    public static double Radius(this Planet planet)
    {
        return radii[(int) planet];
    }    
}

Console.WriteLine(Planet.MARS.Mass().ToString());

`enum` 类型可能是 Java 提供比 C# 更高级功能的唯一语言特性。您不能在枚举中拥有构造函数或方法。此外，只允许整数类型。您可以使用扩展方法来添加缺失的功能。

public class Drop 
      implements ApplicationListener {

   @Override
   public void create() {
      // load the images and sound effects 

      // start the playback of the 
      // background music

      // create resources
   }

   @Override
   public void render() {
      // update      

      // draw      

      // process user input
   }

   @Override
   public void dispose() {
      // dispose of all the native resources
   }

   @Override
   public void resize(int width, int height) {
   }

   @Override
   public void pause() {
   }

   @Override
   public void resume() {
   }
}

public class FroggerGame : Game

  public FroggerGame()
  {
    _graphics = new GraphicsDeviceManager(this);
    Content.RootDirectory = "Content";      
  }


  /// <summary>
  /// Allows the game to perform any initialization it 
  /// needs to before starting to run.
  /// This is where it can query for any required 
  /// services and load any non-graphic
  /// related content.  
  /// </summary>
  protected override void Initialize()
  {
    // TODO: Add your initialization logic here

    base.Initialize();
  }

  /// <summary>
  /// LoadContent will be called once per game and 
  /// is the place to load all of your content.
  /// </summary>
  protected override void LoadContent()
  {          

  }

  /// <summary>
  /// UnloadContent will be called once per game and 
  /// is the place to unload all content.
  /// </summary>
  protected override void UnloadContent()
  {
    // TODO: Unload any non ContentManager content here
  }

  /// <summary>
  /// Allows the game to run logic such as updating 
  /// the world, checking for collisions, gathering
  /// input, and playing audio.
  /// </summary>
  /// <param name="gameTime" />Provides a snapshot of 
  /// timing values.
  protected override void Update(GameTime gameTime)
  {
    base.Update(gameTime);      
  }

  /// <summary>
  /// This is called when the game should draw itself.
  /// </summary>
  /// <param name="gameTime" />Provides a snapshot of
  /// timing values.
  protected override void Draw(GameTime gameTime)
  {

  }
}

Texture dropImage;
Texture bucketImage;
Sound dropSound;
Music rainMusic;
BitmapFont font;

@Override
public void create() {
  dropImage = 
    new Texture(Gdx.files.internal("droplet.png"));
  bucketImage = 
    new Texture(Gdx.files.internal("bucket.png"));
  dropSound = 
    Gdx.audio.newSound(Gdx.files.internal("drop.wav"));
  rainMusic = 
    Gdx.audio.newMusic(Gdx.files.internal("rain.mp3"));
  font = new BitmapFont(
    Gdx.files.internal("fonts/poetsen.fnt"),
    Gdx.files.internal("fonts/poetsen.png"), 
    false);
}

private Texture2D background;
private SpriteFont font;
private Song music;
private SoundEffect jumpSound;

/// <summary>
/// LoadContent will be called once per game and is the 
/// place to load all of your content.
/// </summary>
protected override void LoadContent()
{
  background = 
    loadTexture(content, "data/background");
  font = 
    content.Load("data/Miramonte");
  jumpSound = 
    content.Load<SoundEffect>("data/jump");
  music = 
    content.Load<Song>("data/music");
}

SpriteBatch batch;
OrthographicCamera camera;

@Override
public void render() {
  Gdx.gl.glClearColor(0, 0, 0.2f, 1);
  Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT);

  camera.update();
  batch.setProjectionMatrix(camera.combined);

  batch.begin();
  batch.draw(bucketImage, bucket.x, bucket.y);
  for(Rectangle raindrop: raindrops) {
     batch.draw(dropImage, raindrop.x, raindrop.y);
  }
  batch.end();
}

/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime" />Provides a snapshot 
/// of timing values.
protected override void Draw(GameTime gameTime)
{
  GraphicsDevice.Clear(Color.CornflowerBlue);
  
  batch.Begin();
  Vector position = new Vector2(0, 0);
  batch.Draw(bgTexture, position, Color.White);
  batch.End();
  
  base.Draw(gameTime);
}

/** Draws a rectangle with the bottom left corner at x,y having the given width and height in pixels. The rectangle is offset by originX, originY relative to the origin. Scale specifies the scaling factor by which the rectangle should be scaled around originX, originY. Rotation specifies the angle of counter clockwise rotation of the rectangle around originX, originY. The portion of the {@link Texture} given by srcX, srcY and srcWidth, srcHeight is used. These coordinates and sizes are given in texels. FlipX and flipY specify whether the texture portion should be flipped horizontally or vertically.
* @param x the x-coordinate in screen space
* @param y the y-coordinate in screen space
* @param originX the x-coordinate of the scaling and rotation origin relative to the screen space coordinates
* @param originY the y-coordinate of the scaling and rotation origin relative to the screen space coordinates
* @param width the width in pixels
* @param height the height in pixels
* @param scaleX the scale of the rectangle around originX/originY in x
* @param scaleY the scale of the rectangle around originX/originY in y
* @param rotation the angle of counter clockwise rotation of the rectangle around originX/originY
* @param srcX the x-coordinate in texel space
* @param srcY the y-coordinate in texel space
* @param srcWidth the source with in texels
* @param srcHeight the source height in texels
* @param flipX whether to flip the sprite horizontally
* @param flipY whether to flip the sprite vertically */
public void draw (Texture texture, 
    float x, 
    float y, 
    float originX, 
    float originY, 
    float width, 
    float height, 
    float scaleX,
    float scaleY, 
    float rotation, 
    int srcX, 
    int srcY, 
    int srcWidth, 
    int srcHeight, 
    boolean flipX, 
    boolean flipY)

// A texel is a pixel from the texture.

// Overload for calling Draw() with named parameters
/// <summary>
/// This is a MonoGame Extension method for calling Draw() using named parameters. It is not available in the standard XNA Framework.
/// </summary>
/// <param name='texture'>
/// The Texture2D to draw. Required.
/// </param>
/// <param name='position'>
/// The position to draw at. If left empty, the method will draw at drawRectangle instead.
/// </param>
/// <param name='drawRectangle'>
/// The rectangle to draw at. If left empty, the method will draw at position instead.
/// </param>
/// <param name='sourceRectangle'>
/// The source rectangle of the texture. Default is null
/// </param>
/// <param name='origin'>
/// Origin of the texture. Default is Vector2.Zero
/// </param>
/// <param name='rotation'>
/// Rotation of the texture. Default is 0f
/// </param>
/// <param name='scale'>
/// The scale of the texture as a Vector2. Default is Vector2.One
/// </param>
/// <param name='color'>
/// Color of the texture. Default is Color.White
/// </param>
/// <param name='effect'>
/// SpriteEffect to draw with. Default is SpriteEffects.None
/// </param>
/// <param name='depth'>
/// Draw depth. Default is 0f.
/// </param>
public void Draw (Texture2D texture,
        Vector2? position = null,
        Rectangle? drawRectangle = null,
        Rectangle? sourceRectangle = null,
        Vector2? origin = null,
        float rotation = 0f,
        Vector2? scale = null,
        Color? color = null,
        SpriteEffects effect = SpriteEffects.None,
        float depth = 0f)

// Loading images
public static Texture loadTexture (String file) {
  return new Texture(Gdx.files.internal(file));
}

public static void load () {
  background = loadTexture("data/background.png");
  backgroundRegion = new TextureRegion(background, 0, 0, 320, 480);

  items = loadTexture("data/items.png");
  mainMenu = new TextureRegion(items, 0, 224, 300, 110);
  pauseMenu = new TextureRegion(items, 224, 128, 192, 96);
  ready = new TextureRegion(items, 320, 224, 192, 32);

// Drawing images
private void renderPlatforms () {
  int len = world.platforms.size();
  for (int i = 0; i < len; i++) {
    Platform platform = world.platforms.get(i);
    TextureRegion keyFrame = Assets.platform;
    if (platform.state == Platform.PLATFORM_STATE_PULVERIZING) {
        keyFrame = Assets.brakingPlatform.getKeyFrame(
            platform.stateTime, Animation.ANIMATION_NONLOOPING);
    }

    batch.draw(keyFrame, 
        platform.position.x - 1, platform.position.y - 0.25f,
        2, 0.5f);
  }
}

// Loading images
public static Texture2D loadTexture(ContentManager content, String file) {
  return content.Load<Texture2D>(file);
}

public static void load(ContentManager content)
{
  background = loadTexture(content, "data/background");
  backgroundRegion = new TextureRegion(background, 0, 0, 320, 480);

  items = loadTexture(content, "data/items");
  mainMenu = new TextureRegion(items, 0, 224, 300, 110);
  pauseMenu = new TextureRegion(items, 224, 128, 192, 96);
  ready = new TextureRegion(items, 320, 224, 192, 32);

// Drawing images
private void renderPlatforms() 
{
  int len = world.platforms.Count;
  for (int i = 0; i < len; i++)
  {
    Platform platform = world.platforms[i];
    TextureRegion keyFrame = Assets.platform;
    if (platform.state == Platform.PLATFORM_STATE_PULVERIZING)
    {
        keyFrame = Assets.brakingPlatform.getKeyFrame(
            platform.stateTime, Animation.ANIMATION_NONLOOPING);
    }

    spriteWorld.DrawRegion(keyFrame,
                    platform.position.X - 1, platform.position.Y - 0.25f,
                    2, 0.5f);
  }
}