API tools faq
paste
Advertisement
Guest User

Untitled

a guest
May 23rd, 2021
229
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
GDScript 17.46 KB | None | 0 0
raw download clone embed print report
  1. extends Node
  2.  
  3. enum HexTypes{
  4.     vert,
  5.     hor,
  6. }
  7.  
  8. enum GridTypes{
  9.     rect,
  10.     hex
  11. }
  12.  
  13. enum Views{
  14.     iso,
  15.     front,
  16. }
  17.  
  18. const hex_type = HexTypes.vert
  19. const grid_type = GridTypes.hex
  20. const view = Views.front
  21. const size = 32
  22. const iso_scale = 1.0
  23. const hex_map_size = Vector2(4, 7)
  24.  
  25. var hex_basis:Transform2D
  26. var grid_basis:Transform2D
  27.  
  28. var grid_map_size:Vector2
  29.  
  30. class PriorityStack:
  31.    
  32.     var items:Array
  33.    
  34.     func _init():
  35.         items = Array()
  36.        
  37.     func empty() -> bool:
  38.         return items.size() == 0
  39.        
  40.     func put(item, priority:int) -> void:
  41.         if empty():
  42.             items.append([item, priority])
  43.         elif priority <= items[0][1]:
  44.             items.insert(0, [item, priority])
  45.         elif priority > items[-1][1]:
  46.             items.append([item, priority])
  47.         else:
  48.             for i in range(len(items)):
  49.                 if priority <= items[i][1]:
  50.                     items.insert(i, [item, priority])
  51.                     break
  52.                    
  53.     func take():
  54.         return items.pop_front()[0]
  55.  
  56. func _init():
  57.     var short = int(size*sqrt(3)/2) # 1/2 from short hex diagonal
  58.     var long = int(size/2) # 1/4 from long hex diagonal
  59.    
  60.     hex_basis = Transform2D()
  61.     grid_basis = Transform2D()
  62.    
  63.     grid_map_size = Vector2()
  64.    
  65.     match hex_type:
  66.         HexTypes.vert:
  67.             match view:
  68.                 Views.iso:
  69.                     var pw = int(long*cos(PI/4))
  70.                     var ph = int(short*cos(PI/4))
  71.                    
  72.                     grid_basis.x = Vector2(pw, pw/iso_scale)
  73.                     grid_basis.y = Vector2(-ph, ph/iso_scale)
  74.                    
  75.                 Views.front:
  76.                     grid_basis.x = Vector2(long, 0)
  77.                     grid_basis.y = Vector2(0, short/iso_scale)
  78.                 _:
  79.                     grid_basis.x = Vector2(long, 0)
  80.                     grid_basis.y = Vector2(0, short/iso_scale)
  81.            
  82.             hex_basis.x = grid_basis.x*3 + grid_basis.y
  83.             hex_basis.y = grid_basis.y*2
  84.            
  85.         HexTypes.hor:
  86.             match view:
  87.                 Views.iso:
  88.                     var pw = int(short*cos(PI/4))
  89.                     var ph = int(long*cos(PI/4))
  90.                    
  91.                     grid_basis.x = Vector2(pw, pw/iso_scale)
  92.                     grid_basis.y = Vector2(-ph, ph/iso_scale)
  93.                    
  94.                 Views.front:
  95.                     grid_basis.x = Vector2(short, 0)
  96.                     grid_basis.y = Vector2(0, long/iso_scale)
  97.                    
  98.                 _:
  99.                     grid_basis.x = Vector2(short, 0)
  100.                     grid_basis.y = Vector2(0, long/iso_scale)
  101.            
  102.             hex_basis.x = grid_basis.x*2
  103.             hex_basis.y = grid_basis.x+grid_basis.y*3
  104.            
  105.     match grid_type:
  106.         GridTypes.rect:
  107.             match hex_type:
  108.                 HexTypes.vert:
  109.                     grid_map_size.x = hex_map_size.x*3+1
  110.                     grid_map_size.y = hex_map_size.y*2
  111.                 HexTypes.hor:
  112.                     grid_map_size.x = hex_map_size.x*2
  113.                     grid_map_size.y = hex_map_size.y*3+1
  114.                    
  115.         GridTypes.hex:
  116.             var diagonal = hex_map_size.x*2-1
  117.             match hex_type:
  118.                 HexTypes.vert:
  119.                     grid_map_size.x = diagonal*3+1
  120.                     grid_map_size.y = diagonal*2
  121.                 HexTypes.hor:
  122.                     grid_map_size.x = diagonal*2
  123.                     grid_map_size.y = diagonal*3+1
  124.            
  125. func cell2pixel(cell):
  126.     return cell.x*grid_basis.x + cell.y*grid_basis.y
  127.    
  128. func pxiel2cell(pixel):
  129.     return grid_basis.affine_inverse().xform(pixel).floor()
  130.  
  131. func hex2pixel(hex):
  132.     return hex.x*hex_basis.x + hex.y*hex_basis.y
  133.    
  134. func pixel2hex(pixel):
  135.     return round_hex(hex_basis.affine_inverse().xform(pixel))
  136.    
  137. func round_hex(hex:Vector2):
  138.     var rx = round(hex.x)
  139.     var ry = round(hex.y)
  140.     var rz = round(-hex.x-hex.y)
  141.    
  142.     var x_diff = abs(hex.x-rx)
  143.     var y_diff = abs(hex.y-ry)
  144.     var z_diff = abs(-hex.x-hex.y-rz)
  145.     if x_diff > y_diff and x_diff > z_diff:
  146.         rx = -ry-rz
  147.     elif y_diff > z_diff:
  148.         ry = -rx-rz
  149.     return Vector2(rx, ry)
  150.    
  151. func direct_hex(hex1:Vector2, hex2:Vector2):
  152.     var dx = hex2.x - hex1.x
  153.     var dy = hex2.y - hex1.y
  154.     var dz = -hex2.x-hex2.y + hex1.x+hex1.y
  155.     if dx == 0:
  156.         return Vector2(0, sign(dy))
  157.     elif dy == 0:
  158.         return Vector2(sign(dx), 0)
  159.     elif dz == 0:
  160.         return Vector2(sign(dx), sign(dy))
  161.     else:
  162.         if abs(dz) > abs(dx) and abs(dz) > abs(dy):
  163.             if abs(dx) > abs(dy):
  164.                 return Vector2(sign(dx), 0)
  165.             else:
  166.                 return Vector2(0, sign(dy))
  167.         elif abs(dy) > abs(dx):
  168.             if abs(dz) > abs(dx):
  169.                 return Vector2(0, sign(dy))
  170.             else:
  171.                 return Vector2(sign(dx), sign(dy))
  172.         else:
  173.             if abs(dy) > abs(dz):
  174.                 return Vector2(sign(dx), sign(dy))
  175.             else:
  176.                 return Vector2(sign(dx), 0)
  177.    
  178. func in_map(hex):
  179.     match grid_type:
  180.         GridTypes.hex:
  181.             if hex_type == HexTypes.hor:
  182.                 return _in_hex_grid_hor(hex)
  183.             else: # Vertical
  184.                 return _in_hex_grid_vert(hex)
  185.         GridTypes.rect:
  186.             if hex_type == HexTypes.vert:
  187.                 return _in_rect_grid_vert(hex)
  188.             else: # Hor orientation
  189.                 return _in_rect_grid_hor(hex)
  190.    
  191. func get_map_center():
  192.     match grid_type:
  193.         GridTypes.hex:
  194.             if hex_type == HexTypes.hor:
  195.                 return _get_hor_hex_map_center()
  196.             else: # Vertical
  197.                 return _get_vert_hex_map_center()
  198.         GridTypes.rect:
  199.             return Vector2() # Rect map has no center
  200.    
  201. func get_center_cell(hex:Vector2):
  202.     if hex_type == HexTypes.vert:
  203.         return Vector2(hex.x*3, hex.y*2+hex.x)
  204.     else: # Horizontal
  205.         return Vector2(hex.x*2+hex.y, hex.y*3)
  206.  
  207. func can_stand(hex:Vector2, obsts:PoolVector2Array):
  208.     return in_map(hex) and not (hex in obsts)
  209.    
  210. func neighbors(hex_pos:Vector2, obsts:PoolVector2Array):
  211.     var res:PoolVector2Array = []
  212.     var _neighbors = PoolVector2Array([Vector2(-1, 0), Vector2(1, -1), Vector2(0, -1), Vector2(1, 0), Vector2(0, 1), Vector2(-1, 1)])
  213.     for i in _neighbors:
  214.         if can_stand(i+hex_pos, obsts):
  215.             res.append(i+hex_pos)
  216.     return res
  217.    
  218. func find_path(start:Vector2, goal:Vector2, obsts:PoolVector2Array):
  219.     var frontier = PriorityStack.new()
  220.     frontier.put(start, 0)
  221.     var came_from = {}
  222.     var cost_so_far = {}
  223.     came_from[start] = start
  224.     cost_so_far[start] = 0
  225.    
  226.     var current:Vector2
  227.     var new_cost:int
  228.    
  229.     if not can_stand(goal, obsts):
  230.         return PoolVector2Array()
  231.        
  232.     while not frontier.empty():
  233.         current = frontier.take()
  234.        
  235.         if current == goal:
  236.             break
  237.            
  238.         for next in neighbors(current, obsts):
  239.             new_cost = cost_so_far[current] + 1
  240.                
  241.             if not (next in cost_so_far) or new_cost < cost_so_far[next]:
  242.                 cost_so_far[next] = new_cost
  243.                 frontier.put(next, new_cost+hex_distance(goal, next))
  244.                 came_from[next] = current
  245.                
  246.     if frontier.empty() and current != goal:
  247.         return PoolVector2Array()
  248.        
  249.     current = goal
  250.     var path = PoolVector2Array([current])
  251.    
  252.     while current != start:
  253.         current = came_from[current]
  254.         path.append(current)
  255.    
  256.     path.invert()
  257.     path.remove(0) # removes first position
  258.     return path
  259.    
  260. func rast_line(hex1, hex2):
  261.     var N = hex_distance(hex1, hex2)
  262.     if N == 0: return PoolVector2Array([hex1])
  263.     var res = PoolVector2Array()
  264.     for i in range(N+1):
  265.         res.append(round_hex(lerp(hex1, hex2, i/N)))
  266.     return res
  267.  
  268. func hex_distance(hex1:Vector2, hex2:Vector2):
  269.     var dif = (hex2-hex1)
  270.     return (abs(dif.x) + abs(dif.y) + abs(-dif.x-dif.y))/2
  271.    
  272. func draw_grid(surf:RID, color:Color, width=1.0, antialiasing=false):
  273.     match grid_type:
  274.         GridTypes.rect:
  275.             match hex_type:
  276.                 HexTypes.vert:
  277.                     _draw_vert_rect_grid(surf, color, width, antialiasing)
  278.                 HexTypes.hor:
  279.                     _draw_hor_rect_grid(surf, color, width, antialiasing)
  280.         GridTypes.hex:
  281.             match hex_type:
  282.                 HexTypes.hor:
  283.                     _draw_hor_hex_grid(surf, color, width, antialiasing)
  284.                 HexTypes.vert:
  285.                     _draw_vert_hex_grid(surf, color, width, antialiasing)
  286.                    
  287. func draw_hex(hex, surf, color, width=1.0, antialiasing=false):
  288.     match hex_type:
  289.         HexTypes.vert:
  290.             _draw_vert_hex(hex, surf, color, width, antialiasing)
  291.         HexTypes.hor:
  292.             _draw_hor_hex(hex, surf, color, width, antialiasing)
  293.            
  294. func fill_hex(hex, surf, color, antialiasing):
  295.     if hex_type == HexTypes.hor:
  296.         _fill_hor_hex(hex, surf, color, antialiasing)
  297.     else: # Vertical
  298.         _fill_vert_hex(hex, surf, color, antialiasing)
  299.  
  300. func draw_auxiliary_grid(surf:RID, color:Color, width=1.0, antialiasing=false):
  301.     var offset:Vector2
  302.     if hex_type == HexTypes.hor:
  303.         offset = grid_basis.x+grid_basis.y*2
  304.         if grid_type == GridTypes.hex and int(hex_map_size.x)%2 == 0:
  305.             offset += grid_basis.x
  306.     else:
  307.         offset = grid_basis.x*2+grid_basis.y
  308.         if grid_type == GridTypes.hex and int(hex_map_size.x)%2 == 0:
  309.             offset += grid_basis.y
  310.     for i in grid_map_size.x+1:
  311.         VisualServer.canvas_item_add_line(surf, grid_basis.x*i-offset, grid_basis.x*i+grid_basis.y*grid_map_size.y-offset, color, width, antialiasing)
  312.     for i in grid_map_size.y+1:
  313.         VisualServer.canvas_item_add_line(surf, grid_basis.y*i-offset, grid_basis.x*grid_map_size.x+grid_basis.y*i-offset, color, width, antialiasing)
  314.  
  315. func draw_line(surf, hex1, hex2, color, width=1.0, antialiasing=false):
  316.     var p1 = hex2pixel(hex1)
  317.     var p2 = hex2pixel(hex2)
  318.     VisualServer.canvas_item_add_line(surf, p1, p2, color, width, antialiasing)
  319.    
  320. func draw_polyline(surf, hexes, color, width=1.0, antialiasing=false):
  321.     if len(hexes) < 2: return
  322.     var points = PoolVector2Array()
  323.     for i in hexes:
  324.         points.append(hex2pixel(i))
  325.     VisualServer.canvas_item_add_polyline(surf, points, [color], width, antialiasing)
  326.  
  327. func _get_vert_hex_vertices(hex):
  328.     var pixel = hex2pixel(hex)
  329.     return PoolVector2Array([
  330.         pixel+2*grid_basis.x,
  331.         pixel+grid_basis.x+grid_basis.y,
  332.         pixel-grid_basis.x+grid_basis.y,
  333.         pixel-2*grid_basis.x,
  334.         pixel-grid_basis.x-grid_basis.y,
  335.         pixel+grid_basis.x-grid_basis.y
  336.     ])
  337.    
  338. func _get_hor_hex_vertices(hex):
  339.     var pixel = hex2pixel(hex)
  340.     return PoolVector2Array([
  341.         pixel+grid_basis.x-grid_basis.y,
  342.         pixel+grid_basis.x+grid_basis.y,
  343.         pixel+2*grid_basis.y,
  344.         pixel-grid_basis.x+grid_basis.y,
  345.         pixel-grid_basis.x-grid_basis.y,
  346.         pixel-2*grid_basis.y,
  347.     ])
  348.  
  349. func _get_hor_hex_map_center():
  350.     return Vector2(int((hex_map_size.x-1)/2), hex_map_size.x-1)
  351.    
  352. func _get_vert_hex_map_center():
  353.     return Vector2(hex_map_size.x-1, int((hex_map_size.x-1)/2))
  354.    
  355. func _in_hex_grid_hor(hex):
  356.     var center = _get_hor_hex_map_center()
  357.     var diag = int(hex_map_size.x*2 - 1)
  358.     hex -= center # Vector2 passed by value
  359.     if hex.y < 0:
  360.         return hex.x >= -diag/2+abs(hex.y) and hex.x <= diag/2 and hex.y >= -diag/2 and hex.y <= diag/2
  361.     else:
  362.         return hex.x >= -diag/2 and hex.x <= diag/2-abs(hex.y) and hex.y >= -diag/2 and hex.y <= diag/2
  363.        
  364. func _in_hex_grid_vert(hex):
  365.     var center = _get_vert_hex_map_center()
  366.     var diag = int(hex_map_size.x*2 - 1)
  367.     hex -= center # Vector2 passed by value
  368.     if hex.x < 0:
  369.         return hex.y >= -diag/2+abs(hex.x) and hex.y <= diag/2 and hex.x >= -diag/2 and hex.x <= diag/2
  370.     else:
  371.         return hex.y >= -diag/2 and hex.y <= diag/2-abs(hex.x) and hex.x >= -diag/2 and hex.x <= diag/2
  372.  
  373. func _in_rect_grid_hor(hex):
  374.     return hex.x >= -floor(hex.y/2) and hex.x < hex_map_size.x-ceil(hex.y/2) and hex.y < hex_map_size.y and hex.y >= 0
  375.    
  376. func _in_rect_grid_vert(hex):
  377.     return hex.x >= 0 and hex.x < hex_map_size.x and hex.y >= -floor(hex.x/2) and hex.y < hex_map_size.y-ceil(hex.x/2)
  378.  
  379. func _draw_hor_hex(hex, surf, color, width=1.0, antialiasing=false):
  380.     var points = _get_hor_hex_vertices(hex)
  381.     points.append(points[0])
  382.     VisualServer.canvas_item_add_polyline(surf, points, [color], width, antialiasing)
  383.    
  384. func _draw_vert_hex(hex, surf, color, width=1.0, antialiasing=false):
  385.     var points = _get_vert_hex_vertices(hex)
  386.     points.append(points[0])
  387.     VisualServer.canvas_item_add_polyline(surf, points, [color], width, antialiasing)
  388.    
  389. func _fill_hor_hex(hex, surf, color, antialiasing=false):
  390.     var points = _get_hor_hex_vertices(hex)
  391.     VisualServer.canvas_item_add_polygon(surf, points, [color], [], RID(), RID(), antialiasing)
  392.    
  393. func _fill_vert_hex(hex, surf, color, antialiasing=false):
  394.     var points = _get_vert_hex_vertices(hex)
  395.     VisualServer.canvas_item_add_polygon(surf, points, [color], [], RID(), RID(), antialiasing)
  396.  
  397. func _draw_vert_rect_grid(surf:RID, color:Color, width=1.0, antialiasing=false):
  398.     var offset = grid_basis.x*2+grid_basis.y
  399.     # Drawing horizontal lines
  400.     for i in range(1, grid_map_size.x, 3):
  401.         for j in range(1-i%2, grid_map_size.y+1, 2):
  402.             VisualServer.canvas_item_add_line(surf, grid_basis.x*i+grid_basis.y*j-offset, grid_basis.x*(i+2)+grid_basis.y*j-offset, color, width, antialiasing)
  403.            
  404.     # Drawing vertices
  405.     for i in range(0, grid_map_size.x, 3):
  406.         for j in range(grid_map_size.y):
  407.             if int(hex_map_size.x)%2 == 1 or not(i == grid_map_size.x-1 and (j == 0 or j == grid_map_size.y-1)):
  408.                 if j%2 == i%2:
  409.                     VisualServer.canvas_item_add_line(surf, grid_basis.x*(i+1)+grid_basis.y*j-offset, grid_basis.x*i+grid_basis.y*(j+1)-offset, color, width, antialiasing)
  410.                 else:
  411.                     VisualServer.canvas_item_add_line(surf, grid_basis.x*i+grid_basis.y*j-offset, grid_basis.x*(i+1)+grid_basis.y*(j+1)-offset, color, width, antialiasing)
  412.  
  413. func _draw_hor_rect_grid(surf:RID, color:Color, width=1.0, antialiasing=false):
  414.     var offset = grid_basis.x+grid_basis.y*2
  415.     # Drawing vertical lines
  416.     for i in range(1, grid_map_size.y, 3):
  417.         for j in range(1-i%2, grid_map_size.x+1, 2):
  418.             VisualServer.canvas_item_add_line(surf, grid_basis.x*j+grid_basis.y*i-offset, grid_basis.x*j+grid_basis.y*(i+2)-offset, color, width, antialiasing)
  419.  
  420.     # Drawing vertices
  421.     for i in range(0, grid_map_size.y, 3):
  422.         for j in range(grid_map_size.x):
  423.             if int(hex_map_size.y)%2 == 1 or not (i == grid_map_size.y-1 and (j == 0 or j == grid_map_size.x-1)):
  424.                 if i%2 == j%2:
  425.                     VisualServer.canvas_item_add_line(surf, grid_basis.x*j+grid_basis.y*(i+1)-offset, grid_basis.x*(j+1)+grid_basis.y*i-offset, color, width, antialiasing)
  426.                 else:
  427.                     VisualServer.canvas_item_add_line(surf, grid_basis.x*j+grid_basis.y*i-offset, grid_basis.x*(j+1)+grid_basis.y*(i+1)-offset, color, width, antialiasing)
  428.  
  429. func _draw_hor_hex_grid(surf:RID, color:Color, width=1.0, antialiasing=false):
  430.     var parity = int(hex_map_size.x)%2
  431.     var offset = grid_basis.x+grid_basis.y*2 + grid_basis.x*(1-parity)
  432.     var start
  433.     for i in range(0, grid_map_size.y/2, 3): # Drawing vertices
  434.         start = hex_map_size.x - i/3 - 1
  435.         for j in range(start, grid_map_size.x/2):
  436.             if abs(i%2 - j%2) != parity:
  437.                 # Down diagonal
  438.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*j+grid_basis.y*(i+1)-offset, grid_basis.x*(j+1)+grid_basis.y*i-offset, color)
  439.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(grid_map_size.x-j)+grid_basis.y*(i+1)-offset, grid_basis.x*(grid_map_size.x-j-1)+grid_basis.y*i-offset, color)
  440.  
  441.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*j+grid_basis.y*(grid_map_size.y-i-1)-offset, grid_basis.x*(j+1)+grid_basis.y*(grid_map_size.y-i)-offset, color)
  442.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(grid_map_size.x-j)+grid_basis.y*(grid_map_size.y-i-1)-offset, grid_basis.x*(grid_map_size.x-j-1)+grid_basis.y*(grid_map_size.y-i)-offset, color)
  443.             else:
  444.                 # Top diagonal
  445.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(j)+grid_basis.y*(i)-offset, grid_basis.x*(j+1)+grid_basis.y*(i+1)-offset, color)
  446.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(grid_map_size.x-j)+grid_basis.y*(i)-offset, grid_basis.x*(grid_map_size.x-j-1)+grid_basis.y*(i+1)-offset, color)
  447.  
  448.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(j)+grid_basis.y*(grid_map_size.y-i)-offset, grid_basis.x*(j+1)+grid_basis.y*(grid_map_size.y-i-1)-offset, color)
  449.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(grid_map_size.x-j)+grid_basis.y*(grid_map_size.y-i)-offset, grid_basis.x*(grid_map_size.x-j-1)+grid_basis.y*(grid_map_size.y-i-1)-offset, color)
  450.  
  451.     for i in range(1, grid_map_size.y, 3):
  452.         if i <= grid_map_size.y/2:
  453.             start = hex_map_size.x-1 - i/3
  454.         else:
  455.             start = (i-grid_map_size.y/2)/3
  456.  
  457.         for j in range(abs(parity-i%2), grid_map_size.x+1, 2):
  458.             if j >= start and j <= grid_map_size.x-start:
  459.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*j+grid_basis.y*i-offset, grid_basis.x*j+grid_basis.y*(i+2)-offset, color, width, antialiasing)
  460.  
  461. func _draw_vert_hex_grid(surf:RID, color:Color, width=1.0, antialiasing=false):
  462.     var parity = int(hex_map_size.x)%2
  463.     var offset = grid_basis.x*2+grid_basis.y + (1-parity)*grid_basis.y
  464.     var start
  465.     for j in range(0, grid_map_size.x/2, 3): # Drawing vertices
  466.         start = hex_map_size.x - j/3 - 1
  467.         for i in range(start, grid_map_size.y/2):
  468.             if abs(i%2 - j%2) != parity:
  469.                 # Down diagonal
  470.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(j+1)+grid_basis.y*(i)-offset, grid_basis.x*(j)+grid_basis.y*(i+1)-offset, color)
  471.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(grid_map_size.x-j-1)+grid_basis.y*(i)-offset, grid_basis.x*(grid_map_size.x-j)+grid_basis.y*(i+1)-offset, color)
  472.  
  473.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(j+1)+grid_basis.y*(grid_map_size.y-i)-offset, grid_basis.x*(j)+grid_basis.y*(grid_map_size.y-i-1)-offset, color)
  474.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(grid_map_size.x-j-1)+grid_basis.y*(grid_map_size.y-i)-offset, grid_basis.x*(grid_map_size.x-j)+grid_basis.y*(grid_map_size.y-i-1)-offset, color)
  475.             else:
  476.                 # Top diagonal
  477.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(j)+grid_basis.y*(i)-offset, grid_basis.x*(j+1)+grid_basis.y*(i+1)-offset, color)
  478.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(grid_map_size.x-j)+grid_basis.y*(i)-offset, grid_basis.x*(grid_map_size.x-j-1)+grid_basis.y*(i+1)-offset, color)
  479.  
  480.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(j)+grid_basis.y*(grid_map_size.y-i)-offset, grid_basis.x*(j+1)+grid_basis.y*(grid_map_size.y-i-1)-offset, color)
  481.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*(grid_map_size.x-j)+grid_basis.y*(grid_map_size.y-i)-offset, grid_basis.x*(grid_map_size.x-j-1)+grid_basis.y*(grid_map_size.y-i-1)-offset, color)
  482.  
  483.     for i in range(1, grid_map_size.x, 3):
  484.         if i <= grid_map_size.x/2:
  485.             start = hex_map_size.x-1 - i/3
  486.         else:
  487.             start = (i-grid_map_size.x/2)/3
  488.  
  489.         for j in range(abs(parity-i%2), grid_map_size.y+1, 2):
  490.             if j >= start and j <= grid_map_size.y-start:
  491.                 VisualServer.canvas_item_add_line(surf, grid_basis.x*i+grid_basis.y*j-offset, grid_basis.x*(i+2)+grid_basis.y*(j)-offset, color, width, antialiasing)
  492.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!