seeding-planets/entities/player/inventory/scripts/items/seed.gd

extends Item
class_name Seed

const MUTATION_PROBABILITY = 0.3

const SHOVEL_ICON = preload("res://common/icons/shovel.svg")
const GROWING_ICON = preload("res://common/icons/chevrons-up.svg")
const SCORE_ICON = preload("res://common/icons/growth.svg")

@export var plant_name : String
@export var plant_archetype: PlantArchetype
@export var plant_mutations: Array[PlantMutation]
@export var random_seed : int

func _init(
    _plant_name : String = "",
    _plant_archetype : PlantArchetype = PlantArchetype.get_random(),
    _plant_mutations : Array[PlantMutation] = [],
):
    plant_name = _plant_name
    plant_archetype = _plant_archetype
    plant_mutations = _plant_mutations
    random_seed = randi()

static func generate_from_parent(plant_data : PlantData) -> Seed:
    if randf() > MUTATION_PROBABILITY:
        return Seed.new(
            plant_data.plant_name,
            plant_data.archetype,
            mutate_mutations(plant_data)
        )
    else :
        return Seed.new(
            plant_data.plant_name,
            plant_data.archetype,
            plant_data.mutations.duplicate_deep()
        )

static func generate_random() -> Seed:
    var new_seed = Seed.new(
        Random.generate_random_word(),
        PlantArchetype.get_random(),
        []
    )
    if randf() > MUTATION_PROBABILITY:
        new_seed.plant_mutations.append(
            new_seed.plant_archetype.available_mutations.pick_random().duplicate_deep()
        )

    return new_seed
func get_item_name() -> String:
    return tr("%s_SEED") % plant_name

func get_description() -> String:
    return tr("PLANT_%s_MUST_BE_USED_IN_DECONTAMINATED_ZONE") % plant_name

func get_icon() -> Texture2D:
    return plant_archetype.texture_builder.build_seed_texture(random_seed)

func get_energy_used() -> int:
    return 1

func get_usage_zone_radius() -> int:
    return 35

func get_usage_object_affected(i : InspectableEntity) -> bool:
    return i is Plant

func use_text() -> String:
    return tr("PLANT_%s") % plant_name

func is_one_time_use():
    return true

func can_use(player : Player, zone : Player.ActionZone) -> bool:
    if (
        player.region == null 
    ):
        return false

    var is_there_a_plant_here = false
    for area in zone.get_affected_areas():
        if area is Plant:
            is_there_a_plant_here = true
    
    var is_there_contamination_in_zone = false
    for tile in zone.get_tiles():
        if not player.region.decontamination_layer.is_decontamined(tile):
            is_there_contamination_in_zone = true

    return not is_there_a_plant_here and not is_there_contamination_in_zone

func use(player : Player, zone : Player.ActionZone) -> bool:
    if player.region == null:
        return false

    AudioManager.play_sfx("Dig")
    return player.region.plant(self,zone.get_global_position())

func card_info() -> CardInfo:
    var info = CardInfo.new(
        get_item_name()
    )
    info.texture = icon
    info.type_icon = TYPE_ICON

    info.stats.append(
        CardStatInfo.new(
            str(energy_usage),
            ENERGY_ICON
        )
    )

    var effect_section = CardSectionInfo.new(
        tr("EFFECT"),
        get_description()
    )
    effect_section.title_icon = ACTION_ICON

    if energy_usage > 0:
        effect_section.title_icon = ENERGY_ICON
    
    info.sections.append(effect_section)

    if len(plant_mutations) != 0:
        for m in plant_mutations:
            info.sections.append(m.card_section())
    
    return info

func get_particles() -> Array[Particles.Parameters]:
    var param : Array[Particles.Parameters] = []

    for m in plant_mutations:
        param.append(
            Particles.Parameters.new(
                m.get_icon(),
                PlantMutation.get_rarity_color(m.get_rarity())
            )
        )

    return param

static func mutate_mutations(parent : PlantData) -> Array[PlantMutation]:

    var mutation_possibility : Array[MutationPossibility] = [
        AddMutation.new()
    ]

    if (
        len(parent.mutations) >= GameInfo.game_data.max_mutations_by_plant
    ):
        mutation_possibility = [
            UpgradeMutation.new(),
            RemoveMutation.new(),
        ]
    elif len(parent.mutations) > 0:
        mutation_possibility = [
            AddMutation.new(),
            UpgradeMutation.new(),
            RemoveMutation.new(),
        ]
    
    var chosen_mutation_possibility = mutation_possibility.pick_random()

    return chosen_mutation_possibility.mutate(parent)

class MutationPossibility:
    func mutate(_parent : PlantData)-> Array[PlantMutation]:
        return []

class AddMutation extends MutationPossibility:
    func mutate(parent : PlantData)-> Array[PlantMutation]:
        var new_mutations = parent.mutations.duplicate_deep()
        var possible_new_mutations = parent.archetype.available_mutations.duplicate_deep()

        possible_new_mutations = possible_new_mutations.filter(
            func (m : PlantMutation):
                return parent.mutations.find_custom(func(m2: PlantMutation): return m2.name == m.name) == -1
        )
        
        if len(possible_new_mutations):
            new_mutations.append(possible_new_mutations.pick_random()) 

        return new_mutations

class UpgradeMutation extends MutationPossibility:
    func mutate(
        parent : PlantData
    ) -> Array[PlantMutation]:
        var new_mutations = parent.mutations.duplicate_deep()

        new_mutations.pick_random().level += 1

        return new_mutations

class RemoveMutation extends MutationPossibility:
    func mutate(parent : PlantData)-> Array[PlantMutation]:
        var new_mutations = parent.mutations.duplicate_deep()

        var mut_to_remove = new_mutations.pick_random()
        if mut_to_remove.level > 1:
            mut_to_remove.level -= 1
        else:
            new_mutations.remove_at(new_mutations.find(mut_to_remove))

        return new_mutations