def __init__(self, qra, zoom): self.qra = qra self.zoom = zoom self.lonlat = Tiles.qra_lonlat(self.qra) (self.lon, self.lat) = self.lonlat xytile = Tiles.lonlat_tile(self.lon, self.lat, self.zoom) self.osm_tile = OSM_Tile("(POI)", xytile, (0, 0), self.zoom)
def getCavernTileMap(self): TileMap = [] #chance = 0.6 map, caverns = CellularAutomata.generateMap(self.cellwidth, self.cellheight, chance=0.6, steps=6, birthLimit=3, deathLimit=4) for rows in range(0, len(map)): row = [] for columns in range(0, len(map[0])): if not map[rows][columns]: row.append( Tiles.Tile((columns, rows), self.tileSheet.returnTile(0, 0), False)) else: #row.append(Tiles.AnimTile((columns,rows), self.animTileSheet,True,0,3,10)) row.append( Tiles.Tile((columns, rows), self.tileSheet.returnTile(2, 0), True)) TileMap.append(row) #Adds the tile that goes to next level EndLocation = choice(caverns[-2]) TileMap[EndLocation[0]][EndLocation[1]] = Tiles.LevelTile( (EndLocation[1], EndLocation[0]), self.tileSheet.returnTile(3, 0), False) return TileMap, caverns
def getBlits(self): if self.isEarth or not self.seen: return {"coords": self.coords, "blits": []} blits = [] if self.visible: blits.append({ "tile": Tiles.tiles[self.tileset][self.fillType], "layer": TERRAIN_LAYER }) if self.terrainFeature != None: blits.append({ "tile": Tiles.features[self.terrainFeature], "layer": FEATURE_LAYER }) if self.character != None: blits.append({ "tile": self.character.image, "layer": CHARACTER_LAYER }) else: terrainTile = Tiles.darken( Tiles.tiles[self.tileset][self.fillType]) blits.append({"tile": terrainTile, "layer": TERRAIN_LAYER}) if self.terrainFeature != None: featureTile = Tiles.darken(Tiles.features[self.terrainFeature]) blits.append({"tile": featureTile, "layer": FEATURE_LAYER}) return {"coords": self.coords, "blits": blits}
def clip_lcd_tiles(self): description_fn = "%s-%s-%dx%d.txt" % (SERVER_TYPE, qra, LCD_TILE_WIDTH, LCD_TILE_HEIGHT) try: os.remove(description_fn) except: pass poi_xy = composite_tile.lonlat_xy_in_composite_osm_tile(poi.lonlat) if DEBUG: print "poi_xy %d %d in composite_osm_tile" % poi_xy center_lcd_tile_center_xy = (LCD_TILE_WIDTH / 2, LCD_TILE_HEIGHT / 2) if DEBUG: print "center_lcd_tile_center_xy = %s %s" % (center_lcd_tile_center_xy) for dy in LCD_TILES_DELTAS: for dx in LCD_TILES_DELTAS: if DEBUG: print "Creating LCD_Tile %s (%d %d) " % (Tiles.rose(LCD_TILES_OFFSETS, dx, dy), dx, dy) lcd_tile_dxy = vadd(poi_xy, vmul(LCD_TILE_SIZE, (dx, dy))) composite_box_top_left_xy = vsub(lcd_tile_dxy, center_lcd_tile_center_xy) composite_box_bottom_right_xy = vadd(lcd_tile_dxy, center_lcd_tile_center_xy) box = composite_box_top_left_xy + composite_box_bottom_right_xy lcd_image = self.composite_tile.composite_image.crop(box) osm_tl_dxdy = vsub(vidiv(composite_box_top_left_xy, OSM_TILE_SIZE), OSM_TILES_OFFSETS) osm_br_dxdy = vsub(vidiv(composite_box_bottom_right_xy, OSM_TILE_SIZE), OSM_TILES_OFFSETS) if DEBUG: print " LCD_Tile composite_box_top_left_xy = %d %d" % (composite_box_top_left_xy) print " LCD_Tile osm_tl_dxdy = %d %s upper left is at this location in composite_box: %d %d" % (osm_tl_dxdy + composite_box_top_left_xy) print " LCD_Tile osm_br_dxdy = %d %s bottom right is at this location in composite_box: %d %d" % (osm_br_dxdy + composite_box_top_left_xy) print "osm_tl_dxdy = %s osm_br_dxdy = %s" % (osm_tl_dxdy, osm_br_dxdy) osm_tile_tl = composite_tile.osm_tiles_by_dxdy[osm_tl_dxdy] osm_tile_br = composite_tile.osm_tiles_by_dxdy[osm_br_dxdy] if DEBUG: print " OSM_TILE pixels_per_degree %f %f, %f %f" % (osm_tile_tl.pixels_per_degree+osm_tile_br.pixels_per_degree) print " OSM_Tile %s top_left_lonlat %f %f" % (osm_tile_tl.name, osm_tile_tl.top_left_lon, osm_tile_tl.top_left_lat) lcd_tile_top_left_in_osm_tile = vmod(composite_box_top_left_xy, OSM_TILE_SIZE) lcd_tile_bottom_right_in_osm_tile = vmod(composite_box_bottom_right_xy, OSM_TILE_SIZE) lcd_tile_top_left_lonlat = osm_tile_tl.xy_lonlat(lcd_tile_top_left_in_osm_tile) lcd_tile_bottom_right_lonlat = osm_tile_br.xy_lonlat(lcd_tile_bottom_right_in_osm_tile) #print " LCD_Tile %s (%d,%d) lcd_tile_top_left_in_osm_tile: %d %d" % ((Tiles.rose(LCD_TILES_OFFSETS, dx, dy), dx, dy) + lcd_tile_top_left_in_osm_tile) #print " LCD_Tile %s (%d,%d) top left lon lat %f %f" % ((Tiles.rose(LCD_TILES_OFFSETS, dx, dy), dx, dy) + lcd_tile_top_left_lonlat) if False: self.lcd_tiles[(dx,dy)] = LCD_Tile(Tiles.rose(LCD_TILES_OFFSETS, dx, dy), (dx,dy), lcd_tile_top_left_lonlat, lcd_tile_bottom_right_lonlat, lcd_image) png_fn = self.calculate_lcd_tile_fn(dx, dy) bmp_fn = self.calculate_lcd_bmp_fn(dx, dy) tl_latlon = Tiles.vswap(lcd_tile_top_left_lonlat) br_latlon = Tiles.vswap(lcd_tile_bottom_right_lonlat) lcd_image.save(png_fn, "PNG") lcd_image.save(bmp_fn, "BMP") description = "%d,%d %d,%d\n" % tuple([round(x*1e6) for x in (tl_latlon[0],tl_latlon[1], br_latlon[0],br_latlon[1])]) self.lat_degrees_per_pixel += (br_latlon[0] - tl_latlon[0]) self.lon_degrees_per_pixel += (br_latlon[1] - tl_latlon[1]) if dx == 0 and dy == 0: poi_lcd_tile_tl_latlon = tl_latlon #print "Adding LCD map four corners to %s " % (description_fn) with open(description_fn, 'a') as f: f.write(Tiles.rose(LCD_TILES_OFFSETS, dx,dy)) f.write(" ") f.write(description) self.save_pixels_file(poi_lcd_tile_tl_latlon)
def draw_debug(self, draw): # draw outlines of original OSM tiles in GREEN for dy in OSM_TILES_DELTAS: for dx in OSM_TILES_DELTAS: box1 = vmul(OSM_TILE_SIZE, (vadd((dx, dy), OSM_TILES_OFFSETS))) box2 = vmul(OSM_TILE_SIZE, (vadd((dx, dy), vadd(OSM_TILES_OFFSETS, (1, 1))))) box = box1+box2 draw.rectangle(box, outline='#00ff00') # Draw dot at QRA in BLUE (px, py) = self.lonlat_xy_in_composite_osm_tile(poi.lonlat) #print "qra (px,py) = (%d, %d)" % (px,py) Tiles.drawCircle(draw, px, py, 2, '#0000ff')
def __init__(self, name, xytile, tile_delta, zoom): self.name = name self.xytile = xytile self.tile_delta = tile_delta self.zoom = zoom self.osm_tile_image = None self.size_in_degrees = Tiles.tile_size_in_degrees(self.xytile, self.zoom) self.top_left_lonlat = Tiles.tile_top_left_corner_lonlat(self.xytile, self.zoom) (self.top_left_lon, self.top_left_lat) = self.top_left_lonlat self.pixels_per_degree = vdiv(OSM_TILE_SIZE, self.size_in_degrees) # lon,lat order if DEBUG: print "%s size in degrees dlon=%f dlat=%f" % ((self.name,) + self.size_in_degrees) print "%s pixels_per_degree = don=%f dlat%f" % ((self.name,) + self.pixels_per_degree)
def generate(self, scenery): for i in range(len(self.bMap)): scenery[self.bMap[i].y][self.bMap[i].x] = tiles.Scenery( True, False, self.bMap[i].bImg, self.bMap[i].tImg, self.bMap[i].offSet, 0, -10) for y in range(self.bMap[i].y - self.bMap[i].ySize // 2, self.bMap[i].y + self.bMap[i].ySize // 2 + 1, 1): for x in range(self.bMap[i].x - self.bMap[i].xSize // 2, self.bMap[i].x + self.bMap[i].xSize // 2 + 1, 1): if x != self.bMap[i].x or y != self.bMap[i].y: scenery[y][x] = 6 for y in range(self.bMap[i].y - self.bMap[i].ySize // 2, self.bMap[i].y + self.bMap[i].ySize // 2 + 1): for x in range(self.bMap[i].x - (self.bMap[i].xSize // 2 + 2), self.bMap[i].x + self.bMap[i].xSize // 2 + 2): if y == self.bMap[i].y - self.bMap[ i].ySize // 2 - 1 or y == self.bMap[ i].y + self.bMap[ i].ySize // 2 or x == self.bMap[i].x - ( self.bMap[i].xSize // 2 + 1) or x == self.bMap[ i].x + self.bMap[i].xSize // 2 + 1: scenery[y][x] = 0
def __getTileMap(self, map): tiles = [] #Could probably do this using map or filter or replace, one of those functions for y in range(len(map)): row = [] for x in range(len(map[0])): if map[y][x]: row.append( Tiles.Tile(gridPos=(x, y), collision=False, sprite=self.spritesheet.returnSprite(0, 0))) else: row.append( Tiles.Tile(gridPos=(x, y), collision=True, sprite=self.spritesheet.returnSprite(1, 0))) tiles.append(row) return tiles
def getBlits(self): if self.isEarth or not self.seen: return { "coords": self.coords, "blits": [] } blits = [] if self.visible: blits.append({ "tile": Tiles.tiles[self.tileset][self.fillType], "layer": TERRAIN_LAYER }) if self.terrainFeature != None: blits.append({ "tile": Tiles.features[self.terrainFeature], "layer": FEATURE_LAYER }) if self.character != None: blits.append({ "tile": self.character.image, "layer": CHARACTER_LAYER }) else: terrainTile = Tiles.darken(Tiles.tiles[self.tileset][self.fillType]) blits.append({ "tile": terrainTile, "layer": TERRAIN_LAYER }) if self.terrainFeature != None: featureTile = Tiles.darken(Tiles.features[self.terrainFeature]) blits.append({ "tile": featureTile, "layer": FEATURE_LAYER }) return { "coords": self.coords, "blits": blits }
def create_tiles(self): """ Create tiles from the good sized of image. Return with a Tiles object, which has a list of the image tiles - Tile object. """ tiles = Tiles.Tiles(grid=self.grid) for row in range(self.grid): for col in range(self.grid): x0 = col * self.tile_size y0 = row * self.tile_size x1 = x0 + self.tile_size y1 = y0 + self.tile_size tile_image = ImageTk.PhotoImage( self.image.crop((x0, y0, x1, y1))) tile = Tiles.Tile(self, tile_image, (row, col)) tiles.add(tile) tiles.set_gap(-1) return tiles
def creation_map_objects(): """ Generate based on the numpy array all fields Test: -check if map format is 6x13 and tiles are 140x140 -test if the is exact one start and exact one end -test the path is without holes and has no loops """ global towerplace_bool, MAP, towerfields count_ways = 0 ty = 0 for y in range(6): tx = 0 if y > 0: tx = 50 for x in range(13): value = MAP[y, x] if value == 0: if not towerplace_bool: towerfields.append(Tiles(tx, ty, 140, 140, clickable_field)) elif value == 5: towerfields.append(Tiles(tx, ty, 140, 140, obstacle_map)) elif value == 8: draw_path(count_ways) count_ways += 1 elif value == 1: tx += 50 towerfields.append(Tiles(tx, ty, 140, 140, start_map)) elif value == 2: towerfields.append(Tiles(tx, ty, 140, 140, end_map)) elif 10 < value < 39: first_place = value % 10 second_place = value // 10 towerfields.append( Tiles(tx, ty, 140, 140, tower_image[second_place - 1][first_place - 1])) tx += 140 ty += 140 towerplace_bool = True
def draw_path(path_pos): """ Generate and store the position of a wayfield on the map at a position with the correct image based on the rotation Arguments: postion on path Test: -Path has to be ready -screen has to be 1920x1080 and all Tiles 140x140 -Test if the end is reached or a position not on the path """ global wayfields current_pos = PATH[path_pos][0] next_pos = PATH[path_pos + 1][0] pos_x = 50 + (PATH[path_pos][1] * 140) pos_y = (PATH[path_pos][2]) * 140 if current_pos == 'up' and next_pos == 'right' or current_pos == 'left' and next_pos == 'down': wayfields.append(Tiles(pos_x, pos_y, 140, 140, curve2)) elif current_pos == 'up' and next_pos == 'left' or current_pos == 'right' and next_pos == 'down': wayfields.append(Tiles(pos_x, pos_y, 140, 140, curve1)) elif current_pos == 'down' and next_pos == 'right' or current_pos == 'left' and next_pos == 'up': wayfields.append(Tiles(pos_x, pos_y, 140, 140, curve3)) elif current_pos == 'down' and next_pos == 'down' or current_pos == 'up' and next_pos == 'up': wayfields.append(Tiles(pos_x, pos_y, 140, 140, way_vertical)) elif current_pos == 'right' and next_pos == 'right' or current_pos == 'left' and next_pos == 'left': wayfields.append(Tiles(pos_x, pos_y, 140, 140, way_horizontal)) elif current_pos == 'right' and next_pos == 'up' or current_pos == 'down' and next_pos == 'left': wayfields.append(Tiles(pos_x, pos_y, 140, 140, curve4))
def generateCellularAutomata(width: int = 40, height: int = 30, chance: float = 0.65, steps: int = 2, birthLimit: int = 3, deathLimit: int = 4) -> list: '''Returns a tilemap from the CellularAutomata method''' arr, caverns = CellularAutomata.driver(width, height, chance, steps, birthLimit, deathLimit) tileMap = [] # Iterates over the 2D list returned by the cellauto algorithm # and places a non collidable tile at a true value, and a collidable # tile at the false values for y in range(0, len(arr)): row = [] for x in range(0, len(arr[0])): if arr[y][x] == True: row.append( Tiles.Tile(gridPos=(x, y), collision=False, sprite=spritesheet.returnSprite(0, 0))) elif arr[y][x] == False: row.append( Tiles.Tile(gridPos=(x, y), collision=True, sprite=spritesheet.returnSprite(1, 0))) ''' elif arr[y][x] == 'corridoor': row.append(Tiles.Tile(gridPos=(x, y), collision=False, sprite=spritesheet.returnSprite(0, 2))) ''' tileMap.append(row) y, x = choice(caverns[-1]) tileMap[y][x] = Tiles.LevelTile(gridPos=(x, y), sprite=spritesheet.returnSprite(0, 2)) return tileMap, caverns
def create_map(): #Create The Map #Global Variables Created global continent_map continent_map = [[Tiles.Tile("Ocean") for y in range(MAP_HEIGHT)] for x in range(MAP_WIDTH)] global cities cities = [] #Generate Contents in Map generate_land() generate_cities()
def __init__(self, program): self.x = 0 self.y = 0 self.surface = Tiles.Hallway() self.output = [] self.Computer = Intcode.Intcode() self.Computer.memory = program self.Computer.increase_memory(10) self.Computer.output = asyncio.Queue() self.Computer.output_method = self.Computer.output.put_nowait self.output = asyncio.Queue() self.Computer.input_method = self.output.get self.untested_moves = [] self.direction = 1
def __init__(self, window_width, window_height): self.size = window_width, window_height self.window_width = window_width self.window_height = window_height self.screen = pygame.display.set_mode(self.size) pygame.display.set_icon(load_image('images', 'icon.png')) pygame.display.set_caption('The Dungeons') self.clock = pygame.time.Clock() self.camera = Camera.Camera(self.window_width, self.window_height) self.floor = namedtuple('Floor', ['type', 'name'])('floor', 0) self.player = None # initialize sprites self.game_over_button_sprite = pygame.sprite.GroupSingle() self.main_button_sprites = pygame.sprite.Group() self.portal_sprite = pygame.sprite.GroupSingle() self.player_sprite = pygame.sprite.GroupSingle() self.sword_sprite = pygame.sprite.GroupSingle() self.animated_sprites = pygame.sprite.Group() self.potion_sprites = pygame.sprite.Group() self.floor_sprites = pygame.sprite.Group() self.enemy_sprites = pygame.sprite.Group() self.boxes_sprites = pygame.sprite.Group() self.side_sprites = pygame.sprite.Group() self.all_sprites = pygame.sprite.Group() self.ui_sprites = pygame.sprite.Group() self.tiles = Tiles.return_tiles() self.connection = sqlite3.connect('database.db') # special player variables self.player_health = 20 self.player_score = 0 self.FPS = 60 # const self.k = 19 # special variable which need for right room's drawing self.bg_color = pygame.Color(29, 16, 70) sound = pygame.mixer.Sound('data\\soundtrack1.wav') sound.play(10) sound.set_volume(0.03)
def retrieve(self): if self.composite_image == None: self.composite_image = Image.new("RGB", (OSM_TILE_WIDTH * OSM_TILES_SQUARE, OSM_TILE_HEIGHT * OSM_TILES_SQUARE), (0, 0, 0)) for dy in OSM_TILES_DELTAS: for dx in OSM_TILES_DELTAS: dxdy = (dx, dy) osm_tile = OSM_Tile(Tiles.rose(OSM_TILES_OFFSETS, dx, dy), vadd((self.x, self.y), dxdy), dxdy, zoom) self.osm_tiles_by_xytile[osm_tile.xytile] = osm_tile if DEBUG: print "Adding self.osm_tiles_by_dxdy[%s] = osm_tile" % (dxdy,) self.osm_tiles_by_dxdy[dxdy] = osm_tile osm_tile_image = osm_tile.retrieve() box = (vmul(OSM_TILE_SIZE, vadd((dx, dy), OSM_TILES_OFFSETS)) + vmul(OSM_TILE_SIZE, vadd((dx, dy), vadd(OSM_TILES_OFFSETS, (1, 1))))) self.composite_image.paste(osm_tile_image, box) fn = "%s-%s-%dx%dx%d.png" % (SERVER_TYPE, qra, OSM_TILE_WIDTH, OSM_TILE_HEIGHT, OSM_TILES_SQUARE) if DEBUG: print("Saving composite map image to " + fn) self.composite_image.save(fn) return self.composite_image
def render(self, screen): left = self.left top = self.top self.max_width = len(self.board[0]) self.max_height = len(self.board) for y in range(self.max_height): for x in range(self.max_width): if (x != self.max_width - 1 or y != 0) and ( x != 0 or y != self.max_height - 1) and self.no_tiles: Tiles.Tile(left, top, self.tile_sprites) pygame.draw.rect(screen, color('brown'), (left, top, self.cell_size, self.cell_size), 1) left += self.cell_size top += self.cell_size left = self.left pygame.draw.rect(screen, color('brown'), (self.left, self.top, self.cell_size * self.width, self.cell_size * self.height), 2) self.no_tiles = False
def from_file(path, game): import json with open(path, 'r') as f: json_data = f.read() data = json.loads(json_data) author = data["author"] board_data = data["board"] board = [[0 for _ in range(16)] for _ in range(16)] for i in range(16): #x for j in range(16): #y board[i][j] = Tiles.from_json_data(board_data[i][j]) board, starting_red, starting_blue = MapData.link_special_tiles( game, board) print("Map loaded") return MapData(author, board, starting_red, starting_blue)
def __init__(self, players, connector=None, configuration=None, score_calc=None): self.player_profiles = [player.get_game_info() for player in players] self.player_number = len(self.player_profiles) self.start_player = -1 self.tiles = Tiles.read_hand(config.allTileString) self.fuuro_lists = [[0] * 20] * 4 self.dora_list = [] self.agari_tile = Tiles.Tile() self.tumo = False self.kyoutaku_bon = 0 # number of tensu-bou on table self.bakaze = 0 # 0 -> Tou-huu ni settee s***e self.gyouku = 0 # 3 -> Han Cyan all last self.honba = 0 self.turn = 0 # curr_player = turn % 4 self.random_method = random.shuffle # default method self.configuration = configuration # configuration from utility self.score_calc = mjscore.MJScore() self.client_connector = connector
def render(self, screen): left = self.left top = self.top self.max_width = len(self.board[0]) self.max_height = len(self.board) for y in range(self.max_height): for x in range(self.max_width): if (x != self.max_width - 1 or y != 0) and ( x != 0 or y != self.max_height - 1) and self.no_tiles: Tiles.Tile(left, top, self.tile_sprites) elif x == self.max_width - 1 and y == 0: pygame.draw.rect( screen, color('orange'), (left, top, self.cell_size, self.cell_size), 0) if not game.orange_moved: screen.blit( GetImage("janitor_orange1.png", (76, 76), colorkey=-1).load_image(), (left, top)) elif x == 0 and y == self.max_height - 1: pygame.draw.rect( screen, color('aquamarine3'), (left, top, self.cell_size, self.cell_size), 0) if not game.blue_moved: screen.blit( GetImage("janitor_blue1.png", (76, 76), colorkey=-1).load_image(), (left, top)) pygame.draw.rect(screen, color('brown'), (left, top, self.cell_size, self.cell_size), 1) left += self.cell_size top += self.cell_size left = self.left pygame.draw.rect(screen, color('brown'), (self.left, self.top, self.cell_size * self.width, self.cell_size * self.height), 2) self.no_tiles = False
def __init__ ( self, alpha, numFloatInputs, numIntInputs, memorySize, gamma, numTilings, tableDimensionality ) : self.alpha = alpha self.numFloatInputs = numFloatInputs self.floatInputs = [] for i in range( numFloatInputs ) : self.floatInputs.append ( 0.0 ) ; self.numIntInputs = numIntInputs self.intInputs = [] for i in range( numIntInputs ) : self.intInputs.append ( 0 ) ; self.numTilings = numTilings self.tiles = [] for i in range ( numTilings ) : self.tiles.append ( 0 ) self.memorySize = memorySize self.u = [] # CMAC arrays for i in range ( memorySize ) : #self.u.append ( 1.0 / ( 1.0 - gamma ) ) #self.u.append ( 1.0 / ( 1.0 - gamma - 0.01 ) ) # this is to account for the fact that gamma = 1 for episodic tasks, and gamma < 1 for continuing tasks. #self.u.append ( random.randint ( 1, 20 ) ) #1.0 / ( 1.0 - gamma - 0.01 ) ) # this is to account for the fact that gamma = 1 for episodic tasks, and gamma < 1 for continuing tasks. self.u.append ( 2 ) #1.0 / ( 1.0 - gamma - 0.01 ) ) # this is to account for the fact that gamma = 1 for episodic tasks, and gamma < 1 for continuing tasks. #print ( "Memory Size: ", memorySize, "self.u[", i, "]", self.u[i], "Gamma:" , gamma, "1.0-gamma", 1.0 - gamma ) self.tableDimensionality = tableDimensionality #self.printCMACParams ( ) self.Tile = Tiles.Tiles() return
def start(imgName, num): tile_names = [] tile_x = [] font = cv2.FONT_HERSHEY_SIMPLEX path = os.path.dirname(os.path.abspath(__file__)) train_tiles = Tiles.load_patterns(path + '/new/') image = cv2.imread(imgName) pre_proc = Tiles.preprocess_image(image) cv2.imwrite('pre_proc.jpg', pre_proc) cnts_sort, cnt_is_tile = Tiles.find_tiles(pre_proc) if len(cnts_sort) != 0: tiles = [] k = 0 for i in range(len(cnts_sort)): if (cnt_is_tile[i] == 1): tiles.append(Tiles.preprocess_tile(cnts_sort[i], image, i)) tiles[k].best_match, tiles[k].diff = Tiles.match_tile( tiles[k], train_tiles, i) tile_x.append(tiles[k].coord) # print(tiles[k].best_match) tile_names.append(tiles[k].best_match) # print('---------------') image = Tiles.draw_results(image, tiles[k]) k = k + 1 #if (len(tiles) != 0): # temp_cnts = [] #drawing contours. not necesary #for i in range(len(tiles)): #temp_cnts.append(tiles[i].contour) #cv2.drawContours(image,temp_cnts, -1, (27,150,194), 5) tile_names, tile_x = sort(tile_names, tile_x) #print(tile_names) cv2.imwrite('found.jpg', image) return tile_names
except with the aproval of the author. (contact on e-mail). Anyone can buy rights to use the source code in any commercial products by messaging the author; """ #Import section import Tiles from time import sleep from random import choice from random import randrange #global variables: #Tiles: player=Tiles.PlayerTile('8') grass=Tiles.Tile(True) grass.setGraphic('"') wall=Tiles.Tile(False) wall.setGraphic('[]') water=Tiles.Tile(False) water.setGraphic('~') road=Tiles.Tile(True) road.setGraphic('::') start=Tiles.EventTile(True) start.setGraphic('E') end=Tiles.EventTile(False) end.setGraphic('|=|') tree=Tiles.Tile(False) tree.setGraphic(chr(134)) grate=Tiles.Tile(False)
def tiili(x,y,zoom,xo,yo,xd,yd): doabc() ny = datoja.kartta[datoja.nykyinen] # if ny == "viro": # return 'http://lbs.nutiteq.ee/topo/%d/%d/%d.jpg' % (zoom, x, y) # if ny == "cycle": # return 'http://b.tile.opencyclemap.org/cycle/%d/%d/%d.png' % (zoom, x, y) if ny == 'sailm': y2=y if zoom==13: y2=2371-y+5820 if zoom==14: y2=11639-y+4744 return 'http://mapserver.sailmate.fi/fi/images/%d/%d/%d.png'%(zoom,x,y2) if ny == 'osm': return 'http://%s.tile.openstreetmap.de/%d/%d/%d.png'%(datoja.abc,zoom,x,y) if ny == 'cycle': return 'http://%s.tile.thunderforest.com/cycle/%d/%d/%d.png?apikey=26202fd82b624164a13dbe93fea33a04'%(datoja.abc,zoom,x,y) if ny == 'norja': return 'http://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=topo2&zoom=%d&x=%d&y=%d' % (zoom, x, y) if ny == 'google': return 'https://mts1.google.com/vt/x=%d&y=%d&z=%d' % (x, y, zoom) # return 'http://mt.google.com/vt/v=w2.97&hl=en&x=%d&y=%d&z=%d' % (x, y, zoom) if ny == 'gsat': time.sleep(1) return 'http://khm.google.com/kh/v=113&x=%d&y=%d&z=%d' % (x, y, zoom) # if ny == 'norsjo': # return 'http://opencache.statkart.no/gatekeeper/gk/gk.open_gmaps?layers=sjo_hovedkart2&zoom=%d&x=%d&y=%d' % (zoom, x, y) if ny == 'bing': import Tiles import random return 'http://a%d.ortho.tiles.virtualearth.net/tiles/a%s.jpeg?g=90' % (random.randint(0, 3), Tiles.toMicrosoft(x,y,zoom)) if ny == 'eniro': y2=math.pow(2,zoom)-y-1; return 'http://map.eniro.com/geowebcache/service/tms1.0.0/map/%d/%d/%d.png'%(zoom, x, y2) if ny == 'svesjo': y2=math.pow(2,zoom)-y-1; return 'http://map.eniro.com/geowebcache/service/tms1.0.0/nautical/%d/%d/%d.png'%(zoom, x, y2) if ny == 'kapsi': return 'http://tiles.kartat.kapsi.fi/peruskartta/%d/%d/%d.png'%(zoom, x, y) # if y % 2 == 0: # return 'https://tile1.kapsi.fi/mapcache/peruskartta_3067/%d/%d/%d.png'%(zoom, x, y) # else: # return 'https://tile2.kapsi.fi/mapcache/peruskartta_3067/%d/%d/%d.png'%(zoom, x, y) if ny == 'ilma': return 'http://tiles.kartat.kapsi.fi/ortokuva/%d/%d/%d.png'%(zoom, x, y)
OPTION_PLAYGAME = '4' OPTION_QUIT = '5' """ PROGRAM INITIALIZATION """ # this file is uploaded from the Moby Words project; see http://icon.shef.ac.uk/Moby/mwords.html for details wordlist = "scrabble.txt" # build my dictionary sDict = Dictionary.Dictionary(wordlist) # debugging: print(sDict.words[1]) # debugging: print(sDict.find("zxzxz")) # build my anagram cohort dictionary aDict = Anagrams.Anagrams(sDict.words) # build my bag of tiles bag = Tiles.TileBag() #debugging: print('z: ' + str(bag.valueof('z'))) # this track whether user has been making valid menu choices. is_valid = False """ MAIN METHOD FUNCTIONS""" # user interface outline # main menu # - check if word is valid # - look for anagrams # - play game # prints out the main menu def show_menu():
def lonlat_xy_in_composite_osm_tile(self, lonlat): osm_tile = self.osm_tiles_by_xytile[Tiles.lonlat_tile(lonlat[0], lonlat[1], self.zoom)] #print "OSM tile is '%s' tile_delta %d %d" % ((osm_tile.name,)+ osm_tile.tile_delta) top_left_pixel_xy = vmul(OSM_TILE_SIZE, vadd(osm_tile.tile_delta, OSM_TILES_OFFSETS)) #print "top_left_pixel_xy is %d %d" % top_left_pixel_xy return vadd(top_left_pixel_xy, osm_tile.lonlat_xy(lonlat[0], lonlat[1]))
import Tiles import Intcode with open('input', 'r') as f: game = f.read().split(',') game = [int(x) for x in game] COMP = Intcode.Intcode() COMP.memory = game COMP.increase_memory(10) COMP.run() GAMEBOARD = Tiles.GameSurface() for x, y, t in zip(COMP.output[0::3], COMP.output[1::3], COMP.output[2::3]): GAMEBOARD.set_color((x, y), t) print(GAMEBOARD) print(GAMEBOARD.tilecount[2])
def getZoomString(self, coordinate): return Tiles.toMicrosoft(int(coordinate.column), int(coordinate.row), int(coordinate.zoom))
def getTileMap(self): mapPath = Main.getPath(self.path) self.map = Img.open(mapPath) #Gets a list of all the pixel data in the img in a 1 dimensional list self.map = self.map.convert("RGB") pixels = list(self.map.getdata()) #Sets the size so that the pixel list can be turned into a 2 dimensional array like a grid width, height = self.map.size pixels = [pixels[i * width:(i + 1) * width] for i in range(height)] self.pixels = pixels self.map.close() TileMap = [] #columns then rows for 2D lists for y in range(0, len(self.pixels)): row = [] for x in range(0, len(self.pixels[0])): #Tile format (Position, sprite, collision) #AnimTile format (gridPos, spritesheet,collision, animRow, NoOfFrames, timePeriod) #DamageTile format (gridPos, spritesheet, collision, animRow, NoOfFrames, timePeriod, damageValue) #TransportTile format (gridPos, sprite, collision, destination) #BLACK : Stone if self.pixels[y][x] == (0, 0, 0): row.append( Tiles.Tile((x, y), self.tileSheet.returnTile(2, 0), True)) #RED : lava or generic damageTile elif self.pixels[y][x] == (255, 0, 0): row.append( Tiles.DangerTileAnim((x, y), self.animTileSheet, False, 1, 3, 20, 1, cost=100)) #GREEN : grass elif self.pixels[y][x] == (0, 255, 0): row.append( Tiles.Tile((x, y), self.tileSheet.returnTile(0, 0), False)) #BLUE : water elif self.pixels[y][x] == (0, 0, 255): row.append( Tiles.AnimTile((x, y), self.animTileSheet, True, 0, 3, 10)) #YELLOW : Flowers elif self.pixels[y][x] == (255, 255, 0): row.append( Tiles.Tile((x, y), self.tileSheet.returnTile(1, 0), False)) #MAGENTA : Transport elif self.pixels[y][x] == (255, 0, 255): path = Main.getPath("res/map1.png") row.append( Tiles.TransportTile((x, y), self.tileSheet.returnTile(3, 0), False, path)) #CYAN : ? elif self.pixels[y][x] == (0, 255, 255): path = Main.getPath("res/map2.png") row.append( Tiles.TransportTile((x, y), self.tileSheet.returnTile(3, 0), False, path)) #WHITE : ? elif self.pixels[y][x] == (255, 255, 255): pass else: print("Colour, ", self.pixels[x][y], "has no defining Tile") TileMap.append(row) return TileMap
def getZoomString(self, coordinate): return 'x=%d&y=%d&z=%d' % Tiles.toYahoo(int(coordinate.column), int(coordinate.row), int(coordinate.zoom))
hand2 = players[1].get_game_info().get_hand() hand3 = players[2].get_game_info().get_hand() hand4 = players[3].get_game_info().get_hand() hands = [hand1, hand2, hand3, hand4] controller = GameController(players, None, None, None) controller.initialization() if False: for player in players: hand = "" for item in player.get_game_info().get_hand().tiles: hand += item.get_value() Tiles.print_hand(Tiles.read_hand(hand)) print if True: result = controller.get_score(1) print result if True: result = '' player1 = PlayerInfo.Player() player2 = PlayerInfo.Player() player3 = PlayerInfo.Player() player4 = PlayerInfo.Player()
def calculate_lcd_tile_fn(self, dx, dy): return "%s-%s-%dx%d-%s.png" % (SERVER_TYPE, qra, LCD_TILE_WIDTH, LCD_TILE_HEIGHT, Tiles.rose(LCD_TILES_OFFSETS, dx, dy))
def calculate_lcd_bmp_fn(self, dx, dy): return "map%s.bmp" % (Tiles.rose(LCD_TILES_OFFSETS, dx, dy))