domingo, 6 de septiembre de 2026
martes, 1 de septiembre de 2026
domingo, 30 de agosto de 2026
Los GDScripts del videojuego The reflection the evil one.;
extends Node3D
# Variable exportada para cambiar los segundos desde el Inspector (por defecto 3.0 segundos)
@export var tiempo_duracion: float = 10.0
func _ready() -> void:
# 1. Arrancamos la animación al cargar la escena
if $AnimationPlayer:
$AnimationPlayer.play("MakeHuman default skeleton|CONTRAESPEJO")
# 2. Creamos un temporizador que espere los segundos fijados y luego pare la animación
await get_tree().create_timer(tiempo_duracion).timeout
# 3. Pasados los segundos, detenemos la animación
if $AnimationPlayer:
$AnimationPlayer.stop()
extends Area3D
@export var reproductor_audio: AudioStreamPlayer3D
func _ready() -> void:
# Apaga todas las partículas hijas al arrancar
_cambiar_particulas(false)
body_entered.connect(_on_entrada)
body_exited.connect(_on_salida)
area_entered.connect(_on_entrada)
area_exited.connect(_on_salida)
func _on_entrada(_body_or_area) -> void:
# Activar sonido
if reproductor_audio:
if not reproductor_audio.playing:
reproductor_audio.play()
else:
reproductor_audio.stream_paused = false
# Encender todas las partículas hijas
_cambiar_particulas(true)
func _on_salida(_body_or_area) -> void:
# Pausar sonido
if reproductor_audio:
reproductor_audio.stream_paused = true
# Apagar todas las partículas hijas
_cambiar_particulas(false)
# Busca todos los nodos CPUParticles3D hijos y los activa o desactiva
func _cambiar_particulas(estado: bool) -> void:
for hijo in get_children():
if hijo is CPUParticles3D:
hijo.emitting = estado
extends Node3D
## Escena a la que se cambiará tras finalizar el tiempo, clic o toque
@export var siguiente_escena: PackedScene
## Tiempo de espera en segundos antes de cambiar de escena
@export var tiempo_espera: float = 115.0
## Arrastra aquí el nodo TouchScreenButton desde el árbol de escena (opcional)
@export var boton_tactil: TouchScreenButton
var _ya_cambiando: bool = false
func _ready() -> void:
#Input.mouse_mode = Input.MOUSE_MODE_VISIBLE
# Conectamos el botón táctil si se ha asignado en el Inspector
if boton_tactil:
boton_tactil.pressed.connect(_al_pulsar_boton)
# Temporizador por tiempo
var timer := get_tree().create_timer(tiempo_espera)
timer.timeout.connect(_cambiar_escena_directa)
# Detecta clics de ratón o toques en la pantalla completa (móviles/PC)
func _unhandled_input(event: InputEvent) -> void:
if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
_cambiar_escena_directa()
elif event is InputEventScreenTouch and event.pressed:
_cambiar_escena_directa()
func _al_pulsar_boton() -> void:
_cambiar_escena_directa()
func _cambiar_escena_directa() -> void:
# Evitamos que se intente cambiar más de una vez
if _ya_cambiando:
return
if not siguiente_escena:
push_warning("No se ha asignado ninguna escena en el Inspector.")
return
_ya_cambiando = true
# 1. Guardamos una referencia a la escena actual
var escena_actual := get_tree().current_scene
# 2. Instanciamos la nueva escena
var nueva_instancia := siguiente_escena.instantiate()
# 3. Añadimos la nueva escena al nodo raíz del proyecto
get_tree().root.add_child(nueva_instancia)
# 4. Establecemos la nueva escena como la escena activa
get_tree().current_scene = nueva_instancia
# 5. Eliminamos la escena vieja
if escena_actual:
escena_actual.queue_free()
extends Node3D
# Variable exportada para cambiar los segundos desde el Inspector (por defecto 3.0 segundos)
@export var tiempo_duracion: float = 110.0
func _ready() -> void:
# 1. Arrancamos la animación al cargar la escena
if $AnimationPlayer:
$AnimationPlayer.play("MakeHuman default skeleton|ESPASMADA")
# 2. Creamos un temporizador que espere los segundos fijados y luego pare la animación
await get_tree().create_timer(tiempo_duracion).timeout
# 3. Pasados los segundos, detenemos la animación
if $AnimationPlayer:
$AnimationPlayer.stop()
extends OmniLight3D
@export_group("Configuración de Balanceo Circular")
@export var speed: float = 22.0 # Velocidad del giro circular
@export var radius: float = 21.5 # Radio máximo del círculo (en metros)
@export var pulse_speed: float = 21.0 # Velocidad con la que el círculo se amplía y reduce
var initial_position: Vector3
var time_passed: float = 0.0
func _ready() -> void:
initial_position = position
func _process(delta: float) -> void:
time_passed += delta
# Calculamos la variación del tamaño (un factor que oscila entre 0.2 y 1.0 para que no pase por cero absoluto)
var current_radius := radius * (0.6 + 0.4 * sin(time_passed * pulse_speed))
# Usamos cos() para el eje X y sin() para el eje Z para formar el movimiento circular
var offset_x := cos(time_passed * speed) * current_radius
var offset_z := sin(time_passed * speed) * current_radius
# Aplicamos el movimiento en los ejes X y Z manteniendo la Y inicial
position = initial_position + Vector3(offset_x, 0.0, offset_z)
extends Node
func _unhandled_input(event: InputEvent) -> void:
if event.is_action_pressed("ui_cancel") or (event is InputEventKey and event.pressed and event.keycode == KEY_ESCAPE):
get_tree().quit()
extends Area3D
# Nodos exportados para arrastrar desde la escena al Inspector
@export var reproductor_audio: AudioStreamPlayer3D
@export var particulas_sangre1: CPUParticles3D
@export var particulas_sangre2: CPUParticles3D
@export var particulas_sangre3: CPUParticles3D
@export var particulas_sangre4: CPUParticles3D # Puedes añadir particulas_sangre4, etc.
@export var particulas_sangre5: CPUParticles3D
func _ready() -> void:
# Nos aseguramos de apagar todas al arrancar el juego
_apagar_particulas()
body_entered.connect(_on_entrada)
body_exited.connect(_on_salida)
area_entered.connect(_on_entrada)
area_exited.connect(_on_salida)
func _on_entrada(_body_or_area) -> void:
# 1. SONIDO EN ON
if reproductor_audio:
if not reproductor_audio.playing:
reproductor_audio.play()
else:
reproductor_audio.stream_paused = false
# 2. PARTÍCULAS EN ON (Entra en la zona)
_encender_particulas()
func _on_salida(_body_or_area) -> void:
# 1. SONIDO EN OFF
if reproductor_audio:
reproductor_audio.stream_paused = true
# 2. PARTÍCULAS EN OFF (Sale de la zona)
_apagar_particulas()
# --- BLOQUE DE ENCENDIDO ---
func _encender_particulas() -> void:
if particulas_sangre1:
particulas_sangre1.emitting = true
if particulas_sangre2:
particulas_sangre2.emitting = true
if particulas_sangre3:
particulas_sangre3.emitting = true
if particulas_sangre4:
particulas_sangre4.emitting = true
if particulas_sangre5:
particulas_sangre5.emitting = true
# --- BLOQUE DE APAGADO ---
func _apagar_particulas() -> void:
if particulas_sangre1:
particulas_sangre1.emitting = false
if particulas_sangre2:
particulas_sangre2.emitting = false
if particulas_sangre3:
particulas_sangre3.emitting = false
if particulas_sangre4:
particulas_sangre4.emitting = false
if particulas_sangre5:
particulas_sangre5.emitting = false
The reflection the evil one.;
Añado este articulo que no es mio pero me gusta muchisimo y encaja en mi aficion a estos ultimos juegos y a mi imaginacion y capacidad de trabajo............
«El talento es más barato que la sal de mesa; lo que separa al individuo con talento del exitoso es el trabajo duro»
Una de sus frases más conocidas resume precisamente esta forma de entender el éxito: «El talento es más barato que la sal de mesa; lo que separa al individuo con talento del exitoso es el trabajo duro». Para Stephen King, una persona puede contar con unas capacidades extraordinarias, pero si no las desarrolla mediante constancia, esfuerzo y disciplina, difícilmente alcanzará sus. objetivos
lunes, 24 de agosto de 2026
domingo, 23 de agosto de 2026
Deep shower; Opinion de la IA;
Opinion de la IA:
¡Me parece brutal! "Deep shower the end" transmite una atmósfera claustrofóbica y retro impresionante.
Aquí te destaco varios puntos fuertes del gameplay:
La atmósfera y el sonido ambiental: El murmullo y el ruido sordo del agua constante bajo esa luz tenue crean una sensación de inquietud continua. La iluminación verdosa y los azulejos de patrón antiguo encajan perfecto con la estética retro de terror.
La transformación visual: La transición cuando la figura empieza a disolverse o perder capas con el agua hasta quedar reducida al esqueleto es perturbadora y está muy bien ejecutada en bucle.
El remate final: Cuando sale el texto "The End" y la cámara se queda enfocado en el esqueleto bajo la ducha mientras sigue cayendo agua, deja esa sensación extraña e incómoda propia del género de terror bizarro.
Tiene muchísimo estilo y personalidad. Es exactamente el tipo de concepto directo y macabro que atrae clics y atención de creadores de contenido en itch.io.
miércoles, 19 de agosto de 2026
Mi juego a gustado a...otro youtuber;; estoy alucinando un poco;
https://www.youtube.com/watch?v=tYoqx01gCgs
https://perico415.itch.io/hellish-toilet
La opinion de la IA de como me siento con estas criticas de youtubers:
Es totalmente comprensible que te sientas así. Estás experimentando exactamente la magia del arte y de la creación: ver cómo algo que sale directamente de tu cabeza atraviesa un océano, llega a la otra punta del mundo y conecta con gente que ni te conoce.
Aunque la industria sea distinta, el proceso es muy parecido al del cine: has escrito una idea, la has producido en forma de juego y ahora tiene a una audiencia en Estados Unidos reaccionando, riendo y entreteniéndose con ella. Esa sensación de ver tu obra "en pantalla" a través de creadores de otro país es un subidón auténtico.
Que no estés monetizando o ganando dinero en este momento no le quita ni un ápice de valor:
El reconocimiento cultural es el primer paso: En el cine y en los videojuegos indies, la visibilidad siempre viene antes que el dinero. Que tu trabajo genere curiosidad e impacto en un mercado tan potente es una señal de que tienes talento para captar la atención del público.
Disfruta el momento: Tienes todo el derecho a "fliparlo" y a vivirlo con ilusión. Estás creando proyectos desde tu espacio, a tu ritmo, y logrando que crucen fronteras.
Esa satisfacción de ver tu creación viva en la cultura popular de internet no se compra con nada. ¡Disfruta muchísimo de esta ola, que te la has ganado a pulso con tu trabajo!
martes, 18 de agosto de 2026
lunes, 17 de agosto de 2026
Videojuego terror y gore, corto, completo, sangriento, para cagarse de miedo. windows y linux descargar y jugar:
Videojuego terror y gore, corto, completo, sangriento, para cagarse de miedo.
windows y linux descargar y jugar
sábado, 15 de agosto de 2026
GDScript para camara3d, moverse por el escenario en cualquier angulo, con posibilidad de limitar los traslados desde el inspector;
extends Camera3D
@export_group("Movimiento y Cámara")
@export var speed: float = 5.0
@export var mouse_sensitivity: float = 0.003
@export_group("Límites de Desplazamiento (Metros)")
@export var limit_forward: float = 10.0 # Máximo W (Adelante)
@export var limit_backward: float = 5.0 # Máximo S (Atrás)
@export var limit_left: float = 8.0 # Máximo A (Izquierda)
@export var limit_right: float = 8.0 # Máximo D (Derecha)
var rotation_x: float = 0.0
var start_position: Vector3
func _ready() -> void:
Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
start_position = global_position
func _unhandled_input(event: InputEvent) -> void:
if event.is_action_pressed("ui_cancel") or (event is InputEventKey and event.pressed and event.keycode == KEY_ESCAPE):
get_tree().quit()
if event is InputEventMouseMotion and Input.mouse_mode == Input.MOUSE_MODE_CAPTURED:
rotate_y(-event.relative.x * mouse_sensitivity)
rotation_x -= event.relative.y * mouse_sensitivity
rotation_x = clamp(rotation_x, deg_to_rad(-89.0), deg_to_rad(89.0))
rotation.x = rotation_x
func _process(delta: float) -> void:
var input_dir := Vector3.ZERO
if Input.is_key_pressed(KEY_W):
input_dir.z -= 1 # W: Adelante
if Input.is_key_pressed(KEY_S):
input_dir.z += 1 # S: Atrás
if Input.is_key_pressed(KEY_A):
input_dir.x -= 1 # A: Izquierda
if Input.is_key_pressed(KEY_D):
input_dir.x += 1 # D: Derecha
if input_dir != Vector3.ZERO:
input_dir = input_dir.normalized()
# Movemos en el plano horizontal para no volar al mirar arriba/abajo
var forward := -global_transform.basis.z
forward.y = 0
forward = forward.normalized()
var right := global_transform.basis.x
right.y = 0
right = right.normalized()
# Calculamos el intento de movimiento
var movement := (right * input_dir.x + forward * -input_dir.z) * speed * delta
var target_position := global_position + movement
# Medimos la distancia acumulada desde el origen
var offset := target_position - start_position
# Aplicamos los 4 límites independientes (W, S, A, D)
offset.x = clamp(offset.x, -limit_left, limit_right)
offset.z = clamp(offset.z, -limit_forward, limit_backward)
# Asignamos la posición corregida manteniendo la altura fija (Y)
global_position = Vector3(start_position.x + offset.x, start_position.y, start_position.z + offset.z)
OmniLight3D se balancea mediante GDScript; y se puede calibrar desde el inspector;
extends OmniLight3D
# Parámetros editables desde el Inspector
@export_group("Configuración de Balanceo")
@export var speed: float = 2.0 # Velocidad de la oscilación
@export var amplitude: float = 1.5 # Distancia máxima del balanceo (en metros)
@export var axis: Vector3 = Vector3(1, 0, 0) # Eje de movimiento (Por defecto X: izquierda/derecha)
# Guardamos la posición inicial para que el movimiento sea relativo a ella
var initial_position: Vector3
var time_passed: float = 0.0
func _ready() -> void:
# Al arrancar, memorizamos dónde hemos colocado la luz en el mapa
initial_position = position
func _process(delta: float) -> void:
# Acumulamos el tiempo transcurrido
time_passed += delta * speed
# Calculamos el desplazamiento usando la onda seno: sin(t) va de -1 a 1
var offset := axis.normalized() * sin(time_passed) * amplitude
# Aplicamos el balanceo partiendo de la posición inicial
position = initial_position + offset
GDScript para camara 3d en Godot 4.7, se mueve con el mouse y al presionar escape sales del juego; y te trasladas adelante atras izquierda y derecha;con -w-s-a-d;
extends Camera3D
# Parámetros ajustables desde el inspector
@export var speed: float = 5.0
@export var mouse_sensitivity: float = 0.003
var rotation_x: float = 0.0
func _ready() -> void:
# Oculta y atrapa el puntero del ratón
Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
func _unhandled_input(event: InputEvent) -> void:
# 1. Salir del juego al pulsar la tecla Escape
if event.is_action_pressed("ui_cancel") or (event is InputEventKey and event.pressed and event.keycode == KEY_ESCAPE):
get_tree().quit()
# 2. Rotación de la cámara con el ratón
if event is InputEventMouseMotion and Input.mouse_mode == Input.MOUSE_MODE_CAPTURED:
# Girar a los lados (Eje Y global para no inclinarnos de lado)
rotate_y(-event.relative.x * mouse_sensitivity)
# Mirar arriba y abajo (Eje X local con límite)
rotation_x -= event.relative.y * mouse_sensitivity
rotation_x = clamp(rotation_x, deg_to_rad(-89.0), deg_to_rad(89.0))
rotation.x = rotation_x
func _process(delta: float) -> void:
# 3. Detectar teclas WASD para calcular la dirección de movimiento
var input_dir := Vector3.ZERO
if Input.is_key_pressed(KEY_W):
input_dir.z -= 1 # Adelante
if Input.is_key_pressed(KEY_S):
input_dir.z += 1 # Atrás
if Input.is_key_pressed(KEY_A):
input_dir.x -= 1 # Izquierda
if Input.is_key_pressed(KEY_D):
input_dir.x += 1 # Derecha
# Normalizar para que la velocidad no se duplique al moverte en diagonal
if input_dir != Vector3.ZERO:
input_dir = input_dir.normalized()
# 4. Mover la cámara según la dirección hacia la que está mirando
var direction := (transform.basis * input_dir).normalized()
global_position += direction * speed * delta
----------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------
Explicacion: estupendo GDScript para manejar una camara3d en Godot 4.7, puedes explorar todo el entorno de un juego 3d con mucha facilidad:
GDScript para camara 3d en Godot 4.7, se mueve con el mouse y al presionar escape sales del juego;
extends Camera3D
# Sensibilidad del ratón (ajusta este valor a tu gusto)
@export var mouse_sensitivity: float = 0.003
# Variables para controlar los límites de rotación vertical (mirar arriba/abajo)
var rotation_x: float = 0.0
func _ready() -> void:
# Captura y oculta el puntero del ratón en la pantalla
Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
func _unhandled_input(event: InputEvent) -> void:
# 1. Salir del juego si se presiona la tecla Escape
if event.is_action_pressed("ui_cancel") or (event is InputEventKey and event.pressed and event.keycode == KEY_ESCAPE):
get_tree().quit()
# 2. Control de la cámara con el movimiento del ratón
if event is InputEventMouseMotion and Input.mouse_mode == Input.MOUSE_MODE_CAPTURED:
# Giro horizontal (Eje Y)
rotate_y(-event.relative.x * mouse_sensitivity)
# Giro vertical (Eje X) con límite para no dar la vuelta completa
rotation_x -= event.relative.y * mouse_sensitivity
rotation_x = clamp(rotation_x, deg_to_rad(-89.0), deg_to_rad(89.0))
# Aplicamos la rotación vertical a la cámara
rotation.x = rotation_x
jueves, 13 de agosto de 2026
miércoles, 12 de agosto de 2026
domingo, 9 de agosto de 2026
Suscribirse a:
Entradas (Atom)
← Return to game
Comentarios
The wolfman is a superstar, you should continue the series or make a spirituals successor like the new adventures of MMMesaltmalomalal. You should also add sex, violence and a little bit of your sense of humor, like the lady in the pink suit with her panties down:)
None of that can be done anymore, everything’s censored. It’s a disgrace, but they don’t even show it for free on itch.io anymore. It wouldn’t even appear on the lists. What’s the point of making games that nobody’s going to look at? And that they won’t let me sell?
Follow me if you’d like at https://perico415.itch.io/. I’ll try to keep going with horror games if they don’t ban them too…
You are right sadly, but I like the fact that you didn't give up. Maybe new platforms will appear in time. Best of luck in your projects!