Beiträge von Claan

Claan · 6. April 2016

Ja ich bin dieser "Auffrischer". Wollte aber meine Situation in einem neuen Thread verdeutlichen.

Das stimmt, nur ist es anscheinend so dass ich nicht viel Ahnung von der Materie habe und du mich mit deiner Hilfe auf den richtigen Pfad schicken willst, ich aber manche Sachen falsch verstehe/interpretiere und somit sinnlos irgwas versuche was eig nichts bringt.

So ich habe mir jetzt von Android die Hilfen durchgelesen: Screens

Habe auch die 4 verschiedene Ordner angelegt, ich wäre dir (bzw. euch) sehr verbunden wenn du/ihr mir erklären könntet wie ich es hinbekomme meine Tiles für die 4 verschiedene Formate zudesignen (was die Größen betrifft), damit immer der ganze Bildschirm mit der Höhe von 10 Tiles "bemalt" wird.

Claan · 6. April 2016

@ChampS ich wäre dir sehr verbunden wenn du mir mehr und eine präzisere Antwort geben könntest. Wie man das löst mit java und was alles gemacht werden muss.

Claan · 6. April 2016

Hab nur das mit dem getestet, hab nämlich ne Iphone und alle anderen im Haus auch
Versuche das mal mit dem simulator

Claan · 6. April 2016

Also Tile sind die Elemente der Map, sozusagen bei einem Bild jeder Pixel, der dann weiss oder schwarz ist.
Die Map hat dann als Höhe 10 Tiles die sind zb. 32x32 Pixel und somit dann für den normal Screen geeignet.
Wie muss ich dann die drawable dann nennen mit welchen Kürzeln ?

Claan · 6. April 2016

Hallo alle zusammen,

undzwar wollte ich ein Gerüst für die grafische Oberfläche meines 2D-Spieles erarbeiten. Hier erstmal ein wenig Kontext zu meinem Spiel und dem Code.

Code

public class MainActivity extends AppCompatActivity{
    public static Resources resources;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        resources = getResources();
        GameEngine view = new GameEngine(this);
        setContentView(view);
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
        getWindow().getDecorView().setSystemUiVisibility(
                View.SYSTEM_UI_FLAG_LAYOUT_STABLE
                        | View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
                        | View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
                        | View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
                        | View.SYSTEM_UI_FLAG_FULLSCREEN
                        | View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
    }
}

Alles anzeigen

Code

/**
 * Created by Claan on 30.03.2016.
 */
public class GameEngine extends View
{
    boolean started = false;
    Canvas canvas;
    public static boolean running = true;
    private Handler handler = new Handler();
    View me = this;


    public GameEngine(final Context context) {
        super(context);
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                if (canvas != null) {
                    GameHandler.onTick();
                    GameHandler.onRender(canvas);
                    me.invalidate();
                }
                handler.postDelayed(this, 1000/60);
            }
        };
        handler.post(runnable);


    }


    @Override
    protected void onDraw(Canvas canvas)
    {
        this.canvas = canvas;


        GameHandler.height = canvas.getHeight();
        GameHandler.width = canvas.getWidth();


        if(!started)
        {
            GameHandler.onInit();
            started = true;
        }
    }
}

Alles anzeigen

Code

/**
 * Created by Claan on 30.03.2016.
 */
public class GameHandler
{
    public static int height;
    public static int width;


    static TileMap tileMap;


    private static int tilesGröße = 64; 				//Größe der Tiles 64x64


    public static void onInit()
    {
        //Initialisieren


        tileMap = new TileMap(64);    //Größe der Tiles
        tileMap.loadTiles("/Tilesets/tilesetteil1_groß.gif", 1);
        tileMap.setPosition(0, 0);
        tileMap.setTween(1);
        tileMap.setWelt(0); // 0 == boden 1 != boden
        tileMap.loadMapIntegriert();


    }


    public static void onTick() 
    {


        tileMap.setPosition(
                GameHandler.width / 2 - player.getx(),
                GameHandler.height / 2 - player.gety()
        );


    }


    public static void onRender(Canvas canvas)
    {
        tileMap.draw(canvas);


        hud.draw(canvas);
    }


}

Alles anzeigen

Code

public class TileMap
{
	//Welt	0 = Boden 1 != boden
	private int welt = 0;
	// position
	private double x;
	private double y;
	// bounds
	private int xmin;
	private int ymin;
	private int xmax;
	private int ymax;
	private double tween;
	// map
	private int[][] map = {{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..},
{zahlen..}}


			};
	private int[][] mapType;
	private int tileSize;
	private int numRows = map.length;   //Höhe
	private int numCols = map[0].length;   //Länge
	private int width;
	private int height;


	// tileset
	private Bitmap tileset;
	private int numTilesAcross;
	private Tile[][] tiles;
	// drawing
	private int rowOffset;
	private int colOffset;
	private int numRowsToDraw;
	private int numColsToDraw;
	public TileMap(int tileSize) 
	{
		this.tileSize = tileSize;
		numRowsToDraw = GameHandler.height / tileSize + 2;
		numColsToDraw = GameHandler.width / tileSize + 2;
		tween = 0.07;
	}
	public void loadTiles(String s, int welt)
		{
		try 
		{
			this.welt = welt;


            tileset = BitmapFactory.decodeResource(MainActivity.resources, R.drawable.tilesetteil);


			numTilesAcross = tileset.getWidth() / tileSize;
			tiles = new Tile[2][numTilesAcross];


			Bitmap subimage;
			for(int col = 0; col &lt; numTilesAcross; col++)
			{
				subimage = Bitmap.createBitmap(tileset, col * tileSize, 0, tileSize, tileSize);


				tiles[0][col] = new Tile(subimage, Tile.NORMAL);


				subimage = Bitmap.createBitmap(tileset, col * tileSize, tileSize, tileSize, tileSize);


				tiles[1][col] = new Tile(subimage, Tile.BLOCKED);


				if(subimage == null)
					Log.d("asd", "Null");
				Log.d("asd", "Col" + col);
				Log.d("asd", "NumTileAcross" + numTilesAcross);
			}
		}
		catch(Exception e) 
		{
			e.printStackTrace();
		}
	}


	public void loadMapIntegriert()
	{
		width = numCols * tileSize;
		height = numRows * tileSize;


		xmin = GameHandler.width - width;
		xmax = 0;
		ymin = GameHandler.height - height;
		ymax = 0;
	}
	public int getTileSize() { return tileSize; }
	public double getx() { return x; }
	public double gety() { return y; }
	public int getWidth() { return width; }
	public int getHeight() { return height; }


    public void setWelt( int welt) { this.welt = welt; }


	public int getType(int row, int col) 
	{
		if(row &gt;= 0 && row &lt; 10 && col &gt;= 0 && row &lt; 10)
		{
			int rc = map[row][col];
			int r = rc / numTilesAcross;
			int c = rc % numTilesAcross;
			return tiles[r][c].getType();
		}
		return tiles[0][0].getType();
	}
	//v2
	public int istBlock(int y, int x)
	{
		if(map.length &gt; y && map[0].length &gt; x)
			return getType(y, x);		//oder mapType[y][x];
		else
			return 1;
	}
	public void setTween(double d) { tween = d; }
	public void setPosition(double x, double y) 
	{
		this.x += (x - this.x) * tween;
		this.y += (y - this.y) * tween;
		fixBounds();
		colOffset = (int)-this.x / tileSize;
		rowOffset = (int)-this.y / tileSize;
	}
	private void fixBounds() 
	{
		if(x &lt; xmin) x = xmin;
		if(y &lt; ymin) y = ymin;
		if(x &gt; xmax) x = xmax;
		if(y &gt; ymax) y = ymax;
	}
	public void draw(Canvas canvas)
	{


		for(int row = rowOffset; row &lt; rowOffset + numRowsToDraw; row++)
		{
			if(row &gt;= numRows) break;
			for(int col = colOffset; col &lt; colOffset + numColsToDraw; col++) {
				if(col &gt;= numCols) break;
				if(map[row][col] == 0 && welt != 0) continue;		//Wenn Tile 0 0 nicht verwendet werden soll also nicht da ist, aber ist der Boden
				int rc = map[row][col];
				int r = rc / numTilesAcross;
				int c = rc % numTilesAcross;


                try {
                    canvas.drawBitmap(tiles[r][c].getImage(), (int) x + col * tileSize, (int) y + row * tileSize, null);
                }catch(NullPointerException exe) {}




			}
		}
	}
}

Alles anzeigen

So eig ganz einfach das Array Map hat int Werte die sozusagen die Tiles wiederspiegeln also Bilder, so entsteht die Map. Eig wird sie über eine Java Klasse neu generiert und gespeichert in einer txt Datei, aber mit Android ist das ein bisschen komplizierter.....
So jz mein Anliegen: Es gibt diese 4 Größenklassen ind die die Geräte unterteilt werden:

xlarge screens are at least 960dp x 720dp
large screens are at least 640dp x 480dp
normal screens are at least 470dp x 320dp
small screens are at least 426dp x 320dp

Ich habe dann die Formel: Height / 10 = Tilegröße -> Somit habe ich die Größe damit immer bei allen Geräten die Map 10 Tiles hoch ist oder ?
Nun muss ich die Bilder in der drawable speichern einmal drawable-"Kürzel" für die entsprechende Größe des Bildschirmes ? Oder wie stelle ich das an ?

LG Claan

Claan · 5. April 2016

ok alles klar habe ich jetzt mal so probiert mit mein Versuchshandy LG Optimus 4X und es bleibt unten noch eine Lücke die weiss ist also welche nicht ausgefüllt wird.

Gezeichnet wird alles mit Canvas, muss ich noch was ergänzen damit es skaliert wird ?

Claan · 5. April 2016

ja hab es in einem anderen Thread gefunden und MotionEvent.ACTION_UP hinzugefügt. trz danke

Claan · 5. April 2016

Mein Ziel ist es eig: Mein Spiel für alle verschiedene Handys in der besten Auflösung darzustellen. Das Spielbrett soll immer 10 Tiles hoch sein, die Tiles sind quadratisch.

Claan · 5. April 2016

Sorry aber ich verstehe das noch nicht ganz alles mit dp, dpi und den pixeln.

Schlussfolgerung: meine Tiles Größen sind dann 32dp, 48dp und 72dp stimmts ? Aber das ist dann ja auch mit den Bildern wieder anders, da dort die Größen in pixeln sind....

Kannst mir da vllt weiterhelfen ?

Claan · 5. April 2016

Ja danke hat sich erledigt

Claan · 5. April 2016

Also hat jedes Handy einer dieser 4 Größen und Android sucht sich dann die bestimmte Größe aus oder wie ?

xlarge screens are at least 960dp x 720dp
large screens are at least 640dp x 480dp
normal screens are at least 470dp x 320dp
small screens are at least 426dp x 320dp

Aber wie soll das Funktionieren ?
Bei mir ist es so ich habe ein Spiel und das Spielfeld besteht aus Tiles und die Höhe des Spielfeldes sind immer 10 Tiles heisst das die Tiles so groß sein müssen, dass sie immer den ganzen Bildschirmen ausmalen, aber woher weiss Android welches Bild genommen werden muss ?

Claan · 4. April 2016

auch wenn es alt ist habe ich ein paar Fragen dazu...

Ich arbeite über eine eigen erstellte View, meine Bilder speicher ich in der drawable, meine Idee ist es das ich sozusagen 4 verschiedene Größen der Bilder habe und durch die Formel "Spieler = HEIGHT / 10" auf die passemde Größe des Players komme, da aber es nicht 4 Geräte Größen gibt skaliere ich die Bilder passend damit bei allen Geräten verschiedener Ausflösungen und Größen der Player im Verhältniss gleich groß ist.

Erscheint dieses logisch und klug ?
Und welche Bildschirmgrößen sind vertretten von klein bis groß (Smartphones) ?

Claan · 4. April 2016

Ich wüsste nicht wie das gehen sollte, dass man eine Bitmap die in einer erstellten View existiert mit einem listener versehen kann.....

Wenn ich mit den vorhandenen MotionEvents arbeite bekomme ich es nicht hin, dass er erkennt ob ich es gedrückt halte und wann ich es loslasse (Szenario: pressed & released)
Mit dem MotionEvent.ACTION_UP ist die Zeitspanne zwischen DOWN und UP ne millisekunde, also nicht sehbar.

Code

@Override
    public boolean onTouchEvent(MotionEvent event)
    {
        int action = event.getAction();
        int x = (int) event.getX();  // or getRawX();
        int y = (int) event.getY();
        switch(action & MotionEvent.ACTION_MASK)
        {
            case MotionEvent.ACTION_DOWN:
                if ((x &gt;= button_right_X) && (x &lt; (button_right_X + button_right.getWidth()))
                        && (y &gt;= button_right_Y) && (y &lt; (button_right_Y + button_right.getHeight())))
                {
                    Log.d("asd", "geklickt Rechts");
                    GameHandler.run(0);
                }
             break;
         }
         return false;
     }

Alles anzeigen

(button_right ist eine Bitmap)

Claan · 4. April 2016

Hallo alle zusammen,

undzwar bin ich dabei mein Spiel (Jump and Run) was ich fertig in Java geschrieben habe für Android anzupassen. Habe mich auch schon ganz gut damit ausseinandergesetzt. Ich arbeite mit Canvas und erstelle in der Main ein eigenes View mit onTick() (Update) und onRender() (draw) und init() (Initializierung aller Objekte), nun brauch man ja auch Pfeiltasten zum laufen und spingen die ich mithilfe einer Bitmap zeichne. In Java kann man ja die Tastatur benutzen mit KeyListener, in Android muss man ja OneClickListener benutzen wobei es viele verschiedene Funktionen gibt, jedoch habe ich für Bitmaps nichts passendes bezüglich keyPressed und keyReleased gefunden....

Mein Ziel: Wenn man auf die Bitmap Pfeil drückt und es nicht loslässt registriert das MotionEvent das und bleibt dadrin, wenn ich nicht mehr auf die Bitmap meine FInger halte registriert er dieses.

LG Claan

PS: Wer Rechtsschreibfehler findet darf sie behalten

Beiträge von Claan

Gerüst der grafischen Oberfläche

Gerüst der grafischen Oberfläche

Grafiken für verschiedene Screen Größen /Auflösungen

Gerüst der grafischen Oberfläche

Gerüst der grafischen Oberfläche

Grafiken für verschiedene Screen Größen /Auflösungen

Bitmap MotionEvent

Grafiken für verschiedene Screen Größen /Auflösungen

Grafiken für verschiedene Screen Größen /Auflösungen

Bitmap MotionEvent

Grafiken für verschiedene Screen Größen /Auflösungen

Grafiken für verschiedene Screen Größen /Auflösungen

Bitmap MotionEvent

Bitmap MotionEvent