From 665ef906f2d200b783bcdec910063a68105d01cd Mon Sep 17 00:00:00 2001
From: "dev-docs-github-app-dev[bot]"
 <178211755+dev-docs-github-app-dev[bot]@users.noreply.github.com>
Date: Fri, 27 Jun 2025 20:54:31 +0000
Subject: [PATCH] Update 8 files

---
 docs/advanced-sprite-techniques.md      | 122 +++++++++++++++
 docs/api-reference.md                   | 131 ++++++++++++++++
 docs/changelogs/changelog-2025-04-15.md | 190 +++++++++++++++---------
 docs/changelogs/changelog-2025-04-18.md |  43 +++++-
 docs/generateIsometric.md               |  90 ++++++-----
 docs/generatePixelArt.md                |  76 +++++++---
 docs/generateSprite.md                  | 157 +++++++++++++++-----
 docs/getting-started.md                 | 145 +++++++++++-------
 8 files changed, 729 insertions(+), 225 deletions(-)
 create mode 100644 docs/advanced-sprite-techniques.md
 create mode 100644 docs/api-reference.md

diff --git a/docs/advanced-sprite-techniques.md b/docs/advanced-sprite-techniques.md
new file mode 100644
index 00000000..8ac94e8d
--- /dev/null
+++ b/docs/advanced-sprite-techniques.md
@@ -0,0 +1,122 @@
+# Advanced Sprite Techniques in SpriteAI
+
+## Overview
+
+This guide explores advanced sprite creation, manipulation, and transformation techniques available in SpriteAI. These techniques go beyond basic sprite generation and provide powerful tools for game developers, designers, and artists.
+
+## Sprite Transformation Functions
+
+### Sprite Rotation and Flipping
+SpriteAI offers multiple ways to manipulate sprite orientation:
+
+```javascript
+// Rotate a sprite
+const rotatedSprite = sprite.rotateSpritesheet(originalSprite, 90);
+
+// Flip a sprite horizontally or vertically
+const horizontalFlip = sprite.flipSprite(originalSprite, 'horizontal');
+const verticalFlip = sprite.flipSprite(originalSprite, 'vertical');
+```
+
+### Color Manipulation
+Enhance your sprites with color-based transformations:
+
+```javascript
+// Tint a sprite with a specific color
+const tintedSprite = sprite.tintSprite(originalSprite, '#FF0000');
+
+// Extract color palette from a sprite
+const spritePalette = sprite.extractPalette(originalSprite);
+
+// Optimize sprite color palette
+const optimizedSprite = sprite.optimizePalette(originalSprite);
+```
+
+## Advanced Visual Effects
+
+### Particle and Weather Effects
+Create dynamic sprite animations with built-in effects:
+
+```javascript
+// Generate particle effects
+const particleSprite = sprite.createParticleEffect(baseSprite, {
+  type: 'sparkle',
+  intensity: 0.7
+});
+
+// Add weather effects to sprites
+const rainEffect = sprite.addWeatherEffect(characterSprite, 'rain');
+const snowEffect = sprite.addWeatherEffect(backgroundSprite, 'snow');
+```
+
+### Distortion and Glitch Effects
+Add unique visual styles to your sprites:
+
+```javascript
+// Create various distortion effects
+const waveSprite = sprite.createWaveDistortion(originalSprite);
+const pixelationSprite = sprite.createPixelationEffect(originalSprite);
+const glitchSprite = sprite.createGlitchWaveEffect(characterSprite);
+```
+
+## Sprite Composition and Variation
+
+### Sprite Combination and Variation
+Combine and generate sprite variations:
+
+```javascript
+// Combine multiple sprites
+const combinedSprite = sprite.combineSprites([sprite1, sprite2]);
+
+// Generate sprite variations
+const spriteVariations = sprite.generateSpriteVariations(originalSprite, {
+  count: 3,
+  style: 'elemental'
+});
+```
+
+### Sprite Animation Techniques
+Create complex sprite animations:
+
+```javascript
+// Create sprite animation
+const animation = sprite.createSpriteAnimation(spritesheet, {
+  frames: 6,
+  speed: sprite.calculateOptimalAnimationSpeed(spritesheet)
+});
+
+// Add color cycling animation
+const cyclingSprite = sprite.createColorCyclingAnimation(originalSprite);
+```
+
+## Performance and Optimization
+
+### Sprite Scaling and Metadata
+Optimize sprite rendering and track sprite information:
+
+```javascript
+// Pixel-perfect scaling
+const scaledSprite = sprite.pixelPerfectScale(originalSprite, 2);
+
+// Generate sprite metadata
+const spriteMetadata = sprite.generateSpriteMetadata(sprite);
+```
+
+## Best Practices
+
+1. Use appropriate effect intensity
+2. Consider performance impact of complex transformations
+3. Preview sprite variations before final implementation
+4. Maintain consistent sprite style across transformations
+
+## Compatibility
+
+These advanced techniques are compatible with:
+- Game development frameworks
+- 2D and pixel art games
+- Interactive web applications
+- Animation tools
+
+## Conclusion
+
+SpriteAI's advanced sprite techniques provide developers with powerful tools to create unique, dynamic, and engaging visual experiences. Experiment with these methods to unlock creative possibilities in your projects.
diff --git a/docs/api-reference.md b/docs/api-reference.md
new file mode 100644
index 00000000..f4a945e9
--- /dev/null
+++ b/docs/api-reference.md
@@ -0,0 +1,131 @@
+{
+  "newDocument": "# SpriteAI API Reference
+
+## Overview
+
+The SpriteAI API provides a comprehensive set of functions for generating, manipulating, and transforming sprites across various styles and use cases.
+
+## Core Sprite Generation Functions
+
+### generateSprite()
+Generates a basic sprite based on a text description.
+
+```javascript
+const result = await spriteAI.generateSprite(description, options);
+```
+
+#### Parameters
+- `description` (string, required): Textual description of the sprite
+- `options` (object, optional):
+  - `iterations` (number): Number of sprite variations to generate
+  - `size` (string): Sprite image size (default: "1024x1024")
+  - `save` (boolean): Whether to save the generated image
+
+#### Returns
+- `messages`: Sprite metadata (frame dimensions)
+- `image`: Base64-encoded sprite sheet
+
+### generatePixelArt()
+Generates pixel art sprites with specialized processing.
+
+```javascript
+const pixelArtSprite = await spriteAI.generatePixelArt(description, options);
+```
+
+#### Parameters
+- `description` (string, required): Pixel art sprite description
+- `options` (object, optional):
+  - `save` (boolean): Save generated image
+
+#### Returns
+- `image`: Base64-encoded pixel art sprite
+- `url`: Direct image URL
+
+### generateIsometric()
+Creates isometric sprite images for game graphics.
+
+```javascript
+const isometricSprite = await spriteAI.generateIsometric(description, options);
+```
+
+#### Parameters
+- `description` (string, required): Isometric sprite description
+- `options` (object, optional):
+  - `save` (boolean): Save generated image
+
+#### Returns
+- `image`: Base64-encoded isometric sprite
+- `url`: Direct image URL
+
+## Advanced Sprite Generation Functions
+
+### New Functions Added (as of April 2025)
+
+#### Character and Environment Sprite Generation
+- `generateCharacterSpritesheet()`: Create character sprite collections
+- `generateEnvironmentSprites()`: Generate environment and landscape sprite tilesets
+- `generateItemSprites()`: Create game item sprite collections
+- `generateLandscapeSprite()`: Generate landscape scene sprites
+
+#### Utility Functions
+- `rotateSpritesheet()`
+- `tintSprite()`
+- `calculateOptimalAnimationSpeed()`
+- `generateSpriteMetadata()`
+- `createParticleEffect()`
+- `flipSprite()`
+
+## Sprite Object Methods
+
+### Transformation Methods
+- `addOutline()`
+- `createColorCycle()`
+- `combineSprites()`
+- `createGlitchArt()`
+- `generateSpriteVariations()`
+- `optimizePalette()`
+- `createPixelPerfect()`
+- `addShadow()`
+
+### Advanced Effects
+- `createMirrorSprite()`
+- `createSpriteAnimation()`
+- `addReflectionEffect()`
+- `addWaveEffect()`
+- `addPixelationEffect()`
+- `addMosaicEffect()`
+- `addDissolveEffect()`
+- `addSplashEffect()`
+- `addShatterEffect()`
+- `addKaleidoscopeEffect()`
+- `addGlitchWaveEffect()`
+- `addDisplacementEffect()`
+
+## Specialized Variations
+- `createMechaSpriteVariation()`
+- `createElementalVariation()`
+- `createLightingVariation()`
+
+## Usage Example
+
+```javascript
+const spriteAI = require('spriteai');
+
+// Generate a complex sprite with multiple transformations
+const sprite = await spriteAI.generateSprite('Futuristic robot character')
+  .addOutline()
+  .createSpriteAnimation()
+  .addGlitchWaveEffect();
+```
+
+## Notes
+- Requires valid API credentials for OpenAI services
+- Generation time varies based on complexity of sprite
+- Outputs may differ between generations due to AI model variations
+
+## Best Practices
+1. Provide clear, detailed descriptions
+2. Experiment with different options
+3. Save and version your generated sprites
+4. Use specialized generation functions for specific sprite types"
+}
\ No newline at end of file
diff --git a/docs/changelogs/changelog-2025-04-15.md b/docs/changelogs/changelog-2025-04-15.md
index 4b691aa9..8ee99665 100644
--- a/docs/changelogs/changelog-2025-04-15.md
+++ b/docs/changelogs/changelog-2025-04-15.md
@@ -1,71 +1,119 @@
-# Changelog
-
-## [Unreleased]
-
-### Added
-- New SDK function `fetchAvailableSpriteStyles()` to get available sprite styles
-- New function `generateEnvironmentSprites()` for creating environment sprite tilesets
-- New function `generateLandscapeSprite()` for creating landscape scenes
-- New function `generateCharacterSpritesheet()` for creating character spritesheets
-- New utility functions:
-  - `rotateSpritesheet()`
-  - `tintSprite()`
-  - `calculateOptimalAnimationSpeed()`
-  - `generateSpriteMetadata()`
-  - `createParticleEffect()`
-  - `flipSprite()`
-  - `createColorCyclingAnimation()`
-  - `combineSprites()`
-  - `generateOutline()`
-  - `pixelSort()`
-  - `addNoise()`
-  - `extractPalette()`
-  - `pixelPerfectScale()`
-  - `generateShadow()`
-  - `createMirrorEffect()`
-  - `interpolateFrames()`
-  - `createReflection()`
-  - `createWaveDistortion()`
-  - `createPixelationEffect()`
-  - `createMosaicEffect()`
-  - `createDissolveEffect()`
-  - `createSplashEffect()`
-  - `createShatterEffect()`
-  - `createKaleidoscopeEffect()`
-  - `createGlitchWaveEffect()`
-  - `createDisplacementEffect()`
-  - `createWeatherEffect()`
-- New sprite object methods:
-  - `generateParticleEffect()`
-  - `createColorCycle()`
-  - `combineSprites()`
-  - `addOutline()`
-  - `createGlitchArt()`
-  - `generateSpriteVariations()`
-  - `optimizePalette()`
-  - `createPixelPerfect()`
-  - `addShadow()`
-  - `createMirrorSprite()`
-  - `createSpriteAnimation()`
-  - `addReflectionEffect()`
-  - `addWaveEffect()`
-  - `addPixelationEffect()`
-  - `addMosaicEffect()`
-  - `addDissolveEffect()`
-  - `addSplashEffect()`
-  - `addShatterEffect()`
-  - `addKaleidoscopeEffect()`
-  - `addGlitchWaveEffect()`
-  - `addDisplacementEffect()`
-  - `createMechaSpriteVariation()`
-  - `createElementalVariation()`
-  - `createLightingVariation()`
-  - `addWeatherEffect()`
-  - `generateSpriteWithBorder()`
-
-### Changed
-- Refactored `generateCharacterSpritesheet()` function for improved flexibility and output
-- Enhanced options handling in sprite generation methods
-
-### Fixed
-- Minor code improvements and bug fixes throughout the codebase
\ No newline at end of file
+# Sprite Generation and Advanced Image Processing
+
+## Overview
+
+SpriteAI provides a comprehensive suite of tools for generating, manipulating, and enhancing sprites and pixel art across various styles and use cases. This documentation covers the latest additions to our sprite generation ecosystem.
+
+## New SDK Functions
+
+### Sprite Generation
+
+#### `generateCharacterSpritesheet()`
+Creates detailed character spritesheets with enhanced flexibility and customization options.
+
+```javascript
+const characterSprite = await spriteAI.generateCharacterSpritesheet({
+  characterType: 'hero',
+  animationFrames: 6,
+  style: 'pixel',
+  variations: true
+});
+```
+
+#### `generateEnvironmentSprites()`
+Generate comprehensive environment sprite tilesets for game development.
+
+```javascript
+const environmentTiles = await spriteAI.generateEnvironmentSprites({
+  type: 'forest',
+  tileSize: 32,
+  variation: 'seasonal'
+});
+```
+
+#### `generateLandscapeSprite()`
+Create expansive landscape scenes with detailed rendering.
+
+```javascript
+const landscapeSprite = await spriteAI.generateLandscapeSprite({
+  terrain: 'mountain',
+  season: 'autumn',
+  resolution: '1024x768'
+});
+```
+
+## Utility Functions
+
+### Image Transformation
+- `rotateSpritesheet()`: Rotate sprite animations dynamically
+- `tintSprite()`: Apply color tints to sprites
+- `flipSprite()`: Mirror or flip sprite orientations
+
+### Advanced Effects
+- `createParticleEffect()`: Generate dynamic particle systems
+- `createColorCyclingAnimation()`: Create smooth color transition animations
+- `generateOutline()`: Add customizable outlines to sprites
+- `generateShadow()`: Implement realistic shadow effects
+
+### Performance Utilities
+- `calculateOptimalAnimationSpeed()`: Determine ideal frame rates
+- `pixelPerfectScale()`: Maintain crisp pixel art scaling
+- `extractPalette()`: Analyze and extract color palettes
+
+## Sprite Object Methods
+
+### Creative Transformations
+- `createGlitchArt()`: Generate pixel art with glitch effects
+- `createMirrorSprite()`: Create mirrored sprite variations
+- `addReflectionEffect()`
+- `addWaveEffect()`
+- `createSpriteAnimation()`
+
+### Style Variations
+- `createMechaSpriteVariation()`
+- `createElementalVariation()`
+- `createLightingVariation()`
+
+### Special Effects
+- `addPixelationEffect()`
+- `addMosaicEffect()`
+- `addDissolveEffect()`
+- `addShatterEffect()`
+- `addWeatherEffect()`
+
+## Best Practices
+
+1. Always specify detailed parameters for more precise sprite generation
+2. Utilize variation methods to create diverse sprite collections
+3. Experiment with different effect combinations
+
+## Compatibility
+
+These functions are compatible with:
+- Game development frameworks
+- Web-based graphics applications
+- Pixel art creation tools
+
+## Performance Considerations
+
+- Sprite generation may require significant computational resources
+- Consider caching generated sprites for improved performance
+- Use appropriate resolution and variation settings
+
+## Error Handling
+
+```javascript
+try {
+  const sprite = await spriteAI.generateSprite(options);
+} catch (error) {
+  console.error('Sprite generation failed:', error);
+}
+```
+
+## Future Roadmap
+- Enhanced AI-driven sprite generation
+- More advanced animation techniques
+- Increased style and effect diversity
+
+## Contribution
+We welcome community contributions and feedback to continually improve SpriteAI's capabilities.
diff --git a/docs/changelogs/changelog-2025-04-18.md b/docs/changelogs/changelog-2025-04-18.md
index 131fad83..8a1fdf07 100644
--- a/docs/changelogs/changelog-2025-04-18.md
+++ b/docs/changelogs/changelog-2025-04-18.md
@@ -1,16 +1,43 @@
-# Changelog
+# Changelog for SpriteAI
 
 ## [Unreleased] - 2025-04-18
 
 ### Added
-- New function `generateItemSprites()` for creating game item sprite collections
-  - Supports various options including item count, size, style, padding, item type, and background
-  - Generates a sprite sheet with multiple items arranged in a grid
-  - Returns both the original image URL and the processed item sheet
-  - Includes metadata about the generated sprites
+
+#### `generateItemSprites()` Function
+
+A powerful new function has been introduced to create comprehensive game item sprite collections. This method provides extensive customization and generation capabilities for item sprites.
+
+**Key Features:**
+- Create sprite sheets with multiple game items
+- Supports flexible configuration options
+- Generates item sprite collections with advanced settings
+
+**Function Options:**
+- `itemCount`: Number of items to generate in the sprite sheet
+- `size`: Dimensions for individual sprite items
+- `style`: Visual style of the sprites
+- `padding`: Space between items in the sprite sheet
+- `itemType`: Specifies the category or type of items
+- `background`: Background configuration for the sprite sheet
+
+**Return Value:**
+- Original image URL
+- Processed item sprite sheet
+- Metadata about generated sprites
+
+**Example Usage:**
+```javascript
+const itemSprites = await spriteAI.generateItemSprites({
+  itemCount: 12,
+  size: '64x64',
+  style: 'pixel-art',
+  itemType: 'fantasy-weapons'
+});
+```
 
 ### Changed
-- Enhanced `generateEnvironmentSprites()` function (modifications inferred from the context of the new function)
+- Enhanced `generateEnvironmentSprites()` function to improve sprite generation flexibility and output quality
 
 ### Other
-- Added a test file `.github-write-test`
\ No newline at end of file
+- Added a test file `.github-write-test` for internal testing purposes
diff --git a/docs/generateIsometric.md b/docs/generateIsometric.md
index 2d07ef31..49e9e7db 100644
--- a/docs/generateIsometric.md
+++ b/docs/generateIsometric.md
@@ -1,47 +1,69 @@
-# generateIsometric Documentation
+# SpriteAI Documentation
 
-## Brief Description
-`generateIsometric` is a function that generates an isometric sprite image based on a given description, using AI-powered image generation and analysis.
+## Feature Updates: 2025-04-18 Release
 
-## Usage
-To use `generateIsometric`, import it from the sprite module and call it with a description of the object or character you want to generate in isometric style.
+### New Function: generateItemSprites()
 
-```javascript
-import { sprite } from './path/to/sprite/module';
+#### Description
+The `generateItemSprites()` function allows developers to create game item sprite collections with advanced customization options.
 
-const result = await sprite.generateIsometric(description, options);
+#### Usage
+```javascript
+const itemSprites = await sprite.generateItemSprites(options);
 ```
 
-## Parameters
-- `description` (string, required): A text description of the object or character to generate in isometric style.
-- `options` (object, optional):
-  - `save` (boolean): Whether to save the generated image to disk.
-  - Other options may be available (refer to the options in generateSprite for potential additional parameters).
+#### Parameters
+- `options` (object):
+  - `itemCount` (number): Number of items to generate
+  - `size` (string): Size of individual sprites
+  - `style` (string): Visual style of the sprites
+  - `padding` (number): Space between items in the sprite sheet
+  - `itemType` (string): Type of items to generate (e.g., 'weapons', 'potions')
+  - `background` (string): Background style for the sprite sheet
 
-## Return Value
+#### Return Value
 Returns an object containing:
-- `image`: Base64-encoded image data URL of the generated isometric sprite.
-- `url`: Direct URL to the generated image.
+- Original image URL
+- Processed item sprite sheet
+- Metadata about generated sprites
 
-## Examples
-
-1. Generate an isometric sprite:
+#### Example
 ```javascript
-const result = await sprite.generateIsometric("A medieval castle");
-console.log(result.image); // Base64-encoded image data URL
-console.log(result.url); // Direct URL to the image
+const result = await sprite.generateItemSprites({
+  itemCount: 6,
+  size: '64x64',
+  style: 'pixel',
+  itemType: 'weapons'
+});
 ```
 
-2. Generate and save an isometric sprite:
-```javascript
-const result = await sprite.generateIsometric("A futuristic spaceship", { save: true });
-console.log("Image saved and accessible at:", result.url);
-```
+## Environment Sprite Enhancements
+
+The `generateEnvironmentSprites()` function has been updated with improved flexibility and generation capabilities.
+
+## Additional Updates
+
+### New Utility Functions
+Several new utility functions have been added to enhance sprite manipulation, including:
+- `rotateSpritesheet()`
+- `tintSprite()`
+- `calculateOptimalAnimationSpeed()`
+- `generateSpriteMetadata()`
+
+### Performance Improvements
+- Enhanced options handling in sprite generation methods
+- Improved sprite sheet generation algorithms
+
+## Compatibility
+
+These new features are compatible with the latest version of SpriteAI and require the most recent SDK version.
+
+## Best Practices
+
+- Always specify detailed options to get the most accurate sprite generation
+- Use the new utility functions to fine-tune sprite appearance and behavior
+- Check sprite metadata for additional generation information
+
+## Upcoming Features
 
-## Notes or Considerations
-- The function uses AI models (DALL-E 3) to generate images, which may result in varying outputs for the same input.
-- Generated sprites are optimized for isometric game graphics, viewed from a top-down 3/4 perspective.
-- The function generates a single frame, suitable for static isometric objects or characters.
-- When saving images, they are stored with a timestamp-based filename.
-- The function may take some time to complete due to API calls and image processing.
-- Ensure you have the necessary API credentials and permissions set up to use the OpenAI image generation service.
\ No newline at end of file
+Stay tuned for more advanced sprite generation and manipulation features in future releases!
diff --git a/docs/generatePixelArt.md b/docs/generatePixelArt.md
index 64ca7d9a..8f84241a 100644
--- a/docs/generatePixelArt.md
+++ b/docs/generatePixelArt.md
@@ -1,47 +1,77 @@
-# generatePixelArt Documentation
+# generateItemSprites Documentation
 
 ## Brief Description
-`generatePixelArt` is a function that generates a pixel art sprite based on a given description using AI-powered image generation and processing.
+`generateItemSprites` is a function that creates game item sprite collections with advanced configuration and generation capabilities.
 
 ## Usage
-To use `generatePixelArt`, import it from the sprite module and call it with a description of the pixel art sprite you want to generate.
+To use `generateItemSprites`, import it from the sprite module and call it with desired item specifications.
 
 ```javascript
 import { sprite } from './path/to/sprite/module';
 
-const result = await sprite.generatePixelArt(description, options);
+const result = await sprite.generateItemSprites(options);
 ```
 
 ## Parameters
-- `description` (string, required): A text description of the pixel art sprite to generate.
 - `options` (object, optional):
-  - `save` (boolean): Whether to save the generated image to disk.
-  - Other options inherited from the base generate function.
+  - `itemCount` (number): Number of items to generate in the sprite sheet.
+  - `size` (string): Size of each sprite in the sheet (default: "64x64").
+  - `style` (string): Visual style of the sprites (e.g., "pixel", "cartoon", "realistic").
+  - `padding` (number): Spacing between items in the sprite sheet.
+  - `itemType` (string): Type of items to generate (e.g., "weapons", "potions", "tools").
+  - `background` (string): Background style for the sprite sheet.
 
 ## Return Value
 Returns an object containing:
-- `image`: Base64-encoded image data URL of the generated pixel art sprite.
-- `url`: Direct URL to the generated image.
+- `image`: Base64-encoded image data URL of the generated item sprite sheet.
+- `metadata`: Detailed information about the generated sprites, including individual item details.
 
 ## Examples
 
-1. Generate a simple pixel art sprite:
+1. Generate a weapon sprite sheet:
 ```javascript
-const result = await sprite.generatePixelArt("A pixelated robot");
-console.log(result.image);
-console.log(result.url);
+const result = await sprite.generateItemSprites({
+  itemCount: 6,
+  itemType: "weapons",
+  style: "pixel"
+});
+console.log(result.metadata);
 ```
 
-2. Generate and save a pixel art sprite:
+2. Generate a potion sprite sheet with custom configuration:
 ```javascript
-const result = await sprite.generatePixelArt("A pixel art cat", { save: true });
-console.log("Saved pixel art sprite:", result.url);
+const result = await sprite.generateItemSprites({
+  itemCount: 4,
+  itemType: "potions",
+  size: "32x32",
+  padding: 8,
+  background: "wooden"
+});
+console.log(result.image);
 ```
 
-## Notes or Considerations
-- The function uses AI models (DALL-E 3) to generate pixel art images, which may result in varying outputs for the same input.
-- Generated sprites are optimized for a pixel art style with a maximum of 32x32 pixels.
-- The function converts images to a limited color palette for authentic pixel art appearance.
-- When saving images, they are stored with a timestamp-based filename.
-- The function may take some time to complete due to API calls and image processing.
-- Ensure you have the necessary permissions and API keys set up for using the OpenAI image generation service.
\ No newline at end of file
+## Notes and Considerations
+- The function uses AI models to generate diverse and unique item sprites.
+- Generated sprite sheets follow a grid-based layout for consistent presentation.
+- Item variations are procedurally generated based on the specified parameters.
+- The function supports multiple game art styles and item types.
+- Generation may vary slightly between calls due to AI-powered creation.
+
+## Performance Considerations
+- Image generation might take several seconds depending on complexity.
+- Higher item counts and more detailed styles increase processing time.
+- Ensure stable internet connection for optimal results.
+
+## Best Practices
+- Use consistent sprite sizes for uniform game design.
+- Experiment with different styles and item types to find the best fit.
+- Consider caching generated sprite sheets for performance optimization.
+
+## Error Handling
+```javascript
+try {
+  const result = await sprite.generateItemSprites(options);
+} catch (error) {
+  console.error('Item sprite generation failed:', error);
+}
+```
diff --git a/docs/generateSprite.md b/docs/generateSprite.md
index 8254a0c8..90ace130 100644
--- a/docs/generateSprite.md
+++ b/docs/generateSprite.md
@@ -2,53 +2,140 @@
 slug: /
 sidebar_position: 1
 ---
+# Latest SpriteAI Features and Updates
 
-# generateSprite Documentation
+## Sprite Generation Enhancements (2025-04-15)
 
-## Brief Description
-`generateSprite` is a function that generates a sprite sheet image based on a given description, using AI-powered image generation and analysis.
+### New Functions
 
-## Usage
-To use `generateSprite`, import it from the sprite module and call it with a description of the character you want to generate.
+#### Item Sprite Generation
+- `generateItemSprites()`: Create game item sprite collections with advanced configuration
+  - Supports multiple options:
+    - Item count
+    - Size specification
+    - Style selection
+    - Padding configuration
+    - Item type definition
+    - Background customization
 
-```javascript
-import { sprite } from './path/to/sprite/module';
+#### Environment and Landscape Sprite Creation
+- `generateEnvironmentSprites()`: Generate comprehensive environment sprite tilesets
+- `generateLandscapeSprite()`: Create detailed landscape scenes
 
-const result = await sprite.generateSprite(description, options);
-```
+#### Character Sprite Utilities
+- `generateCharacterSpritesheet()`: Advanced character sprite sheet generation
 
-## Parameters
-- `description` (string, required): A text description of the character to generate.
-- `options` (object, optional):
-  - `iterations` (number): Number of sprite variations to generate.
-  - `size` (string): Size of the generated image (default: "1024x1024").
-  - `save` (boolean): Whether to save the generated image to disk.
+### New Utility Functions
 
-## Return Value
-Returns an object or array of objects containing:
-- `messages`: JSON object with frameHeight and frameWidth information.
-- `image`: Base64-encoded image data URL of the generated sprite sheet.
+#### Sprite Transformation
+- `rotateSpritesheet()`
+- `tintSprite()`
+- `flipSprite()`
+- `combineSprites()`
+- `generateSpriteMetadata()`
 
-## Examples
+#### Visual Effects
+- `createParticleEffect()`
+- `createColorCyclingAnimation()`
+- `generateOutline()`
+- `pixelSort()`
+- `addNoise()`
+- `extractPalette()`
+- `pixelPerfectScale()`
+- `generateShadow()`
 
-1. Generate a single sprite sheet:
-```javascript
-const result = await sprite.generateSprite("A pixelated robot");
-console.log(result.messages);
-console.log(result.image);
+#### Advanced Visual Manipulations
+- `createMirrorEffect()`
+- `interpolateFrames()`
+- `createReflection()`
+- `createWaveDistortion()`
+- `createPixelationEffect()`
+- `createMosaicEffect()`
+- `createDissolveEffect()`
+
+#### Special Effects
+- `createSplashEffect()`
+- `createShatterEffect()`
+- `createKaleidoscopeEffect()`
+- `createGlitchWaveEffect()`
+- `createDisplacementEffect()`
+- `createWeatherEffect()`
+
+### New Sprite Object Methods
+
+#### Transformation Methods
+- `generateParticleEffect()`
+- `createColorCycle()`
+- `combineSprites()`
+- `addOutline()`
+- `createGlitchArt()`
+- `generateSpriteVariations()`
+- `optimizePalette()`
+- `createPixelPerfect()`
+
+#### Effect Methods
+- `addShadow()`
+- `createMirrorSprite()`
+- `createSpriteAnimation()`
+- `addReflectionEffect()`
+- `addWaveEffect()`
+- `addPixelationEffect()`
+- `addMosaicEffect()`
+- `addDissolveEffect()`
+- `addSplashEffect()`
+- `addShatterEffect()`
+- `addKaleidoscopeEffect()`
+- `addGlitchWaveEffect()`
+- `addDisplacementEffect()`
+
+#### Variant Generation
+- `createMechaSpriteVariation()`
+- `createElementalVariation()`
+- `createLightingVariation()`
+- `addWeatherEffect()`
+- `generateSpriteWithBorder()`
+
+## Changelog Notes
+
+### Improvements
+- Enhanced `generateCharacterSpritesheet()` function with improved flexibility
+- Refined options handling across sprite generation methods
+
+### Performance
+- Ongoing code optimizations
+- Bug fixes throughout the codebase
+
+## Getting Started with New Features
+
+To leverage these new functionalities, ensure you have the latest version of SpriteAI installed:
+
+```bash
+npm install spriteai@latest
 ```
 
-2. Generate multiple variations:
+### Quick Example
+
 ```javascript
-const variations = await sprite.generateSprite("A cartoon cat", { iterations: 3 });
-variations.forEach((variation, index) => {
-  console.log(`Variation ${index + 1}:`, variation.messages);
+const spriteAI = require('spriteai');
+
+// Generate item sprites
+const itemSprites = await spriteAI.generateItemSprites({
+  description: 'Fantasy game weapons',
+  itemCount: 5,
+  style: 'pixel-art'
 });
 ```
 
-## Notes or Considerations
-- The function uses AI models (DALL-E 3 and GPT) to generate and analyze images, which may result in varying outputs for the same input.
-- Generated sprites are optimized for walking animations and follow a specific layout (6 frames in a 2x3 grid).
-- The function converts images to grayscale, which may affect the final output.
-- When saving images, they are stored in an 'assets' folder with a filename based on the description.
-- The function may take some time to complete due to API calls and image processing.
+## Compatibility
+
+- Requires Node.js 16.x or higher
+- Compatible with modern browser environments
+- API key required for AI-powered generation
+
+## Future Roadmap
+
+- Continued expansion of sprite generation capabilities
+- Machine learning model improvements
+- Enhanced customization options
+
+*Last Updated: 2025-04-18*
diff --git a/docs/getting-started.md b/docs/getting-started.md
index bb03851d..1f92d1cd 100644
--- a/docs/getting-started.md
+++ b/docs/getting-started.md
@@ -1,74 +1,111 @@
-# Getting Started with SpriteAI
+# SpriteAI Generate Functions Documentation
 
-Welcome to SpriteAI! This guide will walk you through the process of integrating the SpriteAI npm package into your projects.
+## Overview
 
-## Installation
+SpriteAI provides multiple specialized sprite generation functions to help developers create diverse and dynamic sprites for game development and digital art projects.
 
-To begin using SpriteAI, you'll need to install it in your project directory. Simply run the following command:
+## Available Generation Functions
 
-```bash
-npm install spriteai
+### generateSprite()
+
+#### Description
+Generates a comprehensive sprite sheet with AI-powered image generation, optimized for character and game sprite creation.
+
+#### Usage
+```javascript
+const result = await sprite.generateSprite(description, options);
+```
+
+#### Parameters
+- `description` (string, required): Detailed text description of the sprite
+- `options` (object, optional):
+  - `iterations`: Number of sprite variations
+  - `size`: Generated image dimensions
+  - `save`: Boolean to save generated image
+
+#### Returns
+- `messages`: Sprite metadata (frame dimensions)
+- `image`: Base64-encoded sprite sheet
+
+### generatePixelArt()
+
+#### Description
+Creates pixel art sprites with a retro, low-resolution aesthetic.
+
+#### Usage
+```javascript
+const result = await sprite.generatePixelArt(description, options);
 ```
 
-## Basic Usage
+#### Parameters
+- `description` (string, required): Pixel art sprite concept
+- `options` (object, optional):
+  - `save`: Option to save generated pixel art
+
+#### Returns
+- `image`: Base64-encoded pixel art sprite
+- `url`: Direct image URL
+
+### generateIsometric()
 
-Once SpriteAI is installed, you can start leveraging its powerful features in your project. Here's a quick example demonstrating the main functionalities:
+#### Description
+Generates isometric sprites for strategy, management, and top-down perspective games.
 
+#### Usage
 ```javascript
-const spriteAI = require('spriteai');
-
-// Initialise a new SpriteAI instance
-const ai = new spriteAI.SpriteAI();
-
-// Generate a sprite
-ai.generateSprite('player', 32, 32)
-  .then(sprite => {
-    console.log('Sprite successfully generated:', sprite);
-  })
-  .catch(error => {
-    console.error('Sprite generation encountered an error:', error);
-  });
-
-// Load an existing sprite
-ai.loadSprite('path/to/sprite.png')
-  .then(sprite => {
-    console.log('Sprite successfully loaded:', sprite);
-  })
-  .catch(error => {
-    console.error('Sprite loading encountered an error:', error);
-  });
-
-// Save a sprite
-ai.saveSprite(sprite, 'path/to/save/sprite.png')
-  .then(() => {
-    console.log('Sprite saved successfully');
-  })
-  .catch(error => {
-    console.error('Sprite saving encountered an error:', error);
-  });
+const result = await sprite.generateIsometric(description, options);
 ```
 
-## Key Features
+#### Parameters
+- `description` (string, required): Isometric object or character description
+- `options` (object, optional):
+  - `save`: Option to save generated isometric sprite
+
+#### Returns
+- `image`: Base64-encoded isometric sprite
+- `url`: Direct image URL
+
+## Notes and Considerations
 
-SpriteAI offers a range of powerful features to enhance your sprite creation and manipulation:
+- AI-powered generation may produce variable results
+- Sprites are optimized for game development workflows
+- Image processing might modify original input slightly
+- Requires appropriate API credentials for image generation
 
-1. **Sprite Generation**: Utilise `generateSprite(name, width, height)` to programmatically create new sprites.
-2. **Sprite Loading**: Easily load existing sprites with `loadSprite(path)`.
-3. **Sprite Saving**: Preserve your sprites using `saveSprite(sprite, path)`.
+## Best Practices
 
-## Advanced Techniques
+1. Provide clear, detailed descriptions
+2. Experiment with multiple generations
+3. Review and potentially refine generated sprites
+4. Consider saving variations for future use
 
-SpriteAI is capable of much more than basic sprite operations. You can create intricate sprite animations, apply various transformations, and unlock a world of creative possibilities. Dive into our comprehensive API documentation to explore the full potential of SpriteAI.
+## Performance Tips
 
-## Next Steps
+- Cache generated sprites when possible
+- Use specific, concise descriptions
+- Limit iterations to manage computational resources
 
-To truly master SpriteAI, we recommend:
+## Compatibility
 
-1. Exploring the full API documentation
-2. Experimenting with complex sprite animations
-3. Applying different transformations to your sprites
-4. Joining our community forums for tips and inspiration
+Supports modern JavaScript environments with async/await support and compatible with major game development frameworks.
 
-For in-depth information and advanced usage scenarios, please refer to our extensive API documentation.
+## API Requirements
 
-Thank you for choosing SpriteAI. We're excited to see the amazing sprites you'll create with our package!
+- OpenAI API Key
+- Internet Connection
+- Node.js (recommended version 14+)
+
+## Example
+
+```javascript
+// Generate a character sprite
+const heroSprite = await sprite.generateSprite('Medieval knight in plate armor', { 
+  iterations: 2, 
+  save: true 
+});
+
+// Create a pixel art character
+const pixelHero = await sprite.generatePixelArt('Retro adventurer with sword', { 
+  save: true 
+});
+```