diff --git a/DDApp/DDApplication/BotSessionLogger.cs b/DDApp/DDApplication/BotSessionLogger.cs
new file mode 100644
index 0000000..79538c1
--- /dev/null
+++ b/DDApp/DDApplication/BotSessionLogger.cs
@@ -0,0 +1,221 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+namespace DDApplication;
+
+internal sealed class BotSessionLogger : IDisposable
+{
+    private readonly object _gate = new();
+    private readonly DateTimeOffset _startedAt = DateTimeOffset.UtcNow;
+    private readonly Dictionary<string, int> _actionAttempts = new(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<string, int> _actionSuccess = new(StringComparer.OrdinalIgnoreCase);
+
+    private StreamWriter? _eventsWriter;
+    private bool _disposed;
+
+    public string SessionId { get; } = Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture);
+    public string DirectoryPath { get; }
+    public string EventsPath { get; }
+    public string SummaryPath { get; }
+    public string LatestSymlinkPath { get; }
+
+    public BotSessionLogger()
+    {
+        var baseDir = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+        DirectoryPath = Path.Combine(baseDir, "DDApplication", "logs");
+        Directory.CreateDirectory(DirectoryPath);
+
+        var stamp = DateTimeOffset.UtcNow.ToString("yyyyMMdd_HHmmss", CultureInfo.InvariantCulture);
+        EventsPath = Path.Combine(DirectoryPath, $"bot_{stamp}_{SessionId}.events.csv");
+        SummaryPath = Path.Combine(DirectoryPath, $"bot_{stamp}_{SessionId}.summary.txt");
+        LatestSymlinkPath = Path.Combine(DirectoryPath, "latest.log");
+
+        _eventsWriter = new StreamWriter(EventsPath, append: false, Encoding.UTF8) { AutoFlush = true };
+        _eventsWriter.WriteLine("timestamp_utc,event,label,executed,hp,max_hp,kills,deaths,pos_x,pos_y,pressure,details");
+        UpdateLatestSymlink();
+    }
+
+    public void LogDecision(
+        string label,
+        bool executed,
+        double hp,
+        double maxHp,
+        int kills,
+        int deaths,
+        int x,
+        int y,
+        bool pressure,
+        string details)
+    {
+        lock (_gate)
+        {
+            if (_disposed || _eventsWriter is null)
+            {
+                return;
+            }
+
+            Increment(_actionAttempts, label);
+            if (executed)
+            {
+                Increment(_actionSuccess, label);
+            }
+
+            _eventsWriter.WriteLine(string.Join(",",
+                Csv(DateTimeOffset.UtcNow.ToString("O", CultureInfo.InvariantCulture)),
+                Csv("decision"),
+                Csv(label),
+                Csv(executed ? "1" : "0"),
+                Csv(hp.ToString("0.00", CultureInfo.InvariantCulture)),
+                Csv(maxHp.ToString("0.00", CultureInfo.InvariantCulture)),
+                Csv(kills.ToString(CultureInfo.InvariantCulture)),
+                Csv(deaths.ToString(CultureInfo.InvariantCulture)),
+                Csv(x.ToString(CultureInfo.InvariantCulture)),
+                Csv(y.ToString(CultureInfo.InvariantCulture)),
+                Csv(pressure ? "1" : "0"),
+                Csv(details)));
+        }
+    }
+
+    public void LogTelemetry(
+        double hp,
+        double maxHp,
+        int kills,
+        int deaths,
+        double progress,
+        double remaining,
+        string level,
+        int x,
+        int y,
+        string details)
+    {
+        lock (_gate)
+        {
+            if (_disposed || _eventsWriter is null)
+            {
+                return;
+            }
+
+            _eventsWriter.WriteLine(string.Join(",",
+                Csv(DateTimeOffset.UtcNow.ToString("O", CultureInfo.InvariantCulture)),
+                Csv("telemetry"),
+                Csv(level),
+                Csv(""),
+                Csv(hp.ToString("0.00", CultureInfo.InvariantCulture)),
+                Csv(maxHp.ToString("0.00", CultureInfo.InvariantCulture)),
+                Csv(kills.ToString(CultureInfo.InvariantCulture)),
+                Csv(deaths.ToString(CultureInfo.InvariantCulture)),
+                Csv(x.ToString(CultureInfo.InvariantCulture)),
+                Csv(y.ToString(CultureInfo.InvariantCulture)),
+                Csv(""),
+                Csv($"progress={progress:0.00};remaining={remaining:0.00};{details}")));
+        }
+    }
+
+    public void LogEvent(string label, string details)
+    {
+        lock (_gate)
+        {
+            if (_disposed || _eventsWriter is null)
+            {
+                return;
+            }
+
+            _eventsWriter.WriteLine(string.Join(",",
+                Csv(DateTimeOffset.UtcNow.ToString("O", CultureInfo.InvariantCulture)),
+                Csv("event"),
+                Csv(label),
+                Csv(""),
+                Csv(""),
+                Csv(""),
+                Csv(""),
+                Csv(""),
+                Csv(""),
+                Csv(""),
+                Csv(""),
+                Csv(details)));
+        }
+    }
+
+    public void WriteSummaryAndDispose(double finalHp, double finalMaxHp, int finalKills, int finalDeaths)
+    {
+        lock (_gate)
+        {
+            if (_disposed)
+            {
+                return;
+            }
+
+            var elapsed = DateTimeOffset.UtcNow - _startedAt;
+            var minutes = Math.Max(elapsed.TotalMinutes, 0.01);
+            var kd = finalDeaths == 0 ? finalKills : (double)finalKills / finalDeaths;
+
+            var lines = new List<string>
+            {
+                $"session={SessionId}",
+                $"started_utc={_startedAt:O}",
+                $"ended_utc={DateTimeOffset.UtcNow:O}",
+                $"duration_minutes={minutes:0.00}",
+                $"kills={finalKills}",
+                $"deaths={finalDeaths}",
+                $"kd={kd:0.000}",
+                $"kills_per_min={(finalKills / minutes):0.000}",
+                $"deaths_per_min={(finalDeaths / minutes):0.000}",
+                $"final_hp={finalHp:0.00}/{finalMaxHp:0.00}",
+                "actions="
+            };
+
+            foreach (var attempt in _actionAttempts.OrderBy(x => x.Key))
+            {
+                _actionSuccess.TryGetValue(attempt.Key, out var success);
+                var rate = attempt.Value == 0 ? 0 : (double)success / attempt.Value;
+                lines.Add($"  {attempt.Key}: attempts={attempt.Value}, success={success}, rate={rate:0.000}");
+            }
+
+            File.WriteAllLines(SummaryPath, lines, Encoding.UTF8);
+
+            _eventsWriter?.Dispose();
+            _eventsWriter = null;
+            _disposed = true;
+        }
+    }
+
+    public void Dispose()
+    {
+        WriteSummaryAndDispose(0, 0, 0, 0);
+    }
+
+    private static void Increment(Dictionary<string, int> dict, string key)
+    {
+        dict.TryGetValue(key, out var current);
+        dict[key] = current + 1;
+    }
+
+    private static string Csv(string value)
+    {
+        var safe = value.Replace("\"", "\"\"");
+        return $"\"{safe}\"";
+    }
+
+    private void UpdateLatestSymlink()
+    {
+        try
+        {
+            if (File.Exists(LatestSymlinkPath) || Directory.Exists(LatestSymlinkPath))
+            {
+                File.Delete(LatestSymlinkPath);
+            }
+
+            File.CreateSymbolicLink(LatestSymlinkPath, EventsPath);
+        }
+        catch
+        {
+            // Best-effort only; logging should continue even if symlink creation fails.
+        }
+    }
+}
+
+
diff --git a/DDApp/DDApplication/MainWindow.axaml b/DDApp/DDApplication/MainWindow.axaml
index 9c87eff..9aa11a1 100644
--- a/DDApp/DDApplication/MainWindow.axaml
+++ b/DDApp/DDApplication/MainWindow.axaml
@@ -2,10 +2,47 @@
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
-        mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="450"
+        mc:Ignorable="d" d:DesignWidth="1320" d:DesignHeight="860"
+        Width="1320" Height="860"
         x:Class="DDApplication.MainWindow"
-        Title="DDApplication">
-    <Panel HorizontalAlignment="Center" VerticalAlignment="Center">
-        <Label>Welcome to Avalonia!</Label>
-    </Panel>
+        Title="Digital Dojo Bot Controller">
+    <Grid RowDefinitions="Auto,Auto,*,Auto" ColumnDefinitions="2*,2*,3*" Margin="12">
+        <StackPanel Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="3" Orientation="Horizontal" Spacing="8">
+            <Button x:Name="StartButton" Content="Start Bot" Width="120"/>
+            <Button x:Name="StopButton" Content="Stop Bot" Width="120" IsEnabled="False"/>
+            <TextBlock Text="API Key:" VerticalAlignment="Center"/>
+            <TextBox x:Name="ApiKeyBox" Width="360" Watermark="GUID player token"/>
+            <TextBlock x:Name="StatusText" VerticalAlignment="Center" Text="Idle"/>
+        </StackPanel>
+
+        <Border Grid.Row="1" Grid.Column="0" Grid.ColumnSpan="3" Margin="0,8,0,8" Padding="8" BorderThickness="1" CornerRadius="6">
+            <SelectableTextBlock x:Name="StatsText" TextWrapping="Wrap" Text="Waiting for game state..." Focusable="True"/>
+        </Border>
+
+        <Border Grid.Row="2" Grid.Column="0" Margin="0,0,8,0" Padding="8" BorderThickness="1" CornerRadius="6">
+            <Grid RowDefinitions="Auto,*" RowSpacing="6">
+                <TextBlock Text="Bot Knowledge" FontWeight="Bold"/>
+                <ScrollViewer Grid.Row="1" HorizontalScrollBarVisibility="Auto" VerticalScrollBarVisibility="Auto">
+                    <UniformGrid x:Name="KnowledgeGrid" Rows="21" Columns="21"/>
+                </ScrollViewer>
+            </Grid>
+        </Border>
+
+        <Border Grid.Row="2" Grid.Column="1" Margin="0,0,8,0" Padding="8" BorderThickness="1" CornerRadius="6">
+            <Grid RowDefinitions="Auto,Auto,*" RowSpacing="8">
+                <TextBlock Text="Decision + Cooldowns" FontWeight="Bold"/>
+                <TextBlock x:Name="DecisionText" Grid.Row="1" TextWrapping="Wrap" Text="No decision yet."/>
+                <TextBlock x:Name="CooldownText" Grid.Row="2" TextWrapping="Wrap"/>
+            </Grid>
+        </Border>
+
+        <Border Grid.Row="2" Grid.Column="2" Padding="8" BorderThickness="1" CornerRadius="6">
+            <Grid RowDefinitions="Auto,*" RowSpacing="6">
+                <TextBlock Text="Action Log" FontWeight="Bold"/>
+                <ListBox x:Name="LogList" Grid.Row="1"/>
+            </Grid>
+        </Border>
+
+        <TextBlock Grid.Row="3" Grid.Column="0" Grid.ColumnSpan="3" Margin="0,8,0,0" Text="Legend: P=bot, N=scan-nearest, *=high threat, +=medium threat, .=low threat" />
+    </Grid>
 </Window>
diff --git a/DDApp/DDApplication/MainWindow.axaml.cs b/DDApp/DDApplication/MainWindow.axaml.cs
index 2907ab2..5eabd07 100644
--- a/DDApp/DDApplication/MainWindow.axaml.cs
+++ b/DDApp/DDApplication/MainWindow.axaml.cs
@@ -1,13 +1,1016 @@
 using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Globalization;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
 using Avalonia.Controls;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Threading;
 
 namespace DDApplication;
 
 public partial class MainWindow : Window
 {
-    private readonly string _apiKey = Program.Configuration["APIKEY"] ?? throw new ArgumentNullException(nameof(_apiKey));
+    private const int MapRadius = 10;
+    private static readonly TimeSpan TickDelay = TimeSpan.FromMilliseconds(70);
+
+    private static readonly IReadOnlyDictionary<BotAction, TimeSpan> Cooldowns = new Dictionary<BotAction, TimeSpan>
+    {
+        [BotAction.Move] = TimeSpan.FromMilliseconds(250),
+        [BotAction.Hit] = TimeSpan.FromMilliseconds(250),
+        [BotAction.Radar] = TimeSpan.FromMilliseconds(250),
+        [BotAction.Shoot] = TimeSpan.FromMilliseconds(1000),
+        [BotAction.Peek] = TimeSpan.FromMilliseconds(1000),
+        [BotAction.Scan] = TimeSpan.FromMilliseconds(2000),
+        [BotAction.Dash] = TimeSpan.FromMilliseconds(5000),
+        [BotAction.Special] = TimeSpan.FromMilliseconds(5000),
+        [BotAction.Teleport] = TimeSpan.FromMilliseconds(20000),
+    };
+
+    private readonly string _configuredApiKey = Program.Configuration["APIKEY"] ?? string.Empty;
+    private readonly HttpClient _httpClient = new() { Timeout = TimeSpan.FromSeconds(8) };
+    private readonly DigitalDojoApiClient _client;
+    private readonly ObservableCollection<string> _logEntries = [];
+    private readonly Dictionary<(int X, int Y), double> _enemyHeat = [];
+    private readonly Dictionary<string, int> _lastRadar = new(StringComparer.OrdinalIgnoreCase);
+    private readonly Dictionary<Direction, PeekEntitiesAsyncResponse> _lastPeek = [];
+    private readonly Dictionary<BotAction, DateTimeOffset> _lastUse = [];
+    private readonly Dictionary<Direction, int> _blockedDirectionTicks = [];
+    private readonly Queue<DateTimeOffset> _recentDeaths = new();
+    private readonly TextBlock[,] _mapCells = new TextBlock[MapRadius * 2 + 1, MapRadius * 2 + 1];
+    private readonly Random _random = new();
+
+    private CancellationTokenSource? _runCts;
+    private Task? _runTask;
+    private BotSessionLogger? _sessionLogger;
+
+    private Guid _playerToken;
+    private Guid? _gameToken;
+    private bool _botRunning;
+    private int _x;
+    private int _y;
+    private int _peekDirectionIndex;
+    private int _kills;
+    private int _deaths;
+    private double _currentHealth;
+    private double _maxHealth;
+    private double _progress;
+    private double _remainingTime;
+    private string _levelName = "-";
+    private DateTimeOffset _lastStatsAt = DateTimeOffset.MinValue;
+    private DateTimeOffset _lastStatusAt = DateTimeOffset.MinValue;
+    private (int X, int Y)? _nearestEnemy;
+    private Direction _lastMoveDirection = Direction.North;
+    private int _recentDamageTicks;
+    private int _survivalTicks;
+    private bool _lastUnderPressure;
+
     public MainWindow()
     {
+        _client = new DigitalDojoApiClient("https://game-dd.countit.at", _httpClient);
+
         InitializeComponent();
+        BuildKnowledgeGrid();
+
+        ApiKeyBox.Text = _configuredApiKey;
+        LogList.ItemsSource = _logEntries;
+
+        StartButton.Click += async (_, _) => await StartBotAsync();
+        StopButton.Click += async (_, _) => await StopBotAsync(closeGame: true);
+
+        RenderTelemetry("Waiting to start.");
     }
-}
\ No newline at end of file
+
+    protected override async void OnClosed(EventArgs e)
+    {
+        await StopBotAsync(closeGame: false);
+        _httpClient.Dispose();
+        base.OnClosed(e);
+    }
+
+    private async Task StartBotAsync()
+    {
+        if (_botRunning)
+        {
+            return;
+        }
+
+        if (!Guid.TryParse(ApiKeyBox.Text, out var parsedToken))
+        {
+            SetStatus("Invalid API key GUID.");
+            return;
+        }
+
+        _playerToken = parsedToken;
+        _runCts = new CancellationTokenSource();
+        _botRunning = true;
+        _sessionLogger = new BotSessionLogger();
+        _sessionLogger.LogEvent("session-start", "Bot session created");
+
+        StartButton.IsEnabled = false;
+        StopButton.IsEnabled = true;
+        ApiKeyBox.IsEnabled = false;
+
+        ResetKnowledgeState();
+
+        var started = await EnsureGameStartedAsync(_runCts.Token);
+        if (!started)
+        {
+            await StopBotAsync(closeGame: false);
+            return;
+        }
+
+        AppendLog($"Logging to {_sessionLogger.EventsPath}");
+        SetStatus("Bot running.");
+        _runTask = Task.Run(() => BotLoopAsync(_runCts.Token));
+    }
+
+    private async Task StopBotAsync(bool closeGame)
+    {
+        if (_runCts is not null)
+        {
+            _runCts.Cancel();
+        }
+
+        if (_runTask is not null)
+        {
+            try
+            {
+                await _runTask;
+            }
+            catch (OperationCanceledException)
+            {
+                // Normal shutdown path.
+            }
+        }
+
+        _runTask = null;
+        _runCts?.Dispose();
+        _runCts = null;
+
+        if (closeGame && _playerToken != Guid.Empty)
+        {
+            try
+            {
+                await _client.CloseAsync(_playerToken);
+                AppendLog("Game closed.");
+            }
+            catch (Exception ex)
+            {
+                AppendLog($"Close failed: {ex.Message}");
+            }
+        }
+
+        if (_sessionLogger is not null)
+        {
+            _sessionLogger.LogEvent("session-stop", "Bot session stopping");
+            _sessionLogger.WriteSummaryAndDispose(_currentHealth, _maxHealth, _kills, _deaths);
+            AppendLog($"Summary written: {_sessionLogger.SummaryPath}");
+            _sessionLogger = null;
+        }
+
+        _botRunning = false;
+        StartButton.IsEnabled = true;
+        StopButton.IsEnabled = false;
+        ApiKeyBox.IsEnabled = true;
+        SetStatus("Stopped.");
+    }
+
+    private async Task<bool> EnsureGameStartedAsync(CancellationToken ct)
+    {
+        try
+        {
+            var status = await _client.StatusAsync(_playerToken, ct);
+            if (status.Running)
+            {
+                _gameToken = Guid.TryParse(status.Gameid, out var existingGameId) ? existingGameId : null;
+                _levelName = status.Level ?? "-";
+                AppendLog("Reusing running game.");
+                return true;
+            }
+        }
+        catch (ApiException<ErrorResponse>)
+        {
+            // No game running yet.
+        }
+        catch (Exception ex)
+        {
+            AppendLog($"Status check failed: {ex.Message}");
+            return false;
+        }
+
+        try
+        {
+            var created = await _client.CreateAsync(_playerToken, ct);
+            _gameToken = Guid.TryParse(created.Gameid, out var gameId) ? gameId : null;
+            _levelName = created.Level ?? "-";
+            AppendLog($"Game created ({_gameToken?.ToString() ?? "unknown"}).");
+            return true;
+        }
+        catch (Exception ex)
+        {
+            AppendLog($"Create failed: {ex.Message}");
+            return false;
+        }
+    }
+
+    private async Task BotLoopAsync(CancellationToken ct)
+    {
+        while (!ct.IsCancellationRequested)
+        {
+            try
+            {
+                if (_recentDamageTicks > 0)
+                {
+                    _recentDamageTicks--;
+                }
+
+                if (_survivalTicks > 0)
+                {
+                    _survivalTicks--;
+                }
+
+                DecayBlockedDirections();
+                await PollTelemetryAsync(ct);
+                DecayHeat();
+                await GatherSensorsAsync(ct);
+
+                var decision = BuildDecision();
+                if (decision is not null)
+                {
+                    var executed = await decision.Value.Execute(ct);
+                    _sessionLogger?.LogDecision(
+                        decision.Value.Label,
+                        executed,
+                        _currentHealth,
+                        _maxHealth,
+                        _kills,
+                        _deaths,
+                        _x,
+                        _y,
+                        _lastUnderPressure,
+                        decision.Value.Reason);
+
+                    if (executed)
+                    {
+                        AppendLog($"{decision.Value.Label}: {decision.Value.Reason}");
+                    }
+                }
+
+                RenderTelemetry(decision?.Reason ?? "Scanning...");
+                RenderKnowledgeGrid();
+            }
+            catch (OperationCanceledException)
+            {
+                break;
+            }
+            catch (Exception ex)
+            {
+                AppendLog($"Loop error: {ex.Message}");
+                await Task.Delay(300, ct);
+            }
+
+            await Task.Delay(TickDelay, ct);
+        }
+    }
+
+    private async Task PollTelemetryAsync(CancellationToken ct)
+    {
+        var now = DateTimeOffset.UtcNow;
+
+        if (now - _lastStatsAt >= TimeSpan.FromMilliseconds(650))
+        {
+            _lastStatsAt = now;
+            try
+            {
+                var stats = await _client.StatsAsync(_playerToken, ct);
+                var previousHealth = _currentHealth;
+                var previousDeaths = _deaths;
+                _kills = stats.Stats?.Kills ?? _kills;
+                _deaths = stats.Stats?.Deaths ?? _deaths;
+                _currentHealth = stats.Health?.Currenthealth ?? _currentHealth;
+                _maxHealth = stats.Health?.Maxhealth ?? _maxHealth;
+                _progress = stats.Level?.Progress ?? _progress;
+                _remainingTime = stats.Level?.Remainingtime ?? _remainingTime;
+                _levelName = stats.Level?.Name ?? _levelName;
+
+                if (previousHealth > 0.1 && _currentHealth + 0.05 < previousHealth)
+                {
+                    _recentDamageTicks = 20;
+                }
+
+                if (_deaths > previousDeaths)
+                {
+                    var nowDeath = DateTimeOffset.UtcNow;
+                    _recentDeaths.Enqueue(nowDeath);
+                    while (_recentDeaths.Count > 0 && nowDeath - _recentDeaths.Peek() > TimeSpan.FromSeconds(90))
+                    {
+                        _recentDeaths.Dequeue();
+                    }
+
+                    _survivalTicks = Math.Max(_survivalTicks, 180 + _recentDeaths.Count * 30);
+                    _x = 0;
+                    _y = 0;
+                    _enemyHeat.Clear();
+                    _nearestEnemy = null;
+                    _sessionLogger?.LogEvent("death", $"death_count={_deaths};death_window_90s={_recentDeaths.Count}");
+                }
+
+                _sessionLogger?.LogTelemetry(
+                    _currentHealth,
+                    _maxHealth,
+                    _kills,
+                    _deaths,
+                    _progress,
+                    _remainingTime,
+                    _levelName,
+                    _x,
+                    _y,
+                    $"survival_ticks={_survivalTicks};damage_ticks={_recentDamageTicks}");
+            }
+            catch (Exception ex)
+            {
+                AppendLog($"Stats failed: {ex.Message}");
+            }
+        }
+
+        if (now - _lastStatusAt >= TimeSpan.FromSeconds(2))
+        {
+            _lastStatusAt = now;
+            try
+            {
+                var status = await _client.StatusAsync(_playerToken, ct);
+                _levelName = status.Level ?? _levelName;
+                if (_gameToken is null && Guid.TryParse(status.Gameid, out var gameId))
+                {
+                    _gameToken = gameId;
+                }
+            }
+            catch
+            {
+                // Status occasionally fails while game is rotating; ignore.
+            }
+        }
+    }
+
+    private async Task GatherSensorsAsync(CancellationToken ct)
+    {
+        if (Ready(BotAction.Radar))
+        {
+            try
+            {
+                var radar = await _client.RadarAsync(_playerToken, ct);
+                MarkUsed(BotAction.Radar);
+                _lastRadar.Clear();
+                foreach (var kvp in radar.RadarResults ?? new Dictionary<string, int>())
+                {
+                    _lastRadar[kvp.Key] = kvp.Value;
+                }
+
+                ApplyRadarHeat();
+            }
+            catch (Exception ex)
+            {
+                AppendLog($"Radar failed: {ex.Message}");
+            }
+        }
+
+        if (Ready(BotAction.Scan))
+        {
+            try
+            {
+                var scan = await _client.ScanAsync(_playerToken, ct);
+                MarkUsed(BotAction.Scan);
+                var sx = scan.DifferenceToNearestPlayer?.X;
+                var sy = scan.DifferenceToNearestPlayer?.Y;
+                _nearestEnemy = sx.HasValue && sy.HasValue ? (sx.Value, sy.Value) : null;
+                if (_nearestEnemy.HasValue)
+                {
+                    AddHeat(_x + _nearestEnemy.Value.X, _y + _nearestEnemy.Value.Y, 5.5);
+                }
+            }
+            catch (Exception ex)
+            {
+                AppendLog($"Scan failed: {ex.Message}");
+            }
+        }
+
+        if (Ready(BotAction.Peek))
+        {
+            var dir = (Direction)(_peekDirectionIndex % 4);
+            _peekDirectionIndex++;
+            try
+            {
+                var peek = await _client.PeekAsync(_playerToken, (int)dir, ct);
+                MarkUsed(BotAction.Peek);
+                _lastPeek[dir] = peek;
+                ApplyPeekHeat(dir, peek);
+            }
+            catch (Exception ex)
+            {
+                AppendLog($"Peek {dir} failed: {ex.Message}");
+            }
+        }
+    }
+
+    private BotDecision? BuildDecision()
+    {
+        var hpRatio = _maxHealth > 0.1 ? _currentHealth / _maxHealth : 1.0;
+
+        var immediateDir = _lastPeek
+            .Where(x => x.Value.Executed && x.Value.PlayersInSight > 0 && x.Value.SightedPlayerDistance == 1)
+            .Select(x => (Direction?)x.Key)
+            .FirstOrDefault();
+
+        var closeThreats = _lastPeek.Values.Count(x => x.Executed && x.PlayersInSight > 0 && (x.SightedPlayerDistance ?? 99) <= 2);
+        if (_nearestEnemy.HasValue && Math.Abs(_nearestEnemy.Value.X) + Math.Abs(_nearestEnemy.Value.Y) <= 2)
+        {
+            closeThreats++;
+        }
+
+        var underPressure = hpRatio < 0.58 || _recentDamageTicks > 0 || closeThreats >= 2 || _survivalTicks > 0;
+        _lastUnderPressure = underPressure;
+
+        if (Ready(BotAction.Special) && closeThreats >= 2)
+        {
+            return new BotDecision(
+                "specialattack",
+                "Multiple enemies close; AoE yields best kill rate.",
+                async ct =>
+                {
+                    var response = await _client.SpecialattackAsync(_playerToken, ct);
+                    MarkUsed(BotAction.Special);
+                    return response.Executed;
+                });
+        }
+
+        if (immediateDir.HasValue && !underPressure && Ready(BotAction.Hit))
+        {
+            var dir = immediateDir.Value;
+            return new BotDecision(
+                "hit",
+                $"Adjacent enemy at {dir}; highest DPS action.",
+                async ct =>
+                {
+                    var response = await _client.HitAsync(_playerToken, (int)dir, ct);
+                    MarkUsed(BotAction.Hit);
+                    return response.Executed;
+                });
+        }
+
+        if (immediateDir.HasValue && Ready(BotAction.Move))
+        {
+            var retreatDirection = Opposite(immediateDir.Value);
+
+            if (Ready(BotAction.Dash) && (hpRatio < 0.40 || _survivalTicks > 0))
+            {
+                return new BotDecision(
+                    "dash-retreat",
+                    $"High pressure escape via dash -> {retreatDirection}.",
+                    async ct =>
+                    {
+                        var response = await _client.DashAsync(_playerToken, (int)retreatDirection, ct);
+                        MarkUsed(BotAction.Dash);
+                        if (response.Executed)
+                        {
+                            ApplyMovement(retreatDirection, Math.Max(response.BlocksDashed, 1));
+                        }
+
+                        return response.Executed;
+                    });
+            }
+
+            return new BotDecision(
+                "move-retreat",
+                $"Adjacent enemy and pressure high; kite to {retreatDirection}.",
+                async ct =>
+                {
+                    var response = await _client.MoveAsync(_playerToken, (int)retreatDirection, ct);
+                    MarkUsed(BotAction.Move);
+                    var moved = response.Executed && response.Move == true;
+                    RegisterMoveResult(retreatDirection, moved);
+                    if (moved)
+                    {
+                        ApplyMovement(retreatDirection, 1);
+                    }
+
+                    return response.Executed;
+                });
+        }
+
+        if (immediateDir.HasValue && Ready(BotAction.Hit))
+        {
+            var dir = immediateDir.Value;
+            return new BotDecision(
+                "hit-last-stand",
+                $"Adjacent enemy at {dir}; strike while move cooldown is active.",
+                async ct =>
+                {
+                    var response = await _client.HitAsync(_playerToken, (int)dir, ct);
+                    MarkUsed(BotAction.Hit);
+                    return response.Executed;
+                });
+        }
+
+        var bestSight = _lastPeek
+            .Where(x => x.Value.Executed && x.Value.PlayersInSight > 0)
+            .OrderBy(x => x.Value.SightedPlayerDistance ?? int.MaxValue)
+            .FirstOrDefault();
+
+        if (bestSight.Value is not null && Ready(BotAction.Shoot))
+        {
+            var dir = bestSight.Key;
+            var dist = bestSight.Value.SightedPlayerDistance ?? 99;
+            if (!underPressure || dist >= 2)
+            {
+                return new BotDecision(
+                    "shoot",
+                    $"Enemy in line of sight to {dir}; ranged hit before moving.",
+                    async ct =>
+                    {
+                        var response = await _client.ShootAsync(_playerToken, (int)dir, ct);
+                        MarkUsed(BotAction.Shoot);
+                        return response.Executed;
+                    });
+            }
+        }
+
+        var moveDirection = GetBestMoveDirection(chase: !underPressure);
+        if (Ready(BotAction.Move))
+        {
+            var reason = underPressure
+                ? $"Pressure high; reposition toward safer lane -> {moveDirection}."
+                : $"Controlled hunt path -> {moveDirection}.";
+
+            return new BotDecision(
+                "move",
+                reason,
+                async ct =>
+                {
+                    var response = await _client.MoveAsync(_playerToken, (int)moveDirection, ct);
+                    MarkUsed(BotAction.Move);
+                    var moved = response.Executed && response.Move == true;
+                    RegisterMoveResult(moveDirection, moved);
+                    if (moved)
+                    {
+                        ApplyMovement(moveDirection, 1);
+                    }
+
+                    return response.Executed;
+                });
+        }
+
+        return null;
+    }
+
+    private Direction GetBestMoveDirection(bool chase)
+    {
+        var scored = new Dictionary<Direction, double>
+        {
+            [Direction.North] = RadarScore(Direction.North),
+            [Direction.East] = RadarScore(Direction.East),
+            [Direction.South] = RadarScore(Direction.South),
+            [Direction.West] = RadarScore(Direction.West),
+        };
+
+        foreach (var dir in scored.Keys.ToArray())
+        {
+            var score = 0.0;
+            score += chase ? scored[dir] * 1.35 : -scored[dir] * 1.0;
+
+            if (_lastPeek.TryGetValue(dir, out var peek) && peek.Executed)
+            {
+                if (peek.PlayersInSight > 0)
+                {
+                    var dist = Math.Max(1, peek.SightedPlayerDistance ?? 6);
+                    score += chase
+                        ? 7.0 / dist + peek.PlayersInSight * 0.8
+                        : -10.0 / dist - peek.PlayersInSight * 0.7;
+                }
+                else if (!chase)
+                {
+                    score += 0.9;
+                }
+            }
+
+            if (_nearestEnemy.HasValue)
+            {
+                var targetDir = DirectionFromVector(_nearestEnemy.Value.X, _nearestEnemy.Value.Y);
+                var awayDir = Opposite(targetDir);
+                if (chase && dir == targetDir)
+                {
+                    score += 4.0;
+                }
+                else if (!chase && dir == awayDir)
+                {
+                    score += 4.5;
+                }
+                else if (!chase && dir == targetDir)
+                {
+                    score -= 3.5;
+                }
+            }
+
+            if (_survivalTicks > 0 && _nearestEnemy.HasValue)
+            {
+                var safest = Opposite(DirectionFromVector(_nearestEnemy.Value.X, _nearestEnemy.Value.Y));
+                if (dir == safest)
+                {
+                    score += 2.8;
+                }
+            }
+
+            if (_blockedDirectionTicks.TryGetValue(dir, out var blockedTicks) && blockedTicks > 0)
+            {
+                score -= 5.0 + blockedTicks * 0.4;
+            }
+
+            if (dir == Opposite(_lastMoveDirection))
+            {
+                score -= 0.6;
+            }
+
+            score += _survivalTicks > 0 ? _random.NextDouble() * 0.2 : _random.NextDouble() * 0.7;
+            scored[dir] = score;
+        }
+
+        return scored.OrderByDescending(x => x.Value).First().Key;
+    }
+
+    private void ApplyRadarHeat()
+    {
+        var north = RadarScore(Direction.North);
+        var east = RadarScore(Direction.East);
+        var south = RadarScore(Direction.South);
+        var west = RadarScore(Direction.West);
+
+        ApplyDirectionalHeat(Direction.North, north, 0.35);
+        ApplyDirectionalHeat(Direction.East, east, 0.35);
+        ApplyDirectionalHeat(Direction.South, south, 0.35);
+        ApplyDirectionalHeat(Direction.West, west, 0.35);
+    }
+
+    private void ApplyPeekHeat(Direction dir, PeekEntitiesAsyncResponse peek)
+    {
+        if (!peek.Executed || peek.PlayersInSight <= 0)
+        {
+            return;
+        }
+
+        var (dx, dy) = Delta(dir);
+        var sightDistance = peek.SightedPlayerDistance ?? 8;
+        var maxTrace = Math.Clamp(sightDistance, 1, 10);
+
+        for (var i = 1; i <= maxTrace; i++)
+        {
+            var certainty = i == sightDistance ? 5.0 : 0.6;
+            AddHeat(_x + dx * i, _y + dy * i, certainty + peek.PlayersInSight * 0.3);
+        }
+    }
+
+    private void ApplyDirectionalHeat(Direction dir, int count, double factor)
+    {
+        if (count <= 0)
+        {
+            return;
+        }
+
+        var (dx, dy) = Delta(dir);
+        for (var i = 1; i <= 8; i++)
+        {
+            AddHeat(_x + dx * i, _y + dy * i, count * factor * (9 - i));
+        }
+    }
+
+    private void DecayHeat()
+    {
+        if (_enemyHeat.Count == 0)
+        {
+            return;
+        }
+
+        var keys = _enemyHeat.Keys.ToArray();
+        foreach (var key in keys)
+        {
+            _enemyHeat[key] *= 0.92;
+            if (_enemyHeat[key] < 0.2)
+            {
+                _enemyHeat.Remove(key);
+            }
+        }
+    }
+
+    private void ApplyMovement(Direction direction, int steps)
+    {
+        var (dx, dy) = Delta(direction);
+        _x += dx * steps;
+        _y += dy * steps;
+        AddHeat(_x, _y, -2.5);
+    }
+
+    private void AddHeat(int worldX, int worldY, double value)
+    {
+        var key = (worldX, worldY);
+        _enemyHeat.TryGetValue(key, out var current);
+        _enemyHeat[key] = Math.Max(0.0, current + value);
+    }
+
+    private int RadarScore(Direction direction)
+    {
+        var keys = direction switch
+        {
+            Direction.North => new[] { "north", "n", "up", "0" },
+            Direction.East => new[] { "east", "e", "right", "1" },
+            Direction.South => new[] { "south", "s", "down", "2" },
+            Direction.West => new[] { "west", "w", "left", "3" },
+            _ => Array.Empty<string>(),
+        };
+
+        var score = 0;
+        foreach (var key in keys)
+        {
+            if (_lastRadar.TryGetValue(key, out var value))
+            {
+                score = Math.Max(score, value);
+            }
+        }
+
+        return score;
+    }
+
+    private static Direction DirectionFromVector(int x, int y)
+    {
+        if (Math.Abs(x) >= Math.Abs(y))
+        {
+            return x >= 0 ? Direction.East : Direction.West;
+        }
+
+        return y >= 0 ? Direction.South : Direction.North;
+    }
+
+    private static (int dx, int dy) Delta(Direction direction)
+    {
+        return direction switch
+        {
+            Direction.North => (0, -1),
+            Direction.East => (1, 0),
+            Direction.South => (0, 1),
+            Direction.West => (-1, 0),
+            _ => (0, 0),
+        };
+    }
+
+    private bool Ready(BotAction action)
+    {
+        if (!_lastUse.TryGetValue(action, out var time))
+        {
+            return true;
+        }
+
+        return DateTimeOffset.UtcNow - time >= Cooldowns[action];
+    }
+
+    private void MarkUsed(BotAction action)
+    {
+        _lastUse[action] = DateTimeOffset.UtcNow;
+    }
+
+    private void ResetKnowledgeState()
+    {
+        _x = 0;
+        _y = 0;
+        _kills = 0;
+        _deaths = 0;
+        _currentHealth = 0;
+        _maxHealth = 10;
+        _progress = 0;
+        _remainingTime = 0;
+        _peekDirectionIndex = 0;
+        _gameToken = null;
+        _nearestEnemy = null;
+        _recentDamageTicks = 0;
+        _survivalTicks = 0;
+        _lastUnderPressure = false;
+        _lastMoveDirection = Direction.North;
+
+        _enemyHeat.Clear();
+        _lastRadar.Clear();
+        _lastPeek.Clear();
+        _lastUse.Clear();
+        _blockedDirectionTicks.Clear();
+        _recentDeaths.Clear();
+        _logEntries.Clear();
+
+        RenderKnowledgeGrid();
+    }
+
+    private void RenderTelemetry(string decisionReason)
+    {
+        Dispatcher.UIThread.Post(() =>
+        {
+            var hpPercent = _maxHealth <= 0.01 ? 0 : (_currentHealth / _maxHealth) * 100.0;
+            var kdr = (_deaths == 0 ? _kills : (double)_kills / _deaths).ToString("0.00", CultureInfo.InvariantCulture);
+
+            StatsText.Text =
+                $"Level: {_levelName} | Kills: {_kills} | Deaths: {_deaths} | K/D: {kdr} | " +
+                $"HP: {_currentHealth.ToString("0.0", CultureInfo.InvariantCulture)}/{_maxHealth.ToString("0.0", CultureInfo.InvariantCulture)} ({hpPercent.ToString("0", CultureInfo.InvariantCulture)}%) | " +
+                $"Progress: {_progress.ToString("0.0", CultureInfo.InvariantCulture)}% | Remaining: {_remainingTime.ToString("0.00", CultureInfo.InvariantCulture)} min | " +
+                $"Pos (estimated): ({_x}, {_y}) | SurvivalMode: {(_survivalTicks > 0 ? "ON" : "OFF")}";
+
+            var nearest = _nearestEnemy.HasValue ? $"({_nearestEnemy.Value.X}, {_nearestEnemy.Value.Y})" : "none";
+            var radar = _lastRadar.Count == 0
+                ? "none"
+                : string.Join(", ", _lastRadar.OrderBy(x => x.Key).Select(x => $"{x.Key}:{x.Value}"));
+
+            DecisionText.Text =
+                $"Reasoning: {decisionReason}\n" +
+                $"Nearest from scan (relative): {nearest}\n" +
+                $"Radar: {radar}";
+
+            CooldownText.Text = string.Join(
+                Environment.NewLine,
+                Cooldowns
+                    .OrderBy(x => x.Key.ToString())
+                    .Select(x => $"{x.Key,-8} {RemainingText(x.Key)}"));
+        });
+    }
+
+    private string RemainingText(BotAction action)
+    {
+        if (!_lastUse.TryGetValue(action, out var last))
+        {
+            return "ready";
+        }
+
+        var remaining = Cooldowns[action] - (DateTimeOffset.UtcNow - last);
+        if (remaining <= TimeSpan.Zero)
+        {
+            return "ready";
+        }
+
+        return $"{remaining.TotalMilliseconds.ToString("0", CultureInfo.InvariantCulture)} ms";
+    }
+
+    private void SetStatus(string text)
+    {
+        Dispatcher.UIThread.Post(() => StatusText.Text = text);
+    }
+
+    private void AppendLog(string message)
+    {
+        Dispatcher.UIThread.Post(() =>
+        {
+            var stamp = DateTime.Now.ToString("HH:mm:ss", CultureInfo.InvariantCulture);
+            _logEntries.Insert(0, $"[{stamp}] {message}");
+            while (_logEntries.Count > 250)
+            {
+                _logEntries.RemoveAt(_logEntries.Count - 1);
+            }
+        });
+    }
+
+    private void BuildKnowledgeGrid()
+    {
+        for (var row = 0; row < _mapCells.GetLength(0); row++)
+        {
+            for (var col = 0; col < _mapCells.GetLength(1); col++)
+            {
+                var block = new TextBlock
+                {
+                    Text = " ",
+                    Width = 18,
+                    Height = 18,
+                    TextAlignment = TextAlignment.Center,
+                    VerticalAlignment = VerticalAlignment.Center,
+                    HorizontalAlignment = HorizontalAlignment.Center,
+                    FontSize = 11,
+                    FontWeight = FontWeight.SemiBold
+                };
+
+                _mapCells[row, col] = block;
+                KnowledgeGrid.Children.Add(block);
+            }
+        }
+    }
+
+    private void RenderKnowledgeGrid()
+    {
+        Dispatcher.UIThread.Post(() =>
+        {
+            for (var row = 0; row < _mapCells.GetLength(0); row++)
+            {
+                for (var col = 0; col < _mapCells.GetLength(1); col++)
+                {
+                    var worldX = _x + (col - MapRadius);
+                    var worldY = _y + (row - MapRadius);
+                    var cell = _mapCells[row, col];
+
+                    var symbol = " ";
+                    var foreground = Brushes.Gray;
+
+                    if (worldX == _x && worldY == _y)
+                    {
+                        symbol = "P";
+                        foreground = Brushes.DodgerBlue;
+                    }
+                    else if (_nearestEnemy.HasValue
+                             && worldX == _x + _nearestEnemy.Value.X
+                             && worldY == _y + _nearestEnemy.Value.Y)
+                    {
+                        symbol = "N";
+                        foreground = Brushes.OrangeRed;
+                    }
+                    else if (_enemyHeat.TryGetValue((worldX, worldY), out var heat))
+                    {
+                        if (heat >= 5)
+                        {
+                            symbol = "*";
+                            foreground = Brushes.OrangeRed;
+                        }
+                        else if (heat >= 2)
+                        {
+                            symbol = "+";
+                            foreground = Brushes.Gold;
+                        }
+                        else
+                        {
+                            symbol = ".";
+                            foreground = Brushes.LightGray;
+                        }
+                    }
+
+                    cell.Text = symbol;
+                    cell.Foreground = foreground;
+                }
+            }
+        });
+    }
+
+    private readonly record struct BotDecision(
+        string Label,
+        string Reason,
+        Func<CancellationToken, Task<bool>> Execute);
+
+    private enum Direction
+    {
+        North = 0,
+        East = 1,
+        South = 2,
+        West = 3,
+    }
+
+    private enum BotAction
+    {
+        Move,
+        Hit,
+        Radar,
+        Shoot,
+        Peek,
+        Scan,
+        Dash,
+        Special,
+        Teleport,
+    }
+
+    private static Direction Opposite(Direction direction)
+    {
+        return direction switch
+        {
+            Direction.North => Direction.South,
+            Direction.East => Direction.West,
+            Direction.South => Direction.North,
+            Direction.West => Direction.East,
+            _ => Direction.North,
+        };
+    }
+
+    private void RegisterMoveResult(Direction direction, bool moved)
+    {
+        _lastMoveDirection = direction;
+
+        if (moved)
+        {
+            _blockedDirectionTicks.Remove(direction);
+            return;
+        }
+
+        _blockedDirectionTicks.TryGetValue(direction, out var current);
+        _blockedDirectionTicks[direction] = Math.Min(current + 4, 20);
+    }
+
+    private void DecayBlockedDirections()
+    {
+        foreach (var key in _blockedDirectionTicks.Keys.ToArray())
+        {
+            _blockedDirectionTicks[key]--;
+            if (_blockedDirectionTicks[key] <= 0)
+            {
+                _blockedDirectionTicks.Remove(key);
+            }
+        }
+    }
+}
diff --git a/DDApp/DDApplication/Program.cs b/DDApp/DDApplication/Program.cs
index 1dd4d4c..50c5879 100644
--- a/DDApp/DDApplication/Program.cs
+++ b/DDApp/DDApplication/Program.cs
@@ -6,18 +6,17 @@ namespace DDApplication;
 
 internal class Program
 {
-    public static IConfiguration Configuration { get; private set; } = null!;
+    public static IConfiguration Configuration { get; private set; } =  new ConfigurationBuilder()
+            .AddJsonFile("appsettings.json", optional: true)
+            .AddUserSecrets<Program>(optional: true)
+            .AddEnvironmentVariables()
+            .Build();
     // Initialization code. Don't use any Avalonia, third-party APIs or any
     // SynchronizationContext-reliant code before AppMain is called: things aren't initialized
     // yet and stuff might break.
     [STAThread]
     public static int Main(string[] args)
     {
-        Configuration = new ConfigurationBuilder()
-            .AddJsonFile("appsettings.json", optional: true)
-            .AddUserSecrets<Program>(optional: true)
-            .AddEnvironmentVariables()
-            .Build();
         return BuildAvaloniaApp()
             .StartWithClassicDesktopLifetime(args);
     }
diff --git a/DDApp/DDApplication/README.md b/DDApp/DDApplication/README.md
new file mode 100644
index 0000000..a9a6e6b
--- /dev/null
+++ b/DDApp/DDApplication/README.md
@@ -0,0 +1,42 @@
+# Digital Dojo Bot Controller
+
+This Avalonia app runs an autonomous bot for the Digital Dojo singleplayer API and visualizes both current game state and inferred enemy knowledge.
+
+## What it does
+
+- Starts/uses your current game session (`/api/game/{key}/create`, `/status`)
+- Runs a cooldown-aware combat loop (`move`, `hit`, `shoot`, `specialattack`, `radar`, `scan`, `peek`, `dash`)
+- Tries to maximize score by prioritizing fast damage actions when enemies are nearby
+- Shows live stats (kills/deaths, HP, level progress, remaining time)
+- Shows a local knowledge map:
+  - `P` = estimated player position
+  - `N` = nearest enemy from latest scan
+  - `* + .` = inferred enemy threat intensity
+- Shows cooldown timers and action reasoning/logs
+- Writes per-session analytics logs for post-run analysis
+
+## Setup
+
+Set your API key (GUID) in one of these ways:
+
+1. Environment variable: `APIKEY`
+2. User secrets (`Program` already loads user secrets)
+3. Paste it directly into the UI text box before clicking **Start Bot**
+
+## Run
+
+```bash
+dotnet run --project /home/tikaiz/RiderProjects/digitalDojo/DDApp/DDApplication/DDApplication.csproj
+```
+
+## Notes
+
+- Position and map are inferred from your own movement + sensor calls (not an authoritative server map).
+- The strategy is heuristic and tunable; it is designed for high kill throughput while respecting API cooldowns.
+- Session logs are written to `~/.local/share/DDApplication/logs` on Linux:
+  - `*.events.csv` contains timestamped telemetry, decisions, and events
+  - `*.summary.txt` contains aggregate K/D, kills/min, deaths/min, and action success rates
+  - `latest.log` is a symlink that auto-points to the newest `*.events.csv` session log
+
+
+
diff --git a/DDApp/DDApplication/spieleinstieg.txt b/DDApp/DDApplication/spieleinstieg.txt
new file mode 100644
index 0000000..8e73c1a
--- /dev/null
+++ b/DDApp/DDApplication/spieleinstieg.txt
@@ -0,0 +1,633 @@
+Digital Dojo <https://dd.countit.at/> Menü //
+
+  * //Coden lernen<https://dd.countit.at/programmieren-lernen>
+      o //Programmier-Roadmap <https://dd.countit.at/programmieren-lernen>
+      o //Programmierschule <https://dd.countit.at/programmierschule>
+      o //Übungsräume <https://dd.countit.at/dojos>
+      o //Katas <https://dd.countit.at/katas>
+      o //Tutorials <https://dd.countit.at/tutorials>
+  * //Dojo Game<https://dd.countit.at/dojo-game/multiplayer-modus>
+      o //Besiege unseren Bot <https://dd.countit.at/dojo-game>
+      o //Spieleinstieg <https://dd.countit.at/dojo-game/spieleinstieg>
+      o //Levels & Bots <https://dd.countit.at/dojo-game/levels>
+      o //Leaderboard <https://dd.countit.at/dojo-game/leaderboard>
+      o //Multiplayer Modus <https://dd.countit.at/dojo-game/
+        multiplayer-modus>
+      o //Tipps <https://dd.countit.at/dojo-game/tipps>
+  * //Programmier-Challenge <https://dd.countit.at/programmierwettbewerb>
+  * //Bewerben <https://dd.countit.at/bewerben>
+  * //Feedback <https://dd.countit.at/feedback>
+  * // <#>
+    Ausloggen
+
+/
+
+/
+/
+
+/
+
+//Teilen //Facebook <https://www.facebook.com/sharer/sharer.php?
+u=https%3A%2F%2Fdd.countit.at%2Fdojo-game%2Fspieleinstieg> //Instagram
+<https://www.instagram.com/count_it_group/> //LinkedIn <https://
+www.linkedin.com/shareArticle?
+mini=true&url=https%3A%2F%2Fdd.countit.at%2Fdojo-
+game%2Fspieleinstieg&title=&summary=&source=> //E-Mail
+<mailto:m.mustermann@countit.at?subject=Lese-
+Tipp%3A%20Dojo%20Game%20%7C%20Wichtige%20Infos%20zum%20Spieleinstieg&body=Hey%2C%0D%0A%0D%0Aich%20habe%20auf%20https%3A%2F%2Fkarriere.countit.at%20einen%20Beitrag%20gefunden%2C%20der%20dich%20interessieren%20k%C3%B6nnte%3A%0D%0A%22Dojo%20Game%20%7C%20Wichtige%20Infos%20zum%20Spieleinstieg%22%0D%0ASchau%20ihn%20dir%20mal%20an%3A%20https%3A%2F%2Fkarriere.countit.at%2Fdojo-game%2Fspieleinstieg%3Fkaid%3Dsharemail%0D%0A%0D%0ABeste%20Gr%C3%BC%C3%9Fe>
+
+
+  Spieleinstieg
+
+
+        Dojo Game
+
+
+    //Dojo Game | Dein Einstieg ins Spiel
+
+------------------------------------------------------------------------
+
+In diesem Abschnitt findest du alle notwendigen Infos, um das Dojo Game
+zu starten und erste Aktionen durchzuführen.
+
+*Hinweis: *Hol dir deinen persönlichen Zugang <https://dd.countit.at/
+register> bevor du startest bzw. logge dich ein <https://dd.countit.at/
+login>. So erscheinst du später auch am Leaderboard!
+
+
+        Inhaltsverzeichnis
+
+ 1. Das Spiel <#spiel>
+ 2. Vorbereitung <#vorbereitung>
+ 3. API-Schlüssel <#api>
+ 4. Spiel starten & beenden <#starten>
+ 5. Ritter steuern <#ritter>
+
+
+      //Das Spiel
+
+Im Dojo Game geht es, einfach erklärt, um einen *Server*, auf welchem
+ein Spiel für dich bereitgestellt wird. In diesem Spiel gibt es im
+Singleplayer-Modus *einen Gegner, den sogenannten Dojo-Bot,* und deinen
+Charakter. *Dein Ritter* hat dieselben Eigenschaften wie ein vom
+Computer gesteuerter Ritter. Über bestimmte Befehle (diese werden über
+URLs aufgerufen) kannst du deinen Spieler steuern und so programmieren,
+dass dieser mit deinen Gegnern kämpft, vor ihnen wegläuft oder andere
+strategische Aktionen ausführt. Ziel ist es, so viele Gegner wie möglich
+zu eliminieren.
+*Ein Spiel dauert maximal 15 Minuten* - danach wird deine Sitzung
+geschlossen. Es gibt innerhalb dieser 15 Minuten unendlich viele Gegner.
+Wird ein Bot getötet, wird dieser auf einer zufälligen anderen Stelle
+der Map wiedergeboren. Bei Start eines neuen Spiels beginnst du immer
+automatisch neu in Level 1.
+
+
+      //Vorbereitung
+
+Um am Dojo Game teilzunehmen, benötigst du einen an das Internet
+angeschlossenen Computer, einen *Digital Dojo Zugang* <https://
+dd.countit.at/register>. Sobald du eingeloggt <https://dd.countit.at/
+login> bist, findest du im Folgenden deinen *API-Schlüssel*, den du
+schon bald brauchen wirst.
+
+Die Logik deines Spielers kannst du in jeder beliebigen
+Programmiersprache implementieren, da Web-Requests an eine API von fast
+jeder verfügbaren Programmier- und Skriptsprache unterstützt werden.
+
+Falls du Starthilfe benötigst und auf bereits erstellte Algorithmen
+aufbauen möchtest, kannst du dich hier <https://dd.countit.at/dojo-game/
+tipps> umsehen.
+
+Die REST-API Befehle können auch mithilfe vom Fiddler <https://
+www.telerik.com/fiddler> oder dem Postman <https://www.postman.com/
+> gesendet werden. Diese Programme werden meistens zum Testen oder für
+Prototypen verwendet und benötigen keinen Programm-Code zum Funktionieren.
+
+
+        //API-Schlüssel
+
+Mithilfe deines Keys kannst du dich mit unseren Servern verbinden um
+dein Spiel zu starten. Zudem werden damit deine gesendeten Befehle
+identifiziert, damit Aktionen, welche du ausführst, auch wirklich nur
+für dich gelten. Somit wird verhindert, dass du die Spiele anderer User
+stören oder manipulieren kannst. 
+
+*Halte deinen Schlüssel geheim* - er könnte es anderen Nutzern
+ermöglichen, Befehle auszuführen welche nicht in deinem Sinne sind!
+
+
+      //Los geht's
+
+------------------------------------------------------------------------
+
+In diesem Abschnitt erfährst du, wie du ein Spiel startest und beendest,
+den Status des laufenden Spiels abfragen kannst, und wie sich dein
+Ritter steuern lässt.
+
+
+        Wie starte ich ein Spiel? [POST]
+
+
+Um ein Spiel zu starten, benötigst du deinen API-Schlüssel <#api>. Wurde
+dieser Befehl erfolgreich ausgeführt, wird das Spiel automatisch
+gestartet und du kannst direkt Aktionen zum Bewegen des Ritters ausführen.
+
+Falls bereits ein Spiel mit deinem Charakter läuft, musst du dieses
+zuerst beenden, bevor du ein neues erstellen kannst. Spiele werden
+mithilfe eines POST-Requests erzeugt.
+
+https://game-dd.countit.at/api/game/{key}/create
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+https://game-dd.countit.at/api/game/{key}/create
+
+➯ Problem? <https://dd.countit.at/dojo-game/tipps#fehler> 
+➯ Postman-Request <https://dd.countit.at/dojo-game/postman#spielstart>
+
+
+    <http://countit-azure-test.westeurope.cloudapp.azure.com:1337/dojo-
+    game/postman#spieleinstieg>
+
+
+        Wie beende ich ein Spiel? [POST]
+
+
+Ein Spiel wird beendet, wenn du mit deinem API-Key folgenden Befehl als
+POST-Request ausführst:
+
+https://game-dd.countit.at/api/game/{key}/close
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+https://game-dd.countit.at/api/game/{key}/close
+
+➯ Problem? <https://dd.countit.at/dojo-game/tipps#fehler>
+➯ Postman-Request <https://dd.countit.at/dojo-game/postman#spielende>
+
+
+        Status des laufenden Spiels abfragen [GET]
+
+
+Um abfragen zu können, ob mit deinem API-Schlüssel bereits ein Spiel
+läuft, kannst du den folgenden Befehl verwenden. Du erhältst als
+Rückgabewert dasselbe wie beim Erstellen und Schließen eines Spiels
+sowie eine Fehlermeldung, falls kein Spiel vorhanden ist.
+
+https://game-dd.countit.at/api/game/{key}/status
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+https://game-dd.countit.at/api/game/{key}/status
+
+➯ Problem? <https://dd.countit.at/dojo-game/tipps#fehler>
+➯ Postman-Request <https://dd.countit.at/dojo-game/postman#status>
+
+Beim Erstellen und Beenden eines Spiels werden jeweils dieselben Daten
+zurückgeliefert: 
+
+→ Game-ID: Diese macht dein Spiel identifizierbar.
+→ Running: Damit werden dein Spielstatus und der Name des geladenen
+Levels sichtbar.
+
+Der zurückgegebene String ist im JSON Format.
+
+{"gameid":"d2144a67-733a-4e06-8a6b-9ce877b99753","running":true,"level":"The Default Level"}
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+{"gameid":"d2144a67-733a-4e06-8a6b-9ce877b99753","running":true,"level":"The Default Level"}
+
+➯ Was ist JSON? <https://dd.countit.at/dojo-game/tipps#technologie>
+
+
+        //Steuere deinen Ritter
+
+------------------------------------------------------------------------
+
+Ein Ritter hat die Möglichkeit auf einem zweidimensionalen Spielfeld
+verschiedenste Aktionen auszuführen. Aktionen sowie ihre Wirkungen und
+REST Aufrufe sind hier gelistet. Versuche deine Aktionen nicht zu
+schnell hintereinander auszuführen, da du nach jeder Aktion eine gewisse
+Zeit abwarten musst, bis du diese wieder einsetzen kannst. Dein Ritter
+führt nur Befehle aus, welche du ihm gibst. Sendest du deinem Spieler
+keine Aktionen, welche dieser ausführen soll, steht dieser durchgehend
+auf derselben Position und ist verletzbar.
+
+
+        Move [POST]
+
+
+Du kannst deinen Ritter alle 250 Millisekunden um ein Feld in eine der
+vier Himmelsrichtungen bewegen.
+Das Feld "Direction" sollte eine Zahl zwischen 0 und 3 enthalten:
+
+→ 0 für Norden
+→ 1 für Osten
+→ 2 für Süden
+→ 3 für Westen
+
+https://game-dd.countit.at/api/player/{key}/move/{direction}
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+https://game-dd.countit.at/api/player/{key}/move/{direction}
+
+➯ Problem? <https://dd.countit.at/dojo-game/tipps#fehler>
+➯ Postman-Request <https://dd.countit.at/dojo-game/postman#move>
+
+
+        Dash [POST]
+
+
+Dash lässt dich 5 Blöcke in eine von dir bestimmte Richtung bewegen.
+Es hat außerdem einen besonderen Cooldown: Du kannst Dash schon 3
+Sekunden nach der Aktivierung verwenden, aber dein Spieler wird zu
+erschöpft sein und sich nur 3 Blöcke bewegen. Doch aufgepasst, wenn du
+gegen eine Wand dasht nimmst du Schaden in Höhe der verbleibenden Dash-
+Distanz. Nachdem du diese Aktion verwendet hast, musst du 5000
+Millisekunden warten.
+
+https://game-dd.countit.at/api/player/{key}/dash/{direction}
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+https://game-dd.countit.at/api/player/{key}/dash/{direction}
+
+➯ Problem? <https://dd.countit.at/dojo-game/tipps#fehler>
+➯ Postman-Request <https://dd.countit.at/dojo-game/postman#dash>
+
+
+        Hit [POST]
+
+
+Diese Aktion wird benutzt, um mit deinem Ritter zu schlagen. Es kann
+jeweils nur in eine Himmelsrichtung (0 für Norden, 1 für Osten, 2 für
+Süden und 3 für Westen) geschlagen werden und dies nur einen Block weit.
+Danach musst du 250 Millisekunden warten, bis du wieder angreifen
+kannst. Ein normaler Schlag, welcher mit einem Abstand von einem Block
+erzielt wurde, fügt dem Gegner weniger Schaden zu als wenn du auf
+demselben Block wie ein Gegner stehst. Hierbei ist es egal, wie viele
+Gegner auf einem Fleck stehen. Jeder bekommt gleich viel Schaden.
+
+https://game-dd.countit.at/api/player/{key}/hit/{direction}
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+https://game-dd.countit.at/api/player/{key}/hit/{direction}
+
+➯ Problem? <https://dd.countit.at/dojo-game/tipps#fehler>
+➯ Postman-Request <https://dd.countit.at/dojo-game/postman#hit>
+
+
+        Shoot [POST]
+
+
+Shoot benötigt, wie Peek, eine Direction (0 für Norden, 1 für Osten, 2
+für Süden und 3 für Westen), also eine Richtung. Shoot verwendet diese
+Richtung, um einen Schuss in diese Richtung abzugeben. Als Antwort kommt
+zurück, ob diese Aktion ausgeführt wurde und ob ein Gegner getroffen
+wurde. Die Kugel stoppt beim ersten Spieler. Nachdem du diese Aktion
+verwendet hast, musst du 1000 Millisekunden warten.
+
+https://game-dd.countit.at/api/player/{key}/shoot/{direction}
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+https://game-dd.countit.at/api/player/{key}/shoot/{direction}
+
+➯ Problem? <https://dd.countit.at/dojo-game/tipps#fehler>
+➯ Postman-Request <https://dd.countit.at/dojo-game/postman#shoot>
+
+
+        Radar [GET]
+
+
+Mit dem Befehl "Radar" kannst du die Umgebung um deinen Spieler im
+Umkreis von 5 Blöcken auf Feinde überprüfen. Das Feld wird aufgeteilt
+und durchsucht. Danach erhältst du Informationen über die Anzahl der
+Spieler in den 4 Himmelsrichtungen und den Block, auf dem du stehst.
+Nachdem du diese Aktion verwendet hast, musst du 250 Millisekunden warten.
+
+Radar <https://dd.countit.at/media/dojo-game/dojo-game_radar-
+himmelsrichtungen.png>
+https://game-dd.countit.at/api/player/{key}/radar
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+https://game-dd.countit.at/api/player/{key}/radar
+
+➯ Problem? <https://dd.countit.at/dojo-game/tipps#fehler>
+➯ Postman-Request <https://dd.countit.at/dojo-game/postman#radar>
+
+
+        Scan [GET]
+
+
+Mit Scan kannst du den am nächsten stehenden Spieler im Umkreis von 3
+Blöcken finden. Durch den Rückgabewert weißt du dann auch, was seine
+relative Position zu dir ist. Nachdem du diese Aktion verwendet hast,
+musst du 2000 Millisekunden warten.
+
+https://game-dd.countit.at/api/player/{key}/scan
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+https://game-dd.countit.at/api/player/{key}/scan
+
+➯ Problem? <https://dd.countit.at/dojo-game/tipps#fehler>
+➯ Postman-Request? <https://dd.countit.at/dojo-game/postman#scan>
+
+
+        Peek [GET]
+
+
+Peek benötigt, wie Move und Hit, eine Direction (0 für Norden, 1 für
+Osten, 2 für Süden und 3 für Westen). Peek verwendet diese Richtung, um
+zu überprüfen, ob sich in der angegebenen Richtung ein Spieler in deinem
+Sichtfeld befindet. Peek gibt dir dann die Anzahl der Gegner in der
+Sichtlinie und die Distanz zum nächsten stehenden Spieler in dieser
+Sichtlinie zurück. Dies kannst du alle 1000 Millisekunden verwenden.
+
+https://game-dd.countit.at/api/player/{key}/peek/{direction}
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+https://game-dd.countit.at/api/player/{key}/peek/{direction}
+
+➯ Problem? <https://dd.countit.at/dojo-game/tipps#fehler>
+➯ Postman-Request <https://dd.countit.at/dojo-game/postman#peek>
+
+
+        Stats [GET]
+
+
+Mit Stats hast du die Möglichkeit dir deine Kills und Deaths des aktiven
+Spiels anzusehen. Der Rückgabewert weicht vom Rückgabewert der anderen
+Funktionen ab - enthalten sind Informationen zum derzeitigen Level,
+allgemeine Stats sowie Informationen zu den Lebenspunkten eines Spielers.
+
+*progress* - gibt an, wie weit du ein Level bereits abgeschlossen hast (%)
+*remainingtime* - gibt an, wieviele Minuten noch übrig sind bevor das
+Spiel gestoppt wird
+*deathsleft* - gibt an, wie oft du noch sterben darfst, bevor das Spiel
+gestoppt wird
+
+https://game-dd.countit.at/api/player/{key}/stats
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+https://game-dd.countit.at/api/player/{key}/stats
+
+Der Rückgabewert dieser Funktion wurde mit dem letzten Update verändert.
+Hier ein Beispiel für den neuen Rückgabewert:
+
+{"action":"stats","executed":true,"stats":
+{"kills":1,"deaths":1},"level":
+{"progress":6.6,"remainingtime":14.44,"deathsleft":999,"levelid":2,"name":"Bigger Map Level"},"health":{"currenthealth":10.0,"maxhealth":10.0}}
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+{"action":"stats","executed":true,"stats":{"kills":1,"deaths":1},"level":{"progress":6.6,"remainingtime":14.44,"deathsleft":999,"levelid":2,"name":"Bigger Map Level"},"health":{"currenthealth":10.0,"maxhealth":10.0}}
+
+➯ Problem? <https://dd.countit.at/dojo-game/tipps#fehler>
+➯ Postman-Request <https://dd.countit.at/dojo-game/postman#stats>
+
+
+        Specialattack [POST]
+
+
+Specialattack ist eine Aktion, welche du viel seltener als einen
+normalen Schlag ("Hit") einsetzen kannst. Diese hat allerdings eine
+bestimmte Fähigkeit und verursacht dadurch mehr Schaden an deinem
+Gegner. Specialattack nimmt keine Direction als Parameter entgegen,
+sondern führt den Angriff in allen Richtungen mit einem Wirkungskreis
+von 3 Blöcken gleichzeitig aus. Du kannst die Specialattack alle 5000
+Millisekunden ausführen.
+
+https://game-dd.countit.at/api/player/{key}/specialattack
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+https://game-dd.countit.at/api/player/{key}/specialattack
+
+➯ Problem? <https://dd.countit.at/dojo-game/tipps#fehler>
+➯ Postman-Request <https://dd.countit.at/dojo-game/postman#specialattack>
+
+
+        Teleport [GET]
+
+
+Mit Teleport kannst du dich auf ein beliebiges Feld teleportieren. Der
+Trick dabei: Du musst das Feld relativ zu deiner Position mithilfe von x
+und y Koordinaten angeben. 
+Cooldown: 20000 Millisekunden (20 Sekunden)
+
+Achtung: Falls du in einer Wand landest bist du sofort tot. Wenn du
+allerdings einen Gegner erwischst, wird dieser sofort getötet.
+
+https://game-dd.countit.at/api/player/{key}/teleport/{x}/{y}
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+https://game-dd.countit.at/api/player/{key}/teleport/{x}/{y}
+
+➯ Problem? <https://dd.countit.at/dojo-game/tipps#fehler>
+➯ Postman-Request <https://dd.countit.at/dojo-game/postman#teleport>
+
+
+        Rückgabewert
+
+
+Jede Aktion gibt im Prinzip immer einen gleich strukturierten JSON-
+String zurück. Jedoch können sich die Datentypen der einzelnen Felder je
+nach Aktion unterscheiden.
+Hier zwei Beispiele, um dies zu verdeutlichen:
+
+Die Move-Aktion, ohne speziellen Rückgabewert:
+
+{"action":"move","move":"true","executed":"true"}
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+{"action":"move","move":"true","executed":"true"}
+
+Die Radar-Aktion, mit einem Integer als Rückgabewert:
+
+{"action":"radar","radar":2,"executed":"true"}
+text/x-csharp
+
+xxxxxxxxxx
+
+ 
+
+{"action":"radar","radar":2,"executed":"true"}
+
+➯ Was ist JSON? <https://dd.countit.at/dojo-game/tipps#technologie>
+➯ Postman-Request <https://dd.countit.at/dojo-game/postman#rueckgabewerte>
+
+
+    Bereit für die ultimative Programmier-Challenge an deiner Schule?
+
+Alle Infos dazu findest du hier //
+ <https://dd.countit.at/programmierwettbewerb>
+/
+
+/
+
+
+          Ultimative Coding-Roadmap
+
+Unsere Roadmap weist dir den Weg zum Coding-Profi!
+
+Mehr erfahren // <https://dd.countit.at/programmieren-lernen>
+/
+
+/
+
+
+          Besiege unseren Bot
+
+Egal ob als Einzelspieler oder im Mulitplayer-Modus: Stelle dich dem
+Dojo-Bot und beweise, dass du auf das Leaderboard gehörst!
+
+Ich bin bereit! // <https://dd.countit.at/dojo-game>
+/
+
+/
+
+
+          Bewerbung bei COUNT IT
+
+Starte deine Karriere als Softwareentwickler*in bei COUNT IT.
+
+Zum Formular! // <https://dd.countit.at/bewerben>
+
+
+      Über Digital Dojo
+
+Das Digital Dojo ist der virtuelle Übungsraum von COUNT IT.
+
+Angehende Programmierer*innen, Code-Neulinge, Wiedereinsteiger*innen und
+Fortgeschrittene finden hier das nötige Rüstzeug für ihre Karriere.
+
+Du möchtest deine Lehre bei COUNT IT starten? Dann bist du hier richtig
+- besiege deine Gegner im Dojo Game und sichere dir deine Lehrstelle!
+
+Inspire your career.
+
+
+      Navigation
+
+Programmieren lernen <https://dd.countit.at/programmieren-lernen>	News
+<https://dd.countit.at/news>
+Programmierschule <https://dd.countit.at/programmierschule>	Partner
+<https://dd.countit.at/partner>
+Programmier-Challenge <https://dd.countit.at/programmierwettbewerb>	
+Dojo Game <https://dd.countit.at/dojo-game>	
+
+	
+Datenschutz <https://www.countit.at/datenschutz>	Karriere @ COUNT IT
+<https://karriere.countit.at/>
+Impressum <https://www.countit.at/impressum>	COUNT IT
+Softwarehouse <https://it.countit.at/>
+
+
+      Newsletter abonnieren
+
+Der COUNT IT Newsletter liefert viermal jährlich interessante
+Neuigkeiten über das Unternehmen. Gleich anfordern!
+
+E-Mail-Adresse
+Senden
+
+// <https://de-de.facebook.com/COUNTITGroup/> // <https://
+www.instagram.com/count_it_group/> // <https://de.linkedin.com/company/
+count-it-group>
+
+//
+
+COUNT IT Group verwendet Cookies, um die Website bestmöglich an die
+Bedürfnisse der User anpassen zu können.
+
+  * Google
+  * Microsoft
+  * Ahrefs
+  * Statistik
+
+Akzeptieren
+Individuelle EinstellungenIndividuelle Einstellungen ausblenden |
+Datenschutz­erklärung <https://www.countit.at/datenschutz>
+
+Google
+
+Google Analytics und Optimize aggregiert Daten über unsere Besucher und
+ihr Verhalten auf unserer Website. Wir nutzen diese Informationen zur
+Verbesserung unserer Seite.
+
+Microsoft
+
+Microsoft aggregiert Daten über unsere Besucher und ihr Verhalten auf
+unserer Website. Wir nutzen diese Informationen zur Verbesserung unserer
+Seite.
+
+Ahrefs
+
+Ahrefs aggregiert Daten über unsere Besucher und ihr Verhalten auf
+unserer Website. Wir nutzen diese Informationen zur Verbesserung unserer
+Seite.
+
+Statistik
+
+Es werden grundlegend notwendige, anonymisierte Userdaten aufgezeichnet,
+welche nur von uns für Auswertungen verwendet werden!
+
+Cookie Entscheidung speichern