miércoles, 2 de abril de 2025

IA genera videojuego html

 ¡Claro! Aquí te dejo un ejemplo básico de un videojuego en HTML, CSS y JavaScript. Se trata de un juego de "Pong" clásico.


*index.html*

```

<!DOCTYPE html>

<html lang="es">

<head>

    <meta charset="UTF-8">

    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <title>Pong</title>

    <link rel="stylesheet" href="styles.css">

</head>

<body>

    <canvas id="canvas" width="600" height="400"></canvas>

    <script src="script.js"></script>

</body>

</html>

```


*styles.css*

```

body {

    background-color: #f0f0f0;

}


#canvas {

    border: 1px solid #000;

}

```


*script.js*

```

// Obtener el canvas

const canvas = document.getElementById('canvas');

const ctx = canvas.getContext('2d');


// Definir constantes

const WIDTH = canvas.width;

const HEIGHT = canvas.height;

const BALL_SIZE = 20;

const PADDLE_WIDTH = 10;

const PADDLE_HEIGHT = 100;

const FPS = 60;


// Definir variables

let ballX = WIDTH / 2;

let ballY = HEIGHT / 2;

let ballVelX = 5;

let ballVelY = 5;

let paddle1Y = HEIGHT / 2 - PADDLE_HEIGHT / 2;

let paddle2Y = HEIGHT / 2 - PADDLE_HEIGHT / 2;

let score1 = 0;

let score2 = 0;


// Función para dibujar el canvas

function draw() {

    ctx.clearRect(0, 0, WIDTH, HEIGHT);

    ctx.fillStyle = '#000';

    ctx.fillRect(0, paddle1Y, PADDLE_WIDTH, PADDLE_HEIGHT);

    ctx.fillRect(WIDTH - PADDLE_WIDTH, paddle2Y, PADDLE_WIDTH, PADDLE_HEIGHT);

    ctx.beginPath();

    ctx.arc(ballX, ballY, BALL_SIZE / 2, 0, 2 * Math.PI);

    ctx.fill();

    ctx.font = '36px Arial';

    ctx.textAlign = 'left';

    ctx.textBaseline = 'top';

    ctx.fillStyle = '#000';

    ctx.fillText(score1, 10, 10);

    ctx.textAlign = 'right';

    ctx.fillText(score2, WIDTH - 10, 10);

}


// Función para actualizar el juego

function update() {

    ballX += ballVelX;

    ballY += ballVelY;

    if (ballY < 0 || ballY > HEIGHT - BALL_SIZE) {

        ballVelY = -ballVelY;

    }

    if (ballX < 0) {

        score2++;

        ballX = WIDTH / 2;

        ballY = HEIGHT / 2;

        ballVelX = -ballVelX;

    }

    if (ballX > WIDTH - BALL_SIZE) {

        score1++;

        ballX = WIDTH / 2;

        ballY = HEIGHT / 2;

        ballVelX = -ballVelX;

    }

    if (ballX < PADDLE_WIDTH && ballY > paddle1Y && ballY < paddle1Y + PADDLE_HEIGHT) {

        ballVelX = -ballVelX;

    }

    if (ballX > WIDTH - PADDLE_WIDTH - BALL_SIZE && ballY > paddle2Y && ballY < paddle2Y + PADDLE_HEIGHT) {

        ballVelX = -ballVelX;

    }

}


// Función para manejar los eventos del teclado

function handleKeyDown(event) {

    if (event.key === 'w') {

        paddle1Y -= 10;

    }

    if (event.key === 's') {

        paddle1Y += 10;

    }

    if (event.key === 'ArrowUp') {

        paddle2Y -= 10;

    }

    if (event.key === 'ArrowDown') {

        paddle2Y += 10;

    }

}


// Agregar eventos

document.addEventListener('keydown', handleKeyDown);


// Función principal

function main() {

    update();

    draw();

    setTimeout(main, 1000 / FPS);

}


// Iniciar el juego

main();

```


Puedes abrir el archivo `index.html` en un navegador web para jugar. Utiliza las teclas "W" y "S" para controlar la paleta izquierda, y las flechas "Arriba" y "Abajo" para controlar la paleta derecha.

lunes, 31 de marzo de 2025

Subir y bajar una puerta con Godot 4.4; perfecto; en GDScript;

 extends Area3D


@export var velocidad_subida: float = 3.3

@export var velocidad_bajada: float = 3.3  # Cambié el nombre para mayor claridad

@export var altura_maxima: float = 5.0  # Altura máxima que subirá el objeto

@export var altura_inicial: float = 0.0 # Altura inicial del objeto


var objeto: Node3D  # Variable para almacenar el nodo CSGBox3D7

var subiendo: bool = false

var bajando: bool = false

var altura_actual: float = 0.0


func _ready():

    objeto = $CSGBox3D7  # Asignamos el nodo a la variable

    altura_actual = objeto.position.y # Obtiene la altura inicial del objeto

    altura_inicial = altura_actual # guarda la altura inicial


func _physics_process(delta):

    if objeto:  # Verifica si el objeto existe

        if subiendo:

            altura_actual += velocidad_subida * delta

            altura_actual = min(altura_actual, altura_inicial + altura_maxima) # Limita la altura máxima

            objeto.position.y = altura_actual

            if altura_actual >= altura_inicial + altura_maxima:

                subiendo = false  # Detiene la subida al alcanzar la altura máxima

        elif bajando:

            altura_actual -= velocidad_bajada * delta

            altura_actual = max(altura_actual, altura_inicial)  # Limita la altura mínima

            objeto.position.y = altura_actual

            if altura_actual <= altura_inicial:

                bajando = false  # Detiene la bajada al alcanzar la altura inicial


func _on_area_entered(area: Area3D) -> void:

    subiendo = true

    bajando = false


func _on_area_exited(area: Area3D) -> void:

    subiendo = false

    bajando = true

domingo, 30 de marzo de 2025

puerta en Godot 4.4 abrirla;

 extends Area3D


@export var velocidad_subida: float = 1.3


var subiendo: bool = false


func _physics_process(delta):

if subiendo:

if $CSGBox3D7: # verifica si el nodo existe

$CSGBox3D7.translate(Vector3(0, velocidad_subida, 0) * delta)


func _on_area_entered(area: Area3D) -> void:

subiendo = true


func _on_area_exited(area: Area3D) -> void:

subiendo = false


GDScript giro sobre si mismo en eje "y" alterna de izquierda a derecha y de derecha a izquierda; tambien en eje "Z" ;Godot4.4;

 extends MeshInstance3D


@export var rotation_speed_y: float = 0.03

@export var rotation_speed_z: float = 0.02 # Velocidad para el eje Z (ajusta según necesites)

@export var direction_change_interval: float = 3.0


var rotation_direction_y: int = 1

var rotation_direction_z: int = 1

var time_since_direction_change: float = 0.0


func _ready() -> void:

    pass


func _process(delta: float) -> void:

    rotate_y(rotation_speed_y * rotation_direction_y)

    rotate_z(rotation_speed_z * rotation_direction_z)


    time_since_direction_change += delta


    if time_since_direction_change >= direction_change_interval:

        rotation_direction_y *= -1

        rotation_direction_z *= -1

        time_since_direction_change = 0.0

GDScript giro sobre si mismo en eje "y" alterna de izquierda a derecha y de derecha a izquierda; Godot4.4;

 extends MeshInstance3D


@export var rotation_speed: float = 0.03

@export var direction_change_interval: float = 3.0 # Intervalo de cambio de dirección en segundos


var rotation_direction: int = 1

var time_since_direction_change: float = 0.0


func _ready() -> void:

pass


func _process(delta: float) -> void:

rotate_y(rotation_speed * rotation_direction)


time_since_direction_change += delta


if time_since_direction_change >= direction_change_interval:

rotation_direction *= -1

time_since_direction_change = 0.0


GDScript baja puntuacion y escala a reduccion Sprite2D y mesh_instance_3d; hace efectos de barra de vida; funciona;Godot4.4;

 extends Area3D


var score = 10

@onready var mesh_instance_3d = $"../../CharacterBody3D/CollisionShape3D/PROTAGONISTA EXPLORADORA VARIOS MOVIMIENTOS ANDAR CORRER GRITAR_/MeshInstance3D2 PRUEBAS DE CORAZON"

@onready var sprite_rojo = $"Sprite2D rojo"

@onready var label_resta = $"Label resta"


func _ready():

actualizar_visualizacion()


func _on_area_entered(area: Area3D) -> void:

if area.is_ancestor_of(self): #evita que se active el trigger con el mismo objeto que contiene el script

return

#$AudioStreamPlayer3D.play() #si lo quieres activar descomentalo

score -= 1

actualizar_visualizacion()


if score < 0:

get_tree().change_scene_to_file("res://ESCENAS/1-world_environmentESCENA-1-.tscn")


func actualizar_visualizacion():

label_resta.text = str(score)

var escala = float(score) / 10.0

sprite_rojo.scale = Vector2(escala, escala)

mesh_instance_3d.scale = Vector3(escala, escala, escala) #se corrige para que trabaje en 3D

if score <= 0:

sprite_rojo.visible = false

mesh_instance_3d.visible = false


func _on_timer_timeout() -> void:

pass


GDScript efectos de tembleque y de bombeo de un corazon 3d MeshInstance3D;Godot4.4;

 extends MeshInstance3D


@export var shake_amount: float = 5.0

@export var shake_speed: float = 5.4


var original_position: Vector3


func _ready():

original_position = position


func _process(delta):

var random_offset = Vector3(

randf_range(-shake_amount, shake_amount),

randf_range(-shake_amount, shake_amount),

randf_range(-shake_amount, shake_amount)  # Añadido componente Z

)

position = original_position + random_offset


-------------------------------------------------------------------------------------------------------------------------

----------------------------------------------- este de debajo bombea--------------------------------------------


extends MeshInstance3D


@export var pulse_amount: float = 0.5 # Cantidad de expansión/contracción

@export var pulse_speed: float = 2.0  # Velocidad del latido


var original_scale: Vector3

var time: float = 0.0


func _ready():

original_scale = scale


func _process(delta):

time += delta * pulse_speed

var pulse = sin(time) * pulse_amount

scale = original_scale + Vector3(pulse, pulse, pulse) # Expande/contrae uniformemente


# O, si quieres que el latido sea solo en un eje (por ejemplo, el Y):

# scale = original_scale + Vector3(0, pulse, 0)


sábado, 29 de marzo de 2025

extends Sprite2D un GDScript que hace un temblor al Sprite2D, efecto bueno para imitar el miedo de un corazon;Godot4.4;

 extends Sprite2D


@export var shake_amount: float = 5.0

@export var shake_speed: float = 10.0


var original_position: Vector2


func _ready():

    original_position = position


func _process(delta):

    var random_offset = Vector2(randf_range(-shake_amount, shake_amount), randf_range(-shake_amount, shake_amount))

    position = original_position + random_offset

--------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------

Explicacion: este GDScript se combina de maravilla con este enlace, en el que construyo un corazon que se va disipando, como barra de vida....Desarrollo y creacion de videojuegos.Godot,Unity,Blender,Gimp,Game Maker,: Barra de vida en Godot 4.4 en 3d; estudio GDScript;

viernes, 28 de marzo de 2025

Barra de vida en Godot 4.4 en 3d; estudio GDScript;

 extends Area3D


var score = 10


@onready var sprite = $Sprite2D  # Cambiado a Sprite2D

@onready var label_resta = $"Label resta"


func _ready():

actualizar_visualizacion()


func _on_area_entered(area: Area3D) -> void:

#$AudioStreamPlayer3D.play()

score -= 1

actualizar_visualizacion()


if score < 0:

get_tree().change_scene_to_file("res://ESCENAS/1-world_environmentESCENA-1-.tscn")


func actualizar_visualizacion():

label_resta.text = str(score)

var escala = float(score) / 10.0  # Escala basada en la puntuación (0 a 1)

sprite.scale = Vector2(escala, escala)  # Escala uniforme en 2D (Sprite2D)

if score <= 0:

sprite.visible = false  # O puedes usar queue_free() para eliminar el nodo


func _on_timer_timeout() -> void:

pass


-------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------

 Explicación; Se me ocurrió crear un tipo de barra de vida para Godot 4.4. en 3d asociando un grafico al contador de puntos, cuando un personaje choca con una columna se le baja la puntuación 1 punto, a la vez esta coordinado con un grafico, e pensado en un corazón que se va des escalando de forma coordinada ala puntuación que va perdiendo el personaje.........entonces el corazón se va empequeñeciendo dando sensación de perdida de vida........Esto lo hice con ayuda de la IA, yo de programar no tengo ni idea¡¡¡

Conseguí también un cambio de escena al morir el personaje….


sábado, 22 de marzo de 2025

GDScript en Godot 4.4 extends AudioStreamPlayer3D alterna el sonido y lo disminuye y aumenta aleatoriamente;

 extends AudioStreamPlayer3D


@export var min_interval: float = 2.5

@export var max_interval: float = 3.5

@export var fade_out_duration: float = 1.0 # Duración del fade-out en segundos.

@export var fade_in_duration: float = 0.5 # Duración del fade-in en segundos.


var timer: float = 0.0

var is_playing: bool = false

var fade_timer: float = 0.0

var initial_volume: float = 0.0


func _ready():

    timer = randf_range(min_interval, max_interval)

    initial_volume = volume_db


func _process(delta):

    timer -= delta

    fade_timer -= delta


    if timer <= 0.0:

        if is_playing:

            # Inicia el fade-out.

            fade_timer = fade_out_duration

        else:

            # Inicia el fade-in.

            fade_timer = fade_in_duration

            play()


        is_playing = !is_playing

        timer = randf_range(min_interval, max_interval)


    # Efecto de fade-out/fade-in.

    if fade_timer > 0.0:

        if is_playing:

            # Fade-in.

            volume_db = lerp(-80.0, initial_volume, 1.0 - (fade_timer / fade_in_duration))

        else:

            # Fade-out.

            volume_db = lerp(initial_volume, -80.0, 1.0 - (fade_timer / fade_out_duration))

    elif is_playing:

        volume_db = initial_volume #aseguramos que el volumen este al original cuando termina el fade in.

GDScript en Godot 4.4 AudioStreamPlayer3D reproduzca y pause el sonido aleatoriamente cada 8 segundos;

 extends AudioStreamPlayer3D


@export var min_interval: float = 8 # Intervalo mínimo en segundos.

@export var max_interval: float = 8 # Intervalo máximo en segundos.


var timer: float = 0.0

var is_playing: bool = false


func _ready():

# Inicia el temporizador con un intervalo aleatorio.

timer = randf_range(min_interval, max_interval)


func _process(delta):

timer -= delta


if timer <= 0.0:

# Alterna el estado de reproducción.

if is_playing:

stop()

else:

play()


is_playing = !is_playing


# Reinicia el temporizador con un nuevo intervalo aleatorio.

timer = randf_range(min_interval, max_interval)

extends Label GDScript en Godot 4.4 para escalar un texto aleatoriamente y variar su color;

 extends Label


@export var min_scale: float = 1.0

@export var max_scale: float = 1.2

@export var speed: float = 0.4

@export var min_color: Color = Color(1.0, 0.0, 0.0) # Rojo

@export var max_color: Color = Color(1.0, 1.0, 1.0) # Blanco


var scale_direction: int = 1

var current_scale: float = 1.0


func _process(delta):

current_scale += scale_direction * speed * delta


if current_scale > max_scale:

current_scale = max_scale

scale_direction = -1

elif current_scale < min_scale:

current_scale = min_scale

scale_direction = 1


scale = Vector2(current_scale, current_scale)


# Interpolación del color

var color_ratio = (current_scale - min_scale) / (max_scale - min_scale)

modulate = min_color.lerp(max_color, color_ratio)

extends Label GDScript en Godot 4.4 para aumentar y disminuir el tamaño del texto de forma aleatoria;

 extends Label


@export var min_scale: float = 1.0  # Escala mínima del Label

@export var max_scale: float = 1.2  # Escala máxima del Label

@export var speed: float = 0.3  # Velocidad de la animación


var scale_direction: int = 1  # 1 para aumentar, -1 para disminuir

var current_scale: float = 1.0


func _process(delta):

# Actualiza la escala actual

current_scale += scale_direction * speed * delta


# Invierte la dirección si alcanza los límites

if current_scale > max_scale:

current_scale = max_scale

scale_direction = -1

elif current_scale < min_scale:

current_scale = min_scale

scale_direction = 1


# Aplica la escala al Label

scale = Vector2(current_scale, current_scale)

sábado, 15 de marzo de 2025

GDScript para Godot 4.4 imita efecto de parpadeo de luz de una antorcha;

 extends OmniLight3D


@export var intensidad_base: float = 1.0  # Intensidad base de la luz

@export var rango_variacion: float = 0.5  # Rango de variación de la intensidad

@export var velocidad_parpadeo: float = 5.0  # Velocidad de parpadeo


func _process(delta):

# Genera un valor aleatorio dentro del rango de variación

var variacion = randf_range(-rango_variacion, rango_variacion)


# Calcula la nueva intensidad de la luz

var nueva_intensidad = intensidad_base + variacion


# Aplica la nueva intensidad a la luz

light_energy = nueva_intensidad


# Modifica el rango de la luz para simular el parpadeo

var variacion_rango = randf_range(-0.2, 0.2)

omni_range = 9 + variacion_rango # Puedes ajustar el rango base (5)

martes, 11 de marzo de 2025

a10 y a30 ;

 

lunes, 10 de marzo de 2025

Sobre usar musica sin derechos de autor para desarrollos de videojuegos; "CCO";

👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇👇

 Es muy complicado hacer musica si ser musico, algo se puede hacer si a base de ritmos y combinaciones, pero es mas facil asesorarse sobre archivos musicales libres de derechos de autor, asi que consulte a la IA y me resumio sobre "CCO".


En resumen:

  • Si ves "CC0", puedes usar la música sin preocupaciones.
  • No necesitas pedir permiso ni dar atribución.
  • Disfruta de la libertad de usar la música en tus videojuegos y otros proyectos.

Por lo cual, si ves claramente "CCO" junto al archivo, puedes usarlo sin ningun problema.


Es bueno tenerlo en cuenta, es muy facil meter la pata, asi que ya sabeis......"CCO" es una buena opcion.

☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝☝

domingo, 9 de marzo de 2025

Con Godot 4.4. GDScript que sencillo un giro fluido en eje "y";

 extends MeshInstance3D


func _process(delta: float) -> void:

rotate_y(0.0007)

pass

Como se hacen enemigos persiguiendo a player en Godot 4.4;

 GDScript Godot 4.4 se pone al enemigo:

------------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------------------

extends CharacterBody3D


const SPEED = 7.0

const ACCELERATION = 5.5 # Ajusta este valor para la velocidad de respuesta deseada

@onready var navAgent = $NavigationAgent3D

@onready var target = $"../Player"


func _physics_process(delta: float) -> void:

# Añadir gravedad.

if not is_on_floor():

velocity += get_gravity() * delta


if target: # Verifica si el objetivo existe

_update_target_position() # Actualiza la posición del objetivo primero


var currentLocation = global_transform.origin

var nextLocation = navAgent.get_next_path_position()

var nextVelocity = (nextLocation - currentLocation).normalized() * SPEED


velocity = velocity.move_toward(nextVelocity, ACCELERATION * delta) # Usa delta para suavizar la aceleración

move_and_slide()

else:

print("El objetivo (jugador) no existe.")


func _update_target_position():

if target:

navAgent.target_position = target.global_transform.origin

else:

print("El objetivo (jugador) no existe. No se puede actualizar la posición del NavigationAgent.")

-------------------------------------------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------------------------------------------

Un complemento sobre restar puntos vidas al player; cuando le toca el enemigo resta 1 punto en cada choque entrada en su area3d, y al llegar a 0 puntos sale escena de Game over, escribo Game Hover, tengo problemas de ortografia, pero los GDScript son perfectos, cualquier duda o aclaracion hoy en dia es sencillisima de resolver , solo teneis que copiar los GDScript y pegarlos en la IA de vuestro navegador  o IA que utiliceis, y corregira cualquier minimo fallo , Hoy en dia aunque no sepas programar la IA te lo acaba de resolver todo y ayuda a aprender.

----------------------------------------------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------------------------------------------

extends Area3D


var score = 10


func _ready():

pass


func _on_area_entered(area: Area3D) -> void:

$LabelRESTA.text = str(score)

score -= 1


if score < 0:

get_tree().change_scene_to_file("res://ESCENA DE PERDER/PIERDES.tscn")



func _on_timer_timeout() -> void:

pass # Replace with function body.

-------------------------------------------------------------------------------------------------------------------------

-------------------------------------------------------------------------------------------------------------------------

Aqui GDScript para sumar puntos cuando enemigo pasa por los aros aros de un color premio de ese color aros de otro color premio de otro color, al sumar una determinada cantidad de puntos.......

------------------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------------

extends Area3D


var score = 1


func _ready():

pass


func _on_area_entered(area: Area3D) -> void:

$Label.text = str(score)

score += 1


if score > 10:

get_tree().change_scene_to_file("res://TIAS EN PELOTAS -2-/Thriller Part 3.tscn")



func _on_timer_timeout() -> void:

pass # Replace with function body.

---------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------

En unos dias el juego estara en Itch.io de ¡¡forma gratuita para su descarga.!!....desde este enlace https://perico415.itch.io/

--------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------


NavigationRegion3D detalle muy importante en Godot 4.4 3d. para que funcione el GDScript...mirar video superior



Un complemento de juego un GDScript a los 4 segundos del game over retorna al comienzo del juego.

-----------------------------------------------------------------------------------------------------------------------------

extends Node3D


var timer = Timer.new()


func _ready() -> void:

add_child(timer)

timer.one_shot = true

timer.timeout.connect(_on_timer_timeout)

timer.start(4) # Inicia el temporizador de 3 segundos


func _on_timer_timeout():

get_tree().change_scene_to_file("res://MAPnode_3d.tscn") # Cambia a la escena "MAPnode_3d.tscn"


func _process(delta: float) -> void:

pass


miércoles, 5 de marzo de 2025

GDScript para girar particulas 3d con Godot 4.4; ahora todo lo are con Godot 4.4; Adios Godot 4.3;

 extends CPUParticles3D


var rotation_speed : float = 2.0 # Velocidad de rotación en radianes por segundo


func _ready() -> void:

pass


func _process(delta: float) -> void:

rotate_y(rotation_speed * delta)


------------------------------------------------------------------------

otro ejemplo ampliando en eje "x"

---------------------------------------------------------------------------

extends CPUParticles3D


var rotation_speed : float = 2.0 # Velocidad de rotación en radianes por segundo


func _ready() -> void:

pass


func _process(delta: float) -> void:

rotate_y(rotation_speed * delta)

rotate_x(rotation_speed * delta)


martes, 4 de marzo de 2025

GDScript de sumar puntos ; al conseguir 8 puntos cambia a otra escena; esta asu vez se borra y retorna a la primera pasados unos segundos;Godot 4.3;


 extends Area3D


var score = 1


func _ready():

pass


func _on_area_entered(area: Area3D) -> void:

$Label.text = str(score)

score += 1


if score > 8:

get_tree().change_scene_to_file("res://TIAS EN PELOTAS/Hip Hop Dancing AMARILLA.tscn")



func _on_timer_timeout() -> void:

pass # Replace with function body.

--------------------------------------------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------------- Estas 2 capturas de pantalla y GDScripts se complementan en un juego------------------------------------

---------------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------------





GDScript que reproduce una animacion 3d de un nodo, durante 7 segundos; luego cambia a la escena principal;Godot 4.3;


 extends Node3D


var timer = Timer.new()


func _ready() -> void:

$AnimationPlayer.play("mixamo_com")

add_child(timer)

timer.one_shot = true

timer.timeout.connect(_on_timer_timeout)

timer.start(7) # Inicia el temporizador de 3 segundos


func _on_timer_timeout():

get_tree().change_scene_to_file("res://MAPnode_3d.tscn") # Cambia a la escena "MAPnode_3d.tscn"


func _process(delta: float) -> void:

pass

domingo, 2 de marzo de 2025

Enemigo persigue a player en godot 4.3; GDScript del enemigo y del player; y lo nodos y graficos correspondientes;


 extends CharacterBody3D


const SPEED = 5.0

const ACCELERATION = 1.0 # Ajusta este valor para la velocidad de respuesta deseada

@onready var navAgent = $NavigationAgent3D

@onready var target = $"../Player"


func _physics_process(delta: float) -> void:

# Añadir gravedad.

if not is_on_floor():

velocity += get_gravity() * delta


if target: # Verifica si el objetivo existe

_update_target_position() # Actualiza la posición del objetivo primero


var currentLocation = global_transform.origin

var nextLocation = navAgent.get_next_path_position()

var nextVelocity = (nextLocation - currentLocation).normalized() * SPEED


velocity = velocity.move_toward(nextVelocity, ACCELERATION * delta) # Usa delta para suavizar la aceleración

move_and_slide()

else:

print("El objetivo (jugador) no existe.")


func _update_target_position():

if target:

navAgent.target_position = target.global_transform.origin

else:

print("El objetivo (jugador) no existe. No se puede actualizar la posición del NavigationAgent.")

----------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------
Explicacion: el GDScript de encima es para poner al enemigo, es para Godot 4.3 en juego 3d, fijarse en la ilustracion en los nombres de los nodos y los graficos elementos del juego...... el GDScript  inferior es para mover al player.
--------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------------------------------------------------------------------------
extends CharacterBody3D


const SPEED = 5.0
const JUMP_VELOCITY = 4.5


func _physics_process(delta: float) -> void:
# Add the gravity.
if not is_on_floor():
velocity += get_gravity() * delta

# Handle jump.
if Input.is_action_just_pressed("ui_accept") and is_on_floor():
velocity.y = JUMP_VELOCITY

# Get the input direction and handle the movement/deceleration.
# As good practice, you should replace UI actions with custom gameplay actions.
var input_dir := Input.get_vector("ui_left", "ui_right", "ui_up", "ui_down")
var direction := (transform.basis * Vector3(input_dir.x, 0, input_dir.y)).normalized()
if direction:
velocity.x = direction.x * SPEED
velocity.z = direction.z * SPEED
else:
velocity.x = move_toward(velocity.x, 0, SPEED)
velocity.z = move_toward(velocity.z, 0, SPEED)

move_and_slide()







domingo, 23 de febrero de 2025

Sumar puntos con godot 4.3; GDScript; Y AL ALCANZAR 6 PUNTOS CAMBIAR LA ESCENA;

extends Area3D


var score = 1


func _ready():

pass


func _on_area_entered(area: Area3D) -> void:

$Label.text = str(score)

score += 1

if score > 6:

get_tree().change_scene_to_file("res://ESCENAS NIVELES/FINALworld_environment.tscn")

                               ------------------------------------------------------------------------

---------------------------------------------------------------------------------------------------------------------

#Explicacion: arrastrar con el mouse desde la carpeta res:   hacia la linea del codigo escrito, para que este bien enrutado, ("res://ESCENAS  NIVELES/FINALworld_environment.tscn") asi correcto, si en lugar escribiese  ("res://FINALworld_environment.tscn") no funcionaria porque el archivo tscn esta en una subcarpeta dentro de la carpeta "res" osea en "res " contiene la carpeta "ESCENAS  NIVELES"

y "ESCENAS  NIVELES" contiene el archivo tscn "FINALworld_environment.tscn"......esta es mi explicacion que la IA no te explica , ahora pondre la explicacion de la IA................Explicación:

  1. extends Area3D:

    • Esta línea indica que el script está adjunto a un nodo de tipo Area3D. Los nodos Area3D se utilizan para detectar colisiones y superposiciones en un espacio 3D.
  2. var score = 1:

    • Se declara una variable llamada score y se inicializa en 1. Esta variable se utilizará para llevar la cuenta de los puntos.
  3. func _ready(): pass:

    • La función _ready() se llama cuando el nodo está listo para ser utilizado. En este caso, no se realiza ninguna acción específica, por lo que se utiliza pass.
  4. func _on_area_entered(area: Area3D) -> void::

    • Esta función se llama automáticamente cuando otro nodo Area3D entra en el área de este nodo.
    • $Label.text = str(score): Esta linea, le dice al objeto label que muestre el valor de la variable score.
    • score += 1: Incrementa la variable score en 1 cada vez que se detecta una colisión.
  5. if score > 6::

    • Se agrega una condición if para verificar si la variable score es mayor que 6.
  6. get_tree().change_scene_to_file("res://FINALworld_environment.tscn"):

    • Si la condición score > 6 se cumple, esta línea de código se ejecuta.
    • get_tree(): Obtiene el árbol de la escena actual.
    • change_scene_to_file("res://FINALworld_environment.tscn"): Carga y cambia a la escena especificada por la ruta "res://FINALworld_environment.tscn". Asegúrate de que esta ruta sea correcta y que la escena exista en tu proyecto.

Cómo usarlo:

  1. Asegúrate de que tienes una escena llamada "FINALworld_environment.tscn" en la raíz de tu proyecto.
  2. Adjunta este script a un nodo Area3D.
  3. Asegúrate de que hay otro nodo Area3D que puede entrar en el área del nodo al que has adjuntado este script.
  4. Crea un nodo de tipo Label, y nombra ese nodo como "Label".
  5. Cuando el otro nodo Area3D entre en el área 6 veces, la escena cambiará a "FINALworld_environment.tscn". 

Y aqui el gdscript facilitado por la IA:

extends Area3D

var score = 1

func _ready():
    pass

func _on_area_entered(area: Area3D) -> void:
    $Label.text = str(score)
    score += 1
    
    if score > 6:
        get_tree().change_scene_to_file("res://FINALworld_environment.tscn")

Sumar puntos con godot 4.3; GDScript;

 extends Area3D


var score = 1


func _ready():


pass



func _on_area_entered(area: Area3D) -> void:


$Label.text = str(score)


score += 1


pass


---------------------------------------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------------------------------------

Explicacion: tenemos en un juego 3d un Area en el cielo con su colisionador donde tenemos puesto el GDScript, en el nodo Area ponemos el GDScript, en el suelo vamos destruyendo elementos y al subir el premio hacia arriba y tocar el Area que esta por encima va sumando puntuacion, la idea ahora sera hacer que al llegar a una cantidad de puntuacion se active un cambio de nivel, pero ese GDScript lo pondre mas adelante aun e de trabajar en ello.....

GDScript para emitir un sonido al presionar tecla espacio; tambien emite particulas;

 extends CPUParticles3D


# Nombre de la acción en el mapa de entrada que controla las partículas

@export var accion_activar_particulas: String = "ui_accept"

#@export var accion_activar_particulas: String = "mouse_left"


# Referencia al AudioStreamPlayer3D

@onready var audio_player: AudioStreamPlayer3D = $AudioStreamPlayer3D


func _process(delta):

# Verifica si la acción está siendo presionada

if Input.is_action_just_pressed(accion_activar_particulas): #Cambio aqui

# Si la acción está presionada y las partículas no están emitiendo, comienza a emitir

emitting = true

# Reproduce el sonido

audio_player.play()

elif Input.is_action_just_released(accion_activar_particulas):

emitting = false

elif Input.is_action_pressed(accion_activar_particulas):

emitting = true

else:

# Si la acción no está presionada y las partículas están emitiendo, deja de emitir

if emitting:

emitting = false



jueves, 20 de febrero de 2025

GDScript, para Godot 4.3 efecto de sonido al entrar algo en un Area3d;

 extends Area3D


func _ready() -> void:

# Creamos el nodo AudioStreamPlayer3D

var sonido_al_entrar = AudioStreamPlayer3D.new()

# Lo añadimos como hijo del Area3D

add_child(sonido_al_entrar)

# Cargamos el sonido (reemplaza "res://ruta/al/sonido.wav" con la ruta correcta)

sonido_al_entrar.stream = load("res://SONIDOS/HOMBREALAGUA.mp3")


func _on_area_entered(area: Area3D) -> void:

# Reproducimos el sonido

$AudioStreamPlayer3D.play()


-------------------------------------------------------------------------------------------------------------------------

--------------------------------------------------------------------------------------------------------------------------

Exlicacion: En mi nuevo videojuego sobre temas marinos que estoy haciendo con Godot 4.3 queria hacer el efecto de sonido cuando un hombre cae al agua, y lo realice consultando a la IA, y aplicando la ruta donde tenia yo, mi sonido particular "res://SONIDOS/HOMBREALAGUA.mp3".

La IA me resulta muy util pero no lo hace todo, tambien hay que esforzarse y entender, como poner las cosas. Muestro el video pero aqui en este video aun no tiene la captura de video de mi abance, lo pongo para promocionarme ¡¡¡¡¡¡





jueves, 13 de febrero de 2025

Desarrollando juego marino 3d con Godot 4.3.;

 

https://videojuegosenlineaasaco4.blog... Videojuego pronto a la venta en itchi.io, en https://perico415.itch.io/ Videojuego para +18 años, de simulacion y exploracion en 3d, precios muy asequibles , no mas de $2.55, videojuegos indies. A la venta entre el mes de febrero y de marzo del 2025.

miércoles, 5 de febrero de 2025

Resumen de lo aprendido estos últimos meses en Godot 4.3.;

 😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃

Resumen de lo aprendido estos últimos meses en Godot 4.3.

Rutinas que me sirven para aprender ,y formas de aprovechar algunos recurso últimamente.

La IA me resulta fundamental para aprender a programar GDScript.

Es verdad que resuelve muchas papeletas, pero es que con los ejemplos que resuelve y con las conclusiones que saco estoy empezando a aprender a programar con GDScript.


Hoy por ejemplo, quería borrar alternativamente un Label un texto de pantalla.

La IA me lo resolvió con facilidad, desde hay, aplique ese GDScript para encender y apagar una luz de linterna.

Lo mismo con unas plantas, hice un GDScript para que se moviesen por el viento, y ese mismo GDScript manipulado cambiando los valores, me sirvió para balancear un barco en el agua.


Lo mismo con personajes que están dentro de un Area, en el Area tiene su GDScript para que al chocar algo en ella, se instancien otros elementos que me interesan para el juego, y lo puedo aprovechar solamente cambiando el nombre del GDScript y algunas lineas de código.


Me refiero que pudo hacer docenas de Areas con personajes diferentes y situaciones y elementos y gráficos y sonido y lo que se tercie, con infinidad de combinaciones y solo es el mismo GDScript cambiando su nombre y cambiando 2 o 3 lineas de código.


 😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃😃


SpotLight3D mediante GDScript encendemos y apagamos una luz; dos ejemplos; dos formas ;

 extends SpotLight3D


# Llamado cuando el nodo entra en el árbol de la escena por primera vez.

func _ready() -> void:

# Aseguramos que la luz esté apagada al inicio

visible = false  # Establecer la visibilidad a falso


# Variable para rastrear el estado de visibilidad

var es_visible: bool = false


# Llamado cada frame. 'delta' es el tiempo transcurrido desde el frame anterior.

func _process(delta: float) -> void:

if Input.is_action_just_pressed("luzcasco"):

es_visible = !es_visible  # Alternar visibilidad

visible = es_visible       # Aplicar el nuevo estado de visibilidad

------------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------

------------------------------------------------------------------------------------------------------------------

extends SpotLight3D


# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.


# Variable to track visibility state

var is_visible: bool = true


# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

if Input.is_action_just_pressed("luzcasco"):

is_visible = !is_visible  # Toggle visibility

visible = is_visible       # Apply the new visibility state

----------------------------------------------------------------------------------------------------------------

-----------------------------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------------------------

Explicacion: Dos ejemplos de GDScript para Godot4.3 apagar y encender una luz presionando -Ctrl- cullo mapa de entrada utiliza el nombre de "luzcasco".

En el primer ejemplo la luz empieza estando apagada y en el segundo empieza estando encendida, al presionar -Ctrl- vamos alternando en encendido y apagado,  recordar que hay que configurar El Mapa De Entrada de Godot 4.3 para asignar la tecla -Ctrl-  con cualquier nombre inventado, yo por ejemplo puse "luzcasco" porque es una luz que utilizo en mi ultimo juego que lleva en el casco un personaje.



extends Label GDScript en Godot 4.3, desciente un Label y lo borra de pantalla pasado unos segundos;

 extends Label


@export var velocidad_descenso: float = 50.0 # Velocidad de descenso en píxeles por segundo

@export var tiempo_vida: float = 7.0 # Tiempo en segundos antes de desaparecer


var tiempo_transcurrido: float = 0.0


func _process(delta: float) -> void:

    position.y += velocidad_descenso * delta

    tiempo_transcurrido += delta

    if tiempo_transcurrido >= tiempo_vida:

        queue_free()

GDScript para Godot 4.3, borra un texto label al presionar -Esc- y al volver a presionar lo vuelve a poner;

 extends Label


# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.


# Variable to track visibility state

var is_visible: bool = true


# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

if Input.is_action_just_pressed("escapedesalir"):

is_visible = !is_visible  # Toggle visibility

visible = is_visible       # Apply the new visibility state

--------------------------------------------------------------------------------------------------------------------------

-------------------------------------------------------------------------------------------------------------------------

Explicacion: Tengo en el blog otros GDScript con el mismo tema, pero este es el perfecto, el otro giraba el texto label 180 grados en la pantalla y se salia del juego y no se podia ver, luego al presionar otra vez -Esc- volvia a girar y se podia ver de nuevo.

martes, 4 de febrero de 2025

Gdscript, para Godot 4.3 sube un Area3d en eje "y" y a los 14 segundos lo borra; borra el Area3d;

 extends Area3D


var self_destruct_time = 14.0

var elapsed_time = 0.0


# Called when the node enters the scene tree for the first time.

func _ready() -> void:

        pass # Replace with function body.


# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

        elapsed_time += delta

        translate(Vector3(0, 0.019, 0)) # Corrected Vector3 values

        if elapsed_time >= self_destruct_time:

                queue_free()

lunes, 3 de febrero de 2025

Ejemplo de instanciar 3 elementos diferentes mediante GDScript de Godot 4.3;

 extends Area3D

#var Esferauno = preload("res://PERSONAJES MACABROS/ARAÑA/EXPLOTADA ARAÑA.tscn")

var Esferauno = preload("res://ELEMENTOS MARINOS/OSTRAABIERTA2 MUY ABIERTA.tscn")

var Esferados = preload("res://ELEMENTOS MARINOS/DIAMANTE1.tscn")

var Esferatres = preload("res://TIAS/tiadesnudaJ.tscn")

# Called when the node enters the scene tree for the first time.

func _ready() -> void:

pass # Replace with function body.



# Called every frame. 'delta' is the elapsed time since the previous frame.

func _process(delta: float) -> void:

pass



func _on_area_entered(area: Area3D) -> void:


var parent = get_parent()


var CollisionShape3Dcubo = parent.get_node("CollisionShape3D")


var Esferados = Esferados.instantiate()


add_child(Esferados)

var Esferatres = Esferatres.instantiate()


add_child(Esferatres)



get_node("CollisionShape3D").queue_free()


#get_node().queue_free()

pass # Replace with function body.




func _on_area_exited(area: Area3D) -> void:


var Esferauno = Esferauno.instantiate()


add_child(Esferauno)


pass # Replace with function body.

jueves, 30 de enero de 2025

GDScript, proboca que al presionar "W" aga particulas y al no presionar no;

 extends CPUParticles3D


# Nombre de la acción en el mapa de entrada que controla las partículas

@export var accion_activar_particulas: String = "ANDAALANTECONW"


func _process(delta):

# Verifica si la acción está siendo presionada

if Input.is_action_pressed(accion_activar_particulas):

# Si la acción está presionada y las partículas no están emitiendo, comienza a emitir

if not emitting:

emitting = true

else:

# Si la acción no está presionada y las partículas están emitiendo, deja de emitir

if emitting:

emitting = false

-------------------------------------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------------------------------------

explicacion: en godot 4.3 en la configuracion de teclado puse para utilizar la"W" para caminar de mapa de entrada con el nombre "ANDAALANTECONW", en este GDScript ago un efecto de burbujas que solo funcionan cuando el personaje camina, un pèrsonaje debajo del agua..........

viernes, 24 de enero de 2025

Mis desarrollos año 2024 y enero 2025;

 

juego echo con Godot 4.3 Mesaltmalomalal-2;


 

jueves, 23 de enero de 2025

Mesaltmalomalal; videojuego de terror;

 https://perico415.itch.io/mesaltmalomalal



Videojuego de terror y violencia sexual y urbana nocturna, simulación con manejo de la cámara para poder jugar desde donde quieras cualquier angulo, 409 MB ocupa el juego.

Eres un ente de locura que vaga por las alcantarillas de la ciudad en busca de sangre, sacias tu maldad rompiendo otras maldades.

Los gráficos son en 3d y los cambios de cámara son muy cinematográficos, muy fácil de manejar. Echo para Windows.

Ambientación nocturna de ciudad, sugiero jugar constantemente con la cámara para cambiar los puntos de vista y ver como manejamos el personaje, y observar todos los ángulos de vista posibles.

El manejo del juego es muy fácil esta constantemente explicado en la pantalla mientras juegas.

Es para mayores de 18 años.



Nighttime urban horror and sexual violence video game, simulation with camera control so you can play from any angle, the game takes up 409 MB.
You are a crazy entity that wanders through the sewers of the city in search of blood, you satisfy your evil by breaking other evils.
The graphics are in 3D and the camera changes are very cinematic, very easy to handle. Echo for Windows.
Nighttime city setting, I suggest constantly playing with the camera to change the points of view and see how we handle the character, and observe all possible angles of view.
The handling of the game is very easy, it is constantly explained on the screen while you play.
It is for over 18 years old.