Esempio n. 1
0
  /**
   * get all possible playing fields which could be occur when the tile comes into play
   *
   * @return
   */
  public ArrayList<Round> getAllNextPossiblePlayingFields() {
    ArrayList<Round> allpos = new ArrayList<Round>();

    ArrayList<Tile> freeTiles = this.getFreeCells(); // get all unassigned tiles
    for (int i = 0; i < freeTiles.size(); i++) { // iterate trough all tiles
      Tile ctile = freeTiles.get(i);

      PlayingField p_new_2 = (PlayingField) this.makeCopy();
      p_new_2.setValue(ctile.getX(), ctile.getY(), 2);
      allpos.add(
          new Round(
              p_new_2,
              0.9,
              "2 at x=" + ctile.getX() + ", y=" + ctile.getY())); // set 2 with probability of 0.9

      PlayingField p_new_4 = (PlayingField) this.makeCopy();
      p_new_4.setValue(ctile.getX(), ctile.getY(), 4);
      allpos.add(
          new Round(
              p_new_4,
              0.1,
              "4 at x=" + ctile.getX() + ", y=" + ctile.getY())); // set 4 with probability of 0.1
    }

    return allpos;
  }
Esempio n. 2
0
  boolean checkTileCollision(Tile t) {
    Rectangle r1 = new Rectangle(getX(), getY(), WIDTH, HEIGHT);
    if (t.getCollisionType() != 0) {
      Rectangle r2Whole = new Rectangle(t.getX(), t.getY(), 32, 32);
      return (r1.intersects(r2Whole) || r2Whole.intersects(r1));
    } else {
      Rectangle r2p1 = new Rectangle(t.getX(), t.getY(), 16, 16);
      Rectangle r2p2 = new Rectangle(t.getX() + 16, t.getY(), 16, 16);
      Rectangle r2p3 = new Rectangle(t.getX(), t.getY() + 16, 16, 16);
      Rectangle r2p4 = new Rectangle(t.getX() + 16, t.getY() + 16, 16, 16);

      // check collision on the first quadrant if the byte is 1
      if (t.getTileByte(0) == 1) {
        return (r1.intersects(r2p1) || r2p1.intersects(r1));
        // check collision on the second quadrant if the byte is 1
      } else if (t.getTileByte(1) == 1) {
        return (r1.intersects(r2p2) || r2p2.intersects(r1));
        // check collision on the third quadrant if the byte is 1
      } else if (t.getTileByte(2) == 1) {
        return (r1.intersects(r2p3) || r2p3.intersects(r1));
        // check collision on the fourth quadrant if the byte is 1
      } else if (t.getTileByte(3) == 1) {
        return (r1.intersects(r2p4) || r2p4.intersects(r1));
        // otherwise this tile does not have any bytes that are handled
        // we could add different types of collisions
      } else {
        return false;
      }
    }
  }
  private static Tile[] getAdjTiles(Tile[][] grid, Tile x) {
    Tile[] y = new Tile[4];
    if (!(x.getX() == 0)) y[3] = grid[x.getX() - 1][x.getY()];
    if (!(x.getY() == 0)) y[0] = grid[x.getX()][x.getY() - 1];
    if (!(x.getX() == grid.length - 1)) y[1] = grid[x.getX() + 1][x.getY()];
    if (!(x.getY() == grid[0].length - 1)) y[2] = grid[x.getX()][x.getY() + 1];

    return y;
  }
Esempio n. 4
0
 void fixTileCollision(Tile t) {
   while (checkTileCollision(t)) {
     if (x < t.getX()) {
       x -= 2;
     } else if (x > t.getX()) {
       x += 2;
     }
     if (y < t.getY()) {
       y -= 2;
     } else if (y > t.getY()) {
       y += 2;
     }
   }
 }
Esempio n. 5
0
 private void fireTilesChangedIncludeBorder(Set<Tile> tiles) {
   if (showBorder
       && (tileProvider instanceof Dimension)
       && (((Dimension) tileProvider).getDim() == DIM_NORMAL)
       && (((Dimension) tileProvider).getBorder() != null)) {
     final Set<Point> coordSet = new HashSet<>();
     for (Tile tile : tiles) {
       final int tileX = tile.getX(),
           tileY = tile.getY(),
           borderSize = ((Dimension) tileProvider).getBorderSize();
       for (int dx = -borderSize; dx <= borderSize; dx++) {
         for (int dy = -borderSize; dy <= borderSize; dy++) {
           coordSet.add(getTileCoordinates(tileX + dx, tileY + dy));
         }
       }
     }
     for (TileListener listener : listeners) {
       listener.tilesChanged(this, coordSet);
     }
   } else {
     Set<Point> coords = tiles.stream().map(this::getTileCoordinates).collect(Collectors.toSet());
     for (TileListener listener : listeners) {
       listener.tilesChanged(this, coords);
     }
   }
 }
Esempio n. 6
0
  public boolean changeTile(int x, int y, String image) {
    Tile temp = getTile(x, y);

    Entity ent = game.getEntityManager().getEntity(temp.getX(), temp.getY());

    if (ent != null) {
      if (image.contains("concrete"))
        if (ent.getImage().contains("dinosaur") || ent.getImage().contains("fence")) return false;
    }

    if (game.getEntityManager().entityAt(temp.getX(), temp.getY()) && image.contains("water"))
      return false;

    if (game.getParkManager().purchaseEntity(image)) temp.setImage(image);

    return true;
  }
Esempio n. 7
0
 public URL getTileUrl(Tile tile) {
   String url =
       getServerUrl() + "/" + tile.getZoom() + "/" + tile.getX() + "/" + tile.getY() + ".png";
   try {
     return new URL(url);
   } catch (MalformedURLException e) {
     return null;
   }
 }
Esempio n. 8
0
 public void setTile(Tile tile) {
   int x = tile.getX(), y = tile.getY();
   if (x >= 0 && y >= 0 && x < sizeX && y < sizeY) {
     tiles[x][y] = tile;
   }
 }
Esempio n. 9
0
 /**
  * Convert the actual tile coordinates to zoom-corrected (tile provider coordinate system)
  * coordinates.
  *
  * @param tile The tile of which to convert the coordinates.
  * @return The coordinates of the tile in the tile provider coordinate system (corrected for
  *     zoom).
  */
 private Point getTileCoordinates(Tile tile) {
   return getTileCoordinates(tile.getX(), tile.getY());
 }
Esempio n. 10
0
  public void Draw(Canvas canvas) {
    if (!initialized) {
      tiles = new ArrayList<Tile>();
      water = new ArrayList<Tile>();

      TILE_WIDTH = game.getBitmapManager().getBitmap(R.drawable.terrain_grass).getWidth();
      TILE_HEIGHT = game.getBitmapManager().getBitmap(R.drawable.terrain_grass).getHeight();

      generateTerrain(tiles);
      generateWater(water);

      initialized = true;
    }

    float tempWaterOffset = waterOffset;
    tempWaterOffset = (float) Math.round(waterOffset);
    tempWaterOffset = tempWaterOffset % 2 == 0 ? tempWaterOffset : tempWaterOffset + 1;

    for (int i = 0; i < water.size(); i++) {
      float offset_x = (float) (water.get(i).x) * TILE_WIDTH / 2;
      float offset_y = (float) (water.get(i).y) * TILE_HEIGHT;

      if (water.get(i).x % 2 == 1) offset_y += TILE_HEIGHT / 2;

      offset_x += tempWaterOffset;
      offset_y += tempWaterOffset / 2;

      offset_x -= 2 * TILE_WIDTH;
      offset_y -= 2 * TILE_HEIGHT;

      offset_x += (game.getCameraManager().getX() % 2) * TILE_WIDTH / 2;
      offset_y += (game.getCameraManager().getY() % 1) * TILE_HEIGHT;

      Bitmap bmp = game.getBitmapManager().getBitmap(water.get(i).getImageId());
      canvas.drawBitmap(bmp, offset_x, offset_y, null);
    }

    float hoverOffsetX = 100000;
    float hoverOffsetY = 100000;
    int tempHoverX = hoverX - TILE_WIDTH / 2;
    int tempHoverY = hoverY - TILE_HEIGHT;
    Tile temp = tiles.get(0);

    for (int i = 0; i < tiles.size(); i++) {
      Bitmap bmp = game.getBitmapManager().getBitmap(tiles.get(i).getImageId());

      float offset_x = (float) (tiles.get(i).x + game.getCameraManager().getX()) * TILE_WIDTH / 2;
      float offset_y = (float) (tiles.get(i).y + game.getCameraManager().getY()) * TILE_HEIGHT;

      if (tiles.get(i).x % 2 == 1) offset_y += TILE_HEIGHT / 2;

      if (Math.sqrt(Math.pow(offset_x - tempHoverX, 2) + Math.pow(offset_y - tempHoverY, 2))
          < Math.sqrt(
              Math.pow(hoverOffsetX - tempHoverX, 2) + Math.pow(hoverOffsetY - tempHoverY, 2))) {
        hoverOffsetX = offset_x;
        hoverOffsetY = offset_y;
        temp = tiles.get(i);
      }

      if (offset_x < (canvas.getWidth() + TILE_WIDTH)
          && offset_y < (canvas.getHeight() + TILE_HEIGHT)
          && offset_x > -TILE_WIDTH
          && offset_y > -TILE_HEIGHT) canvas.drawBitmap(bmp, offset_x, offset_y, null);
    }

    int color = Color.parseColor("#96FFFF00");

    Entity ent = game.getEntityManager().getEntity(temp.getX(), temp.getY());

    if (ent != null) {
      if (hoverImage.contains("concrete"))
        if (ent.getImage().contains("dinosaur") || ent.getImage().contains("fence"))
          color = Color.parseColor("#96FF0000");
    }

    if (game.getEntityManager().entityAt(temp.getX(), temp.getY()) && hoverImage.contains("water"))
      color = Color.parseColor("#96FF0000");

    Paint paint = new Paint(color);
    ColorFilter filter = new LightingColorFilter(color, 1);
    paint.setColorFilter(filter);
    canvas.drawBitmap(
        game.getBitmapManager()
            .getBitmap(
                game.getResources()
                    .getIdentifier(hoverImage, "drawable", "cpsc372.dinosaur_tycoon")),
        hoverOffsetX,
        hoverOffsetY,
        paint);

    long delta = (System.currentTimeMillis() - gameTime);

    Update(delta);
    gameTime = System.currentTimeMillis();
  }
Esempio n. 11
0
 public int getOffsetX() {
   return tile.getX() % 8;
 }
Esempio n. 12
0
  /**
   * Searches the view port on the live map for caches. The strategy dictates if only live map
   * information is used or if an additional searchByCoordinates query is issued.
   *
   * @param viewport Area to search
   * @param tokens Live map tokens
   * @param strategy Strategy for data retrieval and parsing, @see Strategy
   */
  @NonNull
  private static SearchResult searchByViewport(
      final Viewport viewport, final MapTokens tokens, final LivemapStrategy strategy) {
    Log.d("GCMap.searchByViewport" + viewport.toString());

    final SearchResult searchResult = new SearchResult();

    if (Settings.isDebug()) {
      searchResult.setUrl(viewport.getCenter().format(Format.LAT_LON_DECMINUTE));
    }

    if (strategy.flags.contains(LivemapStrategy.Flag.LOAD_TILES)) {
      final Set<Tile> tiles = Tile.getTilesForViewport(viewport);

      if (Settings.isDebug()) {
        searchResult.setUrl(
            new StringBuilder()
                .append(tiles.iterator().next().getZoomLevel())
                .append(Formatter.SEPARATOR)
                .append(searchResult.getUrl())
                .toString());
      }

      for (final Tile tile : tiles) {
        if (!Tile.cache.contains(tile)) {
          final Parameters params =
              new Parameters(
                  "x", String.valueOf(tile.getX()),
                  "y", String.valueOf(tile.getY()),
                  "z", String.valueOf(tile.getZoomLevel()),
                  "ep", "1",
                  "app", "cgeo");
          if (tokens != null) {
            params.put("k", tokens.getUserSession(), "st", tokens.getSessionToken());
          }
          if (Settings.isExcludeMyCaches()) { // works only for PM
            params.put("hf", "1", "hh", "1"); // hide found, hide hidden
          }
          // ect: exclude cache type (probably), comma separated list
          if (Settings.getCacheType() != CacheType.ALL) {
            params.put("ect", getCacheTypeFilter(Settings.getCacheType()));
          }
          if (tile.getZoomLevel() != 14) {
            params.put("_", String.valueOf(System.currentTimeMillis()));
          }

          // The PNG must be requested first, otherwise the following request would always return
          // with 204 - No Content
          final Single<Bitmap> bitmapObs =
              Tile.requestMapTile(params).onErrorResumeNext(Single.<Bitmap>just(null));
          final Single<String> dataObs =
              Tile.requestMapInfo(GCConstants.URL_MAP_INFO, params, GCConstants.URL_LIVE_MAP)
                  .onErrorResumeNext(Single.just(""));
          try {
            Single.zip(
                    bitmapObs,
                    dataObs,
                    new Func2<Bitmap, String, Void>() {
                      @Override
                      public Void call(final Bitmap bitmap, final String data) {
                        final boolean validBitmap =
                            bitmap != null
                                && bitmap.getWidth() == Tile.TILE_SIZE
                                && bitmap.getHeight() == Tile.TILE_SIZE;

                        if (StringUtils.isEmpty(data)) {
                          Log.w(
                              "GCMap.searchByViewport: No data from server for tile ("
                                  + tile.getX()
                                  + "/"
                                  + tile.getY()
                                  + ")");
                        } else {
                          final SearchResult search =
                              parseMapJSON(data, tile, validBitmap ? bitmap : null, strategy);
                          if (CollectionUtils.isEmpty(search.getGeocodes())) {
                            Log.e(
                                "GCMap.searchByViewport: No cache parsed for viewport " + viewport);
                          } else {
                            synchronized (searchResult) {
                              searchResult.addSearchResult(search);
                            }
                          }
                          synchronized (Tile.cache) {
                            Tile.cache.add(tile);
                          }
                        }

                        // release native bitmap memory
                        if (bitmap != null) {
                          bitmap.recycle();
                        }

                        return null;
                      }
                    })
                .toBlocking()
                .value();
          } catch (final Exception e) {
            Log.e("GCMap.searchByViewPort: connection error");
          }
        }
      }

      // Check for vanished found caches
      if (tiles.iterator().next().getZoomLevel() >= Tile.ZOOMLEVEL_MIN_PERSONALIZED) {
        searchResult.addFilteredGeocodes(
            DataStore.getCachedMissingFromSearch(
                searchResult,
                tiles,
                GCConnector.getInstance(),
                Tile.ZOOMLEVEL_MIN_PERSONALIZED - 1));
      }
    }

    if (strategy.flags.contains(Flag.SEARCH_NEARBY) && Settings.isGCPremiumMember()) {
      final Geopoint center = viewport.getCenter();
      if ((lastSearchViewport == null) || !lastSearchViewport.contains(center)) {
        // FIXME We don't have a RecaptchaReceiver!?
        final SearchResult search =
            GCParser.searchByCoords(center, Settings.getCacheType(), false, null);
        if (search != null && !search.isEmpty()) {
          final Set<String> geocodes = search.getGeocodes();
          lastSearchViewport = DataStore.getBounds(geocodes);
          searchResult.addGeocodes(geocodes);
        }
      }
    }

    return searchResult;
  }
Esempio n. 13
0
 public void removeTile(Tile tile) {
   field[tile.getX()][tile.getY()] = null;
 }
Esempio n. 14
0
 public void insertTile(Tile tile) {
   field[tile.getX()][tile.getY()] = tile;
 }
  private boolean assignSpeeds(Map m, ArrayList<Road> roads) {
    int[][] speeds = new int[m.getLengthX()][m.getLengthY()];
    int count = 0;
    for (Road r : roads) {

      Tile[] adjTiles = getAdjTiles(m.grid, m.grid[r.getX()][r.getY()]);
      Road start = null;
      for (int i = 0; i < 4; i++) {
        if (adjTiles[i] instanceof TrafficLight) {
          start = r;
        }
        if (adjTiles[i] == null || adjTiles[i] instanceof NonRoad) {
          if (i == r.getDirection() || i == Math.abs(r.getDirection() - 4)) {
            start = r;
          }
        }
      }

      if (start != null) {
        int dir = start.getDirection();
        int length = 1;
        Tile t = r;

        //       if(m.getInDir(r,dir) != null){
        t = m.getInDir(r, dir);

        if (t instanceof TrafficLight || t == null || t instanceof NonRoad) {

          int reverseDir = (dir + 2 > 3) ? dir - 2 : dir + 2;
          if (m.getInDir(r, reverseDir) != null) t = m.getInDir(r, reverseDir);

          while (!(t == null || t instanceof TrafficLight || t instanceof NonRoad)) {

            length++;
            if (m.getInDir(t, reverseDir) != null) t = m.getInDir(t, reverseDir);
            else break;
          }
          for (int i = 0; i < length; i++) {
            t = m.getInDir(t, dir); // reverse direction
            speeds[t.getX()][t.getY()] = determineSpeed(length);
          }

        } else {

          while (!(t == null || t instanceof TrafficLight || t instanceof NonRoad)) {

            length++;
            if (m.getInDir(t, dir) != null) t = m.getInDir(t, dir);
            else break;
          }
          int reverseDir = (dir + 2 > 3) ? dir - 2 : dir + 2;

          for (int i = 0; i < length; i++) {
            t = m.getInDir(t, reverseDir); // reverse directions
            speeds[t.getX()][t.getY()] = determineSpeed(length);
          }
        }
      }
      //   }
      count++;
    }
    for (Road r : roads) {
      r.setSpeed(speeds[r.getX()][r.getY()]);
    }
    return true;
  }