205 lines
9.0 KiB
GDScript
205 lines
9.0 KiB
GDScript
extends Node
|
|
|
|
const IMAGE_WIDTH := 2048
|
|
const IMAGE_HEIGHT := 2048
|
|
|
|
const SEED_TEXTURE_SIZE = 150
|
|
|
|
const COLOR_PALETTE: Array[Color] = [
|
|
Color("#78AEBA"),
|
|
Color("#A7B35B"),
|
|
Color("#DB6B75"),
|
|
Color("#EC8E49"),
|
|
Color("#F9FFCE"),
|
|
]
|
|
|
|
const PLACEHOLDER_MATURE_TEXTURE: Texture = preload("res://entities/plants/assets/sprites/default/mature.png")
|
|
const PLACEHOLDER_GROWING_TEXTURE: Texture = preload("res://entities/plants/assets/sprites/default/growing.png")
|
|
|
|
enum OriginType {BRANCH_ORIGIN, MUTATION_ORIGIN, BASE_LEAF_ORIGIN}
|
|
|
|
# @export var parts_archetype_associations: Dictionary[PlantArchetype, PartArchetypeAssociation] TODO:: have the archetypes
|
|
@export var bases: Array[PlantPart]
|
|
@export var baby_bases: Array[PlantPart]
|
|
@export var branches: Array[PlantPart]
|
|
@export var n_branches: int = 2
|
|
@export var base_leaves: Array[PlantPart]
|
|
@export var parts_mutation_associations: Dictionary[String, PartMutationAssociation] # Array[PlantPart]
|
|
|
|
@export var chance_to_have_part := 0.75;
|
|
|
|
@export var origin_weights_base: Dictionary[OriginType, int] = {OriginType.BRANCH_ORIGIN: 10, OriginType.MUTATION_ORIGIN: 10, OriginType.BASE_LEAF_ORIGIN: 10}
|
|
@export var origin_weight_loss := 3
|
|
@export var origin_weight_gain := 1
|
|
|
|
@export var mutation_weight_base := 10
|
|
@export var mutation_weight_loss := 3
|
|
@export var mutation_weight_gain := 1
|
|
@export var seed_texture_sets: Array[SeedTextureSet]
|
|
|
|
var rng := RandomNumberGenerator.new()
|
|
var image: Image = Image.create_empty(IMAGE_WIDTH, IMAGE_HEIGHT, false, Image.FORMAT_RGBA8)
|
|
var image_center: Vector2i = Vector2(0.5, 1) * Vector2(image.get_size())
|
|
|
|
func random_ind(array: Array) -> int:
|
|
return rng.randi_range(0, array.size() - 1)
|
|
|
|
func pick_random(array: Array) -> Variant:
|
|
return array[random_ind(array)]
|
|
|
|
func shuffle(array: Array):
|
|
var available_ind := 0
|
|
for i in range(array.size()):
|
|
var temp = array[available_ind]
|
|
var picked_ind := rng.randi_range(available_ind, array.size() - 1)
|
|
array[available_ind] = array[picked_ind]
|
|
array[picked_ind] = temp
|
|
|
|
func shuffle_weighted(array: Array, weights: Array[int]):
|
|
assert(array.size() == weights.size(), "Suffle with weights not same size")
|
|
|
|
var indices := range(array.size())
|
|
var random_values: Array[int] = []
|
|
for i in range(array.size()):
|
|
random_values.append(rng.randi_range(0, weights[i]))
|
|
|
|
indices.sort_custom(func(a, b): return random_values[a] > random_values[b])
|
|
|
|
var originalArray := array.duplicate()
|
|
var originalWeights := weights.duplicate()
|
|
|
|
for i in range(array.size()):
|
|
array[i] = originalArray[indices[i]]
|
|
weights[i] = originalWeights[indices[i]]
|
|
|
|
func build_seed_texture(random_seed: int) -> Texture:
|
|
rng.seed = random_seed
|
|
|
|
var texture_set: SeedTextureSet = pick_random(seed_texture_sets)
|
|
var seed_image := Image.create(SEED_TEXTURE_SIZE, SEED_TEXTURE_SIZE, false, Image.FORMAT_RGBA8)
|
|
|
|
for color_image in texture_set.color_images:
|
|
color_image.resize(SEED_TEXTURE_SIZE, SEED_TEXTURE_SIZE)
|
|
modulate_image(color_image, pick_random(COLOR_PALETTE))
|
|
seed_image.blend_rect(color_image, Rect2i(0, 0, SEED_TEXTURE_SIZE, SEED_TEXTURE_SIZE), Vector2i.ZERO)
|
|
|
|
if texture_set.outline_image:
|
|
var outline_image = texture_set.outline_image
|
|
outline_image.resize(SEED_TEXTURE_SIZE, SEED_TEXTURE_SIZE)
|
|
seed_image.blend_rect(outline_image, Rect2i(0, 0, SEED_TEXTURE_SIZE, SEED_TEXTURE_SIZE), Vector2i.ZERO)
|
|
|
|
if rng.randi() % 2 == 0:
|
|
seed_image.flip_x()
|
|
|
|
return ImageTexture.create_from_image(image)
|
|
|
|
func build_plant_texture(plant_data: PlantData) -> Texture:
|
|
rng.seed = plant_data.random_seed
|
|
|
|
var texture: Texture
|
|
var base_part: PlantPart
|
|
|
|
match plant_data.get_state():
|
|
PlantData.State.MATURE:
|
|
texture = PLACEHOLDER_MATURE_TEXTURE
|
|
base_part = pick_random(bases)
|
|
PlantData.State.GROWING:
|
|
texture = PLACEHOLDER_GROWING_TEXTURE
|
|
base_part = pick_random(baby_bases)
|
|
_:
|
|
print("Not handled state")
|
|
return null
|
|
|
|
var weight_per_origin_type: Array[int] = origin_weights_base.values().duplicate()
|
|
|
|
var parts_to_place: Dictionary[OriginType, Array] # BRANCH_ORIGIN : Array[PlantPart], MUTATION_ORIGIN : Array[Array[PlantPart]], BASE_LEAF_ORIGIN : Array[PlantPart]
|
|
parts_to_place[OriginType.BRANCH_ORIGIN] = branches
|
|
parts_to_place[OriginType.MUTATION_ORIGIN] = []
|
|
parts_to_place[OriginType.BASE_LEAF_ORIGIN] = base_leaves
|
|
var mutation_weights: Array[int] = []
|
|
for mutation in plant_data.mutations:
|
|
parts_to_place[OriginType.MUTATION_ORIGIN].append(parts_mutation_associations[mutation.id].parts)
|
|
mutation_weights.append(mutation_weight_base)
|
|
|
|
var base_image_coord = blend_part(image_center, -base_part.root.position, base_part)
|
|
populate_part(parts_to_place, weight_per_origin_type, mutation_weights, base_part, base_image_coord)
|
|
|
|
texture = ImageTexture.create_from_image(image)
|
|
image.fill(Color.TRANSPARENT)
|
|
return texture
|
|
|
|
## returns -1 if not found
|
|
func find_random_matching_attach_ind(attach_to_match: PlantAttach, array: Array[PlantPart]) -> int:
|
|
var indices := range(array.size())
|
|
shuffle(indices)
|
|
for i in indices:
|
|
if array[i].root.attach_types.any(func(type): return attach_to_match.attach_types.has(type)):
|
|
return i
|
|
return -1
|
|
|
|
func populate_part(all_parts: Dictionary[OriginType, Array], weight_per_origin_type: Array[int], mutation_weights: Array[int], parent_part: PlantPart, parent_image_coord: Vector2i):
|
|
var part_placed: Array[PlantPart] # same ind as their corresponding attach
|
|
var part_image_coords: Array[Vector2i] # idem
|
|
|
|
# first find and blend parts per attach
|
|
for attach in parent_part.attaches:
|
|
# get part to place
|
|
var part_to_place := get_part(all_parts, weight_per_origin_type, mutation_weights, attach)
|
|
part_placed.append(part_to_place)
|
|
|
|
# blend part
|
|
if part_to_place:
|
|
var part_image_coord := blend_part(parent_image_coord, attach.position, part_to_place)
|
|
part_image_coords.append(part_image_coord)
|
|
else:
|
|
part_image_coords.append(Vector2i.ZERO)
|
|
|
|
# then populate them
|
|
for i in range(part_placed.size()):
|
|
if part_placed[i] != null:
|
|
populate_part(all_parts, weight_per_origin_type, mutation_weights, part_placed[i], part_image_coords[i])
|
|
|
|
|
|
func get_part(all_parts: Dictionary[OriginType, Array], weight_per_origin_type: Array[int], mutation_weights: Array[int], attach: PlantAttach) -> PlantPart:
|
|
var rand := rng.randf()
|
|
if rand <= chance_to_have_part:
|
|
var origins: Array[int] = all_parts.keys().duplicate()
|
|
var weight_copy: Array[int] = weight_per_origin_type.duplicate()
|
|
shuffle_weighted(origins, weight_copy)
|
|
for originIndInd: int in range(origins.size()):
|
|
var originInd: int = origins[originIndInd]
|
|
var origin := originInd as OriginType
|
|
if origin == OriginType.BRANCH_ORIGIN || origin == OriginType.BASE_LEAF_ORIGIN:
|
|
var ind := find_random_matching_attach_ind(attach, all_parts[origin])
|
|
if ind >= 0:
|
|
weight_per_origin_type[origin] -= origin_weight_loss
|
|
weight_per_origin_type[((origin + 1) % 3) as OriginType] += origin_weight_gain
|
|
weight_per_origin_type[((origin + 2) % 3) as OriginType] += origin_weight_gain
|
|
return all_parts[origin][ind]
|
|
else: # find a mutation part to place
|
|
var parts_per_mutations: Array = all_parts[origin]
|
|
shuffle_weighted(parts_per_mutations, mutation_weights)
|
|
for mutation_parts_ind in range(parts_per_mutations.size()):
|
|
var ind := find_random_matching_attach_ind(attach, parts_per_mutations[mutation_parts_ind])
|
|
if ind >= 0:
|
|
for i in range(mutation_weights.size()):
|
|
mutation_weights[i] += mutation_weight_gain
|
|
mutation_weights[mutation_parts_ind] -= mutation_weight_gain + mutation_weight_loss
|
|
weight_per_origin_type[origin] -= origin_weight_loss
|
|
weight_per_origin_type[(origin + 1) % 3] += origin_weight_gain
|
|
weight_per_origin_type[(origin + 2) % 3] += origin_weight_gain
|
|
return parts_per_mutations[mutation_parts_ind][ind]
|
|
return null
|
|
|
|
func blend_part(parent_image_coord: Vector2i, attach_position: Vector2, part_to_blend: PlantPart) -> Vector2i:
|
|
var part_image: Image = part_to_blend.image
|
|
var part_image_center: Vector2i = 0.5 * part_image.get_size()
|
|
var part_image_coord: Vector2i = parent_image_coord + Vector2i(attach_position - part_to_blend.root.position)
|
|
image.blend_rect(part_image, Rect2i(Vector2i.ZERO, part_to_blend.image.get_size()), part_image_coord - part_image_center)
|
|
return part_image_coord
|
|
|
|
func modulate_image(i: Image, color: Color):
|
|
for x in i.get_size().x:
|
|
for y in i.get_size().y:
|
|
i.set_pixel(x, y, i.get_pixel(x, y) * color)
|