Rosewood Development

https://wiki.rosewooddev.io/
Admin
Rosewood Development provides a suite of Minecraft plugins including custom loot, chat formatting,...
Tokens:125,847
Snippets:763
Trust Score:5.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### RoseStacker API Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/getting-started

Guide for getting started with the RoseStacker API, including setup and integration.

```APIDOC
RoseStacker API Usage:

  - Getting Started: Instructions on how to start using the RoseStacker API.
```

--------------------------------

### PlayerParticles API Getting Started

Source: https://wiki.rosewooddev.io/PlayerParticles/getting-started

Guide to getting started with the PlayerParticles API, including setup with Gradle or Maven, obtaining an API instance, and managing dependencies.

```APIDOC
PlayerParticles API:

Getting Started:
  - Introduction
  - Setup:
    - Gradle
    - Maven
  - Getting an API instance
  - Depend/Softdepend

Javadoc: https://wiki.rosewooddev.io/PlayerParticles/javadoc/
```

--------------------------------

### RoseLoot API Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/getting-started

Guide to getting started with the RoseLoot API, including setup with Gradle or Maven, obtaining an API instance, creating loot conditions, and managing plugin dependencies.

```APIDOC
RoseLoot API Usage:

Getting Started:
  - Introduction
  - Setup:
    - Gradle: Add the RoseLoot dependency to your build.gradle file.
    - Maven: Add the RoseLoot dependency to your pom.xml file.
  - Getting an API instance: Obtain an instance of the RoseLoot API to interact with its features.
  - Creating Loot Conditions: Learn how to define custom conditions for loot generation.
  - Depend/Softdepend: Information on how to properly declare dependencies and soft dependencies on RoseLoot.
```

--------------------------------

### PlayerParticles API Usage - Getting Started

Source: https://wiki.rosewooddev.io/PlayerPoints/getting-started

This section guides users on how to get started with the PlayerParticles API, including setup and basic usage instructions.

```APIDOC
PlayerParticles API Usage:
  Getting Started: Guides users through the initial steps of integrating and using the PlayerParticles API.
```

--------------------------------

### RoseStacker API: Getting Started

Source: https://wiki.rosewooddev.io/RoseStacker/getting-started

This section guides users on how to get started with the RoseStacker API. It covers initial setup using build tools like Gradle and Maven, obtaining an API instance, and managing plugin dependencies.

```APIDOC
RoseStacker API Usage: Getting Started

Introduction:
  Provides an overview of the RoseStacker API and its capabilities.

Setup:
  Instructions for integrating RoseStacker into your project.
  - Gradle:
    Specify the RoseStacker dependency in your build.gradle file.
  - Maven:
    Specify the RoseStacker dependency in your pom.xml file.

Getting an API instance:
  Demonstrates how to retrieve an instance of the RoseStacker API to interact with its features.

Depend/Softdepend:
  Information on how to properly declare RoseStacker as a dependency or soft-dependency in your plugin's configuration.
```

--------------------------------

### RoseLoot API Usage Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/generic-values

A guide to getting started with the RoseLoot plugin's API, likely covering initial setup and basic integration.

```markdown
## API Usage

### Getting Started

This guide will walk you through the initial steps to integrate with the RoseLoot API.
```

--------------------------------

### PlayerParticles API Getting Started (Java)

Source: https://wiki.rosewooddev.io/RoseChat/getting-started

A guide for developers on how to start using the PlayerParticles API, covering setup and basic implementation.

```Java
Getting Started:
  * API Usage documentation.
```

--------------------------------

### PlayerParticles API: Getting Started

Source: https://wiki.rosewooddev.io/RoseStacker/getting-started

A guide for developers to start using the PlayerParticles API. It includes information on setup, Javadoc for API reference, and descriptions of the objects used within the API.

```APIDOC
PlayerParticles API Usage: Getting Started

Getting Started:
  Provides initial steps for integrating and using the PlayerParticles API in your projects.

Javadoc:
  Links to the Javadoc documentation for a comprehensive reference of all classes, methods, and parameters within the PlayerParticles API.

Object Descriptions:
  Detailed explanations of the various objects and data structures utilized by the PlayerParticles API, aiding in understanding and implementation.
```

--------------------------------

### PlayerPoints API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/setup-guide

A guide for developers to begin using the PlayerPoints API, including setup and initial implementation steps.

```APIDOC
PlayerPoints API Usage:
  Getting Started:
    This guide outlines the initial steps for integrating and utilizing the PlayerPoints API. It covers setup procedures and basic usage patterns.
```

--------------------------------

### PlayerParticles API Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/getting-started

Instructions for getting started with the PlayerParticles API, including setup and usage.

```APIDOC
PlayerParticles API Usage:

  - Getting Started: How to begin using the PlayerParticles API.
  - Javadoc: Link to the Javadoc documentation for detailed API information.
```

--------------------------------

### RoseLoot API Getting Started

Source: https://wiki.rosewooddev.io/PlayerParticles/getting-started

Information on how to get started with the RoseLoot API, covering initial setup and usage.

```APIDOC
RoseLoot API:

Getting Started: https://wiki.rosewooddev.io/RoseLoot/getting-started/
```

--------------------------------

### RoseChat Setup Guide Example

Source: https://wiki.rosewooddev.io/RoseChat/setup-guide

Provides an example for setting up RoseChat, likely demonstrating a configuration or usage scenario.

```APIDOC
RoseChat Setup Guide:
  Example Usage:
    This section provides a practical example for setting up and using RoseChat. Specific details of the example are not provided in the source text but are referenced via a link.
```

--------------------------------

### PlayerParticles API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/setup-guide

A guide for developers to begin using the PlayerParticles API, including setup and initial implementation steps.

```APIDOC
PlayerParticles API Usage:
  Getting Started:
    This guide provides the necessary steps to start using the PlayerParticles API. It covers initial setup and basic integration procedures.
```

--------------------------------

### RoseStacker API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/setup-guide

Instructions for users to start implementing the RoseStacker API, covering initial setup and basic usage.

```APIDOC
RoseStacker API Usage:
  Getting Started:
    This section provides the initial steps required to integrate and utilize the RoseStacker API. It covers setup and fundamental operations.
```

--------------------------------

### PlayerParticles API: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/introduction

An introductory guide for developers on how to use the PlayerParticles API, covering initial setup and basic functionalities.

```APIDOC
PlayerParticles API Usage:
  Getting Started:
    - Provides an entry point for developers to utilize the PlayerParticles API.
    - Details on initial setup and basic integration steps.
    - Links to further documentation on configuration, permissions, and particle details.
```

--------------------------------

### RoseLoot API Usage - Getting Started

Source: https://wiki.rosewooddev.io/PlayerParticles/introduction

A starting guide for developers interested in using the RoseLoot API. It covers the initial setup and basic principles for integrating RoseLoot's features.

```APIDOC
RoseLoot API Usage:
  Getting Started:
    - Introduction to the RoseLoot API.
    - Initial steps for developers to integrate loot systems.
    - Overview of core API functionalities.
```

--------------------------------

### RoseChat API Getting Started

Source: https://wiki.rosewooddev.io/PlayerParticles/getting-started

Guide to starting with the RoseChat API, including parsing messages, tokens, and custom channels.

```APIDOC
RoseChat API:

Getting Started: https://wiki.rosewooddev.io/RoseChat/getting-started/

Features:
  - Parsing Messages
  - Tokens & Tokenizers
  - Custom Channels
```

--------------------------------

### RoseLoot API Getting Started (Java)

Source: https://wiki.rosewooddev.io/RoseChat/getting-started

This section guides users on integrating the RoseLoot API into their projects, covering initial setup and basic usage patterns.

```Java
Getting Started:
  * API Usage documentation.
```

--------------------------------

### PlayerParticles API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/custom-item-plugins

A guide to starting with the PlayerParticles API, covering setup and basic usage.

```APIDOC
PlayerParticles API - Getting Started:

This section provides instructions for getting started with the PlayerParticles API.

Includes:
- API setup and configuration
- Basic particle spawning commands
- Understanding particle properties
- Example usage scenarios
```

--------------------------------

### RoseChat API Getting Started (Java)

Source: https://wiki.rosewooddev.io/RoseChat/getting-started

This section provides instructions on how to get started with the RoseChat API, including setup with build tools like Gradle and Maven, obtaining an API instance, and managing plugin dependencies.

```Java
Getting Started:
  * Introduction
  * Setup
    * Gradle
    * Maven
  * Getting an API instance
  * Depend/Softdepend
```

--------------------------------

### RoseLoot API Usage - Getting Started

Source: https://wiki.rosewooddev.io/PlayerPoints/getting-started

This section offers a guide to getting started with the RoseLoot API, outlining the initial steps for developers to integrate its features.

```APIDOC
RoseLoot API Usage:
  Getting Started: A foundational guide for developers to start using the RoseLoot API.
```

--------------------------------

### RoseChat API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseStacker/introduction

Guide to begin using the RoseChat API. This section is expected to contain information on initial setup and fundamental API interactions.

```APIDOC
RoseChat API Usage:
  Getting Started:
    - Instructions for developers to start using the RoseChat API.
    - Covers basic integration steps and initial configuration.
```

--------------------------------

### RoseStacker API Getting Started

Source: https://wiki.rosewooddev.io/PlayerParticles/getting-started

Instructions for getting started with the RoseStacker API and its PlaceholderAPI support.

```APIDOC
RoseStacker API:

Getting Started: https://wiki.rosewooddev.io/RoseStacker/getting-started/

Compatibility:
  - PlaceholderAPI Support
```

--------------------------------

### RoseLoot API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/resource-packs

A guide to getting started with the RoseLoot API, providing initial steps for integration and usage.

```APIDOC
RoseLoot API - Getting Started:

Description: Provides an introductory guide to integrating and utilizing the RoseLoot API for custom loot generation and management.

Key Concepts:
  - Pools & Entries: Understand how loot is structured into pools and individual entries.
  - Number Providers: Learn about different methods for generating random numbers to determine loot.
  - Conditions: Explore various conditions that can affect loot drops, including generic, entity-specific, and plugin-compatible values.
  - Item Types & Meta: Details on defining and customizing item properties.
  - Custom Item Plugins: Information on integrating with external plugins for custom items.
  - Context Placeholders: How to use placeholders for dynamic loot generation.
```

--------------------------------

### PlayerPoints API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/custom-item-plugins

A guide to initiating use of the PlayerPoints API, covering setup and fundamental operations.

```APIDOC
PlayerPoints API - Getting Started:

This section provides instructions for beginning with the PlayerPoints API.

Covers:
- API installation and initial configuration
- Basic API calls for points management
- Player data retrieval
- Example scenarios for point system integration
```

--------------------------------

### PlayerPoints API Usage - Getting Started

Source: https://wiki.rosewooddev.io/PlayerPoints/getting-started

This section provides an introduction to using the PlayerPoints API, covering the initial steps and setup required for integration.

```APIDOC
PlayerPoints API Usage:
  Getting Started:
    Introduction: Provides an overview and initial setup for the PlayerPoints API.
```

--------------------------------

### RoseChat API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/plugin-compatibility

A guide for developers on how to start using the RoseChat API, covering basic setup and initial steps for integration.

```APIDOC
RoseChat API Usage - Getting Started:
  - Purpose: Introduction to integrating with the RoseChat API.
  - Steps: Initial setup and basic usage instructions for developers.
```

--------------------------------

### RoseLoot: API Usage - Getting Started

Source: https://wiki.rosewooddev.io/PlayerParticles/particle-details

Guides for integrating and using the RoseLoot plugin's API, covering initial setup and common use cases.

```APIDOC
RoseLoot:
  API Usage:
    Getting Started: Instructions for developers to begin using the RoseLoot API.
```

--------------------------------

### RoseStacker API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/custom-item-plugins

An introductory guide to using the RoseStacker API, covering initial setup and core functionalities.

```APIDOC
RoseStacker API - Getting Started:

This section details how to begin using the RoseStacker API.

Includes:
- API installation and setup
- Basic API operations
- Authentication and authorization
- Example workflows
```

--------------------------------

### RoseLoot Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/item-meta

Provides an introductory guide to the RoseLoot plugin.

```APIDOC
RoseLoot:
  Getting Started: https://wiki.rosewooddev.io/RoseLoot/getting-started/
```

--------------------------------

### RoseStacker: API Usage - Getting Started

Source: https://wiki.rosewooddev.io/PlayerParticles/particle-details

Guides for integrating and using the RoseStacker plugin's API, covering initial setup and common use cases.

```APIDOC
RoseStacker:
  API Usage:
    Getting Started: Instructions for developers to begin using the RoseStacker API.
```

--------------------------------

### PlayerPoints API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/tokens-%26-tokenizers

A guide for developers on integrating with the PlayerPoints plugin's API, covering initial setup and basic operations for managing player points.

```APIDOC
PlayerPoints Plugin API - Getting Started:

API Retrieval:
  // Get the PlayerPoints API instance
  PlayerPointsAPI api = PlayerPointsAPI.getApi();

Key Functions:
  // Get a player's current points balance
  int points = api.getPoints(player);

  // Add points to a player's balance
  api.addPoints(player, amount);

  // Remove points from a player's balance
  api.removePoints(player, amount);

  // Check if a player exists in the system
  boolean playerExists = api.playerExists(player);

Parameters:
  - player: The target player object.
  - amount: The number of points to add or remove.

Dependencies:
  - PlayerPoints plugin must be installed and running.

Related API Sections:
  - PlaceholderAPI Support: Using PlayerPoints placeholders in-game.
```

--------------------------------

### RoseChat: API Usage - Getting Started

Source: https://wiki.rosewooddev.io/PlayerParticles/particle-details

Guides for integrating and using the RoseChat plugin's API, covering initial setup and common use cases.

```APIDOC
RoseChat:
  API Usage:
    Getting Started: Instructions for developers to begin using the RoseChat API.
```

--------------------------------

### RoseLoot API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/setup-guide

Provides guidance on initiating the use of the RoseLoot API, including setup and basic integration steps.

```APIDOC
RoseLoot API Usage:
  Getting Started:
    This guide explains how to begin using the RoseLoot API. It covers essential steps for integration and initial setup.
```

--------------------------------

### RoseChat API Usage - Getting Started

Source: https://wiki.rosewooddev.io/PlayerPoints/getting-started

This section provides a starting point for developers looking to integrate with the RoseChat API, covering essential setup and usage information.

```APIDOC
RoseChat API Usage:
  Getting Started: Introduces the RoseChat API and provides initial steps for developers to begin using it.
```

--------------------------------

### RoseStacker API Getting Started (Java)

Source: https://wiki.rosewooddev.io/RoseChat/getting-started

Instructions for developers to begin using the RoseStacker API, including setup and initial integration steps.

```Java
Getting Started:
  * API Usage documentation.
```

--------------------------------

### RoseChat API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/custom-item-plugins

Guides users on how to begin using the RoseChat API. Covers initial setup and basic functionalities.

```APIDOC
RoseChat API - Getting Started:

This section provides a step-by-step guide to integrate and utilize the RoseChat API within your projects.

Key topics include:
- Installation and setup
- Basic API calls
- Authentication methods
- Example use cases
```

--------------------------------

### RoseStacker API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/resource-packs

This section provides a starting guide for the RoseStacker API, outlining initial steps for implementation.

```APIDOC
RoseStacker API - Getting Started:

Description: An introductory guide to using the RoseStacker API for managing stacked items and entities.

Key Features:
  - Stacking Mechanics: Understand how RoseStacker handles the stacking of items and potentially other game elements.
  - PlaceholderAPI Support: Information on integrating RoseStacker with PlaceholderAPI for displaying stacking information.
  - Commands & Permissions: Details on available commands and their associated permissions for managing stacking.
```

--------------------------------

### PlayerParticles API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/introduction

This documentation explains how to get started with the PlayerParticles plugin's API. It covers the initial setup and fundamental concepts for developers to integrate particle effects.

```APIDOC
PlayerParticles API Usage:
  Getting Started:
    - Provides an introduction to the PlayerParticles plugin's API for developers.
    - Covers initial setup and basic usage for implementing particle effects.
```

--------------------------------

### RoseStacker API Usage - Getting Started

Source: https://wiki.rosewooddev.io/PlayerParticles/introduction

An introductory guide for developers on how to get started with the RoseStacker API. It covers the initial steps for integrating stackable item functionalities.

```APIDOC
RoseStacker API Usage:
  Getting Started:
    - Introduction to the RoseStacker API.
    - Basic steps for integrating stackable item features.
    - Overview of core API functionalities.
```

--------------------------------

### RoseChat API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/tokens-%26-tokenizers

An introductory guide for developers on how to integrate with the RoseChat plugin's API, covering initial setup and basic functionalities for chat management.

```APIDOC
RoseChat Plugin API - Getting Started:

API Access:
  // Obtain the RoseChat API instance
  RoseChatAPI api = RoseChatAPI.getApi();

Core Features:
  // Send a formatted message to a player
  api.sendMessage(player, "&aHello, %player_name%!");

  // Get the formatted display name of a player
  String displayName = api.getDisplayName(player);

  // Check if a player is muted
  boolean isMuted = api.isMuted(player);

Parameters:
  - player: The target player object.
  - message: The string message to send, supporting color codes.

Dependencies:
  - RoseChat plugin must be installed.

Related API Sections:
  - Parsing Messages: How messages are processed.
  - Custom Channels: Creating and managing chat channels.
```

--------------------------------

### RoseChat API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/setup-guide

Details on how to get started with the RoseChat API, likely covering initialization and basic functionalities.

```APIDOC
RoseChat API Usage:
  Getting Started:
    This section guides users on how to begin integrating with the RoseChat API. It may include information on setup, authentication, and initial calls.
```

--------------------------------

### RoseLoot API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/introduction

This section provides guidance on how to get started with the RoseLoot plugin's API. It outlines the initial steps and concepts necessary for integrating with RoseLoot programmatically.

```APIDOC
RoseLoot API Usage:
  Getting Started:
    - Provides an overview of how to integrate with the RoseLoot plugin's API.
    - Covers initial setup and core concepts for programmatic interaction.
```

--------------------------------

### PlayerParticles API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/resource-packs

This section provides an introduction to the PlayerParticles API, covering initial setup and usage.

```APIDOC
PlayerParticles API - Getting Started:

Description: An introductory guide to using the PlayerParticles API for creating and managing particle effects around players.

Key Features:
  - Configuration: Details on how to configure particle effects, including types, timings, and appearance.
  - Permissions: Information on managing permissions related to particle effects.
  - PlaceholderAPI Support: How to integrate PlayerParticles with PlaceholderAPI for dynamic particle behavior based on player data.
```

--------------------------------

### RoseLoot API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/plugin-compatibility

An introductory guide for developers looking to integrate with the RoseLoot API, covering initial setup and basic functionalities.

```APIDOC
RoseLoot API Usage - Getting Started:
  - Purpose: Guide for developers to integrate with RoseLoot.
  - Setup: Initial steps and requirements for API usage.
```

--------------------------------

### PlayerPoints API - Getting Started

Source: https://wiki.rosewooddev.io/PlayerPoints/introduction

Basic information on how to start using the PlayerPoints API. This section typically covers initialization and basic usage patterns.

```APIDOC
API Usage:

Getting Started:
This section provides an overview of how to integrate with the PlayerPoints API. It typically involves obtaining an instance of the PlayerPoints API service within your plugin or application.

Example (Conceptual):
```java
// Assuming you have access to the main plugin instance
PlayerPointsAPI api = PlayerPoints.getApi();

// Get player points
int points = api.getPoints(player.getUniqueId());

// Add points
api.addPoints(player.getUniqueId(), 100);

// Remove points
api.removePoints(player.getUniqueId(), 50);
```

Refer to the Javadoc for detailed method signatures and return types.
```

--------------------------------

### RoseLoot API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/tokens-%26-tokenizers

A guide for developers on how to integrate and use the RoseLoot plugin's API. It covers initial setup and basic API calls for accessing loot functionalities.

```APIDOC
RoseLoot Plugin API - Getting Started:

Initialization:
  // Assuming 'pluginManager' is a PluginManager instance
  RoseLootAPI api = (RoseLootAPI) pluginManager.getPlugin("RoseLoot").getApi();

Core Functionality:
  // Get a loot table by its name
  LootTable lootTable = api.getLootTable("common_items");

  // Generate loot from a table
  List<ItemStack> loot = lootTable.generateLoot();

  // Add items to a player's inventory
  api.giveLoot(player, loot);

Parameters:
  - LootTable name: String identifier for the loot table.
  - Player: The target player object.
  - ItemStack: Represents an item in the game.

Dependencies:
  - Requires the RoseLoot plugin to be installed and enabled.

Related API Sections:
  - Number Providers: How to define custom item drop rates.
  - Pools & Entries: Structure of loot tables and their contents.
```

--------------------------------

### RoseLoot API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/tokens-%26-tokenizers

A guide for developers on how to integrate and use the RoseLoot plugin's API. It covers initial setup and basic API calls for accessing loot functionalities.

```APIDOC
RoseLoot Plugin API - Getting Started:

API Access:
  // Obtain the RoseLoot API instance
  RoseLootAPI api = RoseLootAPI.getApi();

Core Functionality:
  // Get a loot table by its name
  LootTable lootTable = api.getLootTable("common_items");

  // Generate loot from a table
  List<ItemStack> loot = lootTable.generateLoot();

  // Give loot directly to a player
  api.giveLoot(player, loot);

Parameters:
  - player: The target player object.
  - lootTable: The LootTable object to generate items from.
  - loot: A list of ItemStack objects to be given.

Dependencies:
  - Requires the RoseLoot plugin to be installed and enabled.

Related API Sections:
  - Number Providers: How to define custom item drop rates.
  - Pools & Entries: Structure of loot tables and their contents.
```

--------------------------------

### RoseLoot API Usage: Getting Started

Source: https://wiki.rosewooddev.io/index

This section details how to get started with the RoseLoot plugin's API. It likely covers initialization, basic usage, and common patterns for developers integrating with RoseLoot.

```APIDOC
RoseLoot API Usage:
  Getting Started:
    - Provides an entry point for developers to integrate with RoseLoot.
    - Likely includes setup instructions and basic API calls.
    - Dependencies: RoseLoot plugin installed on a Minecraft server.
```

--------------------------------

### PlayerParticles API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseStacker/introduction

This section provides a starting point for developers looking to integrate the PlayerParticles API. It covers essential steps for initial setup and usage.

```APIDOC
PlayerParticles API Usage:
  Getting Started:
    - Initial steps for developers to integrate the PlayerParticles API.
    - Covers setup, basic configuration, and common API calls.
```

--------------------------------

### RoseLoot API Usage: Getting Started

Source: https://wiki.rosewooddev.io/PlayerPoints/introduction

Provides guidance on how to get started with the RoseLoot plugin's API, enabling developers to integrate its features into their own projects.

```APIDOC
RoseLoot API Usage:
  Getting Started:
    - Link: https://wiki.rosewooddev.io/RoseLoot/getting-started/
```

--------------------------------

### PlayerPoints Introduction: Download & Installation

Source: https://wiki.rosewooddev.io/PlayerPoints/introduction

Guides users through the process of downloading and installing the PlayerPoints plugin.

```APIDOC
PlayerPoints Introduction:
  Download & Installation:
    - Link: https://wiki.rosewooddev.io/PlayerPoints/introduction/#download-installation
```

--------------------------------

### RoseChat API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/resource-packs

This section provides an introduction to using the RoseChat API, covering initial setup and core functionalities.

```APIDOC
RoseChat API - Getting Started:

Description: An introductory guide to integrating and utilizing the RoseChat API for advanced chat management and customization.

Core Features:
  - Parsing Messages: Understand how to process and interpret chat messages.
  - Tokens & Tokenizers: Learn about the system for breaking down messages into manageable components.
  - Custom Channels: Information on creating and managing unique chat channels.
  - PlaceholderAPI Support: Details on integrating with PlaceholderAPI for dynamic chat content.
  - Plugin Compatibility: Information on how RoseChat interacts with other server plugins.
```

--------------------------------

### RoseStacker API Usage Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/generic-values

A guide for developers on how to start using the RoseStacker plugin's API for item stacking functionalities.

```markdown
## API Usage

### Getting Started

This section covers the initial steps for integrating with the RoseStacker API to manage item stacking.
```

--------------------------------

### RoseStacker API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/tokens-%26-tokenizers

Instructions for developers on how to begin using the RoseStacker plugin's API, including setup and fundamental API interactions for stack manipulation.

```APIDOC
RoseStacker Plugin API - Getting Started:

API Access:
  // Obtain the RoseStacker API instance
  RoseStackerAPI api = RoseStackerAPI.getInstance();

Core Operations:
  // Get the stack size of an item in a player's inventory
  int stackSize = api.getStackSize(player, itemStack);

  // Set the stack size for an item
  api.setStackSize(player, itemStack, newSize);

  // Check if an item is stackable by RoseStacker
  boolean isStackable = api.isStackable(itemStack);

Parameters:
  - player: The player whose inventory is being accessed.
  - itemStack: The item to query or modify.
  - newSize: The desired new stack size.

Dependencies:
  - RoseStacker plugin must be installed.

Related API Sections:
  - PlaceholderAPI Support: How to use RoseStacker placeholders.
```

--------------------------------

### RoseLoot API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseStacker/introduction

Information on how to get started with the RoseLoot API. This section likely covers basic integration and usage patterns for developers.

```APIDOC
RoseLoot API Usage:
  Getting Started:
    - Provides an overview of how to integrate and use the RoseLoot API.
    - Details on initial setup and common use cases.
```

--------------------------------

### RoseLoot API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/overview

Provides guidance on how to get started with the RoseLoot plugin's API. This section is crucial for developers looking to integrate RoseLoot functionality into their own projects or create custom extensions.

```APIDOC
RoseLoot API:
  Getting Started:
    - Overview of API functionalities
    - Setup and initialization steps
    - Basic examples for common use cases
```

--------------------------------

### RoseChat API: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/introduction

This section provides an overview of how to get started with the RoseChat API, likely for developers integrating with or extending the plugin's chat functionality.

```APIDOC
RoseChat API Usage:
  Getting Started:
    - Provides an entry point for developers to integrate with RoseChat.
    - Details on how to access and utilize RoseChat's features programmatically.
    - Links to further documentation on parsing messages, tokens, and custom channels.
```

--------------------------------

### RoseStacker API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseStacker/introduction

An introductory guide to using the RoseStacker API. This section provides the necessary information to begin integrating RoseStacker's features into other projects.

```APIDOC
RoseStacker API Usage:
  Getting Started:
    - Instructions for developers to start using the RoseStacker API.
    - Covers basic setup, initialization, and core functionalities.
```

--------------------------------

### RoseStacker API Usage: Getting Started

Source: https://wiki.rosewooddev.io/PlayerPoints/introduction

Provides an introduction to the RoseStacker plugin's API, guiding developers on how to integrate its stacking functionalities.

```APIDOC
RoseStacker API Usage:
  Getting Started:
    - Link: https://wiki.rosewooddev.io/RoseStacker/getting-started/
```

--------------------------------

### RoseStacker API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/item-types

A guide to getting started with the RoseStacker API, covering initial setup and basic usage for developers.

```APIDOC
RoseStacker API Usage - Getting Started:
  - Initial setup and dependencies for RoseStacker API.
  - Core classes and methods for interacting with RoseStacker.
  - Basic examples of API calls.
```

--------------------------------

### RoseStacker API Usage

Source: https://wiki.rosewooddev.io/PlayerParticles/configuration

Guides for using the RoseStacker API, including getting started.

```APIDOC
RoseStacker API:
  Getting Started:
    - Description: Initial steps to integrate and use the RoseStacker API.
    - Provides foundational information for developers.
```

--------------------------------

### PlayerParticles API Usage: Getting Started

Source: https://wiki.rosewooddev.io/PlayerPoints/introduction

An introductory guide to using the PlayerParticles plugin's API for creating and managing custom player particle effects.

```APIDOC
PlayerParticles API Usage:
  Getting Started:
    - Link: https://wiki.rosewooddev.io/PlayerParticles/getting-started/
```

--------------------------------

### RoseStacker API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/overview

A guide to initiating the use of the RoseStacker plugin's API. This section is for developers aiming to integrate or extend RoseStacker's stacking mechanics.

```APIDOC
RoseStacker API:
  Getting Started:
    - API overview and capabilities
    - Initial setup and configuration for API access
    - Basic usage examples
```

--------------------------------

### RoseChat API Usage - Getting Started

Source: https://wiki.rosewooddev.io/PlayerParticles/introduction

An introductory guide for developers looking to use the RoseChat API. It outlines the initial steps and concepts for integrating RoseChat's messaging features.

```APIDOC
RoseChat API Usage:
  Getting Started:
    - Introduction to the RoseChat API.
    - Basic integration steps for developers.
    - Overview of core functionalities.
```

--------------------------------

### RoseLoot API: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/incompatibility

An introductory guide to the RoseLoot plugin's API, aimed at developers looking to integrate its loot generation and management features.

```APIDOC
RoseLoot API Usage:
  Getting Started:
    - Introduces the RoseLoot API for developers.
    - Covers initial setup and basic API interactions.
```

--------------------------------

### PlayerParticles API Usage: Getting Started

Source: https://wiki.rosewooddev.io/index

This section details how to get started with the PlayerParticles plugin's API. It's for developers who want to programmatically control or create particle effects for players.

```APIDOC
PlayerParticles API Usage:
  Getting Started:
    - Introduction to using the PlayerParticles API for developers.
    - Covers initial setup and basic API calls for particle management.
    - Dependencies: PlayerParticles plugin installed on a Minecraft server.
```

--------------------------------

### RoseStacker API Usage

Source: https://wiki.rosewooddev.io/RoseLoot/plugin-compatible-values

Guides and examples for using the RoseStacker API to manage entity stacking. Includes getting started information and examples of common API calls.

```APIDOC
RoseStacker API:
  - Getting Started: Provides a basic introduction to using the RoseStacker API within Minecraft plugins.
```

--------------------------------

### RoseLoot Installation Guide

Source: https://wiki.rosewooddev.io/RoseLoot/introduction

Instructions on how to install the RoseLoot plugin into a Minecraft server. This includes downloading from Spigot and placing the JAR file in the plugins directory.

```bash
1. Turn off your Minecraft server.
2. Download the RoseLoot jar file from the Spigot page.
3. Place the jar file into your server's `/plugins` folder.
4. Start your server.
5. A RoseLoot folder will be created in `/plugins/RoseLoot` containing configuration files.
```

--------------------------------

### RoseLoot API Usage

Source: https://wiki.rosewooddev.io/RoseLoot/plugin-compatible-values

Guides and examples for using the RoseLoot API to interact with loot generation and modification. Includes getting started information and examples of common API calls.

```APIDOC
RoseLoot API:
  - Getting Started: Provides a basic introduction to using the RoseLoot API within Minecraft plugins.
  - Number Providers: Explains how to use number providers for dynamic loot amounts.
  - Pools & Entries: Details the structure and usage of loot pools and entries for defining loot tables.
  - Generic Values: Describes the generic values available for conditions and modifiers.
  - Entity-Specific Values: Explains how to use entity-specific values in loot conditions and modifiers.
  - Plugin Compatible Values: Covers how to integrate RoseLoot with other plugins using compatible values.
  - Item Types: Describes the different item types that can be used in loot entries.
  - Item Meta: Explains how to modify item meta data in loot entries.
  - Custom Item Plugins: Details how to integrate custom item plugins with RoseLoot.
  - Context Placeholders: Describes the context placeholders available for dynamic loot generation.
```

--------------------------------

### RoseChat Setup Guide

Source: https://wiki.rosewooddev.io/PlayerParticles/introduction

A step-by-step guide on how to set up and configure the RoseChat plugin on a Minecraft server.

```APIDOC
RoseChat Setup Guide:
  1. Download the RoseChat plugin JAR file.
  2. Place the JAR file into your server's plugins folder.
  3. Start or reload your server.
  4. Configure settings in config.yml and formats.yml.
```

--------------------------------

### RoseStacker API Usage - Getting Started

Source: https://wiki.rosewooddev.io/PlayerPoints/getting-started

This section covers the initial steps for using the RoseStacker API, providing a starting point for developers to integrate its functionality.

```APIDOC
RoseStacker API Usage:
  Getting Started: An introductory guide to using the RoseStacker API for plugin development.
```

--------------------------------

### RoseChat API Usage

Source: https://wiki.rosewooddev.io/RoseLoot/plugin-compatible-values

Guides and examples for using the RoseChat API to customize chat formatting and functionality. Includes getting started information, message parsing, tokenization, and custom channel creation.

```APIDOC
RoseChat API:
  - Getting Started: Provides a basic introduction to using the RoseChat API within Minecraft plugins.
  - Parsing Messages: Explains how to parse chat messages using the RoseChat API.
  - Tokens & Tokenizers: Details the usage of tokens and tokenizers for advanced message formatting.
  - Custom Channels: Describes how to create and manage custom chat channels using the API.
```

--------------------------------

### RoseStacker API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/introduction

This section provides an introduction to using the RoseStacker plugin's API. It covers the initial steps and essential information for developers to begin integrating with RoseStacker.

```APIDOC
RoseStacker API Usage:
  Getting Started:
    - Offers a guide for developers to start using the RoseStacker plugin's API.
    - Includes initial setup instructions and core concepts for API interaction.
```

--------------------------------

### PlayerParticles API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/item-types

A guide for developers on how to start using the PlayerParticles API to create and manage particle effects programmatically.

```APIDOC
PlayerParticles API Usage - Getting Started:
  - Setup instructions for the PlayerParticles API.
  - Core classes and methods for particle manipulation.
  - Basic examples of creating and displaying particles via API.
```

--------------------------------

### RoseLoot API Usage

Source: https://wiki.rosewooddev.io/PlayerParticles/configuration

Guides for using the RoseLoot API, including getting started.

```APIDOC
RoseLoot API:
  Getting Started:
    - Description: Initial steps to integrate and use the RoseLoot API.
    - Provides foundational information for developers.
```

--------------------------------

### PlayerParticles API Usage - Getting Started

Source: https://wiki.rosewooddev.io/PlayerParticles/introduction

Provides an introduction to using the PlayerParticles API. This section likely covers the initial steps for developers to integrate PlayerParticles functionality into their own projects or plugins.

```APIDOC
PlayerParticles API Usage:
  Getting Started:
    - Introduction to the PlayerParticles API.
    - Basic steps for integration.
    - Links to further documentation (Javadoc, Object Descriptions).
```

--------------------------------

### RoseStacker API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/plugin-compatibility

A starting guide for developers interested in using the RoseStacker API, outlining the initial steps for integration and basic usage.

```APIDOC
RoseStacker API Usage - Getting Started:
  - Purpose: Introduction to RoseStacker API integration.
  - Initial Steps: Basic setup and usage instructions for developers.
```

--------------------------------

### Gradle Dependency Setup

Source: https://wiki.rosewooddev.io/PlayerPoints/getting-started

This snippet shows how to configure your Gradle project to include the PlayerPoints library. It specifies the repository to fetch the dependency from and the dependency declaration itself. Ensure you replace `$VERSION$` with the actual version of PlayerPoints you are using.

```gradle
repositories {
    maven {
        url='https://repo.rosewooddev.io/repository/public/'
    }
}

dependencies {
    compile'org.black_ixx:playerpoints:$VERSION$'
}
```

--------------------------------

### PlayerParticles API Usage

Source: https://wiki.rosewooddev.io/PlayerParticles/configuration

Guides for using the PlayerParticles API, including getting started and Javadoc.

```APIDOC
PlayerParticles API:
  Getting Started:
    - Description: Initial steps to integrate and use the PlayerParticles API.
    - Provides foundational information for developers.
  Javadoc:
    - Description: Link to the Javadoc documentation for the PlayerParticles API.
    - Offers detailed technical documentation for developers.
```

--------------------------------

### PlayerParticles API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/plugin-compatibility

Provides a starting point for developers wanting to use the PlayerParticles API, covering essential setup and initial integration steps.

```APIDOC
PlayerParticles API Usage - Getting Started:
  - Purpose: Guide for integrating with the PlayerParticles API.
  - Setup: Initial configuration and basic usage for developers.
```

--------------------------------

### PlayerParticles Installation (Spigot)

Source: https://wiki.rosewooddev.io/PlayerParticles/introduction

Instructions for installing the PlayerParticles plugin from Spigot. This involves downloading the JAR file and placing it in the server's plugins folder.

```text
1. Turn off your server.
2. Download the PlayerParticles JAR file from the Spigot page.
3. Place the JAR file into your server's `/plugins` folder.
4. Start your server.
5. A PlayerParticles folder will be created in `/plugins/PlayerParticles` containing configuration files.
```

--------------------------------

### RoseLoot API Usage

Source: https://wiki.rosewooddev.io/PlayerParticles/permissions

Guides for using the RoseLoot plugin's API, including getting started with its functionalities.

```APIDOC
RoseLoot API Usage:
  Getting Started: Provides an introduction to integrating and using the RoseLoot API.
```

--------------------------------

### PlayerParticles API Usage

Source: https://wiki.rosewooddev.io/RoseLoot/number-providers

Guides users on how to use the PlayerParticles API, including getting started, Javadoc, and object descriptions.

```en
Getting Started
Javadoc
Object Descriptions
```

--------------------------------

### RoseLoot API Usage

Source: https://wiki.rosewooddev.io/RoseLoot/context-placeholders

Guide for integrating with the RoseLoot plugin's API. Covers getting started with API usage.

```APIDOC
RoseLoot API Usage:

Getting Started:
  - Instructions on how to begin using the RoseLoot API.
```

--------------------------------

### RoseStacker API Usage

Source: https://wiki.rosewooddev.io/RoseLoot/context-placeholders

Guide for using the RoseStacker plugin's API, including getting started and PlaceholderAPI support.

```APIDOC
RoseStacker API Usage:

Getting Started:
  - Instructions for beginning with the RoseStacker API.

PlaceholderAPI Support:
  - Information on PlaceholderAPI integration with RoseStacker.
```

--------------------------------

### PlayerPoints Plugin Alternative Installation (Gradle)

Source: https://wiki.rosewooddev.io/PlayerPoints/introduction

Details on how to compile the PlayerPoints plugin from source using Gradle. This is an advanced method for users who wish to build the plugin themselves.

```text
1. Clone the PlayerPoints project from GitHub.
2. Ensure you have Gradle installed.
3. Navigate to the project's root directory in your terminal.
4. Run the command: `./gradlew build`
5. The compiled plugin JAR file will be located in the `./build/libs` directory.
```

--------------------------------

### RoseStacker API: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/incompatibility

An introductory guide for developers on how to use the RoseStacker plugin's API for managing stacked items.

```APIDOC
RoseStacker API Usage:
  Getting Started:
    - Provides an introduction to the RoseStacker API.
    - Outlines the initial steps for developers to use the API.
```

--------------------------------

### RoseChat API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/overview

Details on how to begin using the RoseChat plugin's API. This documentation is intended for developers who want to leverage RoseChat's features programmatically.

```APIDOC
RoseChat API:
  Getting Started:
    - Introduction to the API
    - Core components and their roles
    - Initial setup for API interaction
```

--------------------------------

### PlayerPoints API Usage - Getting Started

Source: https://wiki.rosewooddev.io/RoseLoot/item-types

A guide for developers on how to begin using the PlayerPoints API to manage player points programmatically.

```APIDOC
PlayerPoints API Usage - Getting Started:
  - Initial setup and dependencies for PlayerPoints API.
  - Core classes and methods for point management.
  - Basic examples of API calls for point operations.
```

--------------------------------

### RoseLoot API Usage: Getting Started

Source: https://wiki.rosewooddev.io/RoseChat/plugin-support

An introductory guide for developers on how to utilize the RoseLoot API for integrating loot systems into their projects.

```APIDOC
RoseLoot API Usage:

Getting Started:
  - Initial steps and setup for using the RoseLoot API.
```
Tokens:
Raw