rebeccanod1/Peril_Dice
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

chore: remove obsolete GitHub updater system documentation files

Browse source
This commit is contained in:
RebeccaNod1 2026-04-09 01:40:59 -06:00
parent 394f425ca4
commit 5ec796b204
2 changed files with 0 additions and 281 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

154
GitHub_Updater_System.md
View file

@ -1,154 +0,0 @@
# GitHub-Powered External Updater System
## Architecture: GitHub + Automatic Installation
### Components:
#### 1. **GitHub Integration** (Existing)
- ✅ GitHub Releases API for version detection
- ✅ GitHub raw file downloads for script content
- ✅ Zero infrastructure - uses existing GitHub + Jenkins
- ✅ Professional version management
#### 2. **Peril_Dice_Updater.lsl** (New - External Box)
- Downloads scripts directly from GitHub raw URLs
- Uses GitHub API to get latest release info
- Installs scripts automatically via llRemoteLoadScriptPin()
- Handles the 2048-character LSL limit properly
#### 3. **Update_Receiver.lsl** (Modified existing Update_Checker)
- Scans for nearby updater boxes
- Still checks GitHub API for version comparison
- Coordinates automatic installation with updater box
- Validates successful updates
## User Experience Flow:
### Step 1: Get Updater
- User receives "Peril Dice GitHub Updater v2.8.7" box
- Box description: "Automatic GitHub-powered updater for Peril Dice"
### Step 2: Check & Install
1. User rezzes updater box near their Peril Dice game
2. User touches game → Admin Menu → "Check for Updates"
3. Game checks GitHub API: "v2.8.7 available!"
4. User clicks "Install Update"
5. Game connects to nearby updater box
6. Updater downloads all needed scripts from GitHub
7. Updater installs scripts automatically: "Installing 3 of 17..."
8. Game validates: "✅ Update complete! Now running v2.8.7"
9. User deletes updater box
## Technical Implementation:
### GitHub URLs Used:
```
Version Check: https://api.github.com/repos/RebeccaNod1/Peril/releases/latest
Script Downloads: https://raw.githubusercontent.com/RebeccaNod1/Peril/main/ScriptName.lsl
```
### Script Installation Process:
```lsl
// In Updater Box:
1. llHTTPRequest() to download script from GitHub
2. llRemoteLoadScriptPin() to install in target game
3. Repeat for all 17 scripts in correct order
// In Target Game:
1. llSetRemoteScriptAccessPin() to allow updater access
2. Validate each script installation
3. Report progress to user
```
## Benefits of This Approach:
### ✅ **GitHub Integration Maintained:**
- Same zero-infrastructure benefits
- Automatic version detection
- Professional release management
- Leverages existing CI/CD pipeline
- No separate update server needed
### ✅ **User Experience Improved:**
- One-click automatic installation
- No manual copy/paste required
- Progress indicators and feedback
- Impossible to make installation errors
- Professional software-like experience
### ✅ **Creator Benefits:**
- Same development workflow (commit → push → tag)
- GitHub releases automatically available
- Single updater box for all users
- Easy to distribute via marketplace/group
## Files to Create:
### 1. `Peril_Dice_Updater.lsl`
```lsl
// External updater box script
- GitHub API integration (version checking)
- GitHub raw file downloads (script content)
- Remote script installation
- Progress reporting
- Error handling for network issues
```
### 2. `Update_Receiver.lsl`
```lsl
// Replace Update_Checker.lsl in main game
- Scan for nearby GitHub updater boxes
- GitHub version checking (same as before)
- Coordinate automatic installation
- Validate successful updates
```
### 3. `github-manifest.json` (in repository)
```json
{
"version": "2.8.7",
"scripts": [
{
"name": "Main_Controller_Linkset.lsl",
"link": 1,
"url": "https://raw.githubusercontent.com/RebeccaNod1/Peril/main/Main_Controller_Linkset.lsl",
"required": true
},
// ... all 17 scripts with GitHub URLs
]
}
```
## Advantages Over Current System:
| **Current (Manual)** | **New (GitHub + Auto)** |
|---------------------|-------------------------|
| ❌ User copies/pastes each script | ✅ One-click automatic installation |
| ❌ Easy to make mistakes | ✅ Impossible to mess up |
| ❌ Must update all scripts manually | ✅ Updates only changed scripts |
| ❌ No progress indication | ✅ Clear progress and status |
| ✅ Uses GitHub (good!) | ✅ Still uses GitHub (great!) |
## Implementation Steps:
### Phase 1: Build Core System
1. Create `Peril_Dice_Updater.lsl` with GitHub integration
2. Convert `Update_Checker.lsl` → `Update_Receiver.lsl`
3. Create `github-manifest.json` listing all scripts
4. Test basic single-script updates
### Phase 2: Full Integration
1. Test complete 17-script updates
2. Add progress indicators and error handling
3. Test with multiple game instances
4. Validate version tracking
### Phase 3: Distribution
1. Create professional updater box object
2. Write user instructions
3. Set up distribution (marketplace/group/etc.)
4. Create demo videos
This gives you **all the benefits of GitHub** (zero infrastructure, automatic detection, professional workflow) **plus** the automatic installation that users expect from professional Second Life products!
Should I start building the GitHub-powered external updater system?

127
UPDATER_SYSTEM_PLAN.md
View file

@ -1,127 +0,0 @@
# Peril Dice External Updater System
## Architecture Overview
### Components Needed:
#### 1. **Updater Box** (`Peril_Dice_Updater.lsl`)
- Standalone object that users rez temporarily
- Downloads scripts from GitHub when activated
- Installs scripts into target Peril Dice game via remote loading
- Self-contained - includes all update logic
#### 2. **Update Receiver** (in main game)
- Modified `Update_Checker.lsl` → `Update_Receiver.lsl`
- Scans for nearby updater boxes
- Requests updates when available
- Manages the script replacement process
#### 3. **Script Manifest** (GitHub hosted)
- JSON file listing all scripts and their GitHub URLs
- Version tracking for incremental updates
- Deployment instructions for updater
## Technical Implementation
### Update Process Flow:
```
1. User rezzes "Peril Dice Updater v2.8.7" box
2. User touches their Peril Dice game → "Check for Updates"
3. Game scans for nearby updater boxes (llSensor)
4. Game requests update from updater box
5. Updater downloads scripts from GitHub
6. Game sets script access pin (llSetRemoteScriptAccessPin)
7. Updater installs scripts via llRemoteLoadScriptPin()
8. Game validates installation and reports success
9. User deletes updater box
```
### Key LSL Functions:
- `llSensor()` - Find nearby updater boxes
- `llSetRemoteScriptAccessPin()` - Allow updater access
- `llRemoteLoadScriptPin()` - Install new scripts
- `llHTTPRequest()` - Download scripts from GitHub
- `llGetInventoryName()` - Validate installed scripts
## User Experience
### For Players:
1. Receive "Peril Dice Updater v2.8.7" from creator
2. Rez updater near their game
3. Touch game → Admin Menu → "Check for Updates"
4. See "Update Available: v2.8.6 → v2.8.7"
5. Click "Install Update"
6. Watch progress: "Installing script 3 of 17..."
7. See "✅ Update Complete! Game is now v2.8.7"
8. Delete updater box
### For Creator (You):
1. Build new scripts and test them
2. Commit to GitHub with version bump
3. Create updater box with new version number
4. Distribute updater to users via marketplace/group notices
5. Users get automatic professional updates
## Advantages Over Manual Updates
### ✅ Professional Experience:
- One-click updates like commercial software
- Progress indicators and status messages
- Automatic validation of successful installation
- No copy/paste errors or missed scripts
### ✅ Version Control:
- Updater knows exactly which scripts need updating
- Can do incremental updates (only changed files)
- Prevents version mismatches between scripts
- Tracks what was updated when
### ✅ User Friendly:
- No technical knowledge required
- Clear instructions and feedback
- Impossible to mess up the installation
- Works the same way every time
## Files to Create
### 1. `Peril_Dice_Updater.lsl`
- Main updater script for the external box
- GitHub API integration for script downloads
- Remote script installation logic
- Progress reporting and error handling
### 2. `Update_Receiver.lsl`
- Replace existing Update_Checker.lsl
- Scan for nearby updater boxes
- Coordinate with updater for script replacement
- Validate successful updates
### 3. `updater-manifest.json` (GitHub)
- List of all scripts with GitHub URLs
- Version requirements and dependencies
- Installation order and link assignments
### 4. Instructions for packaging updater boxes
- How to create updater objects for distribution
- Testing procedures for new versions
- Distribution methods (marketplace, group, etc.)
## Implementation Priority
### Phase 1: Core Updater System
1. Create basic updater box with GitHub integration
2. Modify existing Update_Checker to work with updater
3. Test with simple single-script updates
### Phase 2: Full Integration
1. Complete manifest system for all 17 scripts
2. Add progress indicators and error handling
3. Test complete game updates
### Phase 3: Polish & Distribution
1. Create professional updater box object
2. Write user documentation
3. Set up distribution system
This system would provide a truly professional update experience matching commercial Second Life products!