|
|
#!/usr/bin/env python3 |
|
|
""" |
|
|
Example: Loading StarCraft Assets into a Game Engine |
|
|
===================================================== |
|
|
|
|
|
This is a conceptual example showing how to load and use extracted |
|
|
StarCraft assets in a hypothetical game engine. |
|
|
|
|
|
This demonstrates: |
|
|
- Loading audio files |
|
|
- Loading and displaying graphics |
|
|
- Parsing data files |
|
|
- Organizing assets for runtime use |
|
|
|
|
|
Note: This is educational/demonstration code for engine developers. |
|
|
""" |
|
|
|
|
|
from pathlib import Path |
|
|
from typing import Dict, List, Optional |
|
|
import struct |
|
|
|
|
|
|
|
|
class AssetManager: |
|
|
""" |
|
|
Example asset manager for a game engine. |
|
|
|
|
|
This shows how to organize and load StarCraft assets for use |
|
|
in an alternative game engine. |
|
|
""" |
|
|
|
|
|
def __init__(self, assets_dir: str = "assets"): |
|
|
self.assets_dir = Path(assets_dir) |
|
|
self.audio_cache = {} |
|
|
self.graphics_cache = {} |
|
|
self.data_cache = {} |
|
|
|
|
|
print(f"AssetManager initialized with: {self.assets_dir}") |
|
|
|
|
|
def load_audio(self, audio_id: int) -> Optional[bytes]: |
|
|
""" |
|
|
Load an audio file by its ID. |
|
|
|
|
|
Args: |
|
|
audio_id: Numeric ID (e.g., 123 for File00000123.wav) |
|
|
|
|
|
Returns: |
|
|
Audio data as bytes, or None if not found |
|
|
""" |
|
|
# Check cache first |
|
|
if audio_id in self.audio_cache: |
|
|
return self.audio_cache[audio_id] |
|
|
|
|
|
# Find file |
|
|
filename = f"File{audio_id:08d}.wav" |
|
|
audio_path = self.assets_dir / "audio" / filename |
|
|
|
|
|
if not audio_path.exists(): |
|
|
print(f"⚠️ Audio {audio_id} not found: {filename}") |
|
|
return None |
|
|
|
|
|
# Load file |
|
|
with open(audio_path, 'rb') as f: |
|
|
data = f.read() |
|
|
|
|
|
# Cache it |
|
|
self.audio_cache[audio_id] = data |
|
|
|
|
|
print(f"✓ Loaded audio {audio_id}: {len(data)} bytes") |
|
|
return data |
|
|
|
|
|
def load_pcx_image(self, filename: str) -> Optional[Dict]: |
|
|
""" |
|
|
Load a PCX image file. |
|
|
|
|
|
Args: |
|
|
filename: Name of PCX file |
|
|
|
|
|
Returns: |
|
|
Dictionary with image data, or None if failed |
|
|
""" |
|
|
# Check cache |
|
|
if filename in self.graphics_cache: |
|
|
return self.graphics_cache[filename] |
|
|
|
|
|
pcx_path = self.assets_dir / "graphics" / filename |
|
|
|
|
|
if not pcx_path.exists(): |
|
|
print(f"⚠️ Image not found: {filename}") |
|
|
return None |
|
|
|
|
|
# Try to load with PIL if available |
|
|
try: |
|
|
from PIL import Image |
|
|
|
|
|
img = Image.open(pcx_path) |
|
|
|
|
|
image_data = { |
|
|
'width': img.width, |
|
|
'height': img.height, |
|
|
'mode': img.mode, |
|
|
'data': img.tobytes(), |
|
|
'palette': img.getpalette() if img.mode == 'P' else None, |
|
|
'path': str(pcx_path) |
|
|
} |
|
|
|
|
|
self.graphics_cache[filename] = image_data |
|
|
print(f"✓ Loaded image {filename}: {img.width}x{img.height} {img.mode}") |
|
|
|
|
|
return image_data |
|
|
|
|
|
except ImportError: |
|
|
print("⚠️ PIL/Pillow not available - returning raw data") |
|
|
with open(pcx_path, 'rb') as f: |
|
|
raw_data = f.read() |
|
|
return {'raw': raw_data, 'path': str(pcx_path)} |
|
|
except Exception as e: |
|
|
print(f"✗ Failed to load {filename}: {e}") |
|
|
return None |
|
|
|
|
|
def load_palette(self, palette_name: str) -> Optional[List[tuple]]: |
|
|
""" |
|
|
Load a color palette file. |
|
|
|
|
|
Args: |
|
|
palette_name: Name of palette file (.pal or .wpe) |
|
|
|
|
|
Returns: |
|
|
List of (R, G, B) tuples, or None if failed |
|
|
""" |
|
|
pal_path = self.assets_dir / "data" / palette_name |
|
|
|
|
|
if not pal_path.exists(): |
|
|
print(f"⚠️ Palette not found: {palette_name}") |
|
|
return None |
|
|
|
|
|
try: |
|
|
with open(pal_path, 'rb') as f: |
|
|
data = f.read(768) # 256 colors * 3 bytes |
|
|
|
|
|
palette = [] |
|
|
for i in range(0, 768, 3): |
|
|
r, g, b = data[i], data[i+1], data[i+2] |
|
|
palette.append((r, g, b)) |
|
|
|
|
|
print(f"✓ Loaded palette {palette_name}: 256 colors") |
|
|
return palette |
|
|
|
|
|
except Exception as e: |
|
|
print(f"✗ Failed to load palette {palette_name}: {e}") |
|
|
return None |
|
|
|
|
|
def search_assets(self, pattern: str) -> List[Path]: |
|
|
""" |
|
|
Search for assets matching a pattern. |
|
|
|
|
|
Args: |
|
|
pattern: Search pattern (e.g., "*.wav", "unit*") |
|
|
|
|
|
Returns: |
|
|
List of matching file paths |
|
|
""" |
|
|
matches = list(self.assets_dir.rglob(pattern)) |
|
|
return [m for m in matches if m.is_file()] |
|
|
|
|
|
def get_asset_info(self, category: str) -> Dict: |
|
|
""" |
|
|
Get information about a category of assets. |
|
|
|
|
|
Args: |
|
|
category: Category name (e.g., "audio", "graphics") |
|
|
|
|
|
Returns: |
|
|
Dictionary with count and size information |
|
|
""" |
|
|
category_dir = self.assets_dir / category |
|
|
|
|
|
if not category_dir.exists(): |
|
|
return {'exists': False} |
|
|
|
|
|
files = [f for f in category_dir.rglob("*") if f.is_file()] |
|
|
total_size = sum(f.stat().st_size for f in files) |
|
|
|
|
|
return { |
|
|
'exists': True, |
|
|
'count': len(files), |
|
|
'total_size': total_size, |
|
|
'files': [f.name for f in files[:10]] # Sample |
|
|
} |
|
|
|
|
|
|
|
|
class GameEngine: |
|
|
""" |
|
|
Conceptual game engine showing asset integration. |
|
|
|
|
|
This demonstrates how a real game engine might use the |
|
|
extracted StarCraft assets. |
|
|
""" |
|
|
|
|
|
def __init__(self): |
|
|
self.assets = AssetManager() |
|
|
self.loaded_sounds = {} |
|
|
self.loaded_textures = {} |
|
|
|
|
|
print("\n" + "="*80) |
|
|
print("Game Engine Initialized") |
|
|
print("="*80) |
|
|
|
|
|
def preload_common_sounds(self): |
|
|
"""Preload commonly used sound effects""" |
|
|
print("\nPreloading common sounds...") |
|
|
|
|
|
# Example: Load first 10 sound files |
|
|
for sound_id in range(29, 39): # Based on actual file numbers |
|
|
audio_data = self.assets.load_audio(sound_id) |
|
|
if audio_data: |
|
|
self.loaded_sounds[sound_id] = audio_data |
|
|
|
|
|
print(f"✓ Preloaded {len(self.loaded_sounds)} sounds") |
|
|
|
|
|
def preload_ui_graphics(self): |
|
|
"""Preload UI graphics""" |
|
|
print("\nPreloading UI graphics...") |
|
|
|
|
|
# Search for PCX files |
|
|
pcx_files = self.assets.search_assets("*.pcx") |
|
|
|
|
|
# Load first few as examples |
|
|
for pcx_file in pcx_files[:3]: |
|
|
img_data = self.assets.load_pcx_image(pcx_file.name) |
|
|
if img_data: |
|
|
self.loaded_textures[pcx_file.stem] = img_data |
|
|
|
|
|
print(f"✓ Preloaded {len(self.loaded_textures)} textures") |
|
|
|
|
|
def print_asset_summary(self): |
|
|
"""Print summary of available assets""" |
|
|
print("\n" + "="*80) |
|
|
print("Asset Summary") |
|
|
print("="*80) |
|
|
|
|
|
categories = ['audio', 'graphics', 'video', 'data', 'maps'] |
|
|
|
|
|
for category in categories: |
|
|
info = self.assets.get_asset_info(category) |
|
|
if info['exists']: |
|
|
size_mb = info['total_size'] / 1024 / 1024 |
|
|
print(f"\n📁 {category.upper()}/") |
|
|
print(f" Files: {info['count']}") |
|
|
print(f" Size: {size_mb:.1f} MB") |
|
|
|
|
|
if info['files']: |
|
|
print(f" Sample files:") |
|
|
for filename in info['files'][:3]: |
|
|
print(f" - {filename}") |
|
|
|
|
|
def play_sound(self, sound_id: int): |
|
|
""" |
|
|
Play a sound effect (conceptual). |
|
|
|
|
|
In a real engine, this would: |
|
|
1. Get audio data from cache or load it |
|
|
2. Decode the WAV format |
|
|
3. Send to audio mixer |
|
|
4. Play through audio device |
|
|
""" |
|
|
print(f"\n🔊 Playing sound {sound_id}...") |
|
|
|
|
|
if sound_id in self.loaded_sounds: |
|
|
audio_data = self.loaded_sounds[sound_id] |
|
|
print(f" Using cached audio: {len(audio_data)} bytes") |
|
|
else: |
|
|
audio_data = self.assets.load_audio(sound_id) |
|
|
if not audio_data: |
|
|
print(f" ✗ Sound not found!") |
|
|
return |
|
|
|
|
|
# In real engine: decode and play audio |
|
|
print(f" ✓ Audio ready for playback") |
|
|
|
|
|
def render_texture(self, texture_name: str): |
|
|
""" |
|
|
Render a texture (conceptual). |
|
|
|
|
|
In a real engine, this would: |
|
|
1. Get texture from cache or load it |
|
|
2. Upload to GPU |
|
|
3. Render to screen with proper coordinates |
|
|
""" |
|
|
print(f"\n🖼️ Rendering texture: {texture_name}") |
|
|
|
|
|
if texture_name in self.loaded_textures: |
|
|
tex_data = self.loaded_textures[texture_name] |
|
|
if 'width' in tex_data: |
|
|
print(f" Using cached texture: {tex_data['width']}x{tex_data['height']}") |
|
|
else: |
|
|
print(f" Using raw texture data") |
|
|
else: |
|
|
print(f" ⚠️ Texture not in cache - would load on demand") |
|
|
|
|
|
# In real engine: upload to GPU and render |
|
|
print(f" ✓ Texture rendered") |
|
|
|
|
|
|
|
|
def demo(): |
|
|
"""Run a demonstration of asset loading""" |
|
|
print("\n" + "="*80) |
|
|
print("StarCraft Asset Loading Demo") |
|
|
print("="*80) |
|
|
print("\nThis demonstrates how a game engine would load extracted assets") |
|
|
print() |
|
|
|
|
|
# Check if assets exist |
|
|
if not Path("assets").exists(): |
|
|
print("❌ Assets directory not found!") |
|
|
print("\nPlease extract assets first:") |
|
|
print(" python extract_starcraft_assets.py") |
|
|
return |
|
|
|
|
|
# Create engine instance |
|
|
engine = GameEngine() |
|
|
|
|
|
# Show available assets |
|
|
engine.print_asset_summary() |
|
|
|
|
|
# Preload common assets |
|
|
print("\n" + "="*80) |
|
|
print("Preloading Assets") |
|
|
print("="*80) |
|
|
engine.preload_common_sounds() |
|
|
engine.preload_ui_graphics() |
|
|
|
|
|
# Simulate gameplay |
|
|
print("\n" + "="*80) |
|
|
print("Simulating Game Actions") |
|
|
print("="*80) |
|
|
|
|
|
# Play some sounds |
|
|
engine.play_sound(29) |
|
|
engine.play_sound(35) |
|
|
|
|
|
# Render some textures |
|
|
if engine.loaded_textures: |
|
|
first_texture = list(engine.loaded_textures.keys())[0] |
|
|
engine.render_texture(first_texture) |
|
|
|
|
|
# Summary |
|
|
print("\n" + "="*80) |
|
|
print("Demo Complete!") |
|
|
print("="*80) |
|
|
print(f"\nLoaded in memory:") |
|
|
print(f" Sounds: {len(engine.loaded_sounds)}") |
|
|
print(f" Textures: {len(engine.loaded_textures)}") |
|
|
print("\nThis demonstrates the basics of asset loading.") |
|
|
print("A real engine would include:") |
|
|
print(" - Audio decoding and playback") |
|
|
print(" - Texture uploading to GPU") |
|
|
print(" - Sprite rendering with animations") |
|
|
print(" - Data table parsing (units, weapons, etc.)") |
|
|
print(" - Map loading and terrain rendering") |
|
|
print() |
|
|
|
|
|
|
|
|
if __name__ == "__main__": |
|
|
demo()
|
|
|
|
