copygirl
/
YourFortV
1
0
Fork 0
Code Issues Pull Requests Releases Activity

Compare commits

base: copygirl:80e4008ac6e013f8d485b6f1ae5496faa656f3d4
Branches Tags
copygirl:main
..
compare: copygirl:3dc9a3a3daa947144c07a69ccc5de66c96cab007
Branches Tags
copygirl:main

No commits in common. '80e4008ac6e013f8d485b6f1ae5496faa656f3d4' and '3dc9a3a3daa947144c07a69ccc5de66c96cab007' have entirely different histories.
80e4008ac6 ... 3dc9a3a3da

6 changed files with 103 additions and 331 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats
  1. 45
      world/block_region.gd
  2. 1
      world/block_region.gd.uid
  3. 11
      world/chunk.gd
  4. 252
      world/generation/generator_simple.gd
  5. 58
      world/layers/matter.gd
  6. 67
      world/layers/shape.gd

45
world/block_region.gd
Unescape View File

@ -1,45 +0,0 @@
class_name BlockRegion
extends RefCounted
static var LOCAL_CHUNK := BlockRegion.new(Vector2i.ZERO, Vector2i.ONE * (Chunk.SIZE - 1))
var min: Vector2i
var max: Vector2i
func _init(a: Vector2i, b: Vector2i) -> void:
min = a.min(b)
max = a.max(b)
func size() -> Vector2i:
return max - min + Vector2i.ONE
func contains(pos: Vector2i) -> bool:
return (pos.x >= min.x) && (pos.x <= max.x) and (pos.y >= min.y) && (pos.y <= max.y)
func offset(value: Vector2i) -> BlockRegion:
return BlockRegion.new(min + value, max + value)
func extend(amount: int) -> BlockRegion:
var v := Vector2i.ONE * amount
return BlockRegion.new(min - v, max + v)
func array_index(pos: Vector2i) -> int:
assert(contains(pos))
var size := size()
var index := (pos.x - min.x) + (pos.y - min.y) * size.x
return clampi(index, 0, size.x * size.y)
# Custom iterators in GDScript are WEIRD.
func _iter_init(state: Array) -> bool:
state[0] = min
return true
func _iter_next(state: Array) -> bool:
var cur: Vector2i = state[0]
if cur.x < max.x: state[0].x += 1; return true
elif cur.y < max.y: state[0] = Vector2i(min.x, cur.y + 1); return true
else: return false
func _iter_get(state: Variant) -> Vector2i:
return state

1
world/block_region.gd.uid
Unescape View File

@ -1 +0,0 @@
uid://w5fuyrkwf40c

11
world/chunk.gd
Unescape View File

@ -7,7 +7,6 @@ const SIZE := 32 # blocks
signal clean signal clean
var chunk_pos: Vector2i var chunk_pos: Vector2i
var region: BlockRegion
var dirty := false var dirty := false
var tracked_by: Dictionary[ChunkLoader, Variant] # value is unused var tracked_by: Dictionary[ChunkLoader, Variant] # value is unused
@ -20,11 +19,6 @@ func get_players_tracking() -> Array[Player]:
func _init(chunk_pos: Vector2i) -> void: func _init(chunk_pos: Vector2i) -> void:
self.chunk_pos = chunk_pos self.chunk_pos = chunk_pos
var min := chunk_pos * Chunk.SIZE
var max := (chunk_pos + Vector2i.ONE) * Chunk.SIZE - Vector2i.ONE
region = BlockRegion.new(min, max)
name = "Chunk %s" % chunk_pos name = "Chunk %s" % chunk_pos
position = (Vector2(chunk_pos) + Vector2.ONE / 2) * (Block.SIZE * SIZE) position = (Vector2(chunk_pos) + Vector2.ONE / 2) * (Block.SIZE * SIZE)
@ -82,4 +76,7 @@ static func pos_to_center(chunk_pos: Vector2i) -> Vector2:
## Creates an integer index from a chunk-local block position that can be used to index into an array. ## Creates an integer index from a chunk-local block position that can be used to index into an array.
static func array_index(local_pos: Vector2i) -> int: static func array_index(local_pos: Vector2i) -> int:
return BlockRegion.LOCAL_CHUNK.array_index(local_pos) assert((local_pos.x >= 0) and (local_pos.x < Chunk.SIZE))
assert((local_pos.y >= 0) and (local_pos.y < Chunk.SIZE))
# Using `posmod` ensures `local_pos` is valid, and this returns a valid index.
return posmod(local_pos.x, Chunk.SIZE) + posmod(local_pos.y, Chunk.SIZE) * Chunk.SIZE

252
world/generation/generator_simple.gd
Unescape View File

@ -4,7 +4,7 @@ extends RefCounted
const NAME := "simple" const NAME := "simple"
var noise := FastNoiseLite.new() var noise := FastNoiseLite.new()
var array := PackedByteArray() var array := PackedFloat32Array()
var bias_air := 0.0 # Above this, always air var bias_air := 0.0 # Above this, always air
var bias_solid := 64.0 # Below this, always solid var bias_solid := 64.0 # Below this, always solid
@ -17,224 +17,44 @@ func _init() -> void:
noise.fractal_lacunarity = 2.5 noise.fractal_lacunarity = 2.5
noise.fractal_octaves = 3 noise.fractal_octaves = 3
array.resize((Chunk.SIZE + 4) * (Chunk.SIZE + 4)) array.resize((Chunk.SIZE + 1) * (Chunk.SIZE + 1))
func generate(world: World, chunk: Chunk) -> void: func generate(world: World, chunk: Chunk) -> void:
const THRESHOLD := 0.5
var region := chunk.region.extend(2)
var i := 0 var i := 0
for pos in region: for y in Chunk.SIZE + 1:
var bias := (pos.y - bias_air) / (bias_solid - bias_air) for x in Chunk.SIZE + 1:
array[i] = int((noise.get_noise_2dv(Vector2(pos)) + bias) >= THRESHOLD) var local_pos := Vector2i(x, y)
i += 1 var block_pos := (chunk.chunk_pos * Chunk.SIZE) + local_pos
var bias := (block_pos.y - bias_air) / (bias_solid - bias_air)
array[i] = noise.get_noise_2dv(Vector2(block_pos)) + bias
i += 1
var matter: Matter.Layer = chunk.get_or_create_layer(Matter) var matter: Matter.Layer = chunk.get_or_create_layer(Matter)
var shapes: Shape.Layer = chunk.get_or_create_layer(Shape) var shapes: Shape.Layer = chunk.get_or_create_layer(Shape)
for pos in BlockRegion.LOCAL_CHUNK: for x in Chunk.SIZE:
var shape: Shape for y in Chunk.SIZE:
var local_pos := Vector2i(x, y)
var a := array var shape: Shape
const W := (Chunk.SIZE + 4) match _values(local_pos):
i = (pos.x + 2) + (pos.y + 2) * W [ true, true, true, true ]: shape = Shape.FULL
[ false, true, true, true ]: shape = Shape.Base.SLOPE.variants[0]
var values: Array[int] = [ [ true, false, true, true ]: shape = Shape.Base.SLOPE.variants[2]
a[i-2-W*2], a[i-1-W*2], a[i-W*2], a[i+1-W*2], a[i+2-W*2], [ true, true, false, true ]: shape = Shape.Base.SLOPE.variants[3]
a[i-2-W ], a[i-1-W ], a[i-W ], a[i+1-W ], a[i+2-W ], [ true, true, true, false ]: shape = Shape.Base.SLOPE.variants[1]
a[i-2 ], a[i-1 ], a[i ], a[i+1 ], a[i+2 ], [ false, false, true, true ]: shape = Shape.Base.HALF.variants[0]
a[i-2+W ], a[i-1+W ], a[i+W ], a[i+1+W ], a[i+2+W ], [ true, false, false, true ]: shape = Shape.Base.HALF.variants[2]
a[i-2+W*2], a[i-1+W*2], a[i+W*2], a[i+1+W*2], a[i+2+W*2], [ true, true, false, false ]: shape = Shape.Base.HALF.variants[3]
] [ false, true, true, false ]: shape = Shape.Base.HALF.variants[1]
if shape:
# TODO: Implement custom pattern matching that can handle rotation and mirroring. matter.set_at(local_pos, Matter.PLASTIC)
# var x := -1 shapes.set_at(local_pos, shape)
# var pattern: Array[int] = [
# x, x, x, x, x, func _values(pos: Vector2i) -> Array[bool]:
# x, x, 0, 0, 0, return [
# x, 0, 0, 1, 1, _v(pos, 0, 0) >= 0.5,
# x, 1, 1, 1, x, _v(pos, 1, 0) >= 0.5,
# x, x, x, x, x, _v(pos, 1, 1) >= 0.5,
# ] _v(pos, 0, 1) >= 0.5,
]
match values: func _v(pos: Vector2i, x: float, y: float) -> float:
# HALF_SLOPE (non-mirrored) return array[(pos.x + x) + (pos.y + y) * (Chunk.SIZE + 1)]
[
_, _, _, _, _,
_, _, 0, 0, 0,
_, 0, 0, 1, 1,
_, 1, 1, 1, _,
_, _, _, _, _,
]:
shape = Shape.Base.HALF_SLOPE.variants[0]
[
_, 0, 1, _, _,
_, 0, 1, 1, _,
_, 0, 0, 1, _,
_, _, 0, 1, _,
_, _, _, _, _,
]:
shape = Shape.Base.HALF_SLOPE.variants[1]
[
_, _, _, _, _,
_, 1, 1, 1, _,
1, 1, 0, 0, _,
0, 0, 0, _, _,
_, _, _, _, _,
]:
shape = Shape.Base.HALF_SLOPE.variants[2]
[
_, _, _, _, _,
_, 1, 0, _, _,
_, 1, 0, 0, _,
_, 1, 1, 0, _,
_, _, 1, 0, _,
]:
shape = Shape.Base.HALF_SLOPE.variants[3]
[
_, _, _, _, _,
_, 0, 0, 0, _,
0, 0, 1, 1, _,
1, 1, 1, _, _,
_, _, _, _, _,
]:
shape = Shape.Base.HALF_SLOPE_BIG.variants[0]
[
_, _, _, _, _,
_, 0, 1, _, _,
_, 0, 1, 1, _,
_, 0, 0, 1, _,
_, _, 0, 1, _,
]:
shape = Shape.Base.HALF_SLOPE_BIG.variants[1]
[
_, _, _, _, _,
_, _, 1, 1, 1,
_, 1, 1, 0, 0,
_, 0, 0, 0, _,
_, _, _, _, _,
]:
shape = Shape.Base.HALF_SLOPE_BIG.variants[2]
[
_, 1, 0, _, _,
_, 1, 0, 0, _,
_, 1, 1, 0, _,
_, _, 1, 0, _,
_, _, _, _, _,
]:
shape = Shape.Base.HALF_SLOPE_BIG.variants[3]
# HALF_SLOPE (mirrored)
[
_, _, _, _, _,
0, 0, 0, _, _,
1, 1, 0, 0, _,
_, 1, 1, 1, _,
_, _, _, _, _,
]:
shape = Shape.Base.HALF_SLOPE.variants[4]
[
_, _, _, _, _,
_, _, 0, 1, _,
_, 0, 0, 1, _,
_, 0, 1, 1, _,
_, 0, 1, _, _,
]:
shape = Shape.Base.HALF_SLOPE.variants[5]
[
_, _, _, _, _,
_, 1, 1, 1, _,
_, 0, 0, 1, 1,
_, _, 0, 0, 0,
_, _, _, _, _,
]:
shape = Shape.Base.HALF_SLOPE.variants[6]
[
_, _, 1, 0, _,
_, 1, 1, 0, _,
_, 1, 0, 0, _,
_, 1, 0, _, _,
_, _, _, _, _,
]:
shape = Shape.Base.HALF_SLOPE.variants[7]
[
_, _, _, _, _,
_, 0, 0, 0, _,
_, 1, 1, 0, 0,
_, _, 1, 1, 1,
_, _, _, _, _,
]:
shape = Shape.Base.HALF_SLOPE_BIG.variants[4]
[
_, _, 0, 1, _,
_, 0, 0, 1, _,
_, 0, 1, 1, _,
_, 0, 1, _, _,
_, _, _, _, _,
]:
shape = Shape.Base.HALF_SLOPE_BIG.variants[5]
[
_, _, _, _, _,
1, 1, 1, _, _,
0, 0, 1, 1, _,
_, 0, 0, 0, _,
_, _, _, _, _,
]:
shape = Shape.Base.HALF_SLOPE_BIG.variants[6]
[
_, _, _, _, _,
_, _, 1, 0, _,
_, 1, 1, 0, _,
_, 1, 0, 0, _,
_, 1, 0, _, _,
]:
shape = Shape.Base.HALF_SLOPE_BIG.variants[7]
# SLOPE
[
_, _, _, _, _,
_, _, 0, _, _,
_, 0, 0, 1, _,
_, _, 1, _, _,
_, _, _, _, _,
]:
shape = Shape.Base.SLOPE.variants[0]
[
_, _, _, _, _,
_, _, 1, _, _,
_, 0, 0, 1, _,
_, _, 0, _, _,
_, _, _, _, _,
]:
shape = Shape.Base.SLOPE.variants[1]
[
_, _, _, _, _,
_, _, 1, _, _,
_, 1, 0, 0, _,
_, _, 0, _, _,
_, _, _, _, _,
]:
shape = Shape.Base.SLOPE.variants[2]
[
_, _, _, _, _,
_, _, 0, _, _,
_, 1, 0, 0, _,
_, _, 1, _, _,
_, _, _, _, _,
]:
shape = Shape.Base.SLOPE.variants[3]
# FULL
[
_, _, _, _, _,
_, _, _, _, _,
_, _, 1, _, _,
_, _, _, _, _,
_, _, _, _, _,
]:
shape = Shape.FULL
if shape:
matter.set_at(pos, Matter.PLASTIC)
shapes.set_at(pos, shape)

58
world/layers/matter.gd
Unescape View File

@ -5,7 +5,6 @@ static var REGISTRY := Registry.new()
static var NONE := Matter.new("none") static var NONE := Matter.new("none")
static var PLASTIC := Matter.new("plastic") static var PLASTIC := Matter.new("plastic")
## Default matter to return when chunk or layer is not found.
static var DEFAULT := NONE static var DEFAULT := NONE
var id : int var id : int
@ -42,17 +41,16 @@ class Layer extends MeshInstance2D:
@rpc("reliable") @rpc("reliable")
func set_id_at(pos: Vector2i, id: int) -> void: func set_id_at(pos: Vector2i, id: int) -> void:
var index := Chunk.array_index(pos) var index := Chunk.array_index(pos)
if data[index] == id: return if data[index] != id:
# TODO: Keep track of how many non-air blocks are present, to allow for cleaning empty chunks.
data[index] = id
chunk.dirty = true
# TODO: Keep track of how many non-air blocks are present, to allow for cleaning empty chunks.
data[index] = id
chunk.dirty = true
if multiplayer.is_server():
# Send change to every player tracking this chunk. # Send change to every player tracking this chunk.
for player in chunk.get_players_tracking(): if multiplayer.is_server():
if player.network.is_local: continue # skip server player for player in chunk.get_players_tracking():
set_id_at.rpc_id(player.network.peer_id, pos, id) if player.network.is_local: continue # skip server player
set_id_at.rpc_id(player.network.peer_id, pos, id)
func _ready() -> void: func _ready() -> void:
@ -68,25 +66,27 @@ class Layer extends MeshInstance2D:
var shapes: Shape.Layer = chunk.get_layer_or_null(Shape) var shapes: Shape.Layer = chunk.get_layer_or_null(Shape)
if shapes: # Should exist, but let's sanity check. if shapes: # Should exist, but let's sanity check.
for pos in BlockRegion.LOCAL_CHUNK: for x in Chunk.SIZE:
var offset := (Vector2.ONE / 2) + Vector2(pos) for y in Chunk.SIZE:
var pos := Vector2i(x, y)
# TODO: Support different matter. var offset := (Vector2.ONE / 2) + Vector2(pos)
# var matter := get_at(pos)
var shape := shapes.get_at(pos) # TODO: Support different matter.
if shape.points.is_empty(): continue # var matter := get_at(pos)
any_blocks = true var shape := shapes.get_at(pos)
if shape.points.is_empty(): continue
for i in range(2, shape.points.size()): any_blocks = true
var uv0 := shape.uvs[0 ]
var uv1 := shape.uvs[i-1] for i in range(2, shape.points.size()):
var uv2 := shape.uvs[i ] var uv0 := shape.uvs[0 ]
var p0 := (offset + shape.points[0 ]) * Block.SIZE - CHUNK_HALF_SIZE var uv1 := shape.uvs[i-1]
var p1 := (offset + shape.points[i-1]) * Block.SIZE - CHUNK_HALF_SIZE var uv2 := shape.uvs[i ]
var p2 := (offset + shape.points[i ]) * Block.SIZE - CHUNK_HALF_SIZE var p0 := (offset + shape.points[0 ]) * Block.SIZE - CHUNK_HALF_SIZE
m.surface_set_uv(uv0); m.surface_add_vertex_2d(p0) var p1 := (offset + shape.points[i-1]) * Block.SIZE - CHUNK_HALF_SIZE
m.surface_set_uv(uv1); m.surface_add_vertex_2d(p1) var p2 := (offset + shape.points[i ]) * Block.SIZE - CHUNK_HALF_SIZE
m.surface_set_uv(uv2); m.surface_add_vertex_2d(p2) m.surface_set_uv(uv0); m.surface_add_vertex_2d(p0)
m.surface_set_uv(uv1); m.surface_add_vertex_2d(p1)
m.surface_set_uv(uv2); m.surface_add_vertex_2d(p2)
if any_blocks: if any_blocks:
m.surface_end() m.surface_end()

67
world/layers/shape.gd
Unescape View File

@ -9,7 +9,6 @@ static func lookup(id: int) -> Shape:
static var EMPTY : Shape static var EMPTY : Shape
static var FULL : Shape static var FULL : Shape
## Default shape to return when chunk or layer is not found.
static var DEFAULT : Shape static var DEFAULT : Shape
var id : int var id : int
@ -35,14 +34,12 @@ func _init(base: Base, mirror: bool, angle: int, shape: Shape2D, points: PackedV
uvs.append((Vector2.ONE / 2) + point) uvs.append((Vector2.ONE / 2) + point)
## Represents a base shape, before it has been rotated and mirrored
## (if applicable) to create a number of variants based on that shape.
class Base: class Base:
static var EMPTY := Base.new("empty") static var EMPTY := Base.new("empty")
static var FULL := Base.new("full" , _rect()) static var FULL := Base.new("full" , _rect())
static var HALF := Base.new("half" , [ 0,1, 2,1, 2,2, 0,2 ], true) static var HALF := Base.new("half" , [ 0,1, 2,1, 2,2, 0,2 ], true)
static var SLOPE := Base.new("slope" , [ 0,1, 1,0, 1,1 ], true) static var SLOPE := Base.new("slope" , [ 0,1, 1,0, 1,1 ], true)
static var HALF_SLOPE := Base.new("half_slope" , [ 0,2, 2,1, 2,2 ], true, true) static var HALF_SLOPE := Base.new("half_slope" , [ 0,2, 1,0, 2,2 ], true, true)
static var HALF_SLOPE_BIG := Base.new("half_slope_big", [ 0,1, 2,0, 2,2, 0,2 ], true, true) static var HALF_SLOPE_BIG := Base.new("half_slope_big", [ 0,1, 2,0, 2,2, 0,2 ], true, true)
static func _static_init() -> void: static func _static_init() -> void:
@ -63,25 +60,28 @@ class Base:
shape = _rotate(shape) # rotate by 90 degrees (swap x and y components) shape = _rotate(shape) # rotate by 90 degrees (swap x and y components)
variants.append(Shape.new(self, false, 0, shape, _points(shape))) variants.append(Shape.new(self, false, 0, shape, _points(shape)))
elif shape is Array: elif shape is Array:
# Convert points (pairs of `int`s) in `Array` to convex shape. # Convert points (pairs of ints) in array to convex shape.
var factor := float(shape.max()) var factor := float(shape.max())
var points_orig := PackedVector2Array() # untransformed points var points := PackedVector2Array()
for i in range(0, shape.size(), 2): for i in range(0, shape.size(), 2):
var point := Vector2(shape[i] / factor, shape[i + 1] / factor) var point := Vector2(shape[i] / factor, shape[i + 1] / factor)
points_orig.append(point - (Vector2.ONE / 2)) # ensure shape is centered points.append(point - (Vector2.ONE / 2)) # ensure shape is centered
# Add variations of the shape (rotated, mirrored), including the standard shape. # Add variations of the shape (rotated, mirrored), including the standard shape.
for mirror in [ false, true ] if mirrored else [ false ]: for mirror in [ false, true ] if mirrored else [ false ]:
for angle in [ 0, 90, 180, 270 ] if rotated else [ 0 ]: if mirror:
var points := points_orig.duplicate() # transformed points # Mirror (flip) points along the X axis.
# Technically we could skip `duplicate()` if not mirrored and not rotated, but eh. points = points.duplicate()
for i in points.size():
if mirror: # Mirror (flip) points along the X axis. points[i] = points[i] * Transform2D.FLIP_X
for i in points.size(): points[i] *= Transform2D.FLIP_X
if angle != 0: # Rotate points around the center. for angle in [ 0, 90, 180, 270 ] if rotated else [ 0 ]:
if angle != 0:
# Rotate points around the center.
var transform := Transform2D(deg_to_rad(angle), Vector2.ZERO) var transform := Transform2D(deg_to_rad(angle), Vector2.ZERO)
for i in points.size(): points[i] *= transform points = points.duplicate()
for i in points.size():
points[i] = points[i] * transform
var shape_points: PackedVector2Array var shape_points: PackedVector2Array
for point in points: shape_points.append(point * Block.SIZE) for point in points: shape_points.append(point * Block.SIZE)
@ -130,17 +130,16 @@ class Layer extends StaticBody2D:
@rpc("reliable") @rpc("reliable")
func set_id_at(pos: Vector2i, id: int) -> void: func set_id_at(pos: Vector2i, id: int) -> void:
var index := Chunk.array_index(pos) var index := Chunk.array_index(pos)
if data[index] == id: return if data[index] != id:
# TODO: Keep track of how many non-air blocks are present, to allow for cleaning empty chunks.
data[index] = id
chunk.dirty = true
# TODO: Keep track of how many non-air blocks are present, to allow for cleaning empty chunks.
data[index] = id
chunk.dirty = true
if multiplayer.is_server():
# Send change to every player tracking this chunk. # Send change to every player tracking this chunk.
for player in chunk.get_players_tracking(): if multiplayer.is_server():
if player.network.is_local: continue # skip server player for player in chunk.get_players_tracking():
set_id_at.rpc_id(player.network.peer_id, pos, id) if player.network.is_local: continue # skip server player
set_id_at.rpc_id(player.network.peer_id, pos, id)
func _ready() -> void: func _ready() -> void:
@ -156,12 +155,14 @@ class Layer extends StaticBody2D:
if child is CollisionShape2D: if child is CollisionShape2D:
child.queue_free() child.queue_free()
for pos in BlockRegion.LOCAL_CHUNK: for x in Chunk.SIZE:
var shape := get_at(pos) for y in Chunk.SIZE:
if shape.shape == null: continue var pos := Vector2i(x, y)
var shape := get_at(pos)
var shape2d := CollisionShape2D.new() if shape.shape == null: continue
shape2d.name = "Block %s" % pos
shape2d.position = (Vector2(pos) + (Vector2.ONE / 2)) * Block.SIZE - CHUNK_HALF_SIZE var shape2d := CollisionShape2D.new()
shape2d.shape = shape.shape shape2d.name = "Block %s" % pos
add_child(shape2d) shape2d.position = (Vector2(pos) + (Vector2.ONE / 2)) * Block.SIZE - CHUNK_HALF_SIZE
shape2d.shape = shape.shape
add_child(shape2d)

Write Preview
Loading…
Cancel
Save