From edc78c2dd623fb842d68bdb83df56459aa5e5557 Mon Sep 17 00:00:00 2001 From: Cal Corum Date: Thu, 14 Aug 2025 15:17:52 -0500 Subject: [PATCH] CLAUDE: Add comprehensive gaming-aware Tdarr management system MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Created complete gaming detection and priority system - Added gaming schedule configuration and enforcement - Implemented Steam library monitoring with auto-detection - Built comprehensive game process detection for multiple platforms - Added gaming-aware Tdarr worker management with priority controls - Created emergency gaming mode for immediate worker shutdown - Integrated Discord notifications for gaming state changes - Replaced old bash monitoring with enhanced Python monitoring system - Added persistent state management and memory tracking - Implemented configurable gaming time windows and schedules - Updated .gitignore to exclude logs directories šŸ¤– Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude --- .claude/plans/prometheus-grafana-setup.md | 677 ++++++++++++++++++ .gitignore | 3 +- gaming/CONTEXT.md | 95 +++ .../ready-or-not/1144200-nvidia-1440p.conf | 362 ++++++++++ .../ready-or-not/1144200-working.conf | 379 ++++++++++ gaming/examples/ready-or-not/README.md | 159 ++++ gaming/examples/ready-or-not/fix-crash.sh | 280 ++++++++ .../ready-or-not/force-stl-detection.sh | 70 ++ .../ready-or-not/nvidia-environment.conf | 34 + .../ready-or-not/setup-ready-or-not.sh | 217 ++++++ .../ready-or-not/working-baseline-config.md | 61 ++ gaming/scripts/CONTEXT.md | 172 +++++ gaming/scripts/check-stl-logs.sh | 175 +++++ gaming/scripts/clean-slate-setup.sh | 168 +++++ gaming/scripts/diagnose-crash.sh | 255 +++++++ gaming/scripts/fix-steam-override.sh | 140 ++++ gaming/scripts/install-ron-mods.sh | 151 ++++ gaming/scripts/launch-ron-direct.sh | 149 ++++ .../ready-or-not-compatibility-test.sh | 214 ++++++ gaming/scripts/test-vanilla-proton.sh | 114 +++ gaming/scripts/validate-gaming-setup.sh | 229 ++++++ gaming/troubleshooting.md | 217 ++++++ monitoring/scripts/tdarr-timeout-monitor.sh | 452 ------------ monitoring/scripts/tdarr_monitor.py | 49 +- 24 files changed, 4341 insertions(+), 481 deletions(-) create mode 100644 .claude/plans/prometheus-grafana-setup.md create mode 100644 gaming/CONTEXT.md create mode 100644 gaming/examples/ready-or-not/1144200-nvidia-1440p.conf create mode 100644 gaming/examples/ready-or-not/1144200-working.conf create mode 100644 gaming/examples/ready-or-not/README.md create mode 100755 gaming/examples/ready-or-not/fix-crash.sh create mode 100755 gaming/examples/ready-or-not/force-stl-detection.sh create mode 100644 gaming/examples/ready-or-not/nvidia-environment.conf create mode 100755 gaming/examples/ready-or-not/setup-ready-or-not.sh create mode 100644 gaming/examples/ready-or-not/working-baseline-config.md create mode 100644 gaming/scripts/CONTEXT.md create mode 100755 gaming/scripts/check-stl-logs.sh create mode 100755 gaming/scripts/clean-slate-setup.sh create mode 100755 gaming/scripts/diagnose-crash.sh create mode 100755 gaming/scripts/fix-steam-override.sh create mode 100755 gaming/scripts/install-ron-mods.sh create mode 100755 gaming/scripts/launch-ron-direct.sh create mode 100755 gaming/scripts/ready-or-not-compatibility-test.sh create mode 100755 gaming/scripts/test-vanilla-proton.sh create mode 100755 gaming/scripts/validate-gaming-setup.sh create mode 100644 gaming/troubleshooting.md delete mode 100755 monitoring/scripts/tdarr-timeout-monitor.sh diff --git a/.claude/plans/prometheus-grafana-setup.md b/.claude/plans/prometheus-grafana-setup.md new file mode 100644 index 0000000..b4b43f7 --- /dev/null +++ b/.claude/plans/prometheus-grafana-setup.md @@ -0,0 +1,677 @@ +# Prometheus + Grafana Home Lab Monitoring Setup + +## Overview + +This document provides a complete setup for monitoring a Proxmox home lab with 8 Ubuntu Server VMs running Docker applications. The solution uses the Prometheus + Grafana + Alertmanager stack to provide comprehensive monitoring with custom metrics, alerting, and visualization. + +## Architecture + +### Components +- **Prometheus**: Time-series database for metrics collection (pull-based) +- **Grafana**: Web-based visualization and dashboards +- **Alertmanager**: Alert routing and notifications +- **Node Exporter**: System metrics (CPU, memory, disk, network) +- **cAdvisor**: Docker container metrics +- **Custom Exporters**: Application-specific metrics (transcodes, web server stats, etc.) + +### Deployment Strategy +- **Main Monitoring VM**: Runs Prometheus, Grafana, and Alertmanager +- **Each Monitored VM**: Runs Node Exporter, cAdvisor, and any custom exporters +- **Proxmox Host**: Runs Proxmox VE Exporter for hypervisor metrics + +## Main Monitoring Stack Deployment + +### Directory Structure +``` +monitoring/ +ā”œā”€ā”€ docker-compose.yml +ā”œā”€ā”€ prometheus/ +ā”‚ ā”œā”€ā”€ prometheus.yml +ā”‚ ā””ā”€ā”€ alerts.yml +ā”œā”€ā”€ alertmanager/ +ā”‚ ā””ā”€ā”€ alertmanager.yml +ā”œā”€ā”€ grafana/ +ā”‚ ā””ā”€ā”€ provisioning/ +ā”‚ ā”œā”€ā”€ datasources/ +ā”‚ ā”‚ ā””ā”€ā”€ prometheus.yml +ā”‚ ā””ā”€ā”€ dashboards/ +ā”‚ ā””ā”€ā”€ dashboard.yml +ā””ā”€ā”€ data/ + ā”œā”€ā”€ prometheus/ + ā”œā”€ā”€ grafana/ + ā””ā”€ā”€ alertmanager/ +``` + +### Docker Compose Configuration + +```yaml +version: '3.8' + +networks: + monitoring: + driver: bridge + +volumes: + prometheus_data: + grafana_data: + alertmanager_data: + +services: + prometheus: + image: prom/prometheus:latest + container_name: prometheus + restart: unless-stopped + ports: + - "9090:9090" + command: + - '--config.file=/etc/prometheus/prometheus.yml' + - '--storage.tsdb.path=/prometheus' + - '--web.console.libraries=/etc/prometheus/console_libraries' + - '--web.console.templates=/etc/prometheus/consoles' + - '--storage.tsdb.retention.time=200h' + - '--web.enable-lifecycle' + volumes: + - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml + - ./prometheus/alerts.yml:/etc/prometheus/alerts.yml + - prometheus_data:/prometheus + networks: + - monitoring + + grafana: + image: grafana/grafana:latest + container_name: grafana + restart: unless-stopped + ports: + - "3000:3000" + environment: + - GF_SECURITY_ADMIN_USER=admin + - GF_SECURITY_ADMIN_PASSWORD=admin123 + - GF_USERS_ALLOW_SIGN_UP=false + volumes: + - grafana_data:/var/lib/grafana + - ./grafana/provisioning:/etc/grafana/provisioning + networks: + - monitoring + + alertmanager: + image: prom/alertmanager:latest + container_name: alertmanager + restart: unless-stopped + ports: + - "9093:9093" + volumes: + - ./alertmanager/alertmanager.yml:/etc/alertmanager/alertmanager.yml + - alertmanager_data:/alertmanager + command: + - '--config.file=/etc/alertmanager/alertmanager.yml' + - '--storage.path=/alertmanager' + - '--web.external-url=http://localhost:9093' + networks: + - monitoring +``` + +## Configuration Files + +### Prometheus Configuration (prometheus/prometheus.yml) + +```yaml +global: + scrape_interval: 15s + evaluation_interval: 15s + +rule_files: + - "alerts.yml" + +alerting: + alertmanagers: + - static_configs: + - targets: + - alertmanager:9093 + +scrape_configs: + # Prometheus itself + - job_name: 'prometheus' + static_configs: + - targets: ['localhost:9090'] + + # Node Exporters - Update with your VM IPs + - job_name: 'node-exporter' + static_configs: + - targets: + - '192.168.1.101:9100' # VM1 + - '192.168.1.102:9100' # VM2 + - '192.168.1.103:9100' # VM3 + - '192.168.1.104:9100' # VM4 + - '192.168.1.105:9100' # VM5 + - '192.168.1.106:9100' # VM6 + - '192.168.1.107:9100' # VM7 + - '192.168.1.108:9100' # VM8 + + # cAdvisor for Docker metrics + - job_name: 'cadvisor' + static_configs: + - targets: + - '192.168.1.101:8080' # VM1 + - '192.168.1.102:8080' # VM2 + - '192.168.1.103:8080' # VM3 + - '192.168.1.104:8080' # VM4 + - '192.168.1.105:8080' # VM5 + - '192.168.1.106:8080' # VM6 + - '192.168.1.107:8080' # VM7 + - '192.168.1.108:8080' # VM8 + + # Proxmox VE Exporter - Update with your Proxmox host IP + - job_name: 'proxmox' + static_configs: + - targets: ['192.168.1.100:9221'] # Proxmox host + + # Custom application exporters + - job_name: 'custom-apps' + static_configs: + - targets: + - '192.168.1.101:9999' # Custom app metrics + - '192.168.1.102:9999' # Media server metrics + + # Home Assistant Prometheus integration + - job_name: 'homeassistant' + scrape_interval: 30s + metrics_path: /api/prometheus + bearer_token: 'YOUR_LONG_LIVED_ACCESS_TOKEN' # Generate in HA Profile settings + static_configs: + - targets: ['192.168.1.XXX:8123'] # Your Home Assistant IP + + # Home Assistant API exporter (alternative) + - job_name: 'homeassistant-api' + static_configs: + - targets: ['192.168.1.XXX:9998'] # Custom HA exporter + + # HomeKit via MQTT bridge (if using) + - job_name: 'homekit' + static_configs: + - targets: ['192.168.1.XXX:9997'] # Custom HomeKit exporter +``` + +### Alert Rules (prometheus/alerts.yml) + +```yaml +groups: + - name: system-alerts + rules: + - alert: InstanceDown + expr: up == 0 + for: 1m + labels: + severity: critical + annotations: + summary: "Instance {{ $labels.instance }} down" + description: "{{ $labels.instance }} has been down for more than 1 minute." + + - alert: HighCPUUsage + expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[2m])) * 100) > 80 + for: 2m + labels: + severity: warning + annotations: + summary: "High CPU usage on {{ $labels.instance }}" + description: "CPU usage is above 80% for more than 2 minutes." + + - alert: HighMemoryUsage + expr: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100 > 80 + for: 2m + labels: + severity: warning + annotations: + summary: "High memory usage on {{ $labels.instance }}" + description: "Memory usage is above 80% for more than 2 minutes." + + - alert: DiskSpaceLow + expr: (node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100 < 20 + for: 1m + labels: + severity: critical + annotations: + summary: "Low disk space on {{ $labels.instance }}" + description: "Disk space is below 20% on root filesystem." + + - name: docker-alerts + rules: + - alert: ContainerDown + expr: absent(container_last_seen) or time() - container_last_seen > 60 + for: 1m + labels: + severity: warning + annotations: + summary: "Container {{ $labels.name }} is down" + description: "Container has been down for more than 1 minute." +``` + +### Alertmanager Configuration (alertmanager/alertmanager.yml) + +```yaml +global: + smtp_smarthost: 'localhost:587' + smtp_from: 'alertmanager@yourdomain.com' + # Configure with your email settings + +route: + group_by: ['alertname'] + group_wait: 10s + group_interval: 10s + repeat_interval: 1h + receiver: 'web.hook' + routes: + - match: + severity: critical + receiver: 'critical-alerts' + - match: + severity: warning + receiver: 'warning-alerts' + +receivers: + - name: 'web.hook' + webhook_configs: + - url: 'http://127.0.0.1:5001/' + + - name: 'critical-alerts' + email_configs: + - to: 'admin@yourdomain.com' + subject: 'CRITICAL: {{ .GroupLabels.alertname }}' + body: | + {{ range .Alerts }} + Alert: {{ .Annotations.summary }} + Description: {{ .Annotations.description }} + {{ end }} + # Uncomment and configure for Discord/Slack webhooks + # webhook_configs: + # - url: 'YOUR_DISCORD_WEBHOOK_URL' + + - name: 'warning-alerts' + email_configs: + - to: 'admin@yourdomain.com' + subject: 'WARNING: {{ .GroupLabels.alertname }}' + body: | + {{ range .Alerts }} + Alert: {{ .Annotations.summary }} + Description: {{ .Annotations.description }} + {{ end }} + +inhibit_rules: + - source_match: + severity: 'critical' + target_match: + severity: 'warning' + equal: ['alertname', 'dev', 'instance'] +``` + +### Grafana Datasource Provisioning (grafana/provisioning/datasources/prometheus.yml) + +```yaml +apiVersion: 1 + +datasources: + - name: Prometheus + type: prometheus + access: proxy + url: http://prometheus:9090 + isDefault: true +``` + +## VM Configuration + +### Node Exporter and cAdvisor Deployment + +Deploy this on each VM: + +```yaml +# docker-compose.yml for each VM +version: '3.8' + +services: + node-exporter: + image: prom/node-exporter:latest + container_name: node-exporter + restart: unless-stopped + ports: + - "9100:9100" + command: + - '--path.procfs=/host/proc' + - '--path.rootfs=/rootfs' + - '--path.sysfs=/host/sys' + - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)' + volumes: + - /proc:/host/proc:ro + - /sys:/host/sys:ro + - /:/rootfs:ro + + cadvisor: + image: gcr.io/cadvisor/cadvisor:latest + container_name: cadvisor + restart: unless-stopped + ports: + - "8080:8080" + volumes: + - /:/rootfs:ro + - /var/run:/var/run:ro + - /sys:/sys:ro + - /var/lib/docker/:/var/lib/docker:ro + - /dev/disk/:/dev/disk:ro + devices: + - /dev/kmsg +``` + +### Custom Metrics Example + +For media server transcode monitoring: + +```python +#!/usr/bin/env python3 +# custom_exporter.py +from http.server import HTTPServer, BaseHTTPRequestHandler +import subprocess +import json + +class MetricsHandler(BaseHTTPRequestHandler): + def do_GET(self): + if self.path == '/metrics': + metrics = self.get_metrics() + self.send_response(200) + self.send_header('Content-type', 'text/plain') + self.end_headers() + self.wfile.write(metrics.encode()) + else: + self.send_response(404) + self.end_headers() + + def get_metrics(self): + metrics = [] + + # Example: Count completed transcodes from log file + try: + with open('/var/log/transcodes.log', 'r') as f: + completed = len([line for line in f if 'COMPLETED' in line]) + failed = len([line for line in f if 'FAILED' in line]) + + metrics.append(f'transcodes_completed_total {completed}') + metrics.append(f'transcodes_failed_total {failed}') + except FileNotFoundError: + metrics.append('transcodes_completed_total 0') + metrics.append('transcodes_failed_total 0') + + # Add more custom metrics as needed + return '\n'.join(metrics) + '\n' + +if __name__ == '__main__': + server = HTTPServer(('0.0.0.0', 9999), MetricsHandler) + print("Custom metrics server running on port 9999") + server.serve_forever() +``` + +Deploy as a systemd service or Docker container. + +### Home Assistant Metrics Exporter + +```python +#!/usr/bin/env python3 +# homeassistant_exporter.py +import requests +import time +from http.server import HTTPServer, BaseHTTPRequestHandler +import json + +HA_URL = "http://192.168.1.XXX:8123" # Your HA IP +HA_TOKEN = "your-long-lived-access-token" # Generate in HA Profile + +class HAMetricsHandler(BaseHTTPRequestHandler): + def do_GET(self): + if self.path == '/metrics': + metrics = self.get_ha_metrics() + self.send_response(200) + self.send_header('Content-type', 'text/plain') + self.end_headers() + self.wfile.write(metrics.encode()) + else: + self.send_response(404) + self.end_headers() + + def get_ha_metrics(self): + headers = { + "Authorization": f"Bearer {HA_TOKEN}", + "Content-Type": "application/json" + } + + try: + response = requests.get(f"{HA_URL}/api/states", headers=headers, timeout=10) + entities = response.json() + except Exception as e: + return f"# Error fetching HA data: {e}\n" + + metrics = [] + metrics.append("# HELP homeassistant_entity_state Home Assistant entity states") + metrics.append("# TYPE homeassistant_entity_state gauge") + + for entity in entities: + entity_id = entity['entity_id'] + domain = entity_id.split('.')[0] + name = entity_id.replace('.', '_').replace('-', '_') + state = entity['state'] + + # Add labels for better organization + labels = f'domain="{domain}",entity_id="{entity_id}"' + + try: + # Try to convert to numeric value + value = float(state) + metrics.append(f'homeassistant_entity_state{{{labels}}} {value}') + except (ValueError, TypeError): + # Handle boolean states + if state.lower() in ['on', 'true', 'open', 'home']: + metrics.append(f'homeassistant_entity_state{{{labels}}} 1') + elif state.lower() in ['off', 'false', 'closed', 'away']: + metrics.append(f'homeassistant_entity_state{{{labels}}} 0') + else: + # For text states, create info metric + info_labels = f'domain="{domain}",entity_id="{entity_id}",state="{state}"' + metrics.append(f'homeassistant_entity_info{{{info_labels}}} 1') + + return '\n'.join(metrics) + '\n' + +if __name__ == '__main__': + server = HTTPServer(('0.0.0.0', 9998), HAMetricsHandler) + print("Home Assistant metrics exporter running on port 9998") + server.serve_forever() +``` + +### HomeKit Bridge Exporter (Optional) + +```python +#!/usr/bin/env python3 +# homekit_exporter.py - Requires homekit2mqtt or similar bridge +import paho.mqtt.client as mqtt +import json +from http.server import HTTPServer, BaseHTTPRequestHandler +import threading + +MQTT_BROKER = "192.168.1.XXX" # Your MQTT broker +MQTT_PORT = 1883 +HOMEKIT_TOPIC = "homekit/#" + +class HomeKitData: + def __init__(self): + self.devices = {} + self.client = mqtt.Client() + self.client.on_connect = self.on_connect + self.client.on_message = self.on_message + + def on_connect(self, client, userdata, flags, rc): + print(f"Connected to MQTT broker with result code {rc}") + client.subscribe(HOMEKIT_TOPIC) + + def on_message(self, client, userdata, msg): + try: + topic_parts = msg.topic.split('/') + device_id = topic_parts[1] if len(topic_parts) > 1 else "unknown" + characteristic = topic_parts[2] if len(topic_parts) > 2 else "state" + + value = json.loads(msg.payload.decode()) + + if device_id not in self.devices: + self.devices[device_id] = {} + self.devices[device_id][characteristic] = value + except Exception as e: + print(f"Error processing MQTT message: {e}") + +homekit_data = HomeKitData() + +class HomeKitMetricsHandler(BaseHTTPRequestHandler): + def do_GET(self): + if self.path == '/metrics': + metrics = self.get_homekit_metrics() + self.send_response(200) + self.send_header('Content-type', 'text/plain') + self.end_headers() + self.wfile.write(metrics.encode()) + else: + self.send_response(404) + self.end_headers() + + def get_homekit_metrics(self): + metrics = [] + metrics.append("# HELP homekit_device_state HomeKit device states") + metrics.append("# TYPE homekit_device_state gauge") + + for device_id, characteristics in homekit_data.devices.items(): + for char_name, value in characteristics.items(): + labels = f'device_id="{device_id}",characteristic="{char_name}"' + try: + numeric_value = float(value) + metrics.append(f'homekit_device_state{{{labels}}} {numeric_value}') + except (ValueError, TypeError): + # Handle boolean values + if str(value).lower() in ['true', 'on']: + metrics.append(f'homekit_device_state{{{labels}}} 1') + elif str(value).lower() in ['false', 'off']: + metrics.append(f'homekit_device_state{{{labels}}} 0') + + return '\n'.join(metrics) + '\n' + +def start_mqtt_client(): + homekit_data.client.connect(MQTT_BROKER, MQTT_PORT, 60) + homekit_data.client.loop_forever() + +if __name__ == '__main__': + # Start MQTT client in background thread + mqtt_thread = threading.Thread(target=start_mqtt_client) + mqtt_thread.daemon = True + mqtt_thread.start() + + # Start HTTP server + server = HTTPServer(('0.0.0.0', 9997), HomeKitMetricsHandler) + print("HomeKit metrics exporter running on port 9997") + server.serve_forever() +``` + +## Proxmox Host Configuration + +Install Proxmox VE Exporter on your Proxmox host: + +```bash +# On Proxmox host +wget https://github.com/prometheus-pve/prometheus-pve-exporter/releases/latest/download/prometheus-pve-exporter +chmod +x prometheus-pve-exporter + +# Create config file +cat > pve.yml << EOF +default: + user: monitoring@pve + password: your-password + verify_ssl: false +EOF + +# Run the exporter +./prometheus-pve-exporter --config.file=pve.yml +``` + +## Installation Steps + +1. **Create monitoring VM** with adequate resources (4GB RAM, 20GB disk recommended) + +2. **Set up main monitoring stack:** + ```bash + mkdir -p monitoring/{prometheus,alertmanager,grafana/provisioning/{datasources,dashboards}} + cd monitoring + # Copy all configuration files from above + docker-compose up -d + ``` + +3. **Deploy exporters on each VM:** + ```bash + # On each VM + docker-compose -f node-cadvisor-compose.yml up -d + ``` + +4. **Configure Proxmox exporter** on the host + +5. **Set up Home Assistant integration:** + + **Option A: Enable Prometheus in Home Assistant** + ```yaml + # Add to Home Assistant configuration.yaml + prometheus: + namespace: homeassistant + filter: + include_domains: + - sensor + - binary_sensor + - switch + - light + - climate + - weather + ``` + + **Option B: Deploy custom HA exporter** + ```bash + # Create and run the Home Assistant exporter + python3 homeassistant_exporter.py + ``` + +6. **Optional: Set up HomeKit integration** + ```bash + # If using homekit2mqtt bridge + npm install -g homekit2mqtt + homekit2mqtt --mqtt-url mqtt://your-mqtt-broker + + # Then run the HomeKit exporter + python3 homekit_exporter.py + ``` + +7. **Access interfaces:** + - Grafana: http://monitoring-vm-ip:3000 (admin/admin123) + - Prometheus: http://monitoring-vm-ip:9090 + - Alertmanager: http://monitoring-vm-ip:9093 + +8. **Import dashboards** in Grafana: + - Node Exporter Full (Dashboard ID: 1860) + - Docker and system monitoring (Dashboard ID: 893) + - Proxmox VE (Dashboard ID: 10347) + - Home Assistant (Dashboard ID: 11021) + +9. **Generate Home Assistant Long-Lived Access Token:** + - Go to HA Profile ā†’ Long-Lived Access Tokens + - Create new token and update exporter configs + +## Customization Notes + +- Update all IP addresses in prometheus.yml to match your network +- Configure email settings in alertmanager.yml +- Adjust alert thresholds in alerts.yml based on your requirements +- Add custom exporters for specific application monitoring +- Set up proper authentication and SSL for production use + +## Maintenance + +- Monitor disk space usage for time-series data +- Regular backups of configuration files +- Update container images periodically +- Review and tune alert rules based on false positive rates + +This setup provides comprehensive monitoring for your home lab with room for expansion as your infrastructure grows. \ No newline at end of file diff --git a/.gitignore b/.gitignore index b5b53c6..9b003c8 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ .claude/tmp/ tmp/ -__pycache__ \ No newline at end of file +__pycache__ +**/logs/ \ No newline at end of file diff --git a/gaming/CONTEXT.md b/gaming/CONTEXT.md new file mode 100644 index 0000000..0897f42 --- /dev/null +++ b/gaming/CONTEXT.md @@ -0,0 +1,95 @@ +# Gaming Configuration Context + +## Technology Overview +Steam Tinker Launch (STL) provides advanced configuration options for running Windows games on Linux through Steam's Proton compatibility layer. This directory contains configurations, scripts, and documentation for gaming setups. + +## Key Components + +### Steam Tinker Launch (STL) +- **Purpose**: Advanced Proton configuration and game-specific tweaks +- **Config Location**: `~/.config/steamtinkerlaunch/` +- **Game Configs**: `~/.config/steamtinkerlaunch/gamecfgs/` +- **Global Settings**: `~/.config/steamtinkerlaunch/global.conf` + +### Ready or Not Specific +- **Game ID**: 1144200 +- **Engine**: Unreal Engine 4 +- **Anti-Cheat**: EasyAntiCheat (requires `-noeac` for modifications) +- **Common Issues**: Menu freezes, audio crackling, GPU compatibility + +## Hardware Considerations + +### NVIDIA GPU Optimizations +- **NVAPI Support**: Enable for DLSS compatibility +- **DXVK vs VKD3D**: Prefer DXVK for better NVIDIA performance +- **GameScope**: Use with proper display settings +- **Ray Tracing**: Available with compatible Proton versions + +### Monitor Setup Considerations +- **Resolution Scaling**: Configure GameScope for proper scaling +- **Refresh Rate**: Match native monitor capabilities +- **HDR Support**: Enable if hardware supports it + +## Configuration Patterns + +### Performance Settings +```bash +# Essential performance settings +USEGAMEMODERUN="1" # Enable GameMode +USEPROTON="GE-Proton10-11" # Use latest GE-Proton +DXVK_ASYNC="1" # Async shader compilation +DXVK_HDR="1" # HDR support for compatible setups +``` + +### Audio Configuration +```bash +# Audio crackling fixes +CHANGE_PULSE_LATENCY="1" +STL_PULSE_LATENCY_MSEC="120" +``` + +### GameScope Settings +```bash +# Display configuration template +USEGAMESCOPE="1" +GAMESCOPE_ARGS="-W [width] -H [height] -r [refresh_rate] -f --immediate-flips --rt --mangoapp --force-grab-cursor --" +``` + +## Directory Structure +``` +/gaming/ +ā”œā”€ā”€ CONTEXT.md # This file - technology overview +ā”œā”€ā”€ troubleshooting.md # Error handling and debugging +ā”œā”€ā”€ examples/ # Working configurations and templates +ā”‚ ā”œā”€ā”€ ready-or-not/ # Ready or Not specific configs +ā”‚ ā””ā”€ā”€ nvidia-optimized/ # NVIDIA-specific game configs +ā””ā”€ā”€ scripts/ # Gaming automation scripts + ā”œā”€ā”€ CONTEXT.md # Script-specific documentation + ā””ā”€ā”€ steam-helpers/ # Steam and STL helper scripts +``` + +## Best Practices + +### Configuration Management +- Keep per-game configs in `examples/[game-name]/` +- Document hardware-specific settings clearly +- Test one setting at a time when troubleshooting +- Backup working configurations before changes + +### Performance Optimization +- Start with GE-Proton for best compatibility +- Enable GameMode for CPU scheduling +- Use GameScope for resolution/scaling control +- Monitor GPU usage with MangoHUD + +### Troubleshooting Approach +1. Verify base Proton compatibility +2. Test without STL modifications first +3. Add settings incrementally +4. Document working combinations +5. Check hardware-specific requirements + +## Integration Points +- **Monitoring**: Use MangoHUD for performance metrics +- **Scripts**: Automate common gaming tasks +- **Networking**: Configure for multiplayer gaming \ No newline at end of file diff --git a/gaming/examples/ready-or-not/1144200-nvidia-1440p.conf b/gaming/examples/ready-or-not/1144200-nvidia-1440p.conf new file mode 100644 index 0000000..6d24c7d --- /dev/null +++ b/gaming/examples/ready-or-not/1144200-nvidia-1440p.conf @@ -0,0 +1,362 @@ +## config Version: v12.12 +########################## +######### +#SteamTinkerLaunch v12.12 - NVIDIA 4K Monitor/1440p Gaming Optimized +######### +######### +#GAMENAME="Ready Or Not" +#GAMEEXE="ReadyOrNot.exe" +#GAMEID="1144200" +#PROTONVERSION="" +######### +## set the default config file for DXVK_CONFIG_FILE which is used when found - defaults to config found in STLCFGDIR/dxvk +STLDXVKCFG="STLCFGDIR/dxvk/1144200.conf" +########################## +## Keep steamtinkerlaunch open after game exit +KEEPSTLOPEN="0" +## Use Steam Linux Runtime requested by compatibility tool, if available - May need to be manually from Steam if unavailable +USESLR="1" +## Force Steam Linux Runtime if not available +FORCESLR="0" +## Use reaper command if available +USEREAP="1" +## Force reaper command if not available +FORCEREAP="0" +## Start the game with this Proton version +USEPROTON="GE-Proton10-11" +## Use compatdata depending on the Proton version - 'single-proton' for using compatdata per game and Proton version - 'global-proton' for using the same Proton version based compatdata globally for all games +REDIRCOMPDATA="disabled" +## Mode how to handle the steamuser directory on compatdata redirect +REDIRSTEAMUSER="disabled" +## Update Proton-GE automatically to the latest version +AUTOBUMPGE="1" +## Update Proton automatically to the latest version +AUTOBUMPPROTON="0" +## Use a custom command +USECUSTOMCMD="0" +## Start this custom command +CUSTOMCMD="none" +## The command line arguments used for the custom command +CUSTOMCMD_ARGS="none" +## Only start the custom command and skip the regular game executable +ONLY_CUSTOMCMD="0" +## Fork the custom command into the background and continue starting with the regular game executable +FORK_CUSTOMCMD="0" +## passes tools like GameScope, GameMode and MangoHud to the custom command, if they are enabled +EXTPROGS_CUSTOMCMD="0" +## Run this custom command with Proton even if it is not detected as a Windows program +CUSTOMCMDFORCEWIN="0" +## Wait X seconds after having started the custom program before continuing with the game launch. 1 is only wait for the custom program pid +WAITFORCUSTOMCMD="0" +## Inject the custom command by starting it after the game executable is running - overrides 'ONLY_CUSTOMCMD' and 'FORK_CUSTOMCMD' +INJECT_CUSTOMCMD="0" +## Wait X seconds before starting the custom program after the game executable started +INJECTWAIT="0" +## Use IGCSInjector to inject a DLL into the running game executable +USEIGCS="0" +## Inject the UniversalUE4Unlocker with IGCSInjector +UUUSEIGCS="0" +## Wait X seconds before starting the IGCSInjector after the game executable started +IGCSWAIT="0" +## Automatically prepare and execute a UE4 console script on game launch +UUUSEPATCH="0" +## Wait X seconds before starting the UUU patch script after the game executable started +UUUPATCHWAIT="0" +## Prepare VR injection into compatible UE4 games using UniversalUE4Unlocker and IGCSInjector +UUUSEVR="0" +## The own/custom command line arguments used for the game - NVIDIA optimized for Ready or Not +GAMEARGS="-noeac -USEALLAVAILABLECORES -dx12" +## The command line arguments used for the game initially coming hardcoded from Steam - without effect when 'SORTGARGS' is disabled +HARDARGS="nope" +## Enable GameMode for this game +USEGAMEMODERUN="1" +## Enable gamescope for this game - Essential for 1440p on 4K monitor +USEGAMESCOPE="1" +## The command line arguments for gamescope for this game - 1440p gaming on 4K monitor +GAMESCOPE_ARGS="-W 2560 -H 1440 -w 2560 -h 1440 -r 165 -f --immediate-flips --rt --mangoapp --force-grab-cursor --adaptive-sync --" +## Start the game through obs-gamecapture +USEOBSCAP="0" +## Enable Zink to renders OpenGL games in Vulkan +USEZINK="0" +## Set variables required for PrimeRun - Disable for dedicated NVIDIA +USEPRIMERUN="0" +## Pause steamwebhelper on game launch and continue on game stop +TOGSTEAMWEBHELPER="0" +## Enable MangoHud for this game - Disabled since using mangoapp in GameScope +USEMANGOHUD="0" +## Start the game using Mangoapp (enabling gamescope automatically) +USEMANGOAPP="0" +## The MangoHud binary used +MAHUBIN="/usr/bin/mangohud" +## The command line arguments used for MangoHud +MAHUARGS="none" +## Preload MangoHud using LD_PRELOAD +LDPMAHU="0" +## Set the MangoHud variable MANGOHUD to 1 and ignore other MangoHud settings +MAHUVAR="0" +## Use steamtinkerlaunch internal MangoHud config for this game +USEMANGOHUDSTLCFG="0" +## Start game with vkBasalt enabled +ENABLE_VKBASALT="0" +## Enable Nyrna for this game +RUN_NYRNA="0" +## Enable ReplaySorcery for this game +RUN_REPLAY="0" +## Start this game with the x64dbg debugger +RUN_X64DBG="0" +## Start this game with the GDB debugger +RUN_GDB="0" +## Enable Discord Rich Presence via wine-discord-ipc-bridge +USE_WDIB="0" +## Enable Vortex Mode +USEVORTEX="0" +## Timeout in seconds of the Vortex requester - 0 to disable it completely +WAITVORTEX="2" +## Enable Winetricks in Vortex Mode +RUN_VORTEX_WINETRICKS="0" +## Enable Winecfg in Vortex Mode +RUN_VORTEX_WINECFG="0" +## Allow changing the PulseAudio latency +CHANGE_PULSE_LATENCY="1" +## Change PulseAudio latency to n - Optimized for gaming +STL_PULSE_LATENCY_MSEC="60" +## Minimize all visible windows on game start and restore them when game ends +TOGGLEWINDOWS="0" +## Start Winetricks GUI before the game starts +RUN_WINETRICKS="0" +## List of packages to install silently using Winetricks +WINETRICKSPAKS="none" +## Start winecfg before the game starts +RUN_WINECFG="0" +## Use Wine instead of Proton +USEWINE="0" +## Use wineconsole when the exe is a console program +USEWICO="0" +## The Wine Version to use with this game +WINEVERSION="echo" +## The default Wine version to be used when none is selected +WINEDEFAULT="echo" +## Start the game in Wine virtual desktop mode +VIRTUALDESKTOP="0" +## Resolution for the Wine virtual desktop +VDRES="none" +## Start the game using Boxtron/DOSBox +USEBOXTRON="0" +## Start the game using Roberta/ScummVM +USEROBERTA="0" +## Start the game using Luxtorpeda +USELUXTORPEDA="0" +## Allow registry changes for this game +REGEDIT="0" +## Enable stereoscopic geo11-driver for the selected game +USEGEOELF="0" +## Update geo-11 driver automatically when enabled +AUTOGEOELF="0" +## Install ReShade into the game directory +INSTALL_RESHADE="0" +## Use the Depth3D shader with ReShade +RESHADE_DEPTH3D="0" +## Start game with ReShade enabled +USERESHADE="0" +## Use ReShade with the custom command instead of the game - Will be ignored if Only Custom Command is enabled +CUSTOMCMDRESHADE="0" +## Update both ReShade download archive and dlls in gamedir automatically +RESHADEUPDATE="0" +## Toggle ReShade version override +RSOVRD="0" +## ReShade version to override gloabl version with +RSOVRVERS="5.4.2" +## Open menu on game launch to add or remove shaders for the game +CHOOSESHADERS="0" +## Alternative game exe path (f.e. for ReShade installation and the game launcher is in an extra directory) +ALTEXEPATH="/tmp" +## Check the architecture of this exe instead of the default one +ARCHALTEXE="none" +## Enable FidelityFX Super Resolution (FSR) compatible OpenVR +USEOPENVRFSR="0" +## Start this game in VR in Side-by-Side Stereo3D mode +RUNSBSVR="0" +## The command line arguments for the Side-by-Side Stereo3D VR player for this game +VRVIDEOPLAYERARGS="--flat" +## The zoom value for the Stereo3D VR player window +SBSZOOM="1.0" +## Start this game in VR in Side-by-Side Stereo3D mode using geo-11 +SBSVRGEOELF="0" +## Start this game in VR in Side-by-Side Stereo3D mode using Depth3D with ReShade +SBSVRRS="0" +## Start this game in Side-by-Side Stereo3D mode using Depth3D with ReShade +SBSRS="0" +## The minimal window height this game needs to be accepted for Stereo3D VR (f.e. to autoskip launchers) +MINVRWINH="640" +## Stereo3D VR - wait for this alternative exe to determine the PID +WAITFORTHISPID="none" +## Timeout in seconds of the initial requester - 0 to disable it completely +WAITEDITOR="0" +## Create steam_appid.txt file in gamedir if enabled or delete it if disabled +STEAMAPPIDFILE="0" +## Check if Steam collections the game belongs to have a corresponding tweak file +CHECKCOLLECTIONS="1" +## Backup non-empty steamuser directories from the game pfx +BACKUPSTEAMUSER="0" +## When is the steamuser data supposed to be restored from an existing backup +RESTORESTEAMUSER="none" +## symlink the steamuser directory +USESUSYM="0" +## symlink the steamuser directory globally to one directory +USEGLOBSUSYM="0" +## Use internal DXVK config for this game +USE_STLDXVKCFG="1" +## DXVK variables - see 'https://github.com/doitsujin/dxvk' - NVIDIA optimized +DXVK_HUD="fps,memory,gpuload" +## Controls DXVK message logging +DXVK_LOG_LEVEL="none" +## The DXVK log path - 'none' for stdout +DXVK_LOG_PATH="none" +## Scales the DXVK HUD by a factor of x (e.g. 1.5) +DXVK_SCALE="1.0" +## Uses DXVK to limit a game's framerate, default is game's internal framerate limit OR unlimited. NOTE: May conflict with Gamescope and/or other framerate limiters such as MangoHUD +DXVK_FPSLIMIT="none" +## Enable Dxvk async support - Essential for NVIDIA +DXVK_ASYNC="1" +## Enable DXVK HDR support - requires compatible GPU and drivers +DXVK_HDR="1" +## Enable strace for this game +STRACERUN="0" +## The command line arguments for strace for this game +STRACEOPTS="-f -t -e trace=file" +## Enable network-monitor for this game +USENETMON="0" +## Reject internet access for the game +BLOCKINTERNET="0" +## Convenient method for dumping a useful debug log to +PROTON_LOG="0" +## The directory where the Proton logs are stored +PROTON_LOG_DIR="STLCFGDIR/logs/proton/id" +## Use the 'winedebug settings' also for Proton +USEWINEDEBUGPROTON="0" +## Write some useful debug scripts for the game into PROTON_DEBUG_DIR +PROTON_DUMP_DEBUG_COMMANDS="0" +## Root directory for the Proton debug scripts +PROTON_DEBUG_DIR="/tmp" +## Use OpenGL-based WineD3D instead of Vulkan-based DXVK for D3D11, D3D10 and D3D9 +PROTON_USE_WINED3D="0" +## Disable d3d11.dll, for D3D11 games which can fall back to and run better with D3D9 +PROTON_NO_D3D11="0" +## Disable d3d10.dll and dxgi.dll, for D3D10 games which can fall back to and run better with D3D9 +PROTON_NO_D3D10="0" +## Do not use eventfd-based in-process synchronization primitives +PROTON_NO_ESYNC="0" +## Do not use futex-based in-process synchronization primitives +PROTON_NO_FSYNC="0" +## Use Winesync instead of esync/fsync. The winesync kernel module and a compatible Proton need to be used. +ENABLE_WINESYNC="0" +## Proton support for Nvidia's NVAPI GPU support library and DLSS - NVIDIA SPECIFIC +PROTON_ENABLE_NVAPI="1" +## Proton hide Nvidia GPU - DISABLED for NVIDIA systems +PROTON_HIDE_NVIDIA_GPU="0" +## Enable all options required for DLSS - NVIDIA SPECIFIC +USEDLSS="1" +## When enabled, VKD3D_CONFIG is exported as 'dxr11' and '-dx12' is appended to the game command line parameters +USERAYTRACING="0" +## Force Wine to enable the LARGE_ADDRESS_AWARE flag +PROTON_FORCE_LARGE_ADDRESS_AWARE="1" +## Enable Wine fullscreen integer scaling for this game +WINE_FULLSCREEN_INTEGER_SCALING="0" +## Enable FidelityFX Super Resolution (FSR) - a compatible Proton version needs to be selected separately +WINE_FULLSCREEN_FSR="0" +## FSR sharpening strength +WINE_FULLSCREEN_FSR_STRENGTH="2" +## Cleanup Proton Temp directory 'drive_c/users/steamuser/Temp' on exit +CLEANPROTONTEMP="1" +## The WINEDEBUG settings for direct Wine calls for this game +STLWINEDEBUG="-all" +## Wine DLL overrides used for this game +STLWINEDLLOVERRIDES="none" +## The directory for storing Wine logs +WINE_LOG_DIR="STLCFGDIR/logs/wine" +## Custom user script executed when a game starts +USERSTART="none" +## Custom user script executed when a game stops +USERSTOP="none" +## Automatically use Conty if the game exe is 32bit +AUTOCONTY="0" +## Explicitely use Conty for the game +USECONTY="0" +## Open requester after the game exited in less than X seconds +CRASHGUESS="10" +## Open only a wineconsole in the game directory instead of the game +ONLYWICO="0" +## Change the screen resolution to this value before the game starts +GAMESCREENRES="none" +## Default Help URL +HELPURL="none" +## Desktop Icon Mode +CREATEDESKTOPICON="0" +## Fix symlinks pointing to a Proton version unlike the current one +FIXSYMLINKS="0" +## Replace 'windows system file' symlinks in the current WINEPREFIX with the original files they are pointing to +UNSYMLINK="0" +## Delete the compatdata dirextory before game launch, so Steam recreates it automatically updated +DELPFX="0" +## Start this game with the DLL debugger Dependencies +RUN_DEPS="0" +## Sort game command arguments and make hardcoded arguments writable +SORTGARGS="0" +## Timeout in seconds for the Mod Organizer 2 requester - 0 to disable it completely +WAITMO2="2" +## Mod Organizer 2 mode +MO2MODE="disabled" +## Enable Special K for the selected game +USESPECIALK="0" +## enables native Wayland support for SDL games that support it with SDL_VIDEODRIVER=wayland +SDLUSEWAYLAND="0" +## A comma-separated list of named flags, which can be used to enable experimental driver features and performance enhancements for RADV Vulkan driver - DISABLED for NVIDIA +STLRAD_PFTST="none" +## Special K download version +SPEKVERS="default" +## Update SpecialK automatically when using 'default or 'latest' version' +AUTOSPEK="0" +## Use FlawlessWidescreen for the game +USEFWS="0" +## Store game exe data using 'peldd' +USEPEV_PELDD="0" +## Store game exe data using 'pepack' +USEPEV_PEPACK="0" +## Store game exe data using 'peres' +USEPEV_PERES="0" +## Store game exe data using 'pescan' +USEPEV_PESCAN="0" +## DESC_USEPEV_PESEC +USEPEV_PESEC="0" +## Store game exe data using 'pestr' +USEPEV_PESTR="0" +## Store game exe data using 'readpe' +USEPEV_READPE="0" +## A list of options that change the behavior of VKD3D-Proton +STL_VKD3D_CONFIG="none" +## Controls the debug level for log messages produced by VKD3D-Proton +STL_VKD3D_DEBUG="none" +## controls the debug level for log messages produced by the shader compilers +STL_VKD3D_SHADER_DEBUG="none" +## If set, redirects VKD3D_DEBUG logging output to a file instead +STL_VKD3D_LOG_FILE="none" +## A zero-based device index. Use to force the selected Vulkan device +STL_VKD3D_VULKAN_DEVICE="none" +## Skips devices that don't include this substring +STL_VKD3D_FILTER_DEVICE_NAME="none" +## A list of Vulkan extensions that VKD3D-Proton should not use even if available +STL_VKD3D_DISABLE_EXTENSIONS="none" +## Enables additional debug messages in tests +STL_VKD3D_TEST_DEBUG="0" +## A filter string. Only the tests whose names matches the filter string will be run, e.g. VKD3D_TEST_FILTER=clear_render_target. Useful for debugging or developing new tests +STL_VKD3D_TEST_FILTER="none" +## Excludes tests of which the name is included in the string, e.g. VKD3D_TEST_EXCLUDE=test_root_signature_priority,test_conservative_rasterization_dxil +STL_VKD3D_TEST_EXCLUDE="none" +## The test platform controls the behavior of todo(), todo_if(), bug_if() and broken() conditions in tests +STL_VKD3D_TEST_PLATFORM="none" +## Set to 0 to disable bug_if() conditions in tests +STL_VKD3D_TEST_BUG="none" +## If profiling is enabled in the build, a profiling block is emitted to . +STL_VKD3D_PROFILE_PATH="none" +SLOARGS="none" +ASKCNT="0" \ No newline at end of file diff --git a/gaming/examples/ready-or-not/1144200-working.conf b/gaming/examples/ready-or-not/1144200-working.conf new file mode 100644 index 0000000..d0b6406 --- /dev/null +++ b/gaming/examples/ready-or-not/1144200-working.conf @@ -0,0 +1,379 @@ +## config Version: v12.12 +########################## +######### +#SteamTinkerLaunch v12.12 - Working Configuration for Ready or Not +######### +######### +#GAMENAME="Ready Or Not" +#GAMEEXE="ReadyOrNot.exe" +#GAMEID="1144200" +#PROTONVERSION="" +######### + +## Keep steamtinkerlaunch open after game exit +KEEPSTLOPEN="0" +## Use Steam Linux Runtime requested by compatibility tool +USESLR="1" +## Force Steam Linux Runtime if not available +FORCESLR="0" +## Use reaper command if available +USEREAP="1" +## Force reaper command if not available +FORCEREAP="0" + +## Start the game with this Proton version - Using latest for compatibility +USEPROTON="GE-Proton10-11" +## Use compatdata depending on the Proton version +REDIRCOMPDATA="disabled" +## Mode how to handle the steamuser directory on compatdata redirect +REDIRSTEAMUSER="disabled" +## Update Proton-GE automatically to the latest version +AUTOBUMPGE="1" +## Update Proton automatically to the latest version +AUTOBUMPPROTON="0" + +## Use a custom command +USECUSTOMCMD="0" +## Start this custom command +CUSTOMCMD="none" +## The command line arguments used for the custom command +CUSTOMCMD_ARGS="none" +## Only start the custom command and skip the regular game executable +ONLY_CUSTOMCMD="0" +## Fork the custom command into the background and continue starting with the regular game executable +FORK_CUSTOMCMD="0" +## passes tools like GameScope, GameMode and MangoHud to the custom command, if they are enabled +EXTPROGS_CUSTOMCMD="0" +## Run this custom command with Proton even if it is not detected as a Windows program +CUSTOMCMDFORCEWIN="0" +## Wait X seconds after having started the custom program before continuing with the game launch. 1 is only wait for the custom program pid +WAITFORCUSTOMCMD="0" +## Inject the custom command by starting it after the game executable is running - overrides 'ONLY_CUSTOMCMD' and 'FORK_CUSTOMCMD' +INJECT_CUSTOMCMD="0" +## Wait X seconds before starting the custom program after the game executable started +INJECTWAIT="0" +## Use IGCSInjector to inject a DLL into the running game executable +USEIGCS="0" +## Inject the UniversalUE4Unlocker with IGCSInjector +UUUSEIGCS="0" +## Wait X seconds before starting the IGCSInjector after the game executable started +IGCSWAIT="0" +## Automatically prepare and execute a UE4 console script on game launch +UUUSEPATCH="0" +## Wait X seconds before starting the UUU patch script after the game executable started +UUUPATCHWAIT="0" +## Prepare VR injection into compatible UE4 games using UniversalUE4Unlocker and IGCSInjector +UUUSEVR="0" + +## CRITICAL: NO DirectX version forcing - let game auto-detect +## This is the key difference from our failed configs +GAMEARGS="-noeac" +## The command line arguments used for the game initially coming hardcoded from Steam +HARDARGS="" + +## Enable GameMode for this game +USEGAMEMODERUN="1" +## Enable gamescope for this game - 1440p gaming on 4K monitor +USEGAMESCOPE="1" +## The command line arguments for gamescope for this game +GAMESCOPE_ARGS="-W 2560 -H 1440 -w 2560 -h 1440 -r 165 -f --immediate-flips --rt --mangoapp --force-grab-cursor --adaptive-sync --" + +## Start the game through obs-gamecapture +USEOBSCAP="0" +## Enable Zink to renders OpenGL games in Vulkan +USEZINK="0" +## Set variables required for PrimeRun - Disabled for dedicated NVIDIA +USEPRIMERUN="0" +## Pause steamwebhelper on game launch and continue on game stop +TOGSTEAMWEBHELPER="0" + +## Enable MangoHud for this game - Using mangoapp in GameScope instead +USEMANGOHUD="0" +## Start the game using Mangoapp (enabling gamescope automatically) +USEMANGOAPP="0" +## The MangoHud binary used +MAHUBIN="/usr/bin/mangohud" +## The command line arguments used for MangoHud +MAHUARGS="none" +## Preload MangoHud using LD_PRELOAD +LDPMAHU="0" +## Set the MangoHud variable MANGOHUD to 1 and ignore other MangoHud settings +MAHUVAR="0" +## Use steamtinkerlaunch internal MangoHud config for this game +USEMANGOHUDSTLCFG="0" + +## Start game with vkBasalt enabled +ENABLE_VKBASALT="0" +## Enable Nyrna for this game +RUN_NYRNA="0" +## Enable ReplaySorcery for this game +RUN_REPLAY="0" +## Start this game with the x64dbg debugger +RUN_X64DBG="0" +## Start this game with the GDB debugger +RUN_GDB="0" +## Enable Discord Rich Presence via wine-discord-ipc-bridge +USE_WDIB="0" +## Enable Vortex Mode +USEVORTEX="0" +## Timeout in seconds of the Vortex requester - 0 to disable it completely +WAITVORTEX="0" +## Enable Winetricks in Vortex Mode +RUN_VORTEX_WINETRICKS="0" +## Enable Winecfg in Vortex Mode +RUN_VORTEX_WINECFG="0" + +## Allow changing the PulseAudio latency +CHANGE_PULSE_LATENCY="1" +## Change PulseAudio latency to n - Optimized for gaming +STL_PULSE_LATENCY_MSEC="60" + +## Minimize all visible windows on game start and restore them when game ends +TOGGLEWINDOWS="0" +## Start Winetricks GUI before the game starts +RUN_WINETRICKS="0" +## List of packages to install silently using Winetricks +WINETRICKSPAKS="none" +## Start winecfg before the game starts +RUN_WINECFG="0" +## Use Wine instead of Proton +USEWINE="0" +## Use wineconsole when the exe is a console program +USEWICO="0" +## The Wine Version to use with this game +WINEVERSION="echo" +## The default Wine version to be used when none is selected +WINEDEFAULT="echo" +## Start the game in Wine virtual desktop mode +VIRTUALDESKTOP="0" +## Resolution for the Wine virtual desktop +VDRES="none" +## Start the game using Boxtron/DOSBox +USEBOXTRON="0" +## Start the game using Roberta/ScummVM +USEROBERTA="0" +## Start the game using Luxtorpeda +USELUXTORPEDA="0" +## Allow registry changes for this game +REGEDIT="0" +## Enable stereoscopic geo11-driver for the selected game +USEGEOELF="0" +## Update geo-11 driver automatically when enabled +AUTOGEOELF="0" +## Install ReShade into the game directory +INSTALL_RESHADE="0" +## Use the Depth3D shader with ReShade +RESHADE_DEPTH3D="0" +## Start game with ReShade enabled +USERESHADE="0" +## Use ReShade with the custom command instead of the game - Will be ignored if Only Custom Command is enabled +CUSTOMCMDRESHADE="0" +## Update both ReShade download archive and dlls in gamedir automatically +RESHADEUPDATE="0" +## Toggle ReShade version override +RSOVRD="0" +## ReShade version to override gloabl version with +RSOVRVERS="5.4.2" +## Open menu on game launch to add or remove shaders for the game +CHOOSESHADERS="0" +## Alternative game exe path (f.e. for ReShade installation and the game launcher is in an extra directory) +ALTEXEPATH="/tmp" +## Check the architecture of this exe instead of the default one +ARCHALTEXE="none" +## Enable FidelityFX Super Resolution (FSR) compatible OpenVR +USEOPENVRFSR="0" +## Start this game in VR in Side-by-Side Stereo3D mode +RUNSBSVR="0" +## The command line arguments for the Side-by-Side Stereo3D VR player for this game +VRVIDEOPLAYERARGS="--flat" +## The zoom value for the Stereo3D VR player window +SBSZOOM="1.0" +## Start this game in VR in Side-by-Side Stereo3D mode using geo-11 +SBSVRGEOELF="0" +## Start this game in VR in Side-by-Side Stereo3D mode using Depth3D with ReShade +SBSVRRS="0" +## Start this game in Side-by-Side Stereo3D mode using Depth3D with ReShade +SBSRS="0" +## The minimal window height this game needs to be accepted for Stereo3D VR (f.e. to autoskip launchers) +MINVRWINH="640" +## Stereo3D VR - wait for this alternative exe to determine the PID +WAITFORTHISPID="none" +## Timeout in seconds of the initial requester - 0 to disable it completely +WAITEDITOR="0" +## Create steam_appid.txt file in gamedir if enabled or delete it if disabled +STEAMAPPIDFILE="0" +## Check if Steam collections the game belongs to have a corresponding tweak file +CHECKCOLLECTIONS="1" +## Backup non-empty steamuser directories from the game pfx +BACKUPSTEAMUSER="0" +## When is the steamuser data supposed to be restored from an existing backup +RESTORESTEAMUSER="none" +## symlink the steamuser directory +USESUSYM="0" +## symlink the steamuser directory globally to one directory +USEGLOBSUSYM="0" + +## Use internal DXVK config for this game +USE_STLDXVKCFG="1" +## DXVK variables - NVIDIA optimized but not forcing DirectX version +DXVK_HUD="fps,memory,gpuload" +## Controls DXVK message logging +DXVK_LOG_LEVEL="none" +## The DXVK log path - 'none' for stdout +DXVK_LOG_PATH="none" +## Scales the DXVK HUD by a factor of x (e.g. 1.5) +DXVK_SCALE="1.0" +## Uses DXVK to limit a game's framerate, default is game's internal framerate limit OR unlimited +DXVK_FPSLIMIT="none" +## Enable Dxvk async support - Good for NVIDIA +DXVK_ASYNC="1" +## Enable DXVK HDR support - requires compatible GPU and drivers +DXVK_HDR="1" + +## Enable strace for this game +STRACERUN="0" +## The command line arguments for strace for this game +STRACEOPTS="-f -t -e trace=file" +## Enable network-monitor for this game +USENETMON="0" +## Reject internet access for the game +BLOCKINTERNET="0" +## Convenient method for dumping a useful debug log to +PROTON_LOG="0" +## The directory where the Proton logs are stored +PROTON_LOG_DIR="STLCFGDIR/logs/proton/id" +## Use the 'winedebug settings' also for Proton +USEWINEDEBUGPROTON="0" +## Write some useful debug scripts for the game into PROTON_DEBUG_DIR +PROTON_DUMP_DEBUG_COMMANDS="0" +## Root directory for the Proton debug scripts +PROTON_DEBUG_DIR="/tmp" + +## Use OpenGL-based WineD3D instead of Vulkan-based DXVK for D3D11, D3D10 and D3D9 +## CRITICAL: Keep this disabled - let game use modern renderers +PROTON_USE_WINED3D="0" + +## Disable d3d11.dll, for D3D11 games which can fall back to and run better with D3D9 +PROTON_NO_D3D11="0" +## Disable d3d10.dll and dxgi.dll, for D3D10 games which can fall back to and run better with D3D9 +PROTON_NO_D3D10="0" +## Do not use eventfd-based in-process synchronization primitives +PROTON_NO_ESYNC="0" +## Do not use futex-based in-process synchronization primitives +PROTON_NO_FSYNC="0" +## Use Winesync instead of esync/fsync. The winesync kernel module and a compatible Proton need to be used. +ENABLE_WINESYNC="0" + +## Proton support for Nvidia's NVAPI GPU support library and DLSS - NVIDIA SPECIFIC +PROTON_ENABLE_NVAPI="1" +## Proton hide Nvidia GPU - DISABLED for NVIDIA systems +PROTON_HIDE_NVIDIA_GPU="0" +## Enable all options required for DLSS - NVIDIA SPECIFIC +USEDLSS="1" +## When enabled, VKD3D_CONFIG is exported as 'dxr11' and '-dx12' is appended to the game command line parameters +## CRITICAL: Keep this disabled to avoid forcing DirectX versions +USERAYTRACING="0" + +## Force Wine to enable the LARGE_ADDRESS_AWARE flag +PROTON_FORCE_LARGE_ADDRESS_AWARE="1" +## Enable Wine fullscreen integer scaling for this game +WINE_FULLSCREEN_INTEGER_SCALING="0" +## Enable FidelityFX Super Resolution (FSR) - a compatible Proton version needs to be selected separately +WINE_FULLSCREEN_FSR="0" +## FSR sharpening strength +WINE_FULLSCREEN_FSR_STRENGTH="2" +## Cleanup Proton Temp directory 'drive_c/users/steamuser/Temp' on exit +CLEANPROTONTEMP="1" +## The WINEDEBUG settings for direct Wine calls for this game +STLWINEDEBUG="-all" +## Wine DLL overrides used for this game +STLWINEDLLOVERRIDES="none" +## The directory for storing Wine logs +WINE_LOG_DIR="STLCFGDIR/logs/wine" +## Custom user script executed when a game starts +USERSTART="none" +## Custom user script executed when a game stops +USERSTOP="none" +## Automatically use Conty if the game exe is 32bit +AUTOCONTY="0" +## Explicitely use Conty for the game +USECONTY="0" +## Open requester after the game exited in less than X seconds +CRASHGUESS="10" +## Open only a wineconsole in the game directory instead of the game +ONLYWICO="0" +## Change the screen resolution to this value before the game starts +GAMESCREENRES="none" +## Default Help URL +HELPURL="none" +## Desktop Icon Mode +CREATEDESKTOPICON="0" +## Fix symlinks pointing to a Proton version unlike the current one +FIXSYMLINKS="0" +## Replace 'windows system file' symlinks in the current WINEPREFIX with the original files they are pointing to +UNSYMLINK="0" +## Delete the compatdata dirextory before game launch, so Steam recreates it automatically updated +DELPFX="0" +## Start this game with the DLL debugger Dependencies +RUN_DEPS="0" +## Sort game command arguments and make hardcoded arguments writable +SORTGARGS="0" +## Timeout in seconds for the Mod Organizer 2 requester - 0 to disable it completely +WAITMO2="0" +## Mod Organizer 2 mode +MO2MODE="disabled" +## Enable Special K for the selected game +USESPECIALK="0" +## enables native Wayland support for SDL games that support it with SDL_VIDEODRIVER=wayland +SDLUSEWAYLAND="0" +## A comma-separated list of named flags, which can be used to enable experimental driver features and performance enhancements for RADV Vulkan driver - DISABLED for NVIDIA +STLRAD_PFTST="none" +## Special K download version +SPEKVERS="default" +## Update SpecialK automatically when using 'default or 'latest' version' +AUTOSPEK="0" +## Use FlawlessWidescreen for the game +USEFWS="0" +## Store game exe data using 'peldd' +USEPEV_PELDD="0" +## Store game exe data using 'pepack' +USEPEV_PEPACK="0" +## Store game exe data using 'peres' +USEPEV_PERES="0" +## Store game exe data using 'pescan' +USEPEV_PESCAN="0" +## DESC_USEPEV_PESEC +USEPEV_PESEC="0" +## Store game exe data using 'pestr' +USEPEV_PESTR="0" +## Store game exe data using 'readpe' +USEPEV_READPE="0" + +## A list of options that change the behavior of VKD3D-Proton +STL_VKD3D_CONFIG="none" +## Controls the debug level for log messages produced by VKD3D-Proton +STL_VKD3D_DEBUG="none" +## controls the debug level for log messages produced by the shader compilers +STL_VKD3D_SHADER_DEBUG="none" +## If set, redirects VKD3D_DEBUG logging output to a file instead +STL_VKD3D_LOG_FILE="none" +## A zero-based device index. Use to force the selected Vulkan device +STL_VKD3D_VULKAN_DEVICE="none" +## Skips devices that don't include this substring +STL_VKD3D_FILTER_DEVICE_NAME="none" +## A list of Vulkan extensions that VKD3D-Proton should not use even if available +STL_VKD3D_DISABLE_EXTENSIONS="none" +## Enables additional debug messages in tests +STL_VKD3D_TEST_DEBUG="0" +## A filter string. Only the tests whose names matches the filter string will be run, e.g. VKD3D_TEST_FILTER=clear_render_target. Useful for debugging or developing new tests +STL_VKD3D_TEST_FILTER="none" +## Excludes tests of which the name is included in the string, e.g. VKD3D_TEST_EXCLUDE=test_root_signature_priority,test_conservative_rasterization_dxil +STL_VKD3D_TEST_EXCLUDE="none" +## The test platform controls the behavior of todo(), todo_if(), bug_if() and broken() conditions in tests +STL_VKD3D_TEST_PLATFORM="none" +## Set to 0 to disable bug_if() conditions in tests +STL_VKD3D_TEST_BUG="none" +## If profiling is enabled in the build, a profiling block is emitted to . +STL_VKD3D_PROFILE_PATH="none" +SLOARGS="none" +ASKCNT="0" \ No newline at end of file diff --git a/gaming/examples/ready-or-not/README.md b/gaming/examples/ready-or-not/README.md new file mode 100644 index 0000000..99414bd --- /dev/null +++ b/gaming/examples/ready-or-not/README.md @@ -0,0 +1,159 @@ +# Ready or Not - NVIDIA Gaming Setup + +## Overview +This configuration is optimized for: +- **NVIDIA GPU** (adapted from AMD config) +- **4K Monitor with 1440p Gaming** (performance optimization) +- **Steam Tinker Launch** with GameScope scaling +- **DLSS Support** for enhanced performance + +## Key Changes from AMD Config + +### GPU-Specific Changes +| Setting | AMD (Original) | NVIDIA (Adapted) | Reason | +|---------|---------------|------------------|---------| +| `VK_ICD_FILENAMES` | RADV driver paths | NVIDIA driver path | GPU driver selection | +| `PROTON_HIDE_NVIDIA_GPU` | Not applicable | `"0"` (disabled) | Allow DLSS detection | +| `PROTON_ENABLE_NVAPI` | Not applicable | `"1"` (enabled) | Enable NVIDIA APIs | +| `USEDLSS` | Not applicable | `"1"` (enabled) | DLSS support | +| `STLRAD_PFTST` | AMD-specific flags | `"none"` | Remove AMD optimizations | + +### Display Configuration +| Setting | Original | Adapted | Reason | +|---------|----------|---------|---------| +| Resolution | 3440x1440 @ 240Hz | 2560x1440 @ 165Hz | Better performance on 4K monitor | +| GameScope Args | Ultrawide focus | Standard 16:9 + scaling | 4K monitor compatibility | +| Audio Latency | 120ms | 60ms | NVIDIA typically has lower latency | + +### Performance Optimizations +- **DXVK Async**: Enabled for NVIDIA shader optimization +- **HDR Support**: Enabled for compatible setups +- **Memory Management**: Optimized for NVIDIA VRAM handling +- **GameScope**: Configured for 1440pā†’4K scaling + +## Files Included + +### `1144200-nvidia-1440p.conf` +Main Steam Tinker Launch configuration file. Copy to `~/.config/steamtinkerlaunch/gamecfgs/1144200.conf`. + +**Key Features**: +- Game arguments: `-noeac -USEALLAVAILABLECORES -dx12` +- GameScope: 1440p gaming with 4K scaling +- DLSS and NVAPI enabled +- Optimized audio latency (60ms) + +### `nvidia-environment.conf` +Environment variables for NVIDIA optimization. Reference for manual setup. + +### `setup-ready-or-not.sh` +Automated setup script that: +- Checks dependencies (STL, GameScope, NVIDIA drivers) +- Backs up existing configurations +- Installs optimized config files +- Creates DXVK configuration +- Sets up launch helper script + +## Quick Setup + +### 1. Run the Setup Script +```bash +cd /mnt/NV2/Development/claude-home/gaming/examples/ready-or-not/ +./setup-ready-or-not.sh +``` + +### 2. Verify Steam Tinker Launch +- Open Steam +- Go to Ready or Not ā†’ Properties ā†’ Launch Options +- Leave empty or add `%command%` if needed +- STL should automatically detect the game configuration + +### 3. Test Launch +```bash +# Option 1: Use the helper script +~/.local/bin/launch-ready-or-not + +# Option 2: Launch through Steam normally +# STL will automatically apply the configuration +``` + +## Expected Performance + +### With This Configuration +- **Resolution**: 1440p gaming scaled to 4K display +- **Performance**: 60-120+ FPS depending on settings +- **Features**: DLSS enabled, HDR support, optimized audio +- **Compatibility**: EasyAntiCheat disabled (offline/modded play) + +### Performance vs Quality Settings +| Game Setting | Expected FPS | Notes | +|--------------|--------------|--------| +| Ultra + DLSS Quality | 60-80 FPS | Best visual quality | +| High + DLSS Balanced | 80-100 FPS | Good balance | +| Medium + DLSS Performance | 100-120+ FPS | Competitive gaming | + +## Troubleshooting + +### Game Won't Launch +1. Check Steam Tinker Launch is installed and working +2. Verify NVIDIA drivers: `nvidia-smi` +3. Test without STL first (disable in Steam properties) +4. Check logs: `~/.config/steamtinkerlaunch/logs/` + +### Poor Performance +1. Verify DLSS is enabled in-game settings +2. Check GameScope is working: look for scaling indicator +3. Monitor GPU usage: `watch nvidia-smi` +4. Try disabling GameScope temporarily (`USEGAMESCOPE="0"`) + +### Display Issues +1. Verify monitor resolution: `xrandr` +2. Test different GameScope refresh rates +3. Try windowed mode first, then fullscreen +4. Check HDR settings if applicable + +### Audio Problems +1. Increase latency: Change `STL_PULSE_LATENCY_MSEC` to `"120"` +2. Check PipeWire configuration +3. Test with different audio devices +4. Disable audio enhancements in game + +## Advanced Configuration + +### Custom Monitor Refresh Rates +Edit the GameScope arguments in `1144200.conf`: +```bash +# For 144Hz monitors +GAMESCOPE_ARGS="-W 2560 -H 1440 -w 2560 -h 1440 -r 144 -f --immediate-flips --rt --mangoapp --force-grab-cursor --adaptive-sync --" + +# For 120Hz monitors +GAMESCOPE_ARGS="-W 2560 -H 1440 -w 2560 -h 1440 -r 120 -f --immediate-flips --rt --mangoapp --force-grab-cursor --adaptive-sync --" +``` + +### DLSS Quality Settings +In-game DLSS options will be available with this configuration: +- **DLSS Quality**: Best visual quality, ~20% performance boost +- **DLSS Balanced**: Good balance, ~30% performance boost +- **DLSS Performance**: Maximum FPS, ~50% performance boost +- **DLSS Ultra Performance**: Competitive gaming, ~100% performance boost + +### Ray Tracing (Experimental) +To enable ray tracing support: +```bash +# In the config file +USERAYTRACING="1" +STL_VKD3D_CONFIG="dxr11" +``` +**Note**: Ray tracing requires RTX series GPUs and may significantly impact performance. + +## File Backup Locations +The setup script automatically creates backups: +- Config backup: `~/.config/steamtinkerlaunch/gamecfgs/1144200.conf.backup.[timestamp]` +- Logs: `~/.config/steamtinkerlaunch/logs/` +- DXVK cache: `/tmp/dxvk-cache/` + +## Integration with Home Lab +This gaming setup integrates with your existing infrastructure: +- **Monitoring**: MangoHUD provides performance metrics +- **Logging**: STL logs are available for troubleshooting +- **Scripts**: Helper scripts follow your existing patterns +- **Documentation**: Follows your established documentation structure \ No newline at end of file diff --git a/gaming/examples/ready-or-not/fix-crash.sh b/gaming/examples/ready-or-not/fix-crash.sh new file mode 100755 index 0000000..8b84608 --- /dev/null +++ b/gaming/examples/ready-or-not/fix-crash.sh @@ -0,0 +1,280 @@ +#!/bin/bash + +# Ready or Not Crash Fix Script +# Fixes common crash issues with splash screen crashes + +set -e + +GAME_ID="1144200" +STL_CONFIG_DIR="$HOME/.config/steamtinkerlaunch" +GAME_CONFIG="$STL_CONFIG_DIR/gamecfgs/$GAME_ID.conf" + +# Colors +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +log_info() { echo -e "${BLUE}[INFO]${NC} $1"; } +log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; } +log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; } +log_error() { echo -e "${RED}[ERROR]${NC} $1"; } + +backup_config() { + if [ -f "$GAME_CONFIG" ]; then + local backup="$GAME_CONFIG.crash-fix-backup.$(date +%Y%m%d_%H%M%S)" + cp "$GAME_CONFIG" "$backup" + log_success "Config backed up to: $backup" + fi +} + +create_minimal_config() { + log_info "Creating minimal crash-resistant configuration..." + + cat > "$GAME_CONFIG" << 'EOF' +## config Version: v12.12 - MINIMAL CRASH FIX +########################## +#GAMENAME="Ready Or Not" +#GAMEEXE="ReadyOrNot.exe" +#GAMEID="1144200" +########################## + +# Essential settings only +KEEPSTLOPEN="0" +USESLR="1" +FORCESLR="0" +USEREAP="1" +FORCEREAP="0" + +# Proton settings - using stable version +USEPROTON="GE-Proton9-11" +REDIRCOMPDATA="disabled" +REDIRSTEAMUSER="disabled" +AUTOBUMPGE="0" +AUTOBUMPPROTON="0" + +# Game arguments - minimal for crash fix +GAMEARGS="-noeac" +HARDARGS="nope" + +# Performance tools - disabled for crash testing +USEGAMEMODERUN="0" +USEGAMESCOPE="0" +GAMESCOPE_ARGS="none" +USEMANGOHUD="0" +USEMANGOAPP="0" + +# Audio - basic settings +CHANGE_PULSE_LATENCY="1" +STL_PULSE_LATENCY_MSEC="120" + +# Basic Wine/Proton settings +USEWINE="0" +VIRTUALDESKTOP="0" +VDRES="none" + +# DXVK - disabled for crash testing +USE_STLDXVKCFG="0" +DXVK_HUD="0" +DXVK_LOG_LEVEL="none" +DXVK_LOG_PATH="none" +DXVK_ASYNC="0" +DXVK_HDR="0" + +# Proton crash prevention +PROTON_USE_WINED3D="1" +PROTON_NO_D3D11="0" +PROTON_NO_D3D10="0" +PROTON_NO_ESYNC="0" +PROTON_NO_FSYNC="0" +PROTON_FORCE_LARGE_ADDRESS_AWARE="1" +PROTON_LOG="1" +PROTON_LOG_DIR="STLCFGDIR/logs/proton/id" + +# NVIDIA settings - basic only +PROTON_ENABLE_NVAPI="0" +PROTON_HIDE_NVIDIA_GPU="1" +USEDLSS="0" + +# Cleanup and debugging +CLEANPROTONTEMP="1" +CRASHGUESS="5" +STLWINEDEBUG="-all" + +# Disable all extras that could cause crashes +USECUSTOMCMD="0" +USEIGCS="0" +UUUSEIGCS="0" +UUUSEPATCH="0" +UUUSEVR="0" +USEOBSCAP="0" +USEZINK="0" +USEPRIMERUN="0" +TOGSTEAMWEBHELPER="0" +ENABLE_VKBASALT="0" +RUN_NYRNA="0" +RUN_REPLAY="0" +RUN_X64DBG="0" +RUN_GDB="0" +USE_WDIB="0" +USEVORTEX="0" +RUN_WINETRICKS="0" +USEGEOELF="0" +INSTALL_RESHADE="0" +USERESHADE="0" +USEOPENVRFSR="0" +RUNSBSVR="0" +REGEDIT="0" +WAITEDITOR="0" +STEAMAPPIDFILE="0" +CHECKCOLLECTIONS="1" +BACKUPSTEAMUSER="0" +RESTORESTEAMUSER="none" +USESUSYM="0" +USEGLOBSUSYM="0" +STRACERUN="0" +USENETMON="0" +BLOCKINTERNET="0" +USEWINEDEBUGPROTON="0" +PROTON_DUMP_DEBUG_COMMANDS="0" +ENABLE_WINESYNC="0" +USERAYTRACING="0" +WINE_FULLSCREEN_INTEGER_SCALING="0" +WINE_FULLSCREEN_FSR="0" +WINE_FULLSCREEN_FSR_STRENGTH="2" +STLWINEDLLOVERRIDES="none" +WINE_LOG_DIR="STLCFGDIR/logs/wine" +USERSTART="none" +USERSTOP="none" +AUTOCONTY="0" +USECONTY="0" +ONLYWICO="0" +GAMESCREENRES="none" +HELPURL="none" +CREATEDESKTOPICON="0" +FIXSYMLINKS="0" +UNSYMLINK="0" +DELPFX="0" +RUN_DEPS="0" +SORTGARGS="0" +WAITMO2="0" +MO2MODE="disabled" +USESPECIALK="0" +SDLUSEWAYLAND="0" +STLRAD_PFTST="none" +SPEKVERS="default" +AUTOSPEK="0" +USEFWS="0" +USEPEV_PELDD="0" +USEPEV_PEPACK="0" +USEPEV_PERES="0" +USEPEV_PESCAN="0" +USEPEV_PESEC="0" +USEPEV_PESTR="0" +USEPEV_READPE="0" +STL_VKD3D_CONFIG="none" +STL_VKD3D_DEBUG="none" +STL_VKD3D_SHADER_DEBUG="none" +STL_VKD3D_LOG_FILE="none" +STL_VKD3D_VULKAN_DEVICE="none" +STL_VKD3D_FILTER_DEVICE_NAME="none" +STL_VKD3D_DISABLE_EXTENSIONS="none" +STL_VKD3D_TEST_DEBUG="0" +STL_VKD3D_TEST_FILTER="none" +STL_VKD3D_TEST_EXCLUDE="none" +STL_VKD3D_TEST_PLATFORM="none" +STL_VKD3D_TEST_BUG="none" +STL_VKD3D_PROFILE_PATH="none" +SLOARGS="none" +ASKCNT="0" +EOF + + log_success "Minimal configuration created" +} + +clean_old_data() { + log_info "Cleaning old game data that might cause crashes..." + + # Remove old compatdata + local compatdata_paths=( + "$HOME/.steam/steam/steamapps/compatdata/$GAME_ID" + "$HOME/.local/share/Steam/steamapps/compatdata/$GAME_ID" + ) + + for path in "${compatdata_paths[@]}"; do + if [ -d "$path" ]; then + log_info "Removing old compatdata: $path" + rm -rf "$path" + fi + done + + # Clean DXVK cache + if [ -d "/tmp/dxvk-cache" ]; then + log_info "Cleaning DXVK cache" + rm -rf /tmp/dxvk-cache/* + fi + + log_success "Old data cleaned" +} + +create_debug_launch_script() { + log_info "Creating debug launch script..." + + cat > "$HOME/.local/bin/launch-ready-or-not-debug" << 'EOF' +#!/bin/bash + +# Ready or Not Debug Launch Script +# Use this to get detailed crash information + +export PROTON_LOG=1 +export PROTON_LOG_DIR="$HOME/.config/steamtinkerlaunch/logs/proton/debug" +export WINEDEBUG="+dll,+module" + +# Create log directory +mkdir -p "$HOME/.config/steamtinkerlaunch/logs/proton/debug" + +echo "Launching Ready or Not in debug mode..." +echo "Logs will be in: $HOME/.config/steamtinkerlaunch/logs/proton/debug" + +# Launch game +steam steam://rungameid/1144200 + +echo "Check logs for crash details:" +echo "Main log: $HOME/.config/steamtinkerlaunch/logs/proton/debug/steam-1144200.log" +EOF + + chmod +x "$HOME/.local/bin/launch-ready-or-not-debug" + log_success "Debug launcher created: ~/.local/bin/launch-ready-or-not-debug" +} + +show_next_steps() { + echo + log_success "Crash fix applied!" + echo + log_info "Next Steps:" + echo "1. Launch Ready or Not through Steam" + echo "2. If it still crashes, use debug launcher:" + echo " ~/.local/bin/launch-ready-or-not-debug" + echo "3. Check debug logs in ~/.config/steamtinkerlaunch/logs/" + echo "4. If it works, gradually re-enable features:" + echo " - Enable DXVK: PROTON_USE_WINED3D=\"0\", DXVK_ASYNC=\"1\"" + echo " - Enable GameScope: USEGAMESCOPE=\"1\"" + echo " - Enable NVIDIA features: PROTON_ENABLE_NVAPI=\"1\"" + echo + log_warning "Current config uses WineD3D for stability" + log_warning "Performance will be lower but game should run" +} + +main() { + log_info "Fixing Ready or Not splash screen crash..." + echo + + backup_config + clean_old_data + create_minimal_config + create_debug_launch_script + show_next_steps +} + +main "$@" \ No newline at end of file diff --git a/gaming/examples/ready-or-not/force-stl-detection.sh b/gaming/examples/ready-or-not/force-stl-detection.sh new file mode 100755 index 0000000..4ac80f9 --- /dev/null +++ b/gaming/examples/ready-or-not/force-stl-detection.sh @@ -0,0 +1,70 @@ +#!/bin/bash + +# Force Steam Tinker Launch to recognize Ready or Not +# Run this if STL isn't automatically detecting the game + +set -e + +GAME_ID="1144200" +STL_CONFIG_DIR="$HOME/.config/steamtinkerlaunch" +GAME_CONFIG_DIR="$STL_CONFIG_DIR/gamecfgs" + +# Colors +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +log_info() { echo -e "${BLUE}[INFO]${NC} $1"; } +log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; } +log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; } +log_error() { echo -e "${RED}[ERROR]${NC} $1"; } + +# Check if STL is installed +if ! command -v steamtinkerlaunch >/dev/null 2>&1; then + log_error "Steam Tinker Launch not found!" + exit 1 +fi + +log_info "Forcing Steam Tinker Launch to recognize Ready or Not (ID: $GAME_ID)..." + +# Method 1: Use STL's built-in compat add +log_info "Adding game to STL compatibility database..." +if steamtinkerlaunch compat add "$GAME_ID"; then + log_success "Game added to STL database" +else + log_warning "STL compat add failed, trying manual approach..." +fi + +# Method 2: Ensure config file is in the right place +log_info "Verifying configuration file placement..." +if [ -f "/mnt/NV2/Development/claude-home/gaming/examples/ready-or-not/1144200-nvidia-1440p.conf" ]; then + cp "/mnt/NV2/Development/claude-home/gaming/examples/ready-or-not/1144200-nvidia-1440p.conf" "$GAME_CONFIG_DIR/$GAME_ID.conf" + log_success "Configuration file copied to STL directory" +else + log_error "Source configuration file not found!" + exit 1 +fi + +# Method 3: Create STL database entry manually if needed +log_info "Ensuring STL database knows about Ready or Not..." +if [ -d "$STL_CONFIG_DIR" ]; then + # Create a simple database entry + echo "1144200|Ready Or Not|ReadyOrNot.exe" >> "$STL_CONFIG_DIR/gameids.txt" 2>/dev/null || true + log_success "Game entry added to local database" +fi + +# Method 4: Test STL GUI recognition +log_info "Testing STL menu launch..." +echo "You can test if STL recognizes the game by running:" +echo "steamtinkerlaunch $GAME_ID" +echo +echo "Or launch Ready or Not through Steam and look for the STL menu." + +log_success "Force detection completed!" +log_info "Next steps:" +echo "1. Launch Ready or Not through Steam" +echo "2. Look for the Steam Tinker Launch configuration menu" +echo "3. If STL menu doesn't appear, try setting compatibility tool again in Steam" +echo "4. Check ~/.config/steamtinkerlaunch/steamtinkerlaunch.log for errors" \ No newline at end of file diff --git a/gaming/examples/ready-or-not/nvidia-environment.conf b/gaming/examples/ready-or-not/nvidia-environment.conf new file mode 100644 index 0000000..bfdcec2 --- /dev/null +++ b/gaming/examples/ready-or-not/nvidia-environment.conf @@ -0,0 +1,34 @@ +# NVIDIA-optimized environment variables for Ready or Not +# These are sourced before game launch + +# Enable NVIDIA GPU optimizations +__NV_PRIME_RENDER_OFFLOAD="1" +__GLX_VENDOR_LIBRARY_NAME="nvidia" + +# Fix for mods menu freeze - allows the agreement dialog to display properly +PROTON_SET_GAME_DRIVE="1" + +# Audio crackling fixes for PipeWire (optimized for lower latency) +PULSE_LATENCY_MSEC="60" +PIPEWIRE_LATENCY="128/48000" + +# NVIDIA-specific Vulkan optimizations +VK_ICD_FILENAMES="/usr/share/vulkan/icd.d/nvidia_icd.json" + +# DXVK NVIDIA optimizations +DXVK_STATE_CACHE_PATH="/tmp/dxvk-cache" +DXVK_ASYNC="1" +DXVK_HDR="1" + +# NVIDIA DLSS support +PROTON_ENABLE_NVAPI="1" +PROTON_HIDE_NVIDIA_GPU="0" + +# Memory optimizations +PROTON_FORCE_LARGE_ADDRESS_AWARE="1" + +# Disable AMD-specific optimizations +RADV_PERFTEST="" + +# GameScope optimizations for NVIDIA +GAMESCOPE_LIMITER_FILE="/tmp/gamescope_limiter" \ No newline at end of file diff --git a/gaming/examples/ready-or-not/setup-ready-or-not.sh b/gaming/examples/ready-or-not/setup-ready-or-not.sh new file mode 100755 index 0000000..8f40c19 --- /dev/null +++ b/gaming/examples/ready-or-not/setup-ready-or-not.sh @@ -0,0 +1,217 @@ +#!/bin/bash + +# Ready or Not Steam Tinker Launch Setup Script +# Optimized for NVIDIA GPUs and 1440p gaming on 4K monitors + +set -e + +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +STL_CONFIG_DIR="$HOME/.config/steamtinkerlaunch" +GAME_CONFIG_DIR="$STL_CONFIG_DIR/gamecfgs" +GAME_ID="1144200" + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' # No Color + +log_info() { + echo -e "${BLUE}[INFO]${NC} $1" +} + +log_success() { + echo -e "${GREEN}[SUCCESS]${NC} $1" +} + +log_warning() { + echo -e "${YELLOW}[WARNING]${NC} $1" +} + +log_error() { + echo -e "${RED}[ERROR]${NC} $1" +} + +check_dependencies() { + log_info "Checking dependencies..." + + # Check if Steam Tinker Launch is installed + if ! command -v steamtinkerlaunch >/dev/null 2>&1; then + log_error "Steam Tinker Launch is not installed!" + log_info "Please install it first: https://github.com/frostworx/steamtinkerlaunch" + exit 1 + fi + + # Check if GameScope is available + if ! command -v gamescope >/dev/null 2>&1; then + log_warning "GameScope not found. GameScope is recommended for optimal 1440p gaming on 4K monitors." + log_info "Install with: sudo pacman -S gamescope (Arch) or sudo apt install gamescope (Ubuntu)" + fi + + # Check NVIDIA drivers + if ! command -v nvidia-smi >/dev/null 2>&1; then + log_error "NVIDIA drivers not found!" + log_info "Please install NVIDIA drivers first" + exit 1 + fi + + log_success "Dependencies check completed" +} + +backup_existing_config() { + if [ -f "$GAME_CONFIG_DIR/$GAME_ID.conf" ]; then + log_info "Backing up existing configuration..." + cp "$GAME_CONFIG_DIR/$GAME_ID.conf" "$GAME_CONFIG_DIR/$GAME_ID.conf.backup.$(date +%Y%m%d_%H%M%S)" + log_success "Backup created" + fi +} + +setup_directories() { + log_info "Setting up Steam Tinker Launch directories..." + + mkdir -p "$STL_CONFIG_DIR" + mkdir -p "$GAME_CONFIG_DIR" + mkdir -p "$STL_CONFIG_DIR/dxvk" + mkdir -p "$STL_CONFIG_DIR/logs" + + log_success "Directories created" +} + +install_game_config() { + log_info "Installing Ready or Not configuration..." + + if [ ! -f "$SCRIPT_DIR/1144200-nvidia-1440p.conf" ]; then + log_error "Configuration file not found: $SCRIPT_DIR/1144200-nvidia-1440p.conf" + exit 1 + fi + + cp "$SCRIPT_DIR/1144200-nvidia-1440p.conf" "$GAME_CONFIG_DIR/$GAME_ID.conf" + chmod 644 "$GAME_CONFIG_DIR/$GAME_ID.conf" + + log_success "Game configuration installed" +} + +create_dxvk_config() { + log_info "Creating DXVK configuration..." + + cat > "$STL_CONFIG_DIR/dxvk/$GAME_ID.conf" << 'EOF' +# DXVK configuration for Ready or Not (NVIDIA optimized) + +# Reduce input latency +dxgi.maxFrameLatency = 1 +d3d9.maxFrameLatency = 1 + +# NVIDIA-specific optimizations +dxgi.nvapiHack = True + +# Memory management for NVIDIA GPUs +dxgi.maxDeviceMemory = 8192 +dxgi.maxSharedMemory = 1024 + +# Enable async shader compilation +dxvk.enableAsync = True + +# HDR support +dxgi.enableHDR = True + +# Disable tear-free for better performance +dxgi.tearFree = False + +# Sync interval (0 = unlimited, 1 = vsync) +d3d9.presentInterval = 0 +EOF + + log_success "DXVK configuration created" +} + +create_launch_script() { + log_info "Creating launch helper script..." + + cat > "$HOME/.local/bin/launch-ready-or-not" << 'EOF' +#!/bin/bash + +# Ready or Not Launch Helper +# Optimized for NVIDIA + 1440p gaming + +# Source NVIDIA environment variables +export __NV_PRIME_RENDER_OFFLOAD=1 +export __GLX_VENDOR_LIBRARY_NAME=nvidia +export PROTON_SET_GAME_DRIVE=1 +export PULSE_LATENCY_MSEC=60 +export PIPEWIRE_LATENCY=128/48000 +export VK_ICD_FILENAMES=/usr/share/vulkan/icd.d/nvidia_icd.json +export DXVK_ASYNC=1 +export DXVK_HDR=1 +export PROTON_ENABLE_NVAPI=1 +export PROTON_HIDE_NVIDIA_GPU=0 +export PROTON_FORCE_LARGE_ADDRESS_AWARE=1 + +# Launch the game +exec steam steam://rungameid/1144200 +EOF + + chmod +x "$HOME/.local/bin/launch-ready-or-not" + + log_success "Launch helper script created at ~/.local/bin/launch-ready-or-not" +} + +test_configuration() { + log_info "Testing configuration..." + + # Check if game config exists and is readable + if [ -r "$GAME_CONFIG_DIR/$GAME_ID.conf" ]; then + log_success "Game configuration is readable" + else + log_error "Game configuration is not readable" + exit 1 + fi + + # Check if DXVK config exists + if [ -r "$STL_CONFIG_DIR/dxvk/$GAME_ID.conf" ]; then + log_success "DXVK configuration is readable" + else + log_warning "DXVK configuration not found" + fi + + log_success "Configuration test completed" +} + +show_next_steps() { + echo + log_success "Setup completed successfully!" + echo + log_info "Next steps:" + echo "1. Launch Steam and go to Ready or Not properties" + echo "2. In Launch Options, you can optionally add: %command%" + echo "3. Launch the game - Steam Tinker Launch should automatically detect and use the configuration" + echo "4. For troubleshooting, check ~/.config/steamtinkerlaunch/logs/" + echo + log_info "Performance tips:" + echo "- The game is configured for 1440p gaming with DLSS enabled" + echo "- GameScope will handle scaling to your 4K monitor" + echo "- Use the launch helper: ~/.local/bin/launch-ready-or-not" + echo "- Monitor performance with the built-in MangoHUD overlay" + echo + log_info "If you experience issues:" + echo "- Check the troubleshooting guide in this directory" + echo "- Disable GameScope temporarily if needed" + echo "- Try different Proton versions in Steam" +} + +main() { + log_info "Setting up Ready or Not for Steam Tinker Launch..." + log_info "Target: NVIDIA GPU, 1440p gaming on 4K monitor" + echo + + check_dependencies + setup_directories + backup_existing_config + install_game_config + create_dxvk_config + create_launch_script + test_configuration + show_next_steps +} + +main "$@" \ No newline at end of file diff --git a/gaming/examples/ready-or-not/working-baseline-config.md b/gaming/examples/ready-or-not/working-baseline-config.md new file mode 100644 index 0000000..767f22e --- /dev/null +++ b/gaming/examples/ready-or-not/working-baseline-config.md @@ -0,0 +1,61 @@ +# Ready or Not - Working Baseline Configuration + +## āœ… Confirmed Working Setup + +### Successful Configuration (Baseline) +- **Proton Version**: Proton 9.25 (or latest experimental) +- **Launch Mode**: Safe mode (no mods) +- **Launch Options**: Basic (testing DX11 next) +- **Game State**: Successfully loaded mission +- **Date Tested**: 2025-08-13 + +### Key Findings +1. **Game reinstall was necessary** - Previous installations may have had corrupted files +2. **Proton 9.25 works** - Newer versions are actually better for this game +3. **Safe mode bypasses mod conflicts** - Important for initial testing +4. **Anti-cheat handling** - Game ran without explicit `-noeac` in working test + +## Next Test: DX11 Configuration + +### DX11 Test Setup +- **Proton Version**: Keep Proton 9.25 +- **Launch Options**: `%command% -dx11` +- **Expected**: Should work since baseline works + +### If DX11 Test Succeeds + +We can then move to STL with these working parameters: +- Base Proton: Proton 9.25 equivalent (likely GE-Proton10-11) +- Game Arguments: `-dx11` (and add `-noeac` if needed) +- Graphics: Start with DXVK (not WineD3D since newer Proton works) +- Features: Can enable GameScope, DLSS, etc. gradually + +### If DX11 Test Fails + +We know the baseline works, so we can: +- Use basic Proton 9.25 without DX11 override +- Still move to STL but avoid DirectX version forcing +- Focus on performance optimizations instead + +## STL Configuration Strategy + +Once we confirm DX11 status, create STL config based on: + +```bash +# Working baseline settings +USEPROTON="GE-Proton10-11" # Equivalent to Proton 9.25 +GAMEARGS="-dx11" # If DX11 test succeeds +USEGAMEMODERUN="1" # Performance +USEGAMESCOPE="1" # 1440p gaming +DXVK_ASYNC="1" # Since newer Proton works +PROTON_ENABLE_NVAPI="1" # NVIDIA features +USEDLSS="1" # RTX 4080 SUPER optimization +``` + +## Lessons Learned + +1. **Game reinstall solved fundamental issues** +2. **Newer Proton versions work better than expected** +3. **Start simple and build up complexity** +4. **Safe mode is important for initial testing** +5. **Previous configurations may have been interfering** \ No newline at end of file diff --git a/gaming/scripts/CONTEXT.md b/gaming/scripts/CONTEXT.md new file mode 100644 index 0000000..0147af8 --- /dev/null +++ b/gaming/scripts/CONTEXT.md @@ -0,0 +1,172 @@ +# Gaming Scripts Context + +## Overview +This directory contains automation and helper scripts for gaming setup, configuration, and maintenance. These scripts are designed to work with Steam Tinker Launch and various gaming tools on Linux. + +## Script Categories + +### Setup and Configuration +- **Purpose**: Automate initial setup and configuration of gaming environments +- **Target**: Steam Tinker Launch, game-specific configurations, system optimization +- **Pattern**: Interactive setup with validation and backup creation + +### Validation and Testing +- **Purpose**: Verify gaming environment is properly configured +- **Target**: Hardware detection, driver validation, configuration checking +- **Pattern**: Comprehensive system checks with colored output and recommendations + +### Performance Monitoring +- **Purpose**: Monitor and optimize gaming performance +- **Target**: FPS monitoring, resource usage, bottleneck identification +- **Pattern**: Real-time monitoring with logging and alerting + +## Common Patterns + +### Error Handling +```bash +set -e # Exit on error +trap cleanup EXIT # Always cleanup +``` + +### Logging +```bash +# Colored output functions +log_info() { echo -e "${BLUE}[INFO]${NC} $1"; } +log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; } +log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; } +log_error() { echo -e "${RED}[ERROR]${NC} $1"; } +``` + +### Dependency Checking +```bash +check_dependencies() { + local deps=("steam" "gamescope" "nvidia-smi") + for dep in "${deps[@]}"; do + command -v "$dep" >/dev/null 2>&1 || { + log_error "$dep not found" + return 1 + } + done +} +``` + +### Configuration Backup +```bash +backup_config() { + local config_file="$1" + if [ -f "$config_file" ]; then + cp "$config_file" "${config_file}.backup.$(date +%Y%m%d_%H%M%S)" + fi +} +``` + +## Current Scripts + +### `validate-gaming-setup.sh` +**Purpose**: Comprehensive validation of gaming environment +**Features**: +- NVIDIA driver and GPU detection +- Steam and Steam Tinker Launch validation +- GameScope availability check +- Audio system detection +- Display configuration analysis +- Game-specific config validation +- Performance tools availability + +**Usage**: +```bash +./gaming/scripts/validate-gaming-setup.sh +``` + +**Integration**: +- Called by setup scripts for validation +- Can be run independently for troubleshooting +- Provides recommendations for missing components + +## Integration Points + +### With Home Lab Infrastructure +- **Logging**: Scripts log to standard locations for centralized monitoring +- **Monitoring**: Performance scripts can integrate with existing monitoring systems +- **Documentation**: All scripts include comprehensive help and documentation +- **Configuration**: Scripts respect existing configuration patterns and backup strategies + +### With Steam Tinker Launch +- **Config Management**: Scripts handle STL configuration files properly +- **Game Detection**: Scripts can identify and configure specific games +- **Environment Setup**: Scripts set up proper environment variables and system configuration +- **Troubleshooting**: Scripts provide diagnostic information for STL issues + +### With System Services +- **Audio Systems**: Scripts detect and configure PipeWire/PulseAudio +- **Display Managers**: Scripts work with X11 and Wayland display systems +- **GPU Drivers**: Scripts validate and configure NVIDIA/AMD drivers +- **Performance Tools**: Scripts integrate with GameMode, MangoHUD, and other performance tools + +## Development Patterns + +### Script Structure +```bash +#!/bin/bash +# Script description and purpose + +set -e # Exit on error + +# Color definitions +RED='\033[0;31m' +GREEN='\033[0;32m' +# ... etc + +# Logging functions +log_info() { ... } +log_success() { ... } +# ... etc + +# Main functionality functions +check_something() { ... } +setup_something() { ... } +validate_something() { ... } + +# Main execution +main() { + log_info "Starting script..." + check_something + setup_something + validate_something + log_success "Script completed" +} + +main "$@" +``` + +### Testing Approach +- Scripts should validate their own prerequisites +- Include dry-run modes where applicable +- Provide verbose output for debugging +- Include rollback mechanisms for destructive operations + +### Documentation Standards +- Each script includes comprehensive comments +- Usage examples in script headers +- Integration notes for complex setups +- Troubleshooting sections for common issues + +## Maintenance Notes + +### Regular Tasks +- Update game-specific configurations as games are updated +- Validate scripts work with new versions of Steam Tinker Launch +- Test scripts with different hardware configurations +- Update performance optimization settings based on new research + +### Monitoring Integration +- Scripts should support being called from monitoring systems +- Performance scripts should output metrics in parseable formats +- Error conditions should be properly logged and alertable +- Resource usage should be monitored for long-running scripts + +### Security Considerations +- Scripts handle configuration files with proper permissions +- No hardcoded paths or credentials +- Proper input validation for user-provided parameters +- Safe handling of system-level configuration changes \ No newline at end of file diff --git a/gaming/scripts/check-stl-logs.sh b/gaming/scripts/check-stl-logs.sh new file mode 100755 index 0000000..4a16a6a --- /dev/null +++ b/gaming/scripts/check-stl-logs.sh @@ -0,0 +1,175 @@ +#!/bin/bash + +# Steam Tinker Launch Log Checker +# Analyzes recent STL logs for common issues + +set -e + +# Colors +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +log_info() { echo -e "${BLUE}[INFO]${NC} $1"; } +log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; } +log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; } +log_error() { echo -e "${RED}[ERROR]${NC} $1"; } + +STL_LOG_DIR="$HOME/.config/steamtinkerlaunch/logs" +GAME_ID="1144200" + +check_stl_logs() { + log_info "Checking Steam Tinker Launch logs..." + + if [ ! -d "$STL_LOG_DIR" ]; then + log_error "STL logs directory not found: $STL_LOG_DIR" + return 1 + fi + + # Check main STL log + local main_log="$STL_LOG_DIR/steamtinkerlaunch.log" + if [ -f "$main_log" ]; then + log_info "Recent STL activity (last 20 lines):" + echo "----------------------------------------" + tail -20 "$main_log" | while read line; do + if echo "$line" | grep -qi "error\|fail\|crash\|exception"; then + echo -e "${RED}$line${NC}" + elif echo "$line" | grep -qi "warning"; then + echo -e "${YELLOW}$line${NC}" + else + echo "$line" + fi + done + echo "----------------------------------------" + else + log_warning "Main STL log not found" + fi + + # Check for game-specific logs + local proton_log_dir="$STL_LOG_DIR/proton/id" + if [ -d "$proton_log_dir" ]; then + log_info "Checking Proton logs..." + ls -la "$proton_log_dir" 2>/dev/null || log_warning "No Proton logs found" + fi + + # Check for wine logs + local wine_log_dir="$STL_LOG_DIR/wine" + if [ -d "$wine_log_dir" ]; then + log_info "Checking Wine logs..." + ls -la "$wine_log_dir" 2>/dev/null || log_warning "No Wine logs found" + fi + + # Check for DXVK logs + local dxvk_log_dir="$STL_LOG_DIR/dxvk" + if [ -d "$dxvk_log_dir" ]; then + log_info "Checking DXVK logs..." + ls -la "$dxvk_log_dir" 2>/dev/null || log_warning "No DXVK logs found" + fi +} + +check_proton_prefix() { + log_info "Checking Proton prefix status..." + + local compatdata_dirs=( + "$HOME/.steam/steam/steamapps/compatdata/$GAME_ID" + "$HOME/.local/share/Steam/steamapps/compatdata/$GAME_ID" + ) + + for compatdata in "${compatdata_dirs[@]}"; do + if [ -d "$compatdata" ]; then + log_success "Found compatdata: $compatdata" + log_info "Prefix size: $(du -sh "$compatdata" 2>/dev/null | cut -f1)" + + # Check for common crash indicators + if [ -f "$compatdata/pfx/drive_c/users/steamuser/Temp/steam_appid.txt" ]; then + local appid=$(cat "$compatdata/pfx/drive_c/users/steamuser/Temp/steam_appid.txt" 2>/dev/null) + log_info "Steam App ID in prefix: $appid" + fi + + # Check prefix health + if [ -f "$compatdata/pfx/system.reg" ]; then + log_success "Wine prefix appears healthy" + else + log_warning "Wine prefix may be corrupted" + fi + + return 0 + fi + done + + log_warning "No compatdata found - this might be the issue" +} + +analyze_common_crashes() { + log_info "Analyzing for common Ready or Not crash patterns..." + + local main_log="$STL_LOG_DIR/steamtinkerlaunch.log" + if [ -f "$main_log" ]; then + # Check for EasyAntiCheat issues + if grep -qi "easyanticheat\|eac" "$main_log"; then + log_warning "EasyAntiCheat detected in logs - this can cause crashes" + log_info "Solution: Ensure -noeac is in game arguments" + fi + + # Check for DirectX issues + if grep -qi "d3d\|directx\|dxgi" "$main_log"; then + log_warning "DirectX/DXVK issues detected" + log_info "Solution: Try PROTON_USE_WINED3D=1 or different Proton version" + fi + + # Check for memory issues + if grep -qi "memory\|allocation\|heap" "$main_log"; then + log_warning "Memory issues detected" + log_info "Solution: Ensure PROTON_FORCE_LARGE_ADDRESS_AWARE=1 is set" + fi + + # Check for Vulkan issues + if grep -qi "vulkan\|vk_" "$main_log"; then + log_warning "Vulkan issues detected" + log_info "Solution: Verify NVIDIA drivers and Vulkan support" + fi + fi +} + +suggest_fixes() { + echo + log_info "=== Common Fixes for Ready or Not Crashes ===" + echo + echo "1. Reset Proton Prefix:" + echo " rm -rf ~/.steam/steam/steamapps/compatdata/1144200/" + echo " (Steam will recreate on next launch)" + echo + echo "2. Try Different Proton Version:" + echo " - GE-Proton9-11 (older, more stable)" + echo " - Proton 8.0-5 (Steam's stable version)" + echo + echo "3. Disable GameScope temporarily:" + echo " Edit config: USEGAMESCOPE=\"0\"" + echo + echo "4. Enable Wine debug for more info:" + echo " Edit config: PROTON_LOG=\"1\"" + echo + echo "5. Try minimal STL settings:" + echo " - Disable all extras except basic Proton" + echo " - Only keep: GAMEARGS=\"-noeac\"" + echo + echo "6. Fallback to WineD3D:" + echo " Edit config: PROTON_USE_WINED3D=\"1\"" +} + +main() { + log_info "Analyzing Ready or Not crash..." + echo + + check_stl_logs + echo + check_proton_prefix + echo + analyze_common_crashes + + suggest_fixes +} + +main "$@" \ No newline at end of file diff --git a/gaming/scripts/clean-slate-setup.sh b/gaming/scripts/clean-slate-setup.sh new file mode 100755 index 0000000..70fa5d2 --- /dev/null +++ b/gaming/scripts/clean-slate-setup.sh @@ -0,0 +1,168 @@ +#!/bin/bash + +# Ready or Not - Clean Slate Setup +# Removes all previous configurations and starts fresh with the simplest approach + +set -e + +GAME_ID="1144200" + +# Colors +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +log_info() { echo -e "${BLUE}[INFO]${NC} $1"; } +log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; } +log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; } +log_error() { echo -e "${RED}[ERROR]${NC} $1"; } + +clean_all_configs() { + log_info "=== Cleaning All Previous Configurations ===" + + # Remove STL config + if [ -f "$HOME/.config/steamtinkerlaunch/gamecfgs/$GAME_ID.conf" ]; then + log_info "Backing up and removing STL config..." + mv "$HOME/.config/steamtinkerlaunch/gamecfgs/$GAME_ID.conf" \ + "$HOME/.config/steamtinkerlaunch/gamecfgs/$GAME_ID.conf.backup.$(date +%Y%m%d_%H%M%S)" + fi + + # Remove DXVK config + if [ -f "$HOME/.config/steamtinkerlaunch/dxvk/$GAME_ID.conf" ]; then + log_info "Removing DXVK config..." + rm -f "$HOME/.config/steamtinkerlaunch/dxvk/$GAME_ID.conf" + fi + + # Remove compatdata (this forces Steam to recreate everything) + local compatdata_paths=( + "$HOME/.steam/steam/steamapps/compatdata/$GAME_ID" + "$HOME/.local/share/Steam/steamapps/compatdata/$GAME_ID" + "/mnt/NV2/SteamLibrary/steamapps/compatdata/$GAME_ID" + ) + + for path in "${compatdata_paths[@]}"; do + if [ -d "$path" ]; then + log_info "Removing compatdata: $path" + rm -rf "$path" + fi + done + + log_success "All previous configurations cleaned" +} + +simple_steam_setup() { + log_info "=== Simple Steam Setup Instructions ===" + echo + echo "We're going to use the absolute simplest approach:" + echo + echo "1. Right-click Ready or Not in Steam" + echo "2. Properties ā†’ Compatibility" + echo "3. Force compatibility tool: Proton 8.0-5" + echo "4. Launch Options: %command% -noeac" + echo "5. Close properties" + echo + echo "That's it. No STL, no complex settings, just basic Proton." + echo +} + +test_basic_launch() { + log_info "=== Testing Basic Launch ===" + echo + echo "After setting up the simple configuration:" + echo "1. Launch Ready or Not from Steam" + echo "2. Note exactly what happens:" + echo " - Does it reach splash screen?" + echo " - How long does it run?" + echo " - Any error messages?" + echo + echo "This baseline test will tell us if the game can run at all" + echo "with the most basic Proton configuration." + echo +} + +if_basic_fails() { + log_info "=== If Basic Test Fails ===" + echo + echo "If the game still crashes with basic Proton 8.0-5:" + echo + echo "Option A: Try Proton 7.0-6" + echo "- Same setup, just change to Proton 7.0-6" + echo "- This version has better compatibility with older games" + echo + echo "Option B: Add Windows dependencies" + echo "- Install protontricks if not already installed" + echo "- Run: protontricks 1144200 vcrun2019" + echo "- Then test again" + echo + echo "Option C: Different launch arguments" + echo "- Try: %command% -windowed -noeac" + echo "- Or: %command% -dx11 -noeac" + echo +} + +if_basic_works() { + log_info "=== If Basic Test Works ===" + echo + echo "If the game launches and runs (even if it crashes later):" + echo + echo "Great! We have a working baseline." + echo "We can then gradually add improvements:" + echo "1. Better graphics settings" + echo "2. Performance optimizations" + echo "3. 1440p gaming setup" + echo "4. DLSS if working well" + echo + echo "But first, let's just get it running with minimal settings." + echo +} + +check_prerequisites() { + log_info "=== Checking Prerequisites ===" + + # Check if game is installed + if [ -f "/mnt/NV2/SteamLibrary/steamapps/common/Ready Or Not/ReadyOrNot.exe" ]; then + log_success "Ready or Not is installed" + else + log_error "Ready or Not not found - please install through Steam first" + return 1 + fi + + # Check Steam is running + if pgrep -f steam >/dev/null; then + log_success "Steam is running" + else + log_warning "Steam doesn't appear to be running" + fi + + # Check Proton versions available + if [ -d "$HOME/.steam/steam/steamapps/common" ]; then + local proton_versions=$(ls "$HOME/.steam/steam/steamapps/common" | grep -i proton | head -3) + log_info "Available Proton versions:" + echo "$proton_versions" + fi + + echo +} + +main() { + log_info "Ready or Not - Clean Slate Setup" + log_info "Starting completely fresh with the simplest possible configuration" + echo + + check_prerequisites + clean_all_configs + echo + simple_steam_setup + test_basic_launch + echo + if_basic_works + if_basic_fails + + echo + log_success "Clean slate setup complete!" + log_info "Next step: Configure Steam with the simple settings above and test" +} + +main "$@" \ No newline at end of file diff --git a/gaming/scripts/diagnose-crash.sh b/gaming/scripts/diagnose-crash.sh new file mode 100755 index 0000000..8088bcb --- /dev/null +++ b/gaming/scripts/diagnose-crash.sh @@ -0,0 +1,255 @@ +#!/bin/bash + +# Ready or Not Crash Diagnostic Script +# Gathers all relevant crash information + +set -e + +GAME_ID="1144200" + +# Colors +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +log_info() { echo -e "${BLUE}[INFO]${NC} $1"; } +log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; } +log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; } +log_error() { echo -e "${RED}[ERROR]${NC} $1"; } + +check_system_prerequisites() { + log_info "=== System Prerequisites Check ===" + + # Check kernel version + log_info "Kernel: $(uname -r)" + + # Check graphics drivers + if command -v nvidia-smi >/dev/null 2>&1; then + local gpu_info=$(nvidia-smi --query-gpu=name,driver_version --format=csv,noheader,nounits | head -1) + log_info "GPU: $gpu_info" + fi + + # Check Vulkan + if command -v vulkaninfo >/dev/null 2>&1; then + local vulkan_devices=$(vulkaninfo --summary 2>/dev/null | grep "GPU id" | wc -l) + log_info "Vulkan devices: $vulkan_devices" + fi + + # Check Steam process + if pgrep -f steam >/dev/null; then + log_success "Steam is running" + else + log_warning "Steam is not running" + fi + + echo +} + +check_proton_versions() { + log_info "=== Available Proton Versions ===" + + local steam_dirs=( + "$HOME/.steam/steam/steamapps/common" + "$HOME/.local/share/Steam/steamapps/common" + ) + + for steam_dir in "${steam_dirs[@]}"; do + if [ -d "$steam_dir" ]; then + log_info "Proton versions in $steam_dir:" + ls "$steam_dir" 2>/dev/null | grep -i proton || log_warning "No Proton versions found" + fi + done + + echo +} + +test_basic_compatibility() { + log_info "=== Testing Basic Wine/Proton Compatibility ===" + + # Test basic Wine functionality + log_info "Testing Wine with simple Windows executable..." + + # Create a simple test script + cat > /tmp/wine_test.sh << 'EOF' +#!/bin/bash +export WINEPREFIX="/tmp/wine_test_prefix" +export PROTON_LOG=1 + +# Try to run a simple Windows command +timeout 10s wine cmd /c "echo Wine test successful" 2>&1 | head -5 +EOF + + chmod +x /tmp/wine_test.sh + bash /tmp/wine_test.sh || log_warning "Basic Wine test failed" + + # Clean up + rm -rf /tmp/wine_test_prefix /tmp/wine_test.sh 2>/dev/null + + echo +} + +check_steam_library() { + log_info "=== Steam Library Check ===" + + # Look for game in various locations + local found_game=false + local search_paths=( + "$HOME/.steam/steam/steamapps" + "$HOME/.local/share/Steam/steamapps" + "/mnt/*/games/steam/steamapps" + "/mnt/*/Games/Steam/steamapps" + "/mnt/*/*/steamapps" + ) + + for search_path in "${search_paths[@]}"; do + local game_paths=$(find $search_path -name "*Ready*" -type d 2>/dev/null || true) + if [ -n "$game_paths" ]; then + log_success "Found game at: $game_paths" + found_game=true + + # Check game executable + local game_dir="$game_paths" + if [ -f "$game_dir/ReadyOrNot.exe" ]; then + log_success "Game executable found" + log_info "Game size: $(du -sh "$game_dir" 2>/dev/null | cut -f1)" + else + log_warning "Game executable not found in $game_dir" + fi + fi + done + + if ! $found_game; then + log_error "Ready or Not installation not found!" + log_info "Please verify the game is installed through Steam" + fi + + echo +} + +analyze_crash_patterns() { + log_info "=== Crash Pattern Analysis ===" + + # Check for common crash causes + log_info "Checking for common Ready or Not crash patterns:" + + # Check system resources + local memory_mb=$(free -m | awk 'NR==2{printf "%.0f", $7}') + if [ "$memory_mb" -lt 4000 ]; then + log_warning "Low available memory: ${memory_mb}MB (need 4GB+)" + else + log_success "Available memory: ${memory_mb}MB" + fi + + # Check disk space + local disk_space=$(df -h ~ | awk 'NR==2 {print $4}') + log_info "Available disk space: $disk_space" + + # Check for conflicting processes + local conflicting_procs=$(pgrep -f "eac|battleye|vanguard" || true) + if [ -n "$conflicting_procs" ]; then + log_warning "Conflicting anti-cheat processes found: $conflicting_procs" + fi + + echo +} + +suggest_alternative_approaches() { + log_info "=== Alternative Troubleshooting Approaches ===" + + echo "1. Try without Steam Tinker Launch:" + echo " - Set compatibility tool to 'Proton Experimental'" + echo " - Add launch options: PROTON_USE_WINED3D=1 %command% -noeac -dx11" + echo + echo "2. Test with different Proton versions:" + echo " - Proton 8.0-5 (stable)" + echo " - Proton 7.0-6 (older, more compatible)" + echo " - GE-Proton8-32 (community build)" + echo + echo "3. Try Lutris instead of Steam:" + echo " - Install Lutris" + echo " - Use Lutris Wine runners" + echo " - More granular control over Wine settings" + echo + echo "4. Verify game files:" + echo " - Steam ā†’ Ready or Not ā†’ Properties ā†’ Local Files ā†’ Verify integrity" + echo + echo "5. Check for Windows dependencies:" + echo " - Install Visual C++ Redistributables via Winetricks" + echo " - Install DirectX runtime" + echo + echo "6. Hardware-specific issues:" + echo " - Try different display outputs" + echo " - Test with integrated graphics (if available)" + echo " - Check for BIOS/UEFI settings affecting compatibility" + echo +} + +create_manual_test_script() { + log_info "=== Creating Manual Test Script ===" + + cat > /tmp/manual_ready_or_not_test.sh << 'EOF' +#!/bin/bash + +# Manual Ready or Not Test Script +# Run this to test the game with minimal environment + +export STEAM_COMPAT_DATA_PATH="$HOME/.steam/steam/steamapps/compatdata/1144200" +export STEAM_COMPAT_CLIENT_INSTALL_PATH="$HOME/.steam/steam" +export PROTON_LOG=1 +export PROTON_LOG_DIR="/tmp/proton_test_logs" +export WINEDEBUG="+dll,+module,+registry" + +# Create log directory +mkdir -p /tmp/proton_test_logs + +# Find the game executable +GAME_EXE="" +for path in "$HOME/.steam/steam/steamapps/common/Ready Or Not" \ + "$HOME/.local/share/Steam/steamapps/common/Ready Or Not" \ + "/mnt/*/games/steam/steamapps/common/Ready Or Not" \ + "/mnt/*/Games/Steam/steamapps/common/Ready Or Not"; do + if [ -f "$path/ReadyOrNot.exe" ]; then + GAME_EXE="$path/ReadyOrNot.exe" + break + fi +done + +if [ -z "$GAME_EXE" ]; then + echo "ERROR: Ready or Not executable not found!" + exit 1 +fi + +echo "Found game: $GAME_EXE" +echo "Starting manual test..." + +# Try to run the game directly with Proton +timeout 30s ~/.steam/steam/steamapps/common/Proton\ -\ Experimental/proton run "$GAME_EXE" -noeac -dx11 + +echo "Test completed. Check logs in /tmp/proton_test_logs/" +EOF + + chmod +x /tmp/manual_ready_or_not_test.sh + log_success "Manual test script created: /tmp/manual_ready_or_not_test.sh" + echo +} + +main() { + log_info "Starting comprehensive crash diagnosis..." + echo + + check_system_prerequisites + check_proton_versions + test_basic_compatibility + check_steam_library + analyze_crash_patterns + suggest_alternative_approaches + create_manual_test_script + + log_info "=== Summary ===" + log_info "Crash diagnosis complete. Try the suggested approaches above." + log_info "If all else fails, the game may have compatibility issues with your specific system configuration." +} + +main "$@" \ No newline at end of file diff --git a/gaming/scripts/fix-steam-override.sh b/gaming/scripts/fix-steam-override.sh new file mode 100755 index 0000000..02cfec4 --- /dev/null +++ b/gaming/scripts/fix-steam-override.sh @@ -0,0 +1,140 @@ +#!/bin/bash + +# Fix Steam Launch Options Override Issue +# Ensures STL configuration takes precedence over Steam launch options + +set -e + +GAME_ID="1144200" +STL_CONFIG="$HOME/.config/steamtinkerlaunch/gamecfgs/$GAME_ID.conf" + +# Colors +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +log_info() { echo -e "${BLUE}[INFO]${NC} $1"; } +log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; } +log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; } +log_error() { echo -e "${RED}[ERROR]${NC} $1"; } + +check_steam_launch_options() { + log_info "=== Steam Launch Options Check ===" + + # Check if Steam has launch options set + echo "Please check your Steam launch options for Ready or Not:" + echo "1. Right-click Ready or Not in Steam" + echo "2. Properties ā†’ General ā†’ Launch Options" + echo "3. If there are any launch options, CLEAR THEM" + echo "4. The field should be completely empty" + echo + log_warning "Steam launch options are overriding STL configuration!" + log_info "Current Steam command includes: -dx12" + log_info "Our STL config should use: -noeac -dx11" + echo +} + +update_stl_config() { + log_info "=== Updating STL Configuration for Override Fix ===" + + if [ ! -f "$STL_CONFIG" ]; then + log_error "STL config not found: $STL_CONFIG" + return 1 + fi + + # Enable argument sorting to override Steam's arguments + log_info "Enabling argument sorting to override Steam launch options..." + sed -i 's/SORTGARGS="0"/SORTGARGS="1"/' "$STL_CONFIG" + + # Ensure our game arguments are clear + log_info "Setting game arguments to override Steam's -dx12..." + sed -i 's/GAMEARGS="[^"]*"/GAMEARGS="-noeac -dx11"/' "$STL_CONFIG" + + # Make sure hardcoded args can be overridden + sed -i 's/HARDARGS="[^"]*"/HARDARGS=""/' "$STL_CONFIG" + + log_success "STL configuration updated to override Steam arguments" +} + +create_steam_instruction_script() { + log_info "=== Creating Steam Configuration Helper ===" + + cat > /tmp/clear-steam-launch-options.txt << 'EOF' +IMPORTANT: Clear Steam Launch Options for Ready or Not + +Steam is currently overriding our STL configuration with its own launch options. +The game is trying to launch with "-dx12" instead of our configured "-noeac -dx11". + +To fix this: + +1. Open Steam +2. Go to your Library +3. Right-click "Ready or Not" +4. Select "Properties..." +5. In the General tab, find "Launch Options" +6. DELETE everything in the Launch Options field +7. The field should be completely EMPTY +8. Close the Properties window +9. Launch the game again + +Why this happens: +- Steam launch options take precedence over STL configuration +- The "-dx12" argument is causing crashes with our current setup +- STL needs full control over launch arguments for proper configuration + +After clearing Steam's launch options, STL will use: +- Game Arguments: -noeac -dx11 +- DirectX Version: 11 (more stable) +- Anti-Cheat: Disabled +- Renderer: WineD3D (for stability) +EOF + + log_success "Instructions saved to /tmp/clear-steam-launch-options.txt" +} + +verify_config_changes() { + log_info "=== Verifying Configuration Changes ===" + + if grep -q 'SORTGARGS="1"' "$STL_CONFIG"; then + log_success "Argument sorting enabled" + else + log_warning "Argument sorting not enabled" + fi + + local gameargs=$(grep "GAMEARGS=" "$STL_CONFIG" | cut -d'"' -f2) + log_info "Current STL game arguments: $gameargs" + + if [[ "$gameargs" == "-noeac -dx11" ]]; then + log_success "Game arguments are correct" + else + log_warning "Game arguments may need adjustment" + fi +} + +show_testing_steps() { + echo + log_info "=== Next Steps ===" + echo "1. Clear Steam launch options (see /tmp/clear-steam-launch-options.txt)" + echo "2. Launch Ready or Not through Steam" + echo "3. Check STL log to verify our arguments are used:" + echo " tail -f ~/.config/steamtinkerlaunch/logs/steamtinkerlaunch/id/1144200.log" + echo "4. Look for: 'Final game command line arguments: -noeac -dx11'" + echo "5. If still using -dx12, Steam launch options weren't cleared" + echo + log_warning "Game must launch without Steam launch options interfering!" +} + +main() { + log_info "Fixing Steam launch options override issue..." + echo + + check_steam_launch_options + update_stl_config + create_steam_instruction_script + verify_config_changes + show_testing_steps +} + +main "$@" \ No newline at end of file diff --git a/gaming/scripts/install-ron-mods.sh b/gaming/scripts/install-ron-mods.sh new file mode 100755 index 0000000..81267a0 --- /dev/null +++ b/gaming/scripts/install-ron-mods.sh @@ -0,0 +1,151 @@ +#!/bin/bash + +# Ready or Not - Nexus Mods Installer Script +# Extracts and installs .pak files from downloaded zip archives + +set -e + +# Directories +DOWNLOADS_DIR="/home/cal/Downloads" +MODS_DIR="/mnt/NV2/SteamLibrary/steamapps/common/Ready Or Not/ReadyOrNot/Content/Paks/Mods" +TEMP_DIR="/tmp/ron-mod-install" + +# Colors +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +log_info() { echo -e "${BLUE}[INFO]${NC} $1"; } +log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; } +log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; } +log_error() { echo -e "${RED}[ERROR]${NC} $1"; } + +install_mod_zips() { + log_info "=== Ready or Not Mod Installer ===" + echo + + # Create temp directory + mkdir -p "$TEMP_DIR" + + # Find recently downloaded zip files (last 10 minutes) + log_info "Looking for recently downloaded mod zip files..." + local zip_files=($(find "$DOWNLOADS_DIR" -name "*.zip" -mmin -10 2>/dev/null)) + + if [ ${#zip_files[@]} -eq 0 ]; then + log_warning "No recent zip files found in $DOWNLOADS_DIR" + log_info "Looking for all zip files in Downloads..." + zip_files=($(find "$DOWNLOADS_DIR" -name "*.zip" 2>/dev/null)) + fi + + if [ ${#zip_files[@]} -eq 0 ]; then + log_error "No zip files found in Downloads directory" + return 1 + fi + + log_info "Found ${#zip_files[@]} zip file(s)" + echo + + local installed_count=0 + + for zip_file in "${zip_files[@]}"; do + local filename=$(basename "$zip_file") + log_info "Processing: $filename" + + # Create temp extraction directory + local extract_dir="$TEMP_DIR/$(basename "$zip_file" .zip)" + mkdir -p "$extract_dir" + + # Extract zip file + if unzip -q "$zip_file" -d "$extract_dir"; then + log_success "Extracted: $filename" + + # Find .pak files in the extraction + local pak_files=($(find "$extract_dir" -name "*.pak" -type f)) + + if [ ${#pak_files[@]} -gt 0 ]; then + for pak_file in "${pak_files[@]}"; do + local pak_name=$(basename "$pak_file") + local dest_file="$MODS_DIR/$pak_name" + + # Copy pak file to mods directory + if cp "$pak_file" "$dest_file"; then + log_success "Installed: $pak_name" + ((installed_count++)) + else + log_error "Failed to install: $pak_name" + fi + done + else + log_warning "No .pak files found in: $filename" + log_info "Contents:" + find "$extract_dir" -type f | head -10 + fi + else + log_error "Failed to extract: $filename" + fi + + echo + done + + # Cleanup + rm -rf "$TEMP_DIR" + + log_success "Installation complete!" + log_info "Installed $installed_count mod file(s)" + echo + + # Show installed mods + log_info "Currently installed mods:" + if [ -d "$MODS_DIR" ] && [ "$(ls -A "$MODS_DIR" 2>/dev/null)" ]; then + ls -1 "$MODS_DIR"/ | grep "\.pak$" || log_info "No .pak files in Mods directory" + else + log_info "Mods directory is empty" + fi + + echo + log_info "=== Next Steps ===" + echo "1. Launch Ready or Not through Steam Tinker Launch" + echo "2. Mods should be automatically loaded" + echo "3. Check in-game settings or mod menu if available" + echo + log_warning "Important: Only install mods you trust from reputable sources" + log_warning "Some mods may require specific load orders or compatibility patches" +} + +# Show help +show_help() { + echo "Ready or Not Mod Installer" + echo + echo "Usage:" + echo " $0 - Install all recent zip files from Downloads" + echo " $0 --help - Show this help" + echo " $0 --list - List currently installed mods" + echo +} + +# List installed mods +list_mods() { + log_info "Currently installed Ready or Not mods:" + echo + + if [ -d "$MODS_DIR" ] && [ "$(ls -A "$MODS_DIR" 2>/dev/null)" ]; then + ls -la "$MODS_DIR"/ | grep "\.pak$" || log_info "No .pak files found" + else + log_info "No mods installed" + fi +} + +# Main execution +case "${1:-}" in + --help|-h) + show_help + ;; + --list|-l) + list_mods + ;; + *) + install_mod_zips + ;; +esac \ No newline at end of file diff --git a/gaming/scripts/launch-ron-direct.sh b/gaming/scripts/launch-ron-direct.sh new file mode 100755 index 0000000..418c618 --- /dev/null +++ b/gaming/scripts/launch-ron-direct.sh @@ -0,0 +1,149 @@ +#!/bin/bash + +# Ready or Not - Direct Launch Script (Bypass Steam) +# Launches Ready or Not directly with mods enabled + +set -e + +# Game paths +GAME_DIR="/mnt/NV2/SteamLibrary/steamapps/common/Ready Or Not" +GAME_EXE="$GAME_DIR/ReadyOrNot.exe" +WINE_PREFIX="/mnt/NV2/SteamLibrary/steamapps/compatdata/1144200/pfx" +PROTON_PATH="/home/cal/.local/share/Steam/compatibilitytools.d/GE-Proton9-10" + +# Colors +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +log_info() { echo -e "${BLUE}[INFO]${NC} $1"; } +log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; } +log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; } +log_error() { echo -e "${RED}[ERROR]${NC} $1"; } + +launch_direct() { + log_info "=== Ready or Not Direct Launch ===" + echo + + # Check if game exists + if [ ! -f "$GAME_EXE" ]; then + log_error "Game executable not found: $GAME_EXE" + return 1 + fi + + # Check if Proton exists + if [ ! -f "$PROTON_PATH/proton" ]; then + log_error "Proton not found: $PROTON_PATH/proton" + return 1 + fi + + # Check if Wine prefix exists + if [ ! -d "$WINE_PREFIX" ]; then + log_error "Wine prefix not found: $WINE_PREFIX" + return 1 + fi + + log_info "Game directory: $GAME_DIR" + log_info "Wine prefix: $WINE_PREFIX" + log_info "Proton version: GE-Proton9-10" + echo + + # Set environment variables + export WINEPREFIX="$WINE_PREFIX" + export WINEDLLOVERRIDES="steam_api64=n" + export STEAM_COMPAT_DATA_PATH="$WINE_PREFIX" + export STEAM_COMPAT_CLIENT_INSTALL_PATH="/home/cal/.local/share/Steam" + + # Performance settings (matching STL config) + export DXVK_ASYNC=1 + export DXVK_HDR=1 + export DXVK_FPSLIMIT=165 + export PROTON_ENABLE_NVAPI=1 + export PROTON_FORCE_LARGE_ADDRESS_AWARE=1 + + log_info "Environment configured for direct launch" + echo + + # Change to game directory + cd "$GAME_DIR" + + # Launch options + case "${1:-normal}" in + normal) + log_info "Launching in NORMAL mode (mods enabled)" + LAUNCH_ARGS="" + ;; + safe) + log_info "Launching in SAFE mode (mods disabled)" + LAUNCH_ARGS="-paksafemode" + ;; + windowed) + log_info "Launching in WINDOWED mode (mods enabled)" + LAUNCH_ARGS="-windowed" + ;; + *) + log_info "Launching with custom args: $1" + LAUNCH_ARGS="$1" + ;; + esac + + echo + log_info "Starting Ready or Not..." + log_info "Press Ctrl+C to stop" + echo + + # Launch with GameMode if available + if command -v gamemoderun >/dev/null 2>&1; then + log_info "Using GameMode for performance" + exec gamemoderun "$PROTON_PATH/proton" run "$GAME_EXE" $LAUNCH_ARGS + else + log_warning "GameMode not available, launching without it" + exec "$PROTON_PATH/proton" run "$GAME_EXE" $LAUNCH_ARGS + fi +} + +show_help() { + echo "Ready or Not Direct Launcher" + echo + echo "Usage:" + echo " $0 - Launch in normal mode (mods enabled)" + echo " $0 normal - Launch in normal mode (mods enabled)" + echo " $0 safe - Launch in safe mode (mods disabled)" + echo " $0 windowed - Launch in windowed mode (mods enabled)" + echo " $0 'custom args' - Launch with custom arguments" + echo " $0 --help - Show this help" + echo + echo "Examples:" + echo " $0 # Normal launch with mods" + echo " $0 safe # Safe mode without mods" + echo " $0 '-windowed -noeac' # Windowed without anti-cheat" + echo +} + +list_mods() { + log_info "Installed mods:" + echo + + local mods_dir="/mnt/NV2/SteamLibrary/steamapps/common/Ready Or Not/ReadyOrNot/Content/Paks/Mods" + if [ -d "$mods_dir" ] && [ "$(ls -A "$mods_dir" 2>/dev/null)" ]; then + ls -la "$mods_dir"/*.pak 2>/dev/null || log_info "No .pak files found" + else + log_info "No mods installed" + fi + echo +} + +# Main execution +case "${1:-}" in + --help|-h) + show_help + ;; + --mods|-m) + list_mods + ;; + *) + launch_direct "$1" + ;; +esac \ No newline at end of file diff --git a/gaming/scripts/ready-or-not-compatibility-test.sh b/gaming/scripts/ready-or-not-compatibility-test.sh new file mode 100755 index 0000000..d6a3c29 --- /dev/null +++ b/gaming/scripts/ready-or-not-compatibility-test.sh @@ -0,0 +1,214 @@ +#!/bin/bash + +# Ready or Not Comprehensive Compatibility Test +# Tests various Proton versions and Wine configurations + +set -e + +# Colors +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +log_info() { echo -e "${BLUE}[INFO]${NC} $1"; } +log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; } +log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; } +log_error() { echo -e "${RED}[ERROR]${NC} $1"; } + +test_proton_versions() { + log_info "=== Testing Different Proton Versions ===" + echo + echo "Ready or Not is known to have compatibility issues with newer Proton versions." + echo "Let's test with older, more stable versions:" + echo + echo "Test Order (most likely to work first):" + echo "1. Proton 8.0-5 (most stable for older games)" + echo "2. Proton 7.0-6 (even older, better compatibility)" + echo "3. Proton 6.3-8 (legacy support)" + echo "4. GE-Proton8-32 (community version with patches)" + echo + echo "For each version:" + echo "- Change compatibility tool in Steam" + echo "- Keep launch options: PROTON_USE_WINED3D=1 %command% -noeac -dx11" + echo "- Test game launch" + echo "- Note how long it runs before crashing" + echo +} + +test_wine_dependencies() { + log_info "=== Testing Windows Dependencies ===" + echo + echo "Ready or Not may need specific Windows libraries:" + echo + echo "Common missing dependencies for UE4 games:" + echo "- Visual C++ Redistributables (2015, 2017, 2019)" + echo "- DirectX End-User Runtime" + echo "- .NET Framework 4.8" + echo "- Windows Media Format Runtime" + echo + echo "To test these:" + echo "1. Set compatibility to 'Proton 8.0-5'" + echo "2. Launch options: PROTON_USE_WINED3D=1 %command% -noeac -dx11" + echo "3. Before launching game, run:" + echo " protontricks 1144200 --no-term" + echo "4. Install vcrun2019, d3dx9, dotnet48" + echo "5. Then test game" + echo +} + +test_protondb_fixes() { + log_info "=== ProtonDB Community Fixes ===" + echo + echo "Let's check what the community has found works for Ready or Not:" + echo + echo "Common working configurations from ProtonDB:" + echo + echo "Configuration 1 (Most Common):" + echo "- Proton Version: GE-Proton7-55 or Proton 7.0-6" + echo "- Launch Options: PROTON_USE_WINED3D=1 %command% -noeac" + echo "- Additional: Install vcrun2019 via protontricks" + echo + echo "Configuration 2 (Alternative):" + echo "- Proton Version: Proton 8.0-5" + echo "- Launch Options: PROTON_NO_ESYNC=1 PROTON_NO_FSYNC=1 %command% -noeac -dx11" + echo "- Additional: Disable fullscreen optimizations" + echo + echo "Configuration 3 (Fallback):" + echo "- Use Lutris instead of Steam" + echo "- Wine-GE-Proton8-26" + echo "- Manual DXVK installation" + echo +} + +test_system_specific_fixes() { + log_info "=== System-Specific Troubleshooting ===" + echo + echo "Your system (Nobara Linux + RTX 4080 SUPER) specific checks:" + echo + echo "1. NVIDIA Driver Issues:" + echo " - Current driver: $(nvidia-smi --query-gpu=driver_version --format=csv,noheader 2>/dev/null || echo 'Unknown')" + echo " - Try older driver (555.x series) if on 570.x" + echo " - Check for prime-run conflicts" + echo + echo "2. Nobara-Specific Issues:" + echo " - Check if gamemode is conflicting: systemctl --user status gamemode" + echo " - Nobara uses PipeWire - try PULSE_LATENCY_MSEC=200" + echo " - Check for SELinux blocking: sudo sealert -a /var/log/audit/audit.log" + echo + echo "3. Hardware-Specific:" + echo " - RTX 4080 SUPER is very new - may need newer mesa/vulkan" + echo " - Try forcing older Vulkan loader: VK_LOADER_DEBUG=all" + echo " - Test with integrated graphics if available" + echo +} + +create_comprehensive_test_script() { + log_info "=== Creating Comprehensive Test Script ===" + + cat > /tmp/ready_or_not_ultimate_test.sh << 'EOF' +#!/bin/bash + +# Ultimate Ready or Not Compatibility Test +# Tests the most promising configurations in order + +echo "=== Ready or Not Ultimate Compatibility Test ===" +echo + +# Test 1: Proton 8.0-5 with WineD3D and dependencies +echo "TEST 1: Proton 8.0-5 + WineD3D + vcrun2019" +echo "1. Set compatibility: Proton 8.0-5" +echo "2. Launch options: PROTON_USE_WINED3D=1 %command% -noeac -dx11" +echo "3. Run: protontricks 1144200 vcrun2019" +echo "4. Test game" +read -p "Press Enter after test 1..." + +# Test 2: Proton 7.0-6 (most reported working version) +echo +echo "TEST 2: Proton 7.0-6 (Community Favorite)" +echo "1. Set compatibility: Proton 7.0-6" +echo "2. Launch options: PROTON_USE_WINED3D=1 %command% -noeac" +echo "3. Test game" +read -p "Press Enter after test 2..." + +# Test 3: Disable sync technologies +echo +echo "TEST 3: Proton 8.0-5 with sync disabled" +echo "1. Set compatibility: Proton 8.0-5" +echo "2. Launch options: PROTON_NO_ESYNC=1 PROTON_NO_FSYNC=1 PROTON_USE_WINED3D=1 %command% -noeac -dx11" +echo "3. Test game" +read -p "Press Enter after test 3..." + +# Test 4: Minimal environment +echo +echo "TEST 4: Minimal Proton environment" +echo "1. Set compatibility: Proton 8.0-5" +echo "2. Launch options: PROTON_LOG=1 %command% -windowed -noeac" +echo "3. Check logs in ~/.steam/steam/steamapps/compatdata/1144200/" +echo "4. Test game" +read -p "Press Enter after test 4..." + +echo +echo "Which test worked best?" +echo "A) Test 1 (8.0-5 + WineD3D + vcrun2019)" +echo "B) Test 2 (7.0-6 + WineD3D)" +echo "C) Test 3 (8.0-5 no sync)" +echo "D) Test 4 (minimal)" +echo "E) None worked" + +read -p "Enter your answer (A/B/C/D/E): " answer + +case $answer in + A) echo "Great! Use Proton 8.0-5 with WineD3D and vcrun2019" ;; + B) echo "Excellent! Proton 7.0-6 is the solution" ;; + C) echo "Good! Sync issues were the problem" ;; + D) echo "Minimal config works - build from there" ;; + E) echo "We need to try Lutris or investigate deeper" ;; + *) echo "Please run the test again and choose A, B, C, D, or E" ;; +esac +EOF + + chmod +x /tmp/ready_or_not_ultimate_test.sh + log_success "Comprehensive test script created: /tmp/ready_or_not_ultimate_test.sh" + echo +} + +check_protontricks() { + log_info "=== Checking Protontricks Installation ===" + + if command -v protontricks >/dev/null 2>&1; then + log_success "Protontricks is installed" + local version=$(protontricks --version 2>/dev/null || echo "unknown") + log_info "Version: $version" + else + log_warning "Protontricks not installed - needed for Windows dependencies" + echo "Install with: sudo dnf install protontricks" + echo "Or: pipx install protontricks" + fi + echo +} + +main() { + log_info "Ready or Not Comprehensive Compatibility Analysis" + log_info "Since both STL and vanilla Proton crash the same way, this is a deeper compatibility issue" + echo + + test_proton_versions + test_wine_dependencies + test_protondb_fixes + test_system_specific_fixes + check_protontricks + create_comprehensive_test_script + + log_info "=== Recommendation ===" + echo "1. Run the comprehensive test script: /tmp/ready_or_not_ultimate_test.sh" + echo "2. Test each configuration systematically" + echo "3. Most likely to work: Proton 7.0-6 or 8.0-5 with vcrun2019" + echo "4. If all fail: Consider Lutris with Wine-GE" + echo + log_warning "Ready or Not is known to be problematic on Linux" + log_warning "Some users report it simply doesn't work with any Proton version" +} + +main "$@" \ No newline at end of file diff --git a/gaming/scripts/test-vanilla-proton.sh b/gaming/scripts/test-vanilla-proton.sh new file mode 100755 index 0000000..d4fc422 --- /dev/null +++ b/gaming/scripts/test-vanilla-proton.sh @@ -0,0 +1,114 @@ +#!/bin/bash + +# Test Ready or Not with vanilla Proton (bypass STL) +# This will help identify if the issue is STL-specific or general Proton compatibility + +set -e + +# Colors +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +log_info() { echo -e "${BLUE}[INFO]${NC} $1"; } +log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; } +log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; } +log_error() { echo -e "${RED}[ERROR]${NC} $1"; } + +test_vanilla_proton() { + log_info "Testing Ready or Not with vanilla Proton (bypassing STL)..." + echo + + log_warning "This test requires temporarily changing Steam settings:" + echo "1. Right-click Ready or Not in Steam" + echo "2. Properties ā†’ Compatibility" + echo "3. Change from 'Steam Tinker Launch' to 'Proton 9.0 (Beta)'" + echo "4. In Launch Options, add: PROTON_USE_WINED3D=1 %command% -noeac -dx11" + echo "5. Launch the game" + echo + + log_info "What this test tells us:" + echo "- If game works: STL configuration issue" + echo "- If game still crashes: Deeper Proton/Wine compatibility issue" + echo "- If game runs longer: STL is interfering with something" + echo + + log_info "Expected behavior with vanilla Proton + WineD3D:" + echo "- Should bypass most DXVK issues" + echo "- May have lower performance but better compatibility" + echo "- EasyAntiCheat should be disabled with -noeac" + echo + + read -p "Press Enter after you've made these changes and tested the game..." + echo +} + +analyze_results() { + log_info "Test Results Analysis:" + echo + echo "What happened when you tested with vanilla Proton?" + echo + echo "A) Game worked fine:" + echo " ā†’ Issue is with STL configuration" + echo " ā†’ We need to debug STL settings" + echo + echo "B) Game crashed the same way:" + echo " ā†’ Deeper compatibility issue with Ready or Not" + echo " ā†’ May need different Proton version or Wine settings" + echo + echo "C) Game ran longer but still crashed:" + echo " ā†’ Partial improvement, may need additional Wine/Proton tweaks" + echo + echo "D) Game crashed differently:" + echo " ā†’ New error pattern, need to investigate specific failure" + echo +} + +suggest_next_steps() { + log_info "Based on the vanilla Proton test results:" + echo + echo "If Option A (worked fine):" + echo "- Reset STL to absolute minimum settings" + echo "- Gradually add features back one by one" + echo "- Focus on argument passing in STL" + echo + echo "If Option B (same crash):" + echo "- Try older Proton versions (8.0-5, 7.0-6)" + echo "- Install Windows dependencies via Winetricks" + echo "- Check ProtonDB for Ready or Not specific fixes" + echo + echo "If Option C (improvement):" + echo "- Apply same settings in STL that worked in vanilla" + echo "- Fine-tune Wine environment variables" + echo "- Consider hybrid approach" + echo + echo "If Option D (different crash):" + echo "- Analyze new error pattern" + echo "- May indicate progress toward solution" + echo +} + +restore_stl() { + log_info "To restore STL after testing:" + echo "1. Right-click Ready or Not in Steam" + echo "2. Properties ā†’ Compatibility" + echo "3. Change back to 'Steam Tinker Launch'" + echo "4. Clear Launch Options field" + echo "5. STL will use our configured settings" +} + +main() { + log_info "Vanilla Proton Testing for Ready or Not" + log_info "This will help isolate STL vs general compatibility issues" + echo + + test_vanilla_proton + analyze_results + suggest_next_steps + echo + restore_stl +} + +main "$@" \ No newline at end of file diff --git a/gaming/scripts/validate-gaming-setup.sh b/gaming/scripts/validate-gaming-setup.sh new file mode 100755 index 0000000..9b5c084 --- /dev/null +++ b/gaming/scripts/validate-gaming-setup.sh @@ -0,0 +1,229 @@ +#!/bin/bash + +# Gaming Setup Validation Script +# Validates gaming environment and dependencies + +set -e + +# Colors for output +RED='\033[0;31m' +GREEN='\033[0;32m' +YELLOW='\033[1;33m' +BLUE='\033[0;34m' +NC='\033[0m' + +log_info() { echo -e "${BLUE}[INFO]${NC} $1"; } +log_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; } +log_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; } +log_error() { echo -e "${RED}[ERROR]${NC} $1"; } + +check_nvidia_setup() { + log_info "Checking NVIDIA setup..." + + if command -v nvidia-smi >/dev/null 2>&1; then + log_success "NVIDIA drivers installed" + nvidia-smi --query-gpu=name,memory.total --format=csv,noheader,nounits | head -1 + else + log_error "NVIDIA drivers not found" + return 1 + fi + + if command -v vulkaninfo >/dev/null 2>&1; then + local gpu_name=$(vulkaninfo | grep "deviceName" | head -1 | cut -d'"' -f2) + if echo "$gpu_name" | grep -qi nvidia; then + log_success "Vulkan NVIDIA support: $gpu_name" + else + log_warning "Vulkan may not be using NVIDIA GPU: $gpu_name" + fi + else + log_warning "vulkaninfo not available - install vulkan-tools" + fi +} + +check_steam_setup() { + log_info "Checking Steam setup..." + + if command -v steam >/dev/null 2>&1; then + log_success "Steam installed" + else + log_error "Steam not found" + return 1 + fi + + if command -v steamtinkerlaunch >/dev/null 2>&1; then + local stl_version=$(steamtinkerlaunch --version 2>/dev/null || echo "unknown") + log_success "Steam Tinker Launch installed: $stl_version" + else + log_error "Steam Tinker Launch not found" + return 1 + fi +} + +check_gamescope() { + log_info "Checking GameScope..." + + if command -v gamescope >/dev/null 2>&1; then + local gs_version=$(gamescope --version 2>&1 | head -1 || echo "unknown") + log_success "GameScope installed: $gs_version" + else + log_warning "GameScope not found - recommended for 4K monitor scaling" + fi +} + +check_audio_setup() { + log_info "Checking audio setup..." + + if command -v pipewire >/dev/null 2>&1 || pgrep -x pipewire >/dev/null; then + log_success "PipeWire detected" + elif command -v pulseaudio >/dev/null 2>&1 || pgrep -x pulseaudio >/dev/null; then + log_success "PulseAudio detected" + else + log_warning "No audio system detected" + fi +} + +check_display_setup() { + log_info "Checking display setup..." + + if command -v xrandr >/dev/null 2>&1; then + local primary_display=$(xrandr | grep " connected primary" | head -1) + log_info "Primary display: $primary_display" + + if echo "$primary_display" | grep -q "3840x2160"; then + log_success "4K monitor detected" + elif echo "$primary_display" | grep -q "2560x1440"; then + log_success "1440p monitor detected" + else + log_info "Display resolution: $(echo $primary_display | grep -o '[0-9]*x[0-9]*')" + fi + else + log_warning "Cannot detect display information (xrandr not available)" + fi +} + +check_ready_or_not_config() { + log_info "Checking Ready or Not configuration..." + + local config_file="$HOME/.config/steamtinkerlaunch/gamecfgs/1144200.conf" + local dxvk_config="$HOME/.config/steamtinkerlaunch/dxvk/1144200.conf" + + if [ -f "$config_file" ]; then + log_success "Ready or Not STL config found" + + # Check for key NVIDIA settings + if grep -q "PROTON_ENABLE_NVAPI=\"1\"" "$config_file"; then + log_success "NVAPI enabled for DLSS support" + else + log_warning "NVAPI not enabled - DLSS may not work" + fi + + if grep -q "USEGAMESCOPE=\"1\"" "$config_file"; then + log_success "GameScope enabled for display scaling" + else + log_info "GameScope disabled in config" + fi + else + log_error "Ready or Not STL config not found" + log_info "Run: /mnt/NV2/Development/claude-home/gaming/examples/ready-or-not/setup-ready-or-not.sh" + return 1 + fi + + if [ -f "$dxvk_config" ]; then + log_success "DXVK config found" + else + log_warning "DXVK config not found - may impact performance" + fi +} + +check_steam_library() { + log_info "Checking for Ready or Not in Steam library..." + + # Common Steam library locations + local steam_dirs=( + "$HOME/.steam/steam/steamapps" + "$HOME/.local/share/Steam/steamapps" + "/mnt/*/games/steam/steamapps" + "/mnt/*/Games/Steam/steamapps" + ) + + local found=false + for steam_dir in "${steam_dirs[@]}"; do + if [ -d "$steam_dir/common/Ready Or Not" ]; then + log_success "Ready or Not found: $steam_dir/common/Ready Or Not" + found=true + break + fi + done + + if ! $found; then + log_warning "Ready or Not not found in Steam library" + log_info "Make sure the game is installed through Steam" + fi +} + +check_performance_tools() { + log_info "Checking performance monitoring tools..." + + if command -v mangohud >/dev/null 2>&1; then + log_success "MangoHUD available for performance monitoring" + else + log_warning "MangoHUD not found - install for performance overlay" + fi + + if command -v gamemode >/dev/null 2>&1 || [ -f "/usr/lib/libgamemode.so" ]; then + log_success "GameMode available for CPU optimization" + else + log_warning "GameMode not found - install for CPU performance boost" + fi +} + +show_summary() { + echo + log_info "=== Validation Summary ===" + echo "If all checks passed, you should be ready to game!" + echo + log_info "To launch Ready or Not:" + echo "1. Use helper script: ~/.local/bin/launch-ready-or-not" + echo "2. Or launch through Steam (STL will auto-configure)" + echo + log_info "For troubleshooting:" + echo "- Check logs: ~/.config/steamtinkerlaunch/logs/" + echo "- Read guide: /mnt/NV2/Development/claude-home/gaming/troubleshooting.md" + echo "- Monitor performance: Enable MangoHUD overlay in-game" +} + +main() { + log_info "Validating gaming setup for Ready or Not..." + log_info "Target: NVIDIA GPU + Steam Tinker Launch + 1440p gaming" + echo + + local errors=0 + + check_nvidia_setup || ((errors++)) + echo + check_steam_setup || ((errors++)) + echo + check_gamescope + echo + check_audio_setup + echo + check_display_setup + echo + check_ready_or_not_config || ((errors++)) + echo + check_steam_library + echo + check_performance_tools + + if [ $errors -eq 0 ]; then + echo + log_success "All critical checks passed! Gaming setup looks good." + else + echo + log_warning "$errors critical issues found. Please address them before gaming." + fi + + show_summary +} + +main "$@" \ No newline at end of file diff --git a/gaming/troubleshooting.md b/gaming/troubleshooting.md new file mode 100644 index 0000000..91b0600 --- /dev/null +++ b/gaming/troubleshooting.md @@ -0,0 +1,217 @@ +# Gaming Troubleshooting Guide + +## Quick Fixes by Issue Type + +### Game Won't Launch +1. **Check Proton Version**: Try GE-Proton10-11 or Proton 8.0-5 +2. **Verify Paths**: Ensure CUSTOMCMD points to correct executable +3. **Disable STL**: Test with vanilla Proton first +4. **Check Dependencies**: Ensure required libraries are installed + +### Performance Issues +1. **Enable GameMode**: `USEGAMEMODERUN="1"` +2. **Check DXVK Settings**: Ensure ESYNC/FSYNC are enabled +3. **Monitor GPU Usage**: Use MangoHUD to identify bottlenecks +4. **Adjust GameScope**: Try different scaling options + +### Audio Problems +1. **Increase Latency**: `STL_PULSE_LATENCY_MSEC="120"` +2. **PipeWire Fix**: `PIPEWIRE_LATENCY="256/48000"` +3. **Disable Audio Acceleration**: In game settings +4. **Check Audio Device**: Ensure correct output selected + +### Display Issues +1. **GameScope Resolution**: Match native monitor resolution +2. **Fullscreen Toggle**: Try Alt+Enter in-game +3. **Disable Compositing**: Temporarily for testing +4. **Check Graphics Drivers**: Ensure latest NVIDIA drivers + +## Ready or Not Specific Issues + +### Menu Freeze / Mods Menu +**Symptoms**: Game freezes when accessing mods or certain menus +**Solution**: +```bash +# Add to environment variables +PROTON_SET_GAME_DRIVE="1" +``` + +### EasyAntiCheat Issues +**Symptoms**: Game won't start or kicks you from servers +**Solution**: +```bash +# Add to game arguments +GAMEARGS="-noeac" +``` +**Note**: This disables EAC and prevents online play + +### Black Screen on Launch +**Symptoms**: Game launches but shows black screen +**Solutions**: +1. **NVIDIA Driver Issue**: + ```bash + # Try forcing NVIDIA GPU + __NV_PRIME_RENDER_OFFLOAD=1 + __GLX_VENDOR_LIBRARY_NAME=nvidia + ``` + +2. **GameScope Issue**: + ```bash + # Disable GameScope temporarily + USEGAMESCOPE="0" + ``` + +### Performance Stuttering +**Symptoms**: Frequent frame drops or stuttering +**Solutions**: +1. **Enable DXVK Async**: + ```bash + DXVK_ASYNC="1" + ``` + +2. **Force Large Address Aware**: + ```bash + PROTON_FORCE_LARGE_ADDRESS_AWARE="1" + ``` + +3. **Limit Frame Rate**: + ```bash + # In GameScope args + GAMESCOPE_ARGS="-W 3440 -H 1440 -r 240 -f --immediate-flips --rt --fps-limit-method=2 --" + ``` + +## NVIDIA-Specific Troubleshooting + +### GPU Not Detected +1. **Check Driver Installation**: + ```bash + nvidia-smi + lspci | grep -i nvidia + ``` + +2. **Verify Vulkan Support**: + ```bash + vulkaninfo | grep deviceName + ``` + +3. **Force NVIDIA in STL**: + ```bash + USEPRIMERUN="1" # If on hybrid graphics + ``` + +### DLSS Issues +**Enable DLSS Support**: +```bash +PROTON_ENABLE_NVAPI="1" +USEDLSS="1" +PROTON_HIDE_NVIDIA_GPU="0" # Don't hide GPU from game +``` + +### Ray Tracing Problems +**Enable Ray Tracing**: +```bash +USERAYTRACING="1" +STL_VKD3D_CONFIG="dxr11" +``` + +## Configuration File Locations + +### Steam Tinker Launch +- **Global Config**: `~/.config/steamtinkerlaunch/global.conf` +- **Game Configs**: `~/.config/steamtinkerlaunch/gamecfgs/1144200.conf` +- **Logs**: `~/.config/steamtinkerlaunch/logs/` + +### Proton/Steam +- **Compatdata**: `~/.steam/steam/steamapps/compatdata/1144200/` +- **Game Install**: `~/.steam/steam/steamapps/common/Ready Or Not/` + +## Emergency Recovery + +### Reset Game Configuration +```bash +# Backup current config +cp ~/.config/steamtinkerlaunch/gamecfgs/1144200.conf ~/.config/steamtinkerlaunch/gamecfgs/1144200.conf.backup + +# Reset to minimal config +cat > ~/.config/steamtinkerlaunch/gamecfgs/1144200.conf << 'EOF' +USEGAMEMODERUN="1" +USEPROTON="GE-Proton10-11" +GAMEARGS="-noeac" +EOF +``` + +### Clean Proton Prefix +```bash +# Remove compatdata (Steam will recreate) +rm -rf ~/.steam/steam/steamapps/compatdata/1144200/ +# Launch game to regenerate prefix +``` + +### Verify Game Files +1. Open Steam +2. Right-click Ready or Not +3. Properties ā†’ Local Files ā†’ Verify integrity + +## Testing Methodology + +### Systematic Testing +1. **Vanilla Test**: Disable all STL settings +2. **Minimal STL**: Add only essential settings +3. **Incremental**: Add one setting at a time +4. **Document**: Record what works/doesn't work + +### Performance Testing +1. **Baseline**: Test without any modifications +2. **With STL**: Test with recommended settings +3. **Compare**: Use MangoHUD to compare frame rates +4. **Optimize**: Adjust settings based on results + +## Common Error Messages + +| Error | Cause | Solution | +|-------|-------|----------| +| "Failed to initialize graphics" | Driver/GPU issue | Update NVIDIA drivers | +| "EasyAntiCheat timeout" | EAC conflict | Add `-noeac` argument | +| "Access violation" | Memory issue | Enable PROTON_FORCE_LARGE_ADDRESS_AWARE | +| "Vulkan initialization failed" | DXVK issue | Try PROTON_USE_WINED3D="1" | + +## Hardware-Specific Notes + +### High Refresh Rate Monitors +- Ensure GameScope refresh rate matches monitor +- May need to limit frame rate for stability +- Test with vsync on/off + +### Multiple Monitors +- Specify primary display in GameScope +- May need to disable secondary monitors during play +- Check for focus issues + +### HDR Displays +- Enable DXVK_HDR="1" if supported +- Verify game supports HDR output +- May conflict with GameScope HDR + +## Useful Commands + +### Check Running Game Process +```bash +# See game processes and GPU usage +nvidia-smi +ps aux | grep -i "ready\|proton" +``` + +### Monitor Performance +```bash +# Real-time GPU monitoring +watch -n 1 nvidia-smi + +# STL logs +tail -f ~/.config/steamtinkerlaunch/logs/steamtinkerlaunch.log +``` + +### GameScope Debug +```bash +# Launch with GameScope debug +gamescope --debug -- steam steam://rungameid/1144200 +``` \ No newline at end of file diff --git a/monitoring/scripts/tdarr-timeout-monitor.sh b/monitoring/scripts/tdarr-timeout-monitor.sh deleted file mode 100755 index dffda3c..0000000 --- a/monitoring/scripts/tdarr-timeout-monitor.sh +++ /dev/null @@ -1,452 +0,0 @@ -#!/bin/bash - -# Tdarr Enhanced Monitoring System v2.0 -# Monitors Tdarr Server and Node for staging timeouts, worker stalls, and stuck work directories -# Features: Automatic cleanup, Discord notifications with markdown formatting, comprehensive logging -# -# RECENT IMPROVEMENTS (2025-08-10): -# - Added staging section timeout detection and automatic cleanup -# - Implemented structured Discord notifications with working user pings -# - Enhanced JSON handling with proper escaping for special characters -# - Added comprehensive logging with automatic rotation (1MB limit) -# - Fixed shell compatibility for Docker container execution -# - Separated markdown formatting from actionable alerts for proper Discord pings -# -# Runs every 20 minutes via cron: */20 * * * * /path/to/this/script -# Logs: /tmp/tdarr-monitor/monitor.log (auto-rotates at 1MB) - -# Configuration -DISCORD_WEBHOOK="https://discord.com/api/webhooks/1404105821549498398/y2Ud1RK9rzFjv58xbypUfQNe3jrL7ZUq1FkQHa4_dfOHm2ylp93z0f4tY0O8Z-vQgKhD" -SERVER_HOST="tdarr" # SSH alias for Tdarr server -NODE_CONTAINER="tdarr-node-gpu-unmapped" -SCRIPT_DIR="/tmp/tdarr-monitor" -LAST_CHECK_FILE="$SCRIPT_DIR/last_check.timestamp" -LOG_FILE="$SCRIPT_DIR/monitor.log" -MAX_LOG_SIZE="1048576" # 1MB in bytes - -# Function to send Discord notification -send_discord_notification() { - local message="$1" - local color="15158332" # Red color for alerts - - if [[ "$message" == *"success"* ]] || [[ "$message" == *"started"* ]]; then - color="3066993" # Green color for success - fi - - # Check if message contains a ping - extract it to send separately - local ping_message="" - local clean_message="$message" - - if [[ "$message" == *"<@"* ]]; then - # Extract the line with the ping - ping_message=$(echo "$message" | grep -o ".*<@[0-9]*>.*") - # Remove the ping line from the main message - clean_message=$(echo "$message" | grep -v "<@[0-9]*>") - fi - - # Wrap main message in markdown code block - local markdown_message="\`\`\`md -$clean_message -\`\`\`" - - # Add ping message after the markdown block if it exists - if [[ -n "$ping_message" ]]; then - markdown_message="$markdown_message -$ping_message" - fi - - # Properly escape for JSON: backslashes, quotes, and newlines - local escaped_message=$(echo "$markdown_message" | sed 's/\\/\\\\/g; s/"/\\"/g; :a;N;$!ba;s/\n/\\n/g') - - curl -H "Content-Type: application/json" \ - -X POST \ - -d "{\"content\": \"$escaped_message\"}" \ - "$DISCORD_WEBHOOK" 2>/dev/null -} - -# Create script directory -mkdir -p "$SCRIPT_DIR" - -# Enhanced logging functions -log_message() { - echo "$(date '+%Y-%m-%d %H:%M:%S') [INFO] - $1" >> "$LOG_FILE" -} - -log_debug() { - echo "$(date '+%Y-%m-%d %H:%M:%S') [DEBUG] - $1" >> "$LOG_FILE" -} - -log_error() { - echo "$(date '+%Y-%m-%d %H:%M:%S') [ERROR] - $1" >> "$LOG_FILE" -} - -log_warning() { - echo "$(date '+%Y-%m-%d %H:%M:%S') [WARN] - $1" >> "$LOG_FILE" -} - -log_success() { - echo "$(date '+%Y-%m-%d %H:%M:%S') [SUCCESS] - $1" >> "$LOG_FILE" -} - -# Log command execution with timing -log_command() { - local cmd="$1" - local start_time=$(date +%s.%N) - log_debug "Executing command: $cmd" - - local result=$(eval "$cmd" 2>&1) - local exit_code=$? - local end_time=$(date +%s.%N) - local duration=$(echo "$end_time - $start_time" | bc 2>/dev/null || echo "0") - - if [[ $exit_code -eq 0 ]]; then - log_debug "Command completed in ${duration}s (exit: $exit_code)" - if [[ -n "$result" ]]; then - log_debug "Command output: $result" - fi - else - log_error "Command failed in ${duration}s (exit: $exit_code): $result" - fi - - echo "$result" - return $exit_code -} - -rotate_log() { - if [[ -f "$LOG_FILE" ]] && [[ $(stat -f%z "$LOG_FILE" 2>/dev/null || stat -c%s "$LOG_FILE" 2>/dev/null) -gt $MAX_LOG_SIZE ]]; then - mv "$LOG_FILE" "$LOG_FILE.old" - log_message "Log rotated due to size limit" - fi -} - -# Initialize timestamp file if it doesn't exist -if [[ ! -f "$LAST_CHECK_FILE" ]]; then - date +%s > "$LAST_CHECK_FILE" - local message="# šŸŽ¬ Tdarr Monitor -**Timeout monitoring started:** -- Checking every 20 minutes for staging timeouts -- Automatic cleanup of stuck work directories -- Discord notifications enabled - -System monitoring active." - send_discord_notification "$message" -fi - -LAST_CHECK=$(cat "$LAST_CHECK_FILE") -CURRENT_TIME=$(date +%s) - -# Function to check server logs for limbo timeouts -check_server_timeouts() { - local start_time=$(date +%s.%N) - log_message "Starting server timeout check" - - # Get server logs since last check (convert to docker logs format) - local since_docker=$(date -d "@$LAST_CHECK" -u +%Y-%m-%dT%H:%M:%S.000000000Z) - log_debug "Checking server logs since: $since_docker (timestamp: $LAST_CHECK)" - - # Execute SSH command with detailed logging - local ssh_cmd="ssh \"$SERVER_HOST\" \"docker logs --since='$since_docker' tdarr-clean 2>&1\"" - local server_logs=$(log_command "$ssh_cmd") - local ssh_exit=$? - - if [[ $ssh_exit -ne 0 ]]; then - log_error "Failed to retrieve server logs via SSH" - return 1 - fi - - log_debug "Retrieved $(echo "$server_logs" | wc -l) lines of server logs" - - # Process logs for limbo timeouts - local limbo_lines=$(echo "$server_logs" | grep -i "has been in limbo") - local limbo_count=$(echo "$limbo_lines" | grep -c "has been in limbo" 2>/dev/null || echo "0") - log_debug "Found $limbo_count limbo timeout entries in logs" - - local timeouts=$(echo "$limbo_lines" | \ - grep -o "/media/[^']*" | \ - sed 's|/media/||') - - if [[ -n "$timeouts" ]]; then - local count=$(echo "$timeouts" | wc -l) - local files=$(echo "$timeouts" | head -3) # Show first 3 files - log_warning "Found $count file(s) timed out in staging section" - - # Log each timed out file for debugging - echo "$timeouts" | while IFS= read -r file; do - [[ -n "$file" ]] && log_debug "Timed out file: $file" - done - - local message="# šŸŽ¬ Tdarr Monitor -**$count file(s) timed out in staging section:**" - - # Convert files to bullet points - local file_list=$(echo "$files" | sed 's/^/- /') - message="$message -$file_list" - - if [[ $count -gt 3 ]]; then - message="$message -- ... and $(($count - 3)) more files" - fi - - message="$message - -Files were automatically removed from staging and will retry." - - send_discord_notification "$message" - log_success "Sent Discord notification for $count timed out files" - else - log_debug "No files found timed out in staging section" - fi - - local end_time=$(date +%s.%N) - local duration=$(echo "$end_time - $start_time" | bc 2>/dev/null || echo "0") - log_message "Server timeout check completed in ${duration}s" -} - -# Function to check node logs for worker stalls -check_node_stalls() { - local start_time=$(date +%s.%N) - log_message "Starting node stall check" - - # Check if node container is running - local container_status=$(podman ps --format "{{.Status}}" --filter "name=$NODE_CONTAINER" 2>/dev/null) - if [[ -z "$container_status" ]]; then - log_warning "Node container '$NODE_CONTAINER' not found or not running" - return 1 - fi - log_debug "Node container status: $container_status" - - # Get node logs since last check - local node_cmd="podman logs --since=\"@$LAST_CHECK\" \"$NODE_CONTAINER\" 2>&1" - local node_logs=$(log_command "$node_cmd") - local node_exit=$? - - if [[ $node_exit -ne 0 ]]; then - log_error "Failed to retrieve node logs" - return 1 - fi - - log_debug "Retrieved $(echo "$node_logs" | wc -l) lines of node logs" - - # Process logs for worker stalls - local stalls=$(echo "$node_logs" | grep -i "worker.*stalled\|worker.*disconnected") - local stall_count=$(echo "$stalls" | grep -c "worker.*" 2>/dev/null || echo "0") - log_debug "Found $stall_count potential worker stall entries" - - if [[ -n "$stalls" ]]; then - local count=$(echo "$stalls" | wc -l) - local workers=$(echo "$stalls" | grep -o "Worker [^ ]*" | sort -u | head -3) - log_warning "Found $count worker stall(s)" - - # Log each stalled worker for debugging - echo "$stalls" | while IFS= read -r stall_line; do - [[ -n "$stall_line" ]] && log_debug "Worker stall: $stall_line" - done - - local message="# šŸŽ¬ Tdarr Monitor -**$count worker stall(s) detected:**" - - # Convert workers to bullet points - local worker_list=$(echo "$workers" | sed 's/^/- /') - message="$message -$worker_list - -Workers were automatically cancelled and will restart." - - send_discord_notification "$message" - log_success "Sent Discord notification for $count worker stalls" - else - log_debug "No worker stalls detected" - fi - - local end_time=$(date +%s.%N) - local duration=$(echo "$end_time - $start_time" | bc 2>/dev/null || echo "0") - log_message "Node stall check completed in ${duration}s" -} - -# Function to check and clean stuck work directories -check_stuck_workdirs() { - local start_time=$(date +%s.%N) - log_message "Starting stuck work directory check" - - # Find work directories that are failing to be cleaned up - local workdir_cmd="ssh \"$SERVER_HOST\" \"docker logs --since='30m' tdarr-clean 2>&1\"" - local workdir_logs=$(log_command "$workdir_cmd") - local workdir_exit=$? - - if [[ $workdir_exit -ne 0 ]]; then - log_error "Failed to retrieve work directory logs from server" - return 1 - fi - - local enotempty_lines=$(echo "$workdir_logs" | grep "ENOTEMPTY.*tdarr-workDir") - local enotempty_count=$(echo "$enotempty_lines" | grep -c "ENOTEMPTY" 2>/dev/null || echo "0") - log_debug "Found $enotempty_count ENOTEMPTY errors for work directories" - - local stuck_dirs=$(echo "$enotempty_lines" | \ - grep -o "tdarr-workDir[^']*" | \ - sort -u) - - if [[ -n "$stuck_dirs" ]]; then - local count=$(echo "$stuck_dirs" | wc -l) - local cleaned=0 - log_warning "Found $count stuck work directories to clean" - - echo "$stuck_dirs" | while IFS= read -r dir; do - if [[ -n "$dir" ]]; then - log_debug "Attempting to clean stuck directory: $dir" - - # Force cleanup of stuck directory with detailed logging - local cleanup_cmd="ssh \"$SERVER_HOST\" \"docker exec tdarr-clean sh -c ' - if [ -d \"/temp/$dir\" ]; then - echo \"Cleaning /temp/$dir\" - find \"/temp/$dir\" -type f -name \"*.tmp\" -delete 2>/dev/null - find \"/temp/$dir\" -type f -delete 2>/dev/null - find \"/temp/$dir\" -name \".*\" -delete 2>/dev/null - rmdir \"/temp/$dir\" 2>/dev/null && echo \"Successfully removed $dir\" - else - echo \"Directory /temp/$dir not found\" - fi - '\"" - - local cleanup_result=$(log_command "$cleanup_cmd") - local cleanup_exit=$? - - if [[ $cleanup_exit -eq 0 ]] && [[ "$cleanup_result" == *"Successfully removed"* ]]; then - ((cleaned++)) - log_success "Successfully cleaned directory: $dir" - else - log_error "Failed to clean directory: $dir (exit: $cleanup_exit, output: $cleanup_result)" - fi - fi - done - - if [[ $cleaned -gt 0 ]]; then - log_success "Successfully cleaned $cleaned of $count stuck work directories" - local message="# šŸŽ¬ Tdarr Monitor -**Successfully cleaned $cleaned stuck work directories:** -- Removed partial download files (.tmp) -- Cleared blocking staging section cleanup - -System maintenance completed automatically." - send_discord_notification "$message" - else - log_error "Failed to clean any of the $count stuck work directories" - local dir_list=$(echo "$stuck_dirs" | sed 's/^/- /') - local message="# šŸŽ¬ Tdarr Monitor -**$count stuck work directories detected:** -$dir_list - -Cleanup failed - manual intervention may be needed <@258104532423147520>." - send_discord_notification "$message" - fi - else - log_debug "No stuck work directories detected" - fi - - local end_time=$(date +%s.%N) - local duration=$(echo "$end_time - $start_time" | bc 2>/dev/null || echo "0") - log_message "Stuck work directory check completed in ${duration}s" -} - -# Function to check for successful completions -check_completions() { - local start_time=$(date +%s.%N) - log_message "Starting completion check" - - # Check server logs for successful transcodes - local since_docker=$(date -d "@$LAST_CHECK" -u +%Y-%m-%dT%H:%M:%S.000000000Z) - log_debug "Checking for successful transcodes since: $since_docker" - - local completion_cmd="ssh \"$SERVER_HOST\" \"docker logs --since='$since_docker' tdarr-clean 2>&1\"" - local completion_logs=$(log_command "$completion_cmd") - local completion_exit=$? - - if [[ $completion_exit -ne 0 ]]; then - log_error "Failed to retrieve completion logs from server" - return 1 - fi - - local success_lines=$(echo "$completion_logs" | grep -i "transcode.*success\|transcode.*complete") - local successes=$(echo "$success_lines" | wc -l) - log_debug "Found $successes successful transcode completion entries" - - if [[ $successes -gt 0 ]]; then - log_success "Detected $successes successful transcodes" - - # Log sample success entries for debugging - echo "$success_lines" | head -3 | while IFS= read -r success_line; do - [[ -n "$success_line" ]] && log_debug "Success entry: $success_line" - done - - local message="# šŸŽ¬ Tdarr Monitor -**$successes transcode(s) completed successfully:** -- Processing completed without errors -- Files ready for use - -System operating normally." - send_discord_notification "$message" - log_success "Sent Discord notification for $successes completions" - else - log_debug "No successful transcodes detected" - fi - - local end_time=$(date +%s.%N) - local duration=$(echo "$end_time - $start_time" | bc 2>/dev/null || echo "0") - log_message "Completion check completed in ${duration}s" -} - -# Main monitoring logic -main() { - local script_start=$(date +%s.%N) - rotate_log - - log_message "=== Starting Tdarr timeout monitor check ===" - log_debug "Last check: $(date -d "@$LAST_CHECK" 2>/dev/null || echo "Invalid timestamp: $LAST_CHECK")" - log_debug "Current time: $(date)" - log_debug "Time difference: $((CURRENT_TIME - LAST_CHECK)) seconds" - log_debug "Server host: $SERVER_HOST" - log_debug "Node container: $NODE_CONTAINER" - log_debug "Log file: $LOG_FILE (size: $(stat -c%s "$LOG_FILE" 2>/dev/null || echo "0") bytes)" - - # Only proceed if more than 15 minutes (900 seconds) since last check - if [[ $((CURRENT_TIME - LAST_CHECK)) -lt 900 ]]; then - log_warning "Less than 15 minutes since last check, skipping ($(($CURRENT_TIME - $LAST_CHECK))s elapsed)" - exit 0 - fi - - # Perform checks with error handling - log_message "Beginning monitoring checks..." - - if ! check_server_timeouts; then - log_error "Server timeout check failed" - fi - - if ! check_node_stalls; then - log_error "Node stall check failed" - fi - - if ! check_stuck_workdirs; then - log_error "Stuck work directory check failed" - fi - - Optional: Check for successes (comment out if too noisy) - if ! check_completions; then - log_error "Completion check failed" - fi - - # Update timestamp - echo "$CURRENT_TIME" > "$LAST_CHECK_FILE" - if [[ $? -eq 0 ]]; then - log_debug "Updated timestamp file: $LAST_CHECK_FILE" - else - log_error "Failed to update timestamp file: $LAST_CHECK_FILE" - fi - - local script_end=$(date +%s.%N) - local total_duration=$(echo "$script_end - $script_start" | bc 2>/dev/null || echo "0") - log_success "=== Monitor check completed in ${total_duration}s ===" -} - -# Run main function -main "$@" \ No newline at end of file diff --git a/monitoring/scripts/tdarr_monitor.py b/monitoring/scripts/tdarr_monitor.py index db936f4..ad546d1 100755 --- a/monitoring/scripts/tdarr_monitor.py +++ b/monitoring/scripts/tdarr_monitor.py @@ -58,6 +58,7 @@ import requests from urllib.parse import urljoin + @dataclass class WorkerSnapshot: worker_id: str @@ -222,7 +223,7 @@ class DiscordEmbed: if self.fields is None: self.fields = [] if self.timestamp is None: - self.timestamp = datetime.utcnow().isoformat() + self.timestamp = datetime.now().isoformat() class DiscordNotifier: @@ -300,14 +301,14 @@ class DiscordNotifier: ws = stuck_job.worker_snapshot field_value = ( f"**File:** {os.path.basename(ws.file)}\n" - f"**Progress:** {ws.percentage}%\n" f"**Status:** {ws.status}\n" + f"**Progress:** {ws.percentage}%\n" f"**Duration:** {stuck_job.stuck_duration_minutes:.1f} minutes\n" f"**Node:** {ws.node_id}" ) fields.append(DiscordEmbedField( - name=f"šŸšØ Stuck Job {i+1}: {ws.worker_id}", + name=f"Stuck Job {i+1}: {ws.worker_id}", value=field_value, inline=True )) @@ -323,7 +324,7 @@ class DiscordNotifier: title = f"šŸšØ Tdarr Stuck Jobs Detected ({len(stuck_jobs)})" description = ( f"Detected {len(stuck_jobs)} stuck job{'s' if len(stuck_jobs) != 1 else ''} " - f"in your Tdarr system. These jobs may need manual intervention." + f"in your Tdarr system. These jobs will follow the requested clear behavior." ) return self.send_embed_message( @@ -431,7 +432,7 @@ class DiscordNotifier: class StuckJobDetector: - def __init__(self, memory_file: str = ".claude/tmp/tdarr_memory.pkl", stuck_threshold_minutes: int = 30): + def __init__(self, memory_file: str = "/mnt/NV2/Development/claude-home/logs/tdarr_memory.pkl", stuck_threshold_minutes: int = 30): """Initialize stuck job detector with memory persistence.""" self.memory_file = os.path.abspath(memory_file) # Use absolute path self.stuck_threshold_minutes = stuck_threshold_minutes @@ -666,15 +667,21 @@ class TdarrMonitor: level = getattr(logging, log_level.upper(), logging.INFO) root_logger.setLevel(level) - # Create formatter - formatter = logging.Formatter( + # Create formatters + console_formatter = logging.Formatter( '%(asctime)s - %(name)s - %(levelname)s - %(message)s', datefmt='%Y-%m-%d %H:%M:%S' ) + # Enhanced file formatter for better readability + file_formatter = logging.Formatter( + '%(asctime)s [%(levelname)-7s] %(module)-12s | %(message)s', + datefmt='%H:%M:%S' + ) + # Console handler (for interactive use) console_handler = logging.StreamHandler(sys.stdout) - console_handler.setFormatter(formatter) + console_handler.setFormatter(console_formatter) root_logger.addHandler(console_handler) # File handler with rotation (if log_file specified) @@ -691,7 +698,7 @@ class TdarrMonitor: backupCount=5, encoding='utf-8' ) - file_handler.setFormatter(formatter) + file_handler.setFormatter(file_formatter) root_logger.addHandler(file_handler) def _make_request(self, endpoint: str) -> Optional[Dict[str, Any]]: @@ -1000,20 +1007,9 @@ class TdarrMonitor: total_count=node_status.node_summary.total_nodes if node_status.node_summary else 0 ) - # Queue status - queue_status = self.get_queue_status() - queue_healthy = not queue_status.error - queue_check = HealthCheck( - status='accessible' if queue_healthy else 'error', - healthy=queue_healthy, - accessible=queue_healthy, - total_items=queue_status.queue_stats.total_files if queue_status.queue_stats else 0 - ) - checks = { 'server': server_check, - 'nodes': nodes_check, - 'queue': queue_check + 'nodes': nodes_check } # Determine overall health @@ -1037,15 +1033,15 @@ def main(): parser.add_argument('--verbose', action='store_true', help='Enable verbose logging') parser.add_argument('--detect-stuck', action='store_true', help='Enable stuck job detection') parser.add_argument('--stuck-threshold', type=int, default=30, help='Minutes before job is considered stuck (default: 30)') - parser.add_argument('--memory-file', default='.claude/tmp/tdarr_memory.pkl', help='Path to memory state file') + parser.add_argument('--memory-file', default='/mnt/NV2/Development/claude-home/logs/tdarr_memory.pkl', help='Path to memory state file') parser.add_argument('--clear-memory', action='store_true', help='Clear memory state and exit') parser.add_argument('--discord-webhook', default='https://discord.com/api/webhooks/1404105821549498398/y2Ud1RK9rzFjv58xbypUfQNe3jrL7ZUq1FkQHa4_dfOHm2ylp93z0f4tY0O8Z-vQgKhD', help='Discord webhook URL for notifications (default: configured webhook)') parser.add_argument('--discord-alerts', action='store_true', help='Enable Discord alerts for stuck jobs and system status') parser.add_argument('--discord-test', action='store_true', help='Send test Discord message and exit') - parser.add_argument('--log-file', default='./scripts/logs/tdarr_monitor.log', - help='Path to log file with rotation (default: ./scripts/logs/tdarr_monitor.log)') + parser.add_argument('--log-file', default='/mnt/NV2/Development/claude-home/logs/tdarr_monitor.log', + help='Path to log file with rotation (default: /mnt/NV2/Development/claude-home/logs/tdarr_monitor.log)') parser.add_argument('--log-level', choices=['DEBUG', 'INFO', 'WARNING', 'ERROR'], default='INFO', help='Logging level (default: INFO)') parser.add_argument('--no-log-file', action='store_true', help='Disable file logging, console only') @@ -1117,10 +1113,7 @@ def main(): if args.check == 'all': result = { 'server_status': monitor.get_server_status(), - 'queue_status': monitor.get_queue_status(), - 'node_status': monitor.get_node_status(), - 'library_status': monitor.get_library_status(), - 'statistics': monitor.get_statistics() + 'node_status': monitor.get_node_status() } elif args.check == 'status': result = monitor.get_server_status()