Timer Synchronisation Problem

Railwanderer · 2015-03-15T00:43:13+0100

Halli hallo

ich melde mich zurück mit einem neuen Problem.
Ich habe mir zum Test eine 2D Tile Map App gemacht, die zurzeit
eine Map aus einem 2D int Array lädt, und dann für die Koordinaten des
Spielers ein Raster erstellt (ebenfalls 2d int array) der den Screen Bereich des
Spielers darstellt. Dieses Raster verschiebt sich mit dem Spieler.

Der Spieler wird in einem laufendem Thread je nach input (touch event)
um ein Tile bewegt. Dazu zählt der Timer in einem gewissen Intervall von 0 bis 1
und dieser (Speed) wert wird auf den Spieler addiert ( seine X tile und Y tile Position).

Das Raster das den Bereich des Spielers zeichnet (+1 für den Rand) verschiebt diesen gezeichneten Bereich abhängig vom Spieler X und Y zu 0.0 . Dabei hängt der Bereich (MapView) an gewissen Eckpunkten, innerhalb dessen dann der Spieler nicht mehr zentriert sondern auf seinem wirklichen Tile gezeichnet wird.

Soweit läuft alles wie ich es mir vorstelle, ist der Spieler in der Ecke, verschiebt sich die Map nicht mehr ( die MapView) und der Spieler läuft frei rum.
verlasse ich nun die Ecke fängt ab der Mitte an die MapView sich zu bewegen, und fixiert den Spieler bis er wieder an den anderen Rand kommt (zb. am linken rand ist die mitte der mapview bei X=0+mapviewWidth/2), dort wartet dann die mapview wieder bis der spieler vom Randgebiet zurück zur mitte der view läuft.

nun das Problem,
ich möchte diese Mapview umschreiben dass sie auch unterschiedliche Kartengrössen berechnen kann und unterschiedliche View Bereiche.

Da allerdings die Mapview von der Spieler Position abhängt und sich um diese berechnet, muss ich eine Möglichkeit finden synchron den wert aus dem spieler run() rauszulesen. denn bei einer tile map wie dieser:

0 1 2345678 910111213141516171819

0 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,|,0,0,0,0,0,0,}, //x = view Center
1 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,|,0,0,0,0,0,0,}, //ü = Beispiel spieler Position
2 {0,0,0,ü,0,0,0,0,0,0,0,0,0,0,|,0,0,0,0,0,0,},
3 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,|,0,0,0,0,0,0,},
4 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,|,0,0,0,0,0,0,},
5 {0,0,0,0,0,0,x,0,0,0,0,0,0,0,|,0,0,0,0,0,0,},
6 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,|,0,0,0,0,0,0,},
7 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,|,0,0,0,0,0,0,},
8 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,|,0,0,0,0,0,0,},
9 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,|,0,0,0,0,0,0,},
-----------------------------------
10{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
11{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
12{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
13{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
14{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
15{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
16{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
17{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
18{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
19{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},

von 20 x20 Tiles also Positionen von 0 -19
läd die Mapview immer 15*10 tiles.
Die mitte der View ist also bei X = 7
(Wegen des arrays das 8. Tile. dieses wird dann allerdings mit einem
Wert von 7 gezeichnet, da 7*32 genau die stelle vorgibt wo das achte Tile gezeichnet wird):

MapView X achse
0123456 7 891011121314
i | //tile wird am i Punkt gezeichnet.
| |

mitte Y ist beim 6ten Tile, dem unteren der Mitte.denn der spieler soll später 2 tile gross werden.

Mapview y Achse:
0
1
2
3
4
5 X
6
7
8
9

somit muss meine view sich bei einer map von 20x20 für den fall
das zB. der spieler links oben ist bei
x = 7 und Y = 5 aufhängen, da sie dann den Bereich bis zum rand abdeckt, und der spieler sich im links oberen Bereich des Bildschirms dann frei bewegen kann ( die mitte verlässt).

das problem beginnt auf der anderen Seite:
trifft der rechte rand der mapview den rand der Map soll sie anhalten.

normalerweise müsste es bei x tile:
x = (mapwidth-1)- mapviewwidth/2 sein also:
12= (20-1)(da array von 0bis19) - Math.floor (15/2)

komischerweise ist an dieser Position allerdings mein Center X der
Map view nicht gleich des Player X , ich vermute da es asynchron von der Berechnung des Player Threads abgerufen wird. wie kann ich sichergehn dass zeitgleich bzw direkt hintereinander der wert geschrieben und abgerufen wird?

im logcat siehts so aus, ich laufe hier von rechts unten (19,19) nach links am unteren rand entlang (19,0) und zurück nach recht auf (19,19). links und recht drücke ich einmal weiter gegen den rand, um die werte zu aktualisieren ( verlasse ich die map werd ich auf dem tile davor festgenagelt)

man sieht es werden komische werte abgerufen obwohl out put direkt unter einander ausgeführt wird.

Code:

    Creating Player
03-14 23:59:06.195    7842-7871/android.railwanderer.mapwindowtest I/System.out -Player created-
03-14 23:59:06.195    7842-7871/android.railwanderer.mapwindowtest I/System.out [ 03-14 23:59:06.195  7842: 7871 V/MapScreen ]
    init MapScreen
03-14 23:59:06.195    7842-7871/android.railwanderer.mapwindowtest V/Map init Map
03-14 23:59:06.200    7842-7871/android.railwanderer.mapwindowtest V/MapView init MapView
03-14 23:59:06.200    7842-7871/android.railwanderer.mapwindowtest V/MapView init MapView finished
03-14 23:59:06.200    7842-7871/android.railwanderer.mapwindowtest V/Map init Map finished
03-14 23:59:06.200    7842-7871/android.railwanderer.mapwindowtest V/MapScreen init MapScreen finished
03-14 23:59:09.665    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 18.9985 Y tile: 19.0
03-14 23:59:09.665    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:14.100    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 17.9995 Y tile: 19.0
03-14 23:59:14.100    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:15.765    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 16.9985 Y tile: 19.0
03-14 23:59:15.765    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:17.000    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 15.9995 Y tile: 19.0
03-14 23:59:17.000    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:17.785    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 14.955025 Y tile: 19.0
03-14 23:59:17.785    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:18.600    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 13.9995 Y tile: 19.0
03-14 23:59:18.600    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:19.315    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 13.0 Y tile: 19.0
03-14 23:59:19.320    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:20.070    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 11.9995 Y tile: 19.0
03-14 23:59:20.070    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:22.415    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 10.999001 Y tile: 19.0
03-14 23:59:22.415    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 11.0MapView center Y: 15.0
03-14 23:59:23.235    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 9.9995 Y tile: 19.0
03-14 23:59:23.235    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 10.0MapView center Y: 15.0
03-14 23:59:23.920    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 8.9995 Y tile: 19.0
03-14 23:59:23.920    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 9.0MapView center Y: 15.0
03-14 23:59:24.500    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 7.9989996 Y tile: 19.0
03-14 23:59:24.500    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 8.0MapView center Y: 15.0
03-14 23:59:25.035    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 6.9995 Y tile: 19.0
03-14 23:59:25.035    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:25.665    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 5.9984994 Y tile: 19.0
03-14 23:59:25.665    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:26.285    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 4.9984994 Y tile: 19.0
03-14 23:59:26.285    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:26.835    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 3.9995 Y tile: 19.0
03-14 23:59:26.835    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:27.370    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 2.9995 Y tile: 19.0
03-14 23:59:27.370    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:27.935    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 1.9990001 Y tile: 19.0
03-14 23:59:27.935    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:28.470    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 0.9995 Y tile: 19.0
03-14 23:59:28.470    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:35.870    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: -5.0E-4 Y tile: 19.0
03-14 23:59:35.870    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:37.435    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 5.0E-4 Y tile: 19.0
03-14 23:59:37.435    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:38.355    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 1.0005 Y tile: 19.0
03-14 23:59:38.355    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:38.985    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 2.001 Y tile: 19.0
03-14 23:59:38.990    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:39.605    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 3.001 Y tile: 19.0
03-14 23:59:39.605    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:40.155    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 4.0005 Y tile: 19.0
03-14 23:59:40.155    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:40.690    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 5.0005 Y tile: 19.0
03-14 23:59:40.690    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:41.190    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 6.002501 Y tile: 19.0
03-14 23:59:41.190    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:41.690    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 7.0010004 Y tile: 19.0
03-14 23:59:41.690    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 7.0MapView center Y: 15.0
03-14 23:59:42.140    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 8.0005 Y tile: 19.0
03-14 23:59:42.140    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 8.0MapView center Y: 15.0
03-14 23:59:42.805    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 9.0005 Y tile: 19.0
03-14 23:59:42.805    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 9.0MapView center Y: 15.0
03-14 23:59:43.535    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 10.001499 Y tile: 19.0
03-14 23:59:43.535    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 10.0MapView center Y: 15.0
03-14 23:59:44.355    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 11.000999 Y tile: 19.0
03-14 23:59:44.355    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 11.0MapView center Y: 15.0
03-14 23:59:45.085    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 12.001999 Y tile: 19.0
03-14 23:59:45.090    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:45.670    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 13.000999 Y tile: 19.0
03-14 23:59:45.670    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:46.190    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 14.0 Y tile: 19.0
03-14 23:59:46.190    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:46.770    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 15.0005 Y tile: 19.0
03-14 23:59:46.770    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:48.175    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 16.0005 Y tile: 19.0
03-14 23:59:48.175    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:48.720    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 17.0015 Y tile: 19.0
03-14 23:59:48.720    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:49.340    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 18.0005 Y tile: 19.0
03-14 23:59:49.340    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:49.990    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 19.001 Y tile: 19.0
03-14 23:59:49.990    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:50.640    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 19.0 Y tile: 19.0
03-14 23:59:50.640    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0
03-14 23:59:51.525    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates X tile: 19.001 Y tile: 19.0
03-14 23:59:51.525    7842-7871/android.railwanderer.mapwindowtest V/Player Coordinates MapView center X: 12.0MapView center Y: 15.0

/MapScreen Class (View)

Code:

package android.railwanderer.mapwindowtest.Tilestuff;

import android.graphics.Color;
import android.railwanderer.mapwindowtest.Assets;
import android.railwanderer.mapwindowtest.MainActivity;
import android.railwanderer.mapwindowtest.MainMenueScreen;
import android.railwanderer.mapwindowtest.Player;
import android.railwanderer.mapwindowtest.Settings;
import android.railwanderer.mapwindowtest.implementation.KeyboardHandler;
import android.railwanderer.mapwindowtest.interfaces.Game;
import android.railwanderer.mapwindowtest.interfaces.Graphics;
import android.railwanderer.mapwindowtest.interfaces.Input;
import android.railwanderer.mapwindowtest.interfaces.Screen;
import android.util.Log;

import java.util.List;

/**
 * Created by jesjjes on 09.03.15.
 */
public class MapScreen extends Screen {

    public static Map tileMap;
    Player player;
    double screenX = 0;
    double screenY = 0;
    MapCode map1 = new Codemap1();
    MapCode map2 = new Codemap1();
// TODO: init other maps
// TODO: write methods to change current map with initialized maps

    //---------------------------------------------------------------------------------------------- Update
    public MapScreen(Game game) {

        super(game);
        this.player= Player.player;
        player.setDirection(2);
        Log.v("MapScreen","init MapScreen");

        //initialise World
        tileMap = new Map(map1);


        KeyboardHandler.wentBack = false;
        Log.v("MapScreen","init MapScreen finished");
    }

    //---------------------------------------------------------------------------------------------- Update
    @Override
    public void update(float deltaTime) {
        Graphics g = game.getGraphics();
        List<Input.TouchEvent> touchEvents = game.getInput().getTouchEvents();
        game.getInput().getKeyEvents();

        // check backbutton
        if (game.getInput().isKeyPressed(Input.KeyEvent.KEY_BACK)) {

            if (!KeyboardHandler.wentBack) {
                KeyboardHandler.wentBack=true;
                game.setScreen(new MainMenueScreen(game));

            }

        }

        // on Touch Event
        int len = touchEvents.size();
        for (int i = 0; i < len; i++) {
            Input.TouchEvent event = touchEvents.get(i);

            // Event Down
            if (event.type == Input.TouchEvent.TOUCH_DRAGGED || event.type == Input.TouchEvent.TOUCH_DOWN) {
                    if(!KeyboardHandler.wentBack) {
                        KeyboardHandler.wentBack = true;
                        // check Move Direction of Player
                        player.checkMove(event, player);
                        // walk a step
                        player.walking = true;
                        Log.v("Player Coordinates ", " X tile: "+player.xTile+" Y tile: "+player.yTile);
                        Log.v("Player Coordinates ", "MapView center X: "+tileMap.mapView.mapViewCenterX+
                                "MapView center Y: "+tileMap.mapView.mapViewCenterY);

                    }

            }
            // Event UP
            if (event.type == Input.TouchEvent.TOUCH_UP) {
                //update Player
                KeyboardHandler.wentBack = false;
                player.walking=false;
            }
        }

        player.update(deltaTime,player);
        tileMap.update(deltaTime);
        if(player.xTile==14&&player.yTile==11){
            player.xTile=0;
            player.yTile=0;
        }

    }



    @Override
    public void present(float deltaTime) {
        Graphics g = game.getGraphics();

        g.drawRect(0, 0, 481, 320, Color.BLACK);

        //draw tileMap
        tileMap.drawTilemap(tileMap, g);

        if(player.xTile<0){
            player.xTile=0;
        }
        if(player.yTile<0){
            player.yTile=0;
        }
        if(player.xTile> tileMap.mapWidth-1){
            player.xTile=tileMap.mapWidth-1;
        }
        if(player.yTile> tileMap.mapHeight-1){
            player.yTile= tileMap.mapHeight-1;
        }

        if(player.xTile<= 7) {
            screenX = player.xTile;
        }
        if (player.xTile >= 12) {
            screenX = player.xTile-5;
        }
        if(player.yTile <= 5) {
            screenY = player.yTile;
        }
        if(player.yTile >=15){
            screenY=player.yTile -10;     // ??? wieso dieser wert von -10 müsste doch einfach player.yTile sein.....da am unteren rand die reichen sichtbar sind :S
        } 

        else if(!tileMap.mapView.isAligned){
            screenX=7;
            screenY=5;
        }
        [COLOR="Red"]hier wird der Spieler gezeichnet ( ein ausschnitt aus dem tile sheet[/COLOR]
        g.drawPixmap(Assets.grassTileSheet, (int) (screenX* 32), (int) ((screenY) * 32), (32 * 55), 0, 32, 32);
    }




    // check if touch in bounds of rectangle
    private boolean inBounds(Input.TouchEvent event, int x, int y, int width, int height) {

        if(event.x > x && event.x < x + width - 1 && event.y > y && event.y < y + height - 1)
            return true;
        else
            return false;
    }





    @Override
    public void pause() {

        Settings.save(game.getFileIO());
    }

    @Override
    public void resume() {
    }

    @Override
    public void dispose() {
    }
    public Player getPlayer(){
        return player;
    }
}

Map Klasse:

Code:

public class Map {

    Player player;
    int direction;
    double xOffset, yOffset;
    public int playerOffx, playerOffy;
    Tiles tiles[][];
    int[][] tilesID;
    int mapWidth;
    int mapHeight;
    int mapSheetNr;


    public MapView mapView;

    //---------------------------------------------------------------------------------------------- Constructor
    public Map(MapCode map) {


        Log.v("Map","init Map");

        // catch player
        this.player = Player.player;
        this.direction = player.getDirection();

        // select map to initalise
        //------------------------------------------------------------------------------------------ Map constructor

                mapHeight =map.mapH;
                mapWidth = map.mapW;
                mapSheetNr = map.mapSheet;
                tiles = new Tiles[mapWidth][mapHeight];
                tilesID = map.mapCode;
                // fill Tiles Array with new Tiles
                for (int worldX = 0; worldX < mapWidth; worldX++) {
                    for (int worldY = 0; worldY < mapHeight; worldY++) {
                        // create new Tile
                        tiles[worldX][worldY] = new Tiles(tilesID[worldX][worldY]);
                        // save Position of Tile
                        tiles[worldX][worldY].setTilePosition(worldX,worldY);
                    }
                }




        mapView = new MapView(this);
        Log.v("Map","init Map finished");
    }

    //---------------------------------------------------------------------------------------------- Update
    public void update(float deltaTime) {

        mapView.update();
    }

    //---------------------------------------------------------------------------------------------- Draw Map
    public void drawTilemap(Map tileMap, Graphics g) {

        mapView.drawMapView(g);
    }
}

MapView Klasse:

Code:

public class MapView {

    // MiniMap
    int miniScale;                           // scale factor of map
    int miniSize ;                           // size of minimap in px
    int nullX ;                              // right aligned
    int nullY;
    // Map Refrence
    Map map;
    Tiles tiles[][];

    // Player Refrence
    Player player ;

    // MapView
    public double mapViewCenterX, mapViewCenterY;
    boolean alignedRight,alignedLeft,alignedUp,alignedDown;
    public boolean isAligned;
    double xOffset, yOffset;

    //---------------------------------------------------------------------------------------------- Constructor
    public MapView(Map map){

        Log.v("MapView", "init MapView");
        //catch Map
        this.map = map;
        this.tiles = map.tiles;

        //catch Player
        this.player = Player.player;

        //calculate View
        calculateViewTiles(player);

        createMiniMap();
        Log.v("MapView","init MapView finished");
        xOffset = 0.0;
        yOffset = 0.0;
    }

    //---------------------------------------------------------------------------------------------- Update
    public void update(){
        calculateViewTiles(player);
    }

    //---------------------------------------------------------------------------------------------- Calculate Map View
    public void calculateViewTiles(Player player) {

        // get Player Position
        checkMapViewCenter();

        // set tiles in range of player to draw = true
        for (int calcY = (int)(mapViewCenterY)-((Player.viewWindow_HEIGHT/2)); calcY <= (int)mapViewCenterY+((Player.viewWindow_HEIGHT/2)); calcY++) {
            for (int calcX = (int)(mapViewCenterX)-((Player.viewWindow_WIDTH/2)); calcX <= (int)mapViewCenterX+1+Player.viewWindow_WIDTH/2; calcX++) {

                if(calcX<map.mapWidth && calcY<map.mapHeight) {
                    try {
                        tiles[calcY][calcX].setToDraw(true);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    //---------------------------------------------------------------------------------------------- Check MapView Center
    public void checkMapViewCenter() {

        // left aligned
        if(player.xTile <= Math.floor(Player.viewWindow_WIDTH/2)) {     // 7
            mapViewCenterX = Math.floor(Player.viewWindow_WIDTH/2);     // 7
            alignedLeft = true;
        }else {
            alignedLeft = false;
        }
        //right aligned
        if(player.xTile >= (map.mapWidth-1)-(Math.floor(Player.viewWindow_WIDTH/2))) {  // 12
            mapViewCenterX = (map.mapWidth-1)-(Math.floor(Player.viewWindow_WIDTH/2));  // 12
            alignedRight = true;
        }else {
            alignedRight = false;
        }
        //up aligned
        if(player.yTile <= Math.floor(Player.viewWindow_HEIGHT/2)){     // 5
            mapViewCenterY =Math.floor(Player.viewWindow_HEIGHT/2);     // 5
            alignedUp = true;
        }else {
            alignedUp = false;
        }
        //down aligned
        if(player.yTile >= (map.mapHeight)-(Math.floor(Player.viewWindow_HEIGHT/2))){                // 15
            mapViewCenterY = (map.mapHeight)-(Math.floor(Player.viewWindow_HEIGHT/2));               // 15
            alignedDown = true;
        }else {
            alignedDown = false;
        }

        if(!alignedLeft && !alignedRight) {
            mapViewCenterX = player.xTile;
        }
        if(!alignedDown && !alignedUp){
            mapViewCenterY = player.yTile;
        }

        if(alignedLeft || alignedRight || alignedUp || alignedDown){
            isAligned = true;
        }else{
            isAligned =false;
        }
        xOffset = mapViewCenterX-Math.floor(Player.viewWindow_WIDTH/2);
        yOffset = mapViewCenterY-Math.floor(Player.viewWindow_HEIGHT/2);
       }



    //---------------------------------------------------------------------------------------------- Draw MapView
    public void drawMapView(Graphics g) {
        int y = 0;
        int x = 0;
        for (int calcY = (int) (mapViewCenterY)  - (int) (Player.viewWindow_HEIGHT/2); calcY < (int) mapViewCenterY +1+(int) (Player.viewWindow_HEIGHT/2); calcY++) {
            for (int calcX = (int) (mapViewCenterX) - (int) (Player.viewWindow_WIDTH/2); calcX < (int) mapViewCenterX + (int) (Player.viewWindow_WIDTH/2)+2; calcX++) {
                if(calcX<map.mapWidth&&calcY<map.mapHeight) {
                    try {
                        tiles[calcY][calcX].draw(map.mapSheetNr, map.tilesID[calcY][calcX], g, (int)(32 *  (calcX - xOffset)),(int) (32 *  (calcY - yOffset)));
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }

        }
        drawMiniMap(map, g);
    }


    //----------------------------------------------------------------------------------------------Create MiniMap
    public void createMiniMap() {
        //minimap origin
        miniScale = 3;                          // scale factor of map
        miniSize = (map.mapWidth)*miniScale;              // size of minimap in px
        nullX =(Player.viewWindow_WIDTH*32) - (miniSize +1);        // right aligned
        nullY = 1;

    }
    //----------------------------------------------------------------------------------------------Draw MiniMap
    public void drawMiniMap(Map tileMap, Graphics g) {

        g.drawLine(nullX, 0, nullX + miniSize, 0, Color.argb(125,255, 255, 255));                          //  --
        g.drawLine(nullX-1,0,nullX-1,nullY+miniSize+1,Color.argb(125,255,255,255));                         // |
        g.drawLine(nullX+miniSize,0,nullX+miniSize,nullY+miniSize+1,Color.argb(125,255,255,255));           //    |
        g.drawLine(nullX,nullY+miniSize,nullX+miniSize,nullY+miniSize,Color.argb(125,255,255,255));         //  --

        g.drawRect(nullX,nullY,miniSize,miniSize,Color.argb(125,0,0,0));

        g.drawRect((int)(nullX+tileMap.player.xTile*miniScale),(int)(nullY+tileMap.player.yTile*miniScale),
                miniScale,miniScale,Color.RED);

    }
}

Player Klasse:

Code:

public class Player implements Runnable{

    public static Player player = new Player(19,19);

    public boolean walking;
    public float xTile, yTile;
    double xCord, yCord;

    public final static int UP = 0;
    public final static int RIGHT = 1;
    public final static int DOWN = 2;
    public final static int LEFT = 3;
    public int direction;

    float startTime;
    static final float waitTime = 0.1f;
    static float totalTime;
    public Map tilemap;
    float speed = 0.0005f;
    long firstTime;
    float deltaTime;
    boolean finished;

    Thread thread;


    public static int viewWindow_WIDTH = 15;
    public static int viewWindow_HEIGHT = 10;

    public Player(int x, int y) {
        System.out.println(" ");
        System.out.println("Creating Player");
        xTile = x;
        yTile = y;
        xCord = 0;
        yCord = 0;

        startTime = 0;
        walking = false;

        direction = 0;
        totalTime = 0;
        finished= true;


        thread = new Thread(this);

        this.tilemap = MapScreen.tileMap;
        System.out.println(" -Player created- ");
        System.out.println(" ");

    }

    public void update(float deltaTime, Player player){

              this.deltaTime = deltaTime;
              firstTime = System.currentTimeMillis();

              try {
                    player.thread.start();

              }catch (Exception e) {

              }
    }

    @Override
    public void run(){
        while(true) {
            while (walking) {
                finished = false;
                if (direction == UP) {
                    yCord = 0;
                    why:
                    while (yCord < 1) {
                        totalTime += (System.currentTimeMillis()) - firstTime;
                        firstTime = System.currentTimeMillis();
                        if (totalTime > waitTime) {
                            yCord += speed;
                            yTile -= speed;
                            totalTime -= waitTime;
                        }
                        if (yCord >= 1) {
                            yCord = 0;
                            yTile = Math.round(yTile);
                            if(!KeyboardHandler.wentBack) {
                                break why;
                            }else{
                                KeyboardHandler.wentBack = false;
                                break why;
                            }
                        }
                    }
                }
                if (direction == RIGHT) {
                    why:
                    while (xCord < 1) {
                        totalTime += System.currentTimeMillis() - firstTime;
                        firstTime = System.currentTimeMillis();
                        if (totalTime > waitTime) {
                            xCord += speed;
                            xTile += speed;
                            totalTime -= waitTime;

                        }
                        if (xCord >= 1) {
                            xCord = 0;
                            xTile = Math.round(xTile);
                            if(!KeyboardHandler.wentBack) {
                                break why;
                            }else{
                                KeyboardHandler.wentBack = false;
                                break why;
                            }
                        }
                    }
                }
                if (direction == DOWN) {
                    why:
                    while (yCord < 1) {
                        totalTime += System.currentTimeMillis() - firstTime;
                        firstTime = System.currentTimeMillis();
                        if (totalTime > waitTime) {
                            yCord += speed;
                            yTile += speed;
                            totalTime -= waitTime;
                        }
                        if (yCord >= 1) {
                            yCord = 0;
                            yTile = Math.round(yTile);
                            if(!KeyboardHandler.wentBack) {
                                break why;
                            }else{
                                KeyboardHandler.wentBack = false;
                                break why;
                            }
                        }
                    }
                }
                if (direction == LEFT) {
                    why:
                    while (xCord < 1) {
                        totalTime += System.currentTimeMillis() - firstTime;
                        firstTime = System.currentTimeMillis();

                        if (totalTime > waitTime) {
                            xCord += speed;
                            xTile -= speed;
                            totalTime -= waitTime;
                        }

                        if (xCord >= 1) {
                            xCord = 0;
                            xTile = Math.round(xTile);
                            if(!KeyboardHandler.wentBack) {
                                break why;
                            }else{
                                KeyboardHandler.wentBack = false;
                                break why;
                            }
                        }
                    }
                }
            }
        }
    }


    public void checkMove(Input.TouchEvent event, Player player) {

        if (event.type == Input.TouchEvent.TOUCH_DRAGGED || event.type == Input.TouchEvent.TOUCH_DOWN) {

            if (event.y < (viewWindow_HEIGHT / 2) * 32 && event.x > (viewWindow_WIDTH / 3) * 32 && event.x < ((viewWindow_WIDTH / 3) * 2) * 32) {
                player.direction = 0;

            } else if (event.x > (viewWindow_WIDTH / 2) * 32 && event.y > (viewWindow_HEIGHT / 3) * 32 && event.y < (viewWindow_HEIGHT / 3) * 2 * 32) {
                player.direction = 1;

            } else if (event.y > (viewWindow_HEIGHT / 2) * 32 && event.x > (viewWindow_WIDTH / 2) * 32 && event.x < ((viewWindow_WIDTH / 3) * 2) * 32) {
                player.direction = 2;

            } else if (event.x < (viewWindow_WIDTH / 2) * 32 && event.y > (viewWindow_HEIGHT / 3) * 32 && event.y < (viewWindow_HEIGHT / 3) * 2 * 32) {
                player.direction = 3;
            }
        }
    }

    public double getX(){

        return xTile;
    }

    public double getY(){

        return yTile;
    }

    public int getDirection(){
        return direction;
    }

    public void setDirection(int direction){

        this.direction = direction;
    }

}

Ihr würdet mir wirklich helfen, ich verstehe nicht warum der Spieler Tile nicht der wirkliche Tile ist, irgendwie wandert die map langsamer mit, oder die werte der View werden verspätet aus dem Run thread des players gelesen, nur dadurch kann sie doch hinterher hängen :S

Achja und man kann sicher alles besser Lösen

aber ich wollte mal mir eine
komplett eigene Idee davon machen, bitte mal übersehen

Der ursprüngliche Beitrag von 00:11 Uhr wurde um 00:43 Uhr ergänzt:

okay hab mein Denkfehler gefunden

läuft jetzt , die - 10 ist der offset...
lg

Jaiel · 2015-03-15T05:08:43+0100

Wow gut das ich runtergescrollt habe zum edit...btw es wurde hier ein extra unterforum für spieleentwicklung eingerichtet

ich hatte darum gebeten für genau solche Themen ein spezielles unterforum einzurichten ; )

Railwanderer · 2015-03-18T16:00:41+0100

okay beim nächsten mal halte ich mich dran

ja leider ziemlich chaotisch mein Map Engine.... aber er wird

man kann umherlaufen,
an den Kartenrändern läuft der Spieler weiter ansonsten ist er in der Mitte fixiert und die Karte bewegt sich. Sie unterstützt bis zu 4 Layer und zeichnet den Gewissen Tile /zb baumspitze) transparent, wenn der spieler dahinter steht.
Bin nur gespannt ob das alles so easy bleibt

steig jetzt kaum noch durch in meinen Klassen :S

ein Problem das ich habe

int[][] mapCode={
{0,0,0,0,0,0},
{0,0,0,0,0,0},
{0,0,0,0,0,0},
{0,0,0,0,0,0}
}

wie kann ich den oberen Array zwar in einer Klasse Map definieren also:
public class Map{
int [][] mapCode;
}
aber dann in einer Klasse wie:

public class Map1 extends Map{

// Array Beschreibung

mapCode = {
{0,0,0,0,0,0},
{0,0,0,0,0,0},
{0,0,0,0,0,0},
{0,0,0,0,0,0}
}
}

initialisieren? Es heisst immer Array Initializer not allowed here :/
egal ob ich es in die Klasse oder den Constructor schreibe.

Jaiel · 2015-03-18T16:35:53+0100

also du musst das array in eienr schleife natürlich mit werten belegen.

mapCode ist eine Referenz...ein zeiger sozusagen...der auf einen Speicherplatz zeigt wo das Array beginnt

du hast ein array von int also 4 byte lang

mapCode[2][4] z.B. sagt der Maschine:
gehe zu dieser referenz im speicher
lies immer 4 bytes aus(da ein int)
schreite 2*6*4bytes+4*4bytes(weil du ein4x6 array hast) weiter und lies diese bytes

hier ein bild dazu :http://www.mathematik.uni-ulm.de/nu...ficComputing/doc/session1/formula_page1_3.gif

beim ersten element wären es dann schreite 0*4 bytes plus0*4 bytes weiter und lies 4 bytes raus.

ich denke du weißt was ich meine....du kannst einen pointer/referenz keine werte zu weisen nur speicheradressen(das geht nciht in java,aber in den c sprachen zum beispiel)

also nochmal kurz du versuchst eine speicherreferenz mit einem array zu initialisieren....nciht gut....du musst die stellen auf die die referenz zeigt initialisieren...in einer schleife oder direkt

Der ursprüngliche Beitrag von 16:31 Uhr wurde um 16:35 Uhr ergänzt:

und : falls du tile maps schnell erstellen willst kannst du das heir amchen...ich glaube du bekommst dann ein json string und kannst das in deinen code parsen oder wie man das auch nennt Tiled Map Editor

Railwanderer · 2015-03-19T15:58:47+0100

okay danke

das wird das problem sein. an den tiled map editor habe ich aufh gedacht,
denke aber ich werde mir zur uebung selbst einen (simplen) schreiben

pure java programme hab ich noch nicht so oft geschrieben

Quick results: Click search for more Results…

Timer Synchronisation Problem

Railwanderer

Ambitioniertes Mitglied

Jaiel

Dauergast

Railwanderer

Ambitioniertes Mitglied

Jaiel

Dauergast

Railwanderer

Ambitioniertes Mitglied

Ähnliche Themen