Elysia Tools

Durchsuche Tools, Beispiele, visuelle Erklärungen und Themenguides an einem klaren Ort.

Beliebte Kategorien

Themen

Sprache
ZHDERUPTENFRES

Elysia Tools

Mobile Navigation

Spieleentwicklung

Godot Engine Beispiele

Godot Engine Beispiele einschließlich 2D/3D-Spiele, GDScript, C# und Engine-Funktionen

Beispiele

Einträge in dieser Sammlung

QuellcodegdscriptEinfach

Godot Hello World

Grundlegende Godot Engine-Einrichtung und erste Spielbeispiele mit GDScript

Schwierigkeit

3/10

Geschätzte Zeit

20 min

Schlagwörter

godot, game development, gdscript, 2d, 3d

Voraussetzungen

Basic programming concepts, Game development basics

gdscript
# Godot Engine Hello World Examples

# 1. Basic Scene Setup
# Create a new scene with a Sprite and Camera2D

# main.gd - Main scene script
extends Node

func _ready():
    print("Hello, Godot World!")
    setup_scene()

func setup_scene():
    # Create a simple sprite
    var sprite = Sprite2D.new()
    var texture = load("res://icon.png")
    sprite.texture = texture
    sprite.position = Vector2(100, 100)
    add_child(sprite)

    # Add a label
    var label = Label.new()
    label.text = "Hello, Godot!"
    label.position = Vector2(50, 50)
    label.add_theme_font_size_override("font_size", 24)
    add_child(label)

# 2. Basic Player Movement
# player.gd - Attach to a CharacterBody2D
extends CharacterBody2D

@export var speed = 300.0
@export var jump_velocity = -400.0

# Get the gravity from the project settings
var gravity = ProjectSettings.get_setting("physics/2d/default_gravity")

func _physics_process(delta):
    # Add gravity
    if not is_on_floor():
        velocity.y += gravity * delta

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

    # Get input direction
    var direction = Input.get_axis("ui_left", "ui_right")

    # Apply movement
    if direction:
        velocity.x = direction * speed
    else:
        velocity.x = move_toward(velocity.x, 0, speed)

    move_and_slide()

# 3. Basic 2D Platformer Setup
# Level.gd - Level management
extends Node2D

@export var respawn_position: Vector2 = Vector2(100, 100)
var player: CharacterBody2D

func _ready():
    player = $Player
    player.global_position = respawn_position

func _process(_delta):
    # Check for reset
    if Input.is_action_just_pressed("reset"):
        reset_level()

func reset_level():
    player.global_position = respawn_position
    player.velocity = Vector2.ZERO

# 4. Simple Collectible System
# collectible.gd - Attach to Area2D
extends Area2D

signal collected

func _ready():
    # Connect the body entered signal
    body_entered.connect(_on_body_entered)

func _on_body_entered(body):
    if body.name == "Player":
        # Emit signal and disappear
        collected.emit()
        queue_free()

# 5. Basic UI System
# ui.gd - UI Controller
extends Control

@onready var score_label: Label = $ScoreLabel
@onready var lives_label: Label = $LivesLabel
@onready var game_over_label: Label = $GameOverLabel

var score = 0
var lives = 3

func _ready():
    update_ui()

func add_score(points: int):
    score += points
    update_ui()

func lose_life():
    lives -= 1
    update_ui()

    if lives <= 0:
        game_over()

func update_ui():
    score_label.text = "Score: " + str(score)
    lives_label.text = "Lives: " + str(lives)

func game_over():
    game_over_label.visible = true
    get_tree().paused = true

# 6. Input Map Setup
# project.godot - Input configuration
[application]
config/name="Hello Godot"
run/main_scene="res://scenes/main.tscn"

[input]
move_left={
"deadzone": 0.5,
"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194319,"key_label":0,"unicode":0,"echo":false,"script":null)
]
}
move_right={
"deadzone": 0.5,
"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":4194321,"key_label":0,"unicode":0,"echo":false,"script":null)
]
}
jump={
"deadzone": 0.5,
"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":32,"key_label":0,"unicode":32,"echo":false,"script":null)
]
}

# 7. Basic 3D Scene
# player_3d.gd - First person controller
extends CharacterBody3D

@export var speed = 5.0
@export var jump_velocity = 4.5
@export var sensitivity = 0.003

# Get gravity from project settings
var gravity = ProjectSettings.get_setting("physics/3d/default_gravity")
@onready var camera = $Head/Camera3D

func _ready():
    Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)

func _unhandled_input(event):
    if event is InputEventMouseMotion:
        rotate_y(-event.relative.x * sensitivity)
        camera.rotate_x(-event.relative.y * sensitivity)
        camera.rotation.x = clamp(camera.rotation.x, deg_to_rad(-80), deg_to_rad(80))

func _physics_process(delta):
    # Add gravity
    if not is_on_floor():
        velocity.y -= gravity * delta

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

    # Get input direction
    var input_dir = Input.get_vector("move_left", "move_right", "move_forward", "move_backward")
    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()

# 8. Basic Animation Player
# animated_sprite.gd - Animation controller
extends AnimatedSprite2D

func _ready():
    # Play idle animation by default
    play("idle")

# Connect to character body movement
func play_walk_animation(is_moving: bool):
    if is_moving:
        if animation != "walk":
            play("walk")
    else:
        if animation != "idle":
            play("idle")

# 9. Scene Transitions
# scene_manager.gd
extends Node

@export var transition_duration: float = 1.0
@onready var color_rect: ColorRect = $ColorRect

func _ready():
    color_rect.visible = false

func transition_to_scene(scene_path: String):
    # Fade to black
    var tween = create_tween()
    color_rect.visible = true
    color_rect.modulate.a = 0.0

    tween.tween_property(color_rect, "modulate:a", 1.0, transition_duration / 2)
    tween.tween_callback(_load_scene.bind(scene_path))
    tween.tween_property(color_rect, "modulate:a", 0.0, transition_duration / 2)
    tween.tween_callback(_hide_transition)

func _load_scene(scene_path: String):
    get_tree().change_scene_to_file(scene_path)

func _hide_transition():
    color_rect.visible = false

# 10. Basic Audio Manager
# audio_manager.gd
extends Node

@onready var music_player: AudioStreamPlayer = $MusicPlayer
@onready var sfx_player: AudioStreamPlayer2D = $SFXPlayer

var music_volume: float = 0.8
var sfx_volume: float = 0.9

func play_music(stream: AudioStream, volume: float = music_volume):
    music_player.stream = stream
    music_player.volume_db = linear_to_db(volume)
    music_player.play()

func play_sfx(stream: AudioStream, position: Vector2 = Vector2.ZERO, volume: float = sfx_volume):
    if sfx_player is AudioStreamPlayer2D:
        sfx_player.global_position = position

    sfx_player.stream = stream
    sfx_player.volume_db = linear_to_db(volume)
    sfx_player.play()

func set_music_volume(volume: float):
    music_volume = clamp(volume, 0.0, 1.0)
    music_player.volume_db = linear_to_db(music_volume)

func set_sfx_volume(volume: float):
    sfx_volume = clamp(volume, 0.0, 1.0)
    sfx_player.volume_db = linear_to_db(sfx_volume)

# Usage examples and project structure

# File structure:
# res://
# ├── scenes/
# │   ├── main.tscn
# │   ├── player.tscn
# │   ├── level.tscn
# │   └── ui.tscn
# ├── scripts/
# │   ├── main.gd
# │   ├── player.gd
# │   ├── collectible.gd
# │   └── ui.gd
# ├── assets/
# │   ├── textures/
# │   ├── sounds/
# │   └── fonts/
# └── project.godot

print("Godot Hello World examples loaded!")
print("1. Create your first scene with Node2D")
print("2. Add a Sprite2D with a texture")
print("3. Create a player with CharacterBody2D")
print("4. Set up input actions in Project Settings")
print("5. Add UI elements with Control nodes")
print("6. Experiment with 3D scenes")
print("7. Add animations with AnimationPlayer")
print("8. Implement scene transitions")
print("9. Add sound effects and music")
print("10. Package your game for export")
QuellcodegdscriptMittel

Erweiterte GDScript-Programmierung

Erweiterte GDScript-Pattern, OOP-Konzepte und Engine-Integrationstechniken

Schwierigkeit

7/10

Geschätzte Zeit

40 min

Schlagwörter

godot, gdscript, advanced, design patterns

Voraussetzungen

GDScript basics, Godot engine fundamentals

gdscript
# Advanced GDScript Programming Examples

# 1. Singleton Pattern - Global Manager
# AutoLoad Singleton: GameManager.gd
extends Node

signal game_state_changed(new_state: GameState)
signal score_changed(new_score: int)
signal lives_changed(new_lives: int)

enum GameState {
    MENU,
    PLAYING,
    PAUSED,
    GAME_OVER
}

var current_state: GameState = GameState.MENU : set = _set_game_state
var score: int = 0 : set = _set_score
var lives: int = 3 : set = _set_lives
var high_score: int = 0

var current_level: int = 1
var player_data: Dictionary = {}

func _ready():
    load_game_data()

func _set_game_state(new_state: GameState):
    if current_state != new_state:
        current_state = new_state
        game_state_changed.emit(new_state)

        match new_state:
            GameState.PLAYING:
                Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)
            GameState.MENU, GameState.PAUSED:
                Input.set_mouse_mode(Input.MOUSE_MODE_VISIBLE)

func _set_score(new_score: int):
    if new_score != score:
        score = new_score
        score_changed.emit(score)

        if score > high_score:
            high_score = score
            save_game_data()

func _set_lives(new_lives: int):
    if new_lives != lives:
        lives = new_lives
        lives_changed.emit(lives)

        if lives <= 0:
            current_state = GameState.GAME_OVER

func save_game_data():
    var save_data = {
        "high_score": high_score,
        "current_level": current_level,
        "player_data": player_data
    }

    var file = FileAccess.open("user://savegame.save", FileAccess.WRITE)
    if file:
        file.store_var(save_data)
        file.close()

func load_game_data():
    var file = FileAccess.open("user://savegame.save", FileAccess.READ)
    if file:
        var save_data = file.get_var()
        file.close()

        high_score = save_data.get("high_score", 0)
        current_level = save_data.get("current_level", 1)
        player_data = save_data.get("player_data", {})

# 2. State Machine Pattern
# state_machine.gd
extends Node

class_name StateMachine

var state: State = null
var states: Dictionary = {}

func _ready():
    # Add states from child nodes
    for child in get_children():
        if child is State:
            states[child.name.to_lower()] = child
            child.state_machine = self

func change_state(state_name: String) -> void:
    var new_state = states.get(state_name.to_lower())

    if new_state and new_state != state:
        if state:
            state.exit()

        state = new_state
        state.enter()

func _physics_process(delta):
    if state:
        state._physics_process(delta)

func _process(delta):
    if state:
        state._process(delta)

# Base State Class
class State extends Node:
    var state_machine: StateMachine

    func enter():
        pass

    func exit():
        pass

    func _process(delta):
        pass

    func _physics_process(delta):
        pass

# Player States
# IdleState.gd
extends "res://scripts/state.gd"

func enter():
    owner.animation_player.play("idle")
    owner.velocity = Vector2.ZERO

func _physics_process(delta):
    if Input.is_action_just_pressed("jump") and owner.is_on_floor():
        state_machine.change_state("jump")
        return

    var direction = Input.get_axis("move_left", "move_right")
    if direction != 0:
        state_machine.change_state("run")
        return

    if not owner.is_on_floor():
        state_machine.change_state("fall")

# 3. Event System - Observer Pattern
# event_bus.gd
extends Node

signal player_died
signal level_completed
signal enemy_spawned(enemy_path: String)
signal item_collected(item_type: String, value: int)

static var instance: EventBus

func _ready():
    if instance == null:
        instance = self
    else:
        queue_free()

# Usage in other scripts:
# EventBus.instance.enemy_spawned.emit("res://scenes/enemies/goblin.tscn")

# 4. Object Pooling Pattern
# object_pool.gd
extends Node

class_name ObjectPool

@export var scene: PackedScene
@export var initial_size: int = 10

var pool: Array[Node] = []
var active_objects: Array[Node] = []

func _ready():
    for i in initial_size:
        var instance = scene.instantiate()
        add_child(instance)
        instance.visible = false
        pool.push_back(instance)

func get_object():
    var obj: Node

    if pool.size() > 0:
        obj = pool.pop_back()
    else:
        obj = scene.instantiate()
        add_child(obj)

    obj.visible = true
    active_objects.push_back(obj)
    return obj

func return_object(obj: Node):
    if obj in active_objects:
        active_objects.erase(obj)
        obj.visible = false
        pool.push_back(obj)

func clear():
    for obj in active_objects:
        obj.queue_free()
    active_objects.clear()

    for obj in pool:
        obj.queue_free()
    pool.clear()

# 5. Component System
# component.gd
extends Node
class_name Component

var entity: Node

func set_entity(new_entity: Node):
    entity = new_entity

# Health Component
class_name HealthComponent
extends Component

@export var max_health: float = 100.0
var current_health: float

signal health_changed(new_health: float)
signal died

func _ready():
    current_health = max_health

func take_damage(damage: float):
    current_health = max(0, current_health - damage)
    health_changed.emit(current_health)

    if current_health <= 0:
        died.emit()

func heal(amount: float):
    current_health = min(max_health, current_health + amount)
    health_changed.emit(current_health)

# 6. Data Persistence with JSON
# data_manager.gd
extends Node

class_name DataManager

var player_data_path = "user://player_data.json"

func save_player_data(data: Dictionary):
    var file = FileAccess.open(player_data_path, FileAccess.WRITE)
    if file:
        file.store_string(JSON.stringify(data))
        file.close()

func load_player_data() -> Dictionary:
    var file = FileAccess.open(player_data_path, FileAccess.READ)
    if file:
        var json_string = file.get_as_text()
        file.close()

        var json = JSON.new()
        var parse_result = json.parse(json_string)

        if parse_result == OK:
            return json.data
        else:
            print("Error parsing JSON: ", parse_result)

    return {}

func delete_player_data():
    if FileAccess.file_exists(player_data_path):
        DirAccess.remove_absolute(player_data_path)

# 7. Custom Resource Types
# item_resource.gd
extends Resource
class_name ItemResource

@export var name: String
@export var description: String
@export var icon: Texture2D
@export var value: int
@export var stack_size: int = 1
@export var rarity: String = "common"

func use(user: Node):
    # Override in child classes
    pass

# Weapon Resource
class WeaponResource extends ItemResource:
@export var damage: int
@export var attack_speed: float
@export var range: float

func use(user: Node):
    if user.has_method("attack"):
        user.attack(damage, range)

# 8. Procedural Generation
# dungeon_generator.gd
extends Node

class_name DungeonGenerator

@export var width: int = 50
@export var height: int = 50
@export var room_count: int = 10
@export var min_room_size: int = 3
@export var max_room_size: int = 10

var grid: Array[int] = []
var rooms: Array[Rect2i] = []

func generate() -> Array[Vector2i]:
    # Initialize grid with walls (1 = wall, 0 = floor)
    grid.clear()
    grid.resize(width * height)
    grid.fill(1)

    # Generate rooms
    rooms.clear()
    for i in room_count:
        var room = generate_room()
        if place_room(room):
            rooms.push_back(room)

    # Connect rooms with corridors
    connect_rooms()

    # Convert grid to coordinates
    var floor_positions: Array[Vector2i] = []
    for y in range(height):
        for x in range(width):
            if grid[y * width + x] == 0:
                floor_positions.push_back(Vector2i(x, y))

    return floor_positions

func generate_room() -> Rect2i:
    var room_width = randi_range(min_room_size, max_room_size)
    var room_height = randi_range(min_room_size, max_room_size)
    var x = randi_range(1, width - room_width - 1)
    var y = randi_range(1, height - room_height - 1)

    return Rect2i(x, y, room_width, room_height)

func place_room(room: Rect2i) -> bool:
    # Check if room overlaps with existing rooms
    for existing_room in rooms:
        if room.intersects(existing_room, true):
            return false

    # Carve room into grid
    for y in range(room.position.y, room.position.y + room.size.y):
        for x in range(room.position.x, room.position.x + room.size.x):
            grid[y * width + x] = 0

    return true

func connect_rooms():
    for i in range(rooms.size() - 1):
        var room1 = rooms[i]
        var room2 = rooms[i + 1]

        var start = room1.get_center()
        var end = room2.get_center()

        # Create L-shaped corridor
        create_corridor(start.x, start.y, end.x, start.y)
        create_corridor(end.x, start.y, end.x, end.y)

func create_corridor(x1: int, y1: int, x2: int, y2: int):
    # Horizontal corridor
    var x_start = min(x1, x2)
    var x_end = max(x1, x2)
    for x in range(x_start, x_end + 1):
        if x > 0 and x < width - 1 and y1 > 0 and y1 < height - 1:
            grid[y1 * width + x] = 0

    # Vertical corridor
    var y_start = min(y1, y2)
    var y_end = max(y1, y2)
    for y in range(y_start, y_end + 1):
        if x2 > 0 and x2 < width - 1 and y > 0 and y < height - 1:
            grid[y * width + x2] = 0

# 9. Advanced Animation System
# animation_controller.gd
extends Node

class_name AnimationController

@onready var animation_player: AnimationPlayer = get_parent().get_node("AnimationPlayer")
@onready var sprite: Sprite2D = get_parent()

var current_animation: String = ""
var is_facing_right: bool = true

func play_animation(anim_name: String, forced: bool = false):
    if anim_name != current_animation or forced:
        current_animation = anim_name
        animation_player.play(anim_name)

func set_facing_direction(direction: float):
    if direction > 0 and not is_facing_right:
        flip_horizontal()
    elif direction < 0 and is_facing_right:
        flip_horizontal()

func flip_horizontal():
    is_facing_right = not is_facing_right
    sprite.flip_h = not sprite.flip_h

# 10. AI Behavior Tree
# behavior_tree.gd
extends Node

class_name BehaviorTree

var root_node: BTNode

func _ready():
    build_tree()

func build_tree():
    # Example behavior tree structure
    root_node = BTSelector.new([
        BTPriority.new([
            BTCondition.new(check_health),
            BTSequence.new([
                BTAction.new(find_enemy),
                BTAction.new(attack_enemy)
            ])
        ]),
        BTAction.new(patrol)
    ])

func _process(delta):
    if root_node:
        root_node.execute()

# Behavior Tree Node Base Class
class BTNode:
    var parent: BTNode
    var children: Array[BTNode] = []

    func add_child(node: BTNode):
        children.push_back(node)
        node.parent = self

    func execute() -> bool:
        return false

# Action Node
class BTAction extends BTNode:
    var action_callable: Callable

    func _init(callable: Callable):
        action_callable = callable

    func execute() -> bool:
        return action_callable.call()

# Condition Node
class BTCondition extends BTNode:
    var condition_callable: Callable

    func _init(callable: Callable):
        condition_callable = callable

    func execute() -> bool:
        return condition_callable.call()

# Selector Node (OR)
class BTSelector extends BTNode:
    func _init(nodes: Array[BTNode] = []):
        for node in nodes:
            add_child(node)

    func execute() -> bool:
        for child in children:
            if child.execute():
                return true
        return false

# Priority Node (ordered selector)
class BTPriority extends BTSelector:
    pass

# Sequence Node (AND)
class BTSequence extends BTNode:
    func _init(nodes: Array[BTNode] = []):
        for node in nodes:
            add_child(node)

    func execute() -> bool:
        for child in children:
            if not child.execute():
                return false
        return true

print("Advanced GDScript examples loaded!")
print("These patterns demonstrate professional game development practices.")
QuellcodecsharpMittel

Godot C# Integration

C#-Scripting in Godot mit .NET-Integration, erweiterten Funktionen und Performance-Optimierung

Schwierigkeit

8/10

Geschätzte Zeit

50 min

Schlagwörter

godot, csharp, dotnet, advanced

Voraussetzungen

C# programming, Godot basics, OOP concepts

csharp
// Godot C# Integration Examples
// Requires Godot 4.x with .NET support enabled

using Godot;
using System;
using System.Collections.Generic;
using System.Linq;

// 1. Basic C# Player Controller
public partial class PlayerController : CharacterBody2D
{
    [ExportGroup("Movement Settings")]
    [Export] public float Speed { get; set; } = 300.0f;
    [Export] public float JumpVelocity { get; set; } = -400.0f;
    [Export] public float Acceleration { get; set; } = 1000.0f;
    [Export] public float Friction { get; set; } = 1000.0f;

    [ExportGroup("References")]
    [Export] public AnimatedSprite2D AnimatedSprite { get; set; }
    [Export] public CollisionShape2D CollisionShape { get; set; }

    private float _gravity = ProjectSettings.GetSetting("physics/2d/default_gravity").AsSingle();
    private PlayerState _currentState = PlayerState.Idle;

    private enum PlayerState
    {
        Idle,
        Running,
        Jumping,
        Falling,
        Attacking,
        Hurt
    }

    public override void _Ready()
    {
        GD.Print("Player controller initialized with C#!");

        // Initialize components
        if (AnimatedSprite == null)
            AnimatedSprite = GetNode<AnimatedSprite2D>("AnimatedSprite2D");

        if (CollisionShape == null)
            CollisionShape = GetNode<CollisionShape2D>("CollisionShape2D");

        // Connect signals
        AnimatedSprite.AnimationFinished += OnAnimationFinished;
    }

    public override void _PhysicsProcess(double delta)
    {
        HandleGravity(delta);
        HandleInput(delta);
        HandleStates();
        MoveAndSlide();
    }

    private void HandleGravity(double delta)
    {
        if (!IsOnFloor())
        {
            Velocity = Velocity with { Y = (float)(Velocity.Y + _gravity * delta) };
        }
    }

    private void HandleInput(double delta)
    {
        // Handle Jump
        if (Input.IsActionJustPressed("jump") && IsOnFloor())
        {
            Velocity = Velocity with { Y = JumpVelocity };
            ChangeState(PlayerState.Jumping);
        }

        // Handle Attack
        if (Input.IsActionJustPressed("attack"))
        {
            ChangeState(PlayerState.Attacking);
        }

        // Handle Movement
        var direction = Input.GetAxis("ui_left", "ui_right");

        if (direction != 0)
        {
            Velocity = Velocity with {
                X = Mathf.MoveToward(Velocity.X, direction * Speed, (float)(Acceleration * delta))
            };
            AnimatedSprite.FlipH = direction < 0;
        }
        else
        {
            Velocity = Velocity with {
                X = Mathf.MoveToward(Velocity.X, 0, (float)(Friction * delta))
            };
        }
    }

    private void HandleStates()
    {
        var newstate = PlayerState.Idle;

        if (_currentState == PlayerState.Attacking || _currentState == PlayerState.Hurt)
        {
            return; // Don't change state during attack or hurt
        }

        if (!IsOnFloor())
        {
            newstate = Velocity.Y < 0 ? PlayerState.Jumping : PlayerState.Falling;
        }
        else if (Mathf.Abs(Velocity.X) > 10f)
        {
            newstate = PlayerState.Running;
        }

        ChangeState(newstate);
    }

    private void ChangeState(PlayerState newState)
    {
        if (_currentState == newState) return;

        _currentState = newState;

        switch (_currentState)
        {
            case PlayerState.Idle:
                AnimatedSprite.Play("idle");
                break;
            case PlayerState.Running:
                AnimatedSprite.Play("run");
                break;
            case PlayerState.Jumping:
                AnimatedSprite.Play("jump");
                break;
            case PlayerState.Falling:
                AnimatedSprite.Play("fall");
                break;
            case PlayerState.Attacking:
                AnimatedSprite.Play("attack");
                break;
            case PlayerState.Hurt:
                AnimatedSprite.Play("hurt");
                break;
        }
    }

    private void OnAnimationFinished()
    {
        if (_currentState == PlayerState.Attacking || _currentState == PlayerState.Hurt)
        {
            ChangeState(PlayerState.Idle);
        }
    }
}

// 2. Singleton GameManager in C#
public partial class GameManager : Node
{
    public static GameManager Instance { get; private set; }

    [Signal] public delegate void ScoreChangedEventHandler(int newScore);
    [Signal] public delegate void LivesChangedEventHandler(int newLives);
    [Signal] public delegate void GameStateChangedEventHandler(GameState newState);

    public enum GameState
    {
        Menu,
        Playing,
        Paused,
        GameOver
    }

    private GameState _currentState = GameState.Menu;
    private int _score = 0;
    private int _lives = 3;
    private int _highScore = 0;
    private int _currentLevel = 1;

    // Properties with setters that emit signals
    public GameState CurrentState
    {
        get => _currentState;
        set
        {
            if (_currentState != value)
            {
                _currentState = value;
                EmitSignal(GameStateChangedSignalName, (int)value);

                switch (value)
                {
                    case GameState.Playing:
                        Input.MouseMode = Input.MouseModeEnum.Captured;
                        break;
                    case GameState.Menu:
                    case GameState.Paused:
                        Input.MouseMode = Input.MouseModeEnum.Visible;
                        break;
                }
            }
        }
    }

    public int Score
    {
        get => _score;
        set
        {
            if (_score != value)
            {
                _score = value;
                EmitSignal(ScoreChangedSignalName, value);

                if (_score > _highScore)
                {
                    _highScore = _score;
                    SaveGameData();
                }
            }
        }
    }

    public int Lives
    {
        get => _lives;
        set
        {
            if (_lives != value)
            {
                _lives = Mathf.Max(0, value);
                EmitSignal(LivesChangedSignalName, _lives);

                if (_lives <= 0)
                {
                    CurrentState = GameState.GameOver;
                }
            }
        }
    }

    public override void _Ready()
    {
        if (Instance == null)
        {
            Instance = this;
            LoadGameData();
        }
        else
        {
            QueueFree();
        }
    }

    public void AddScore(int points)
    {
        Score += points;
    }

    public void LoseLife()
    {
        Lives--;
    }

    public void ResetGame()
    {
        Score = 0;
        Lives = 3;
        CurrentLevel = 1;
        CurrentState = GameState.Menu;
    }

    private const string SavePath = "user://savegame.json";

    public void SaveGameData()
    {
        var saveData = new
        {
            highScore = _highScore,
            currentLevel = _currentLevel,
            lastPlayed = DateTime.Now.ToString("O")
        };

        var file = FileAccess.Open(SavePath, FileAccess.ModeFlags.Write);
        if (file != null)
        {
            var json = Json.Stringify(saveData);
            file.StoreString(json);
            file.Close();
        }
    }

    public void LoadGameData()
    {
        if (!FileAccess.FileExists(SavePath)) return;

        var file = FileAccess.Open(SavePath, FileAccess.ModeFlags.Read);
        if (file != null)
        {
            var json = file.GetAsText();
            file.Close();

            var jsonParse = new Json();
            var parseResult = jsonParse.Parse(json);

            if (parseResult == Error.Ok)
            {
                var data = jsonParse.Data.AsGodotDictionary();
                _highScore = data.Get("highScore", 0).AsInt32();
                _currentLevel = data.Get("currentLevel", 1).AsInt32();
            }
        }
    }
}

// 3. Enemy AI with C#
public partial class EnemyAI : CharacterBody2D
{
    [Export] public float Speed { get; set; } = 100.0f;
    [Export] public float DetectionRange { get; set; } = 150.0f;
    [Export] public float AttackRange { get; set; } = 50.0f;
    [Export] public float AttackCooldown { get; set; } = 1.0f;

    private Node2D _target;
    private Vector2 _patrolDirection;
    private float _attackTimer = 0f;
    private EnemyState _currentState = EnemyState.Patrol;

    private enum EnemyState
    {
        Patrol,
        Chase,
        Attack,
        Idle
    }

    [Export] public PackedScene ProjectileScene { get; set; }

    public override void _Ready()
    {
        _patrolDirection = new Vector2(GD.Randf(), GD.Randf()).Normalized();

        // Find player
        _target = GetTree().GetFirstNodeInGroup("player") as Node2D;
    }

    public override void _PhysicsProcess(double delta)
    {
        UpdateState();
        HandleMovement(delta);
        HandleAttack(delta);
        MoveAndSlide();
    }

    private void UpdateState()
    {
        if (_target == null)
        {
            _currentState = EnemyState.Idle;
            return;
        }

        var distanceToTarget = GlobalPosition.DistanceTo(_target.GlobalPosition);

        switch (_currentState)
        {
            case EnemyState.Patrol:
                if (distanceToTarget <= DetectionRange)
                {
                    _currentState = EnemyState.Chase;
                }
                break;

            case EnemyState.Chase:
                if (distanceToTarget <= AttackRange)
                {
                    _currentState = EnemyState.Attack;
                }
                else if (distanceToTarget > DetectionRange * 1.5f)
                {
                    _currentState = EnemyState.Patrol;
                }
                break;

            case EnemyState.Attack:
                if (distanceToTarget > AttackRange)
                {
                    _currentState = EnemyState.Chase;
                }
                break;
        }
    }

    private void HandleMovement(double delta)
    {
        switch (_currentState)
        {
            case EnemyState.Patrol:
                Velocity = _patrolDirection * Speed;

                // Check for walls and change direction
                if (IsOnWall())
                {
                    _patrolDirection = -_patrolDirection;
                }
                break;

            case EnemyState.Chase:
                if (_target != null)
                {
                    var direction = (_target.GlobalPosition - GlobalPosition).Normalized();
                    Velocity = direction * Speed;
                }
                break;

            default:
                Velocity = Vector2.Zero;
                break;
        }
    }

    private void HandleAttack(double delta)
    {
        if (_currentState == EnemyState.Attack)
        {
            _attackTimer -= (float)delta;

            if (_attackTimer <= 0f && _target != null)
            {
                PerformAttack();
                _attackTimer = AttackCooldown;
            }
        }
    }

    private void PerformAttack()
    {
        if (ProjectileScene == null || _target == null) return;

        var projectile = ProjectileScene.Instantiate() as Node2D;
        if (projectile != null)
        {
            GetParent().AddChild(projectile);
            projectile.GlobalPosition = GlobalPosition;

            // Set projectile direction towards target
            var direction = (_target.GlobalPosition - GlobalPosition).Normalized();
            projectile.Call("SetDirection", direction);
        }
    }
}

// 4. Inventory System with C#
public partial class InventoryManager : Node
{
    [Signal] public delegate void ItemAddedEventHandler(ItemData item);
    [Signal] public delegate void ItemRemovedEventHandler(ItemData item);
    [Signal] public delegate void InventoryChangedEventHandler();

    public List<InventorySlot> Slots { get; private set; } = new List<InventorySlot>();
    public int Capacity { get; private set; } = 20;

    public InventoryManager()
    {
        // Initialize inventory slots
        for (int i = 0; i < Capacity; i++)
        {
            Slots.Add(new InventorySlot());
        }
    }

    public bool AddItem(ItemData item, int quantity = 1)
    {
        // Try to stack with existing items
        if (item.IsStackable)
        {
            foreach (var slot in Slots)
            {
                if (slot.Item?.Id == item.Id && slot.Quantity < item.MaxStackSize)
                {
                    var canAdd = Mathf.Min(quantity, item.MaxStackSize - slot.Quantity);
                    slot.Quantity += canAdd;
                    quantity -= canAdd;

                    EmitSignal(ItemAddedSignalName, item);
                    EmitSignal(InventoryChangedSignalName);

                    if (quantity <= 0) return true;
                }
            }
        }

        // Try to add to empty slots
        foreach (var slot in Slots)
        {
            if (slot.Item == null)
            {
                slot.Item = item;
                slot.Quantity = quantity;

                EmitSignal(ItemAddedSignalName, item);
                EmitSignal(InventoryChangedSignalName);

                return true;
            }
        }

        return false; // No space available
    }

    public bool RemoveItem(ItemData item, int quantity = 1)
    {
        foreach (var slot in Slots)
        {
            if (slot.Item?.Id == item.Id)
            {
                if (slot.Quantity >= quantity)
                {
                    slot.Quantity -= quantity;

                    if (slot.Quantity <= 0)
                    {
                        slot.Item = null;
                        slot.Quantity = 0;
                    }

                    EmitSignal(ItemRemovedSignalName, item);
                    EmitSignal(InventoryChangedSignalName);

                    return true;
                }
            }
        }

        return false; // Item not found
    }

    public int GetItemCount(ItemData item)
    {
        int total = 0;
        foreach (var slot in Slots)
        {
            if (slot.Item?.Id == item.Id)
            {
                total += slot.Quantity;
            }
        }
        return total;
    }

    public List<InventorySlot> GetItemsByType(Type itemType)
    {
        return Slots.Where(slot => slot.Item?.GetType() == itemType).ToList();
    }
}

// Data classes
public partial class ItemData : Resource
{
    [Export] public string Id { get; set; }
    [Export] public string Name { get; set; }
    [Export] public string Description { get; set; }
    [Export] public Texture2D Icon { get; set; }
    [Export] public int MaxStackSize { get; set; } = 1;
    [Export] public bool IsStackable => MaxStackSize > 1;
    [Export] public int Value { get; set; }

    public virtual void Use(Node user)
    {
        GD.Print($"Using {Name}");
    }
}

public partial class WeaponData : ItemData
{
    [Export] public int Damage { get; set; }
    [Export] public float AttackSpeed { get; set; } = 1.0f;
    [Export] public float Range { get; set; } = 50.0f;

    public override void Use(Node user)
    {
        GD.Print($"Attacking with {Name} for {Damage} damage");

        // Find enemies in range and deal damage
        var spaceState = user.GetWorld2D().DirectSpaceState;
        var query = PhysicsShapeQueryParameters2D.CreateCircle(user.GlobalPosition, Range);
        query.CollisionMask = 1 << 1; // Enemy layer

        var results = spaceState.IntersectShape(query);
        foreach (var result in results)
        {
            var enemy = result.Collider as EnemyAI;
            enemy?.Call("TakeDamage", Damage);
        }
    }
}

public class InventorySlot
{
    public ItemData Item { get; set; }
    public int Quantity { get; set; }
    public bool IsEmpty => Item == null || Quantity <= 0;
}

// 5. UI Manager with C#
public partial class UIManager : Control
{
    [Export] public PackedScene DamageNumberScene { get; set; }

    private Control _hudContainer;
    private Label _scoreLabel;
    private Label _livesLabel;
    private Control _pauseMenu;
    private Control _gameOverScreen;

    public override void _Ready()
    {
        // Find UI elements
        _hudContainer = GetNode<Control>("HUDContainer");
        _scoreLabel = GetNode<Label>("HUDContainer/ScoreLabel");
        _livesLabel = GetNode<Label>("HUDContainer/LivesLabel");
        _pauseMenu = GetNode<Control>("PauseMenu");
        _gameOverScreen = GetNode<Control>("GameOverScreen");

        // Connect to GameManager signals
        if (GameManager.Instance != null)
        {
            GameManager.Instance.ScoreChanged += OnScoreChanged;
            GameManager.Instance.LivesChanged += OnLivesChanged;
            GameManager.Instance.GameStateChanged += OnGameStateChanged;
        }

        // Initialize UI state
        _pauseMenu.Visible = false;
        _gameOverScreen.Visible = false;
    }

    private void OnScoreChanged(int newScore)
    {
        if (_scoreLabel != null)
        {
            _scoreLabel.Text = $"Score: {newScore}";
        }
    }

    private void OnLivesChanged(int newLives)
    {
        if (_livesLabel != null)
        {
            _livesLabel.Text = $"Lives: {newLives}";
        }
    }

    private void OnGameStateChanged(GameManager.GameState newState)
    {
        switch (newState)
        {
            case GameManager.GameState.Menu:
                _hudContainer.Visible = false;
                _pauseMenu.Visible = false;
                _gameOverScreen.Visible = false;
                break;

            case GameManager.GameState.Playing:
                _hudContainer.Visible = true;
                _pauseMenu.Visible = false;
                _gameOverScreen.Visible = false;
                break;

            case GameManager.GameState.Paused:
                _pauseMenu.Visible = true;
                break;

            case GameManager.GameState.GameOver:
                _gameOverScreen.Visible = true;
                break;
        }
    }

    public void ShowDamageNumber(Vector2 position, int damage, bool isCrit = false)
    {
        if (DamageNumberScene == null) return;

        var damageNumber = DamageNumberScene.Instantiate() as Control;
        if (damageNumber != null)
        {
            AddChild(damageNumber);
            damageNumber.GlobalPosition = position;

            var label = damageNumber.GetNode<Label>("Label");
            if (label != null)
            {
                label.Text = damage.ToString();
                label.Modulate = isCrit ? Colors.Red : Colors.Yellow;
            }

            // Animate the damage number
            var tween = CreateTween();
            tween.TweenProperty(damageNumber, "global_position", position + Vector2.Up * 50, 1.0f);
            tween.TweenProperty(damageNumber, "modulate:a", 0f, 0.5f);
            tween.TweenCallback(Callable.From(() => damageNumber.QueueFree()));
        }
    }
}

// 6. Performance Optimizations
public partial class ObjectPoolCSharp : Node
{
    [Export] public PackedScene PooledScene { get; set; }
    [Export] public int InitialSize { get; set; } = 10;

    private readonly Queue<Node> _pool = new Queue<Node>();
    private readonly List<Node> _activeObjects = new List<Node>();

    public override void _Ready()
    {
        // Pre-allocate objects
        for (int i = 0; i < InitialSize; i++)
        {
            var obj = PooledScene.Instantiate();
            AddChild(obj);
            obj.Visible = false;
            _pool.Enqueue(obj);
        }
    }

    public Node GetObject()
    {
        Node obj;

        if (_pool.Count > 0)
        {
            obj = _pool.Dequeue();
        }
        else
        {
            obj = PooledScene.Instantiate();
            AddChild(obj);
        }

        obj.Visible = true;
        _activeObjects.Add(obj);

        return obj;
    }

    public void ReturnObject(Node obj)
    {
        if (_activeObjects.Contains(obj))
        {
            _activeObjects.Remove(obj);
            obj.Visible = false;
            _pool.Enqueue(obj);
        }
    }

    public void Clear()
    {
        foreach (var obj in _activeObjects)
        {
            obj.QueueFree();
        }
        _activeObjects.Clear();

        while (_pool.Count > 0)
        {
            var obj = _pool.Dequeue();
            obj.QueueFree();
        }
    }
}

// Project configuration for C#
// project.godot (C# enabled section)
/*
[application]
config/name="Godot C# Game"
run/main_scene="res://scenes/Main.tscn"

[dotnet]
project/assembly_name="MyGame"

[rendering]
renderer/rendering_method="mobile"
renderer/rendering_method.mobile="gl_compatibility"
*/

/*
To use C# in Godot:
1. Create new project with C# template
2. Enable .NET support in Project Settings
3. Install .NET SDK 6.0 or later
4. Create .cs files in the C# project structure
5. Use Godot editor or Visual Studio/VS Code for development

C# benefits in Godot:
- Strong typing and better IDE support
- Access to .NET ecosystem
- Better performance for complex logic
- Advanced debugging and profiling tools
- LINQ and modern C# features
- Async/await support
*/

Werkzeuge

Tools, die oft mit diesem Beispiel genutzt werden

Verwandt

Verwandte Beispielsammlungen

Verwandt

Verwandte Themen

Thema

JSON Schema aus Beispielen und Tabellen ableiten

Leiten Sie aus repräsentativen JSON-Beispielen oder XLSX-Zeilen einen prüfbaren JSON-Schema-Entwurf ab und kontrollieren Sie Typen, Pflichtfelder, Nullwerte und Ausreißer, bevor er als Vertrag dient.

Thema

Klassische Browsergames und schnelle Rätsel

Wähle ein sofort spielbares Browsergame für eine kurze Pause: 2048, Minesweeper, Memory, Quiz und Klassiker für zwei.

Thema

Prompt Engineering und LLM-Eingabevorbereitung

Bereiten Sie LLM-Eingaben vor: Prompts strukturieren, Tokens schaetzen, Sprache uebersetzen oder erkennen, PDF-Belege reinigen und Injection-, Mathematik-, Regex- und Datenrisiken pruefen.

Thema

Selbst gehostetes Gewinnspiel-Widget prüfen und zur Einbettung übergeben

Konfiguration, API-Beispiele, Lesbarkeit und responsive Ansichten prüfen und die Widget-Dateien mit nachvollziehbaren Browser-Abnahmetests übergeben.

Start
Werkzeuge3212
Beispiele593
Visualisierungen471
Dateibetrachter103
Themen239
Schlagwörter333
Bilder, Audio & Video657

Werkzeuge für Bild-, Audio- und Videobearbeitung, Konvertierung und Optimierung

Mathe, Datum & Finanzen647

Rechner, Zahlenwerkzeuge, Datumslogik, Statistik und Finanztools

Design & Farbe298

Werkzeuge für Farben, Layouts, Grafiken, visuelle Gestaltung und Designhilfen

Text & Schreiben209

Werkzeuge für Schreiben, Bereinigung, Formatierung, Extraktion und Textanalyse

Entwicklung & Web193

Entwicklerwerkzeuge, Netzwerk-Utilities, Web-Debugging und Automatisierungshelfer

Konvertierung & Kodierung175

Werkzeuge für Format-, Datei-, Archiv-, Einheiten- und Kodierungskonvertierung

Lead-Quiz veröffentlichen und Kontakte sicher übergeben
Gedenktexte: Familienprüfung und Übergabe zum Druck
Private Gewohnheiten: Sicherung, Wiederherstellung und Freigabeprüfung
Vom Artikel zu X- und LinkedIn-Entwürfen: Faktenprüfung und Übergabe
Interaktive Markdown-Lektion prüfen und offline übergeben

© 2026 Elysia Tools. Alle Rechte vorbehalten.

DokumentationTarifeÜber unsNutzungsbedingungenDatenschutzerklärungCookiesKontakt

Media

Smart Remux

Container per Stream Copy wechseln.

Media

MOV-zu-MP4-Konverter

MOV-Videodateien in MP4-Format konvertieren

Media

MP4-zu-MOV-Konverter

MP4-Videodateien in MOV-Format konvertieren

Media

Batch-Video-Konverter

Konvertieren Sie mehrere Videodateien zwischen verschiedenen Formaten wie MP4, WebM, MKV, AVI, MOV mit Qualitatseinstellungen und Stapelverarbeitung

Media

Video zu GIF Optimiert

Konvertiert Videos in optimiertes GIF-Format mit erweiterten Komprimierungseinstellungen

Media

Video-Schneider

Videoclips präzise schneiden mit Unterstützung für mehrere Formate und Qualitätseinstellungen

Media

Video Horizontal Spiegeln

Spiegelt Videos links-rechts und behaelt nach Moeglichkeit Containerformat und Audio bei

Media

Video-Stream-Extraktor

Prueft Streams zuerst und extrahiert Audio, stummes Video oder beides ohne Transkodierung

Spieleentwicklung

Bevy Game Engine Beispiele

Bevy Rust Game Engine Beispiele mit ECS, 2D/3D Grafiken, Audio und Spielmechaniken

Spieleentwicklung

Unity C# Skriptbeispiele

Unity C# Skriptbeispiele für Spielerbewegung, UI-Systeme, Physik, Animationen und Spielmechaniken

Spieleentwicklung

Phaser.js Beispiele

Phaser.js Spiel-Engine Beispiele einschließlich 2D-Spiele, Animationen, Physik, Sprites und interaktive Spielmechaniken

C#

Windows Dateioperationen - C# Beispiele

Umfassende C# Dateioperationsbeispiele für Windows-Plattform einschließlich Text-E/A, Kopieren, Verzeichnisdurchlauf und Dateisystemoperationen

Textverarbeitung

Beispiele für Doppelte Zeilen

Beispieldateien mit verschiedenen Arten doppelter Zeilen zum Testen von Tools zum Entfernen von Duplikaten

Textverarbeitung

Sonderzeichen-Beispiele

Beispieltextdateien mit verschiedenen Sonderzeichen, Interpunktionszeichen und Symbolen zum Testen der Entfernung nicht-alphanumerischer Zeichen