### Riot Games API: Game Client API - Insecure CURL Example

Source: https://developer.riotgames.com/docs/lol/index

An example using CURL to access the Game Client API locally, ignoring SSL certificate errors. This is useful for testing and development when dealing with self-signed certificates.

```bash
curl --insecure https://127.0.0.1:2999/swagger/v3/openapi.json
```

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

### Data Dragon Champion List

Source: https://developer.riotgames.com/docs/lol/index

Fetches a JSON file containing a list of all champions with brief summaries. This is useful for getting an overview of available champions.

```APIDOC
GET https://ddragon.leagueoflegends.com/cdn/{version}/data/{language}/champion.json

Example:
GET https://ddragon.leagueoflegends.com/cdn/15.16.1/data/en_US/champion.json
```

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

### Item Effect Amount Example

Source: https://developer.riotgames.com/docs/lol/index

Demonstrates how specific item effects are represented in the 'effect' field of item data. 'Effect1Amount' in this example shows the value for damage blocked by Doran's Shield.

```json
"effect": {
  "Effect1Amount": "8"
}
```

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

### Riot Games API Key Use Cases

Source: https://developer.riotgames.com/docs/lol/index

Differentiates between production and personal API keys, outlining the criteria and examples for approved use cases for each, as well as detailing unapproved use cases.

```APIDOC
Game Policy - Use Cases:

Production Keys:
  - Meant for larger-size, professional projects.
  - Evaluation factors: Use case approval, developer's ability to deliver.
  - Demonstrating use case requires:
    - Established brand adding Riot Games to portfolio.
    - Fully functional and testable new app.
    - Mostly testable prototype.
    - Mockups showing intent and user flow.
    - Deck showing ambition, intent, and user flow.
  - Riot needs to see user flow (account creation, login, queuing).
  - Must provide link to working site, mockup, prototype, or rendering.

Personal Keys:
  - Meant for smaller-size, personal projects.
  - Examples of Approved Use Cases:
    - Personal sites.
    - School projects.
    - Proof of concept for Production Key request.
    - Showing (self) player stats.
    - Running tournaments.
    - Training tools (view own match histories, aggregate stats).
    - Looking For Game (LFG) tools.
    - Game overlays (static data pre-game).
    - Aggregate player stats (no specific players).
    - Official Ladder Leaderboards.

Unapproved Use Cases:
  - Displaying win rates for Augments or Arena Mode items.
  - Providing game-session-specific information unknown to the player.
  - Apps that dictate player decisions.
  - Violating general game policies.
  - Publicly displaying custom match history unless player opts in (League of Legends specific).
  - Custom match data only available to player via RSO.
```

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

### Replay API Endpoints

Source: https://developer.riotgames.com/docs/lol/index

Provides an overview of the Replay API endpoints for controlling replay functionality, including getting game information, managing playback, rendering, and recording.

```APIDOC
GET https://127.0.0.1:2999/replay/game
Information about the game client process.
```

```APIDOC
GET https://127.0.0.1:2999/replay/playback
Returns the current replay playback state such as pause and current time.
```

```APIDOC
POST https://127.0.0.1:2999/replay/playback
Allows modifying the playback state such as play/pause and the game time to seek to. All values are optional.
```

```APIDOC
GET https://127.0.0.1:2999/replay/render
Returns the current render properties.
```

```APIDOC
POST https://127.0.0.1:2999/replay/render
Allows modifying the current render properties. All values are optional.
```

```APIDOC
GET https://127.0.0.1:2999/replay/recording
Returns the current status of video recording. Poll this resource for progress on the output.
```

```APIDOC
POST https://127.0.0.1:2999/replay/recording
Post to begin a recording specifying the codec and output filepath. Subsequent GET requests to this resource will update the status.
```

```APIDOC
GET https://127.0.0.1:2999/replay/sequence
Returns the sequence currently being applied.
```

```APIDOC
POST https://127.0.0.1:2999/replay/sequence
Post to apply a sequence of keyframes that the replay should play. Post an empty object to remove the sequence.
```

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

### Active Player Runes

Source: https://developer.riotgames.com/docs/lol/index

Retrieves the complete rune setup for the active player, including primary and secondary rune trees, keystone, and stat runes.

```APIDOC
GET https://127.0.0.1:2999/liveclientdata/activeplayerrunes
Description: Retrieve the full list of runes for the active player.
Response Body Example:
{
    "keystone": {
        "displayName": "Electrocute",
        "id": 8112,
        "rawDescription": "perk_tooltip_Electrocute",
        "rawDisplayName": "perk_displayname_Electrocute"
    },
    "primaryRuneTree": {
        "displayName": "Domination",
        "id": 8100,
        "rawDescription": "perkstyle_tooltip_7200",
        "rawDisplayName": "perkstyle_displayname_7200"
    },
    "secondaryRuneTree": {
        "displayName": "Sorcery",
        "id": 8200,
        "rawDescription": "perkstyle_tooltip_7202",
        "rawDisplayName": "perkstyle_displayname_7202"
    },
    "generalRunes": [
        {
            "displayName": "Electrocute",
            "id": 8112,
            "rawDescription": "perk_tooltip_Electrocute",
            "rawDisplayName": "perk_displayname_Electrocute"
        },
        ...
    ],
    "statRunes": [
        {
            "id": 5007,
            "rawDescription": "perk_tooltip_StatModCooldownReductionScaling"
        },
        {
            "id": 5008,
            "rawDescription": "perk_tooltip_StatModAdaptive"
        },
        {
            "id": 5003,
            "rawDescription": "perk_tooltip_StatModMagicResist"
        }
    ]
}
```

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

### Riot Games Tournament API

Source: https://developer.riotgames.com/docs/lol/index

Covers the Tournament API for creating and managing tournaments. Includes best practices, API notes, use case examples, methods for generating tournament codes, server callbacks, and lobby events.

```APIDOC
Tournament API:
  - Best Practices: Recommendations for using the Tournament API effectively.
  - Tournament API Notes: Important considerations and updates.
  - Use Case Example: A practical example of using the API.
  - Tournaments API Methods:
    - Generating Tournament Codes: Functionality to create unique tournament codes.
    - Server Callback: Setting up callbacks for tournament events.
    - Lobby Events: Handling events related to tournament lobbies.
```

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

### League of Legends Game Modes

Source: https://developer.riotgames.com/docs/lol/index

Lists available game modes with their descriptions. For example, 'CLASSIC' covers Summoner's Rift and Twisted Treeline.

```json
[
  {
    "gameMode": "CLASSIC",
    "description": "Classic Summoner's Rift and Twisted Treeline games"
  },
  ...
]
```

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

### Riot Games API: Live Client Data API - Get All Game Data

Source: https://developer.riotgames.com/docs/lol/index

Endpoint to retrieve all available data during an active game. While useful for testing, it's recommended to use more specific endpoints for targeted data retrieval to improve efficiency.

```APIDOC
GET https://127.0.0.1:2999/liveclientdata/allgamedata
  Description: Get all available live game data.
  Returns:
    - A comprehensive JSON object containing all game and player data.
  Note:
    - A sample response can be found at: https://static.developer.riotgames.com/docs/lol/liveclientdata_sample.json
```

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

### Sample Server Callback JSON Payload

Source: https://developer.riotgames.com/docs/lol/index

This JSON object represents the data structure that League of Legends servers send in the HTTP POST request to a tournament provider's registered URL when a game has completed. It contains information such as the game's start time, a short code, metadata, game ID, game name, type, map, mode, and region.

```json
{
  "startTime": 1234567890000,
  "shortCode": "NA1234a-1a23b456-a1b2-1abc-ab12-1234567890ab",
  "metaData": "{\"title\":\"Game 42 - Finals\"}",
  "gameId": 1234567890,
  "gameName": "a123bc45-ab1c-1a23-ab12-12345a67b89c",
  "gameType": "Practice",
  "gameMap": 11,
  "gameMode": "CLASSIC",
  "region": "NA1"
}
```

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

### Riot Games API: Get Lobby Events by Tournament Code

Source: https://developer.riotgames.com/docs/lol/index

Retrieves pre-game lobby events for a given tournament code. This is useful for tournament administration systems to track game start and player activity. The data includes timestamps, event types, and summoner IDs.

```APIDOC
GET /lobby-events/by-code/{tournamentCode}
  Description: Query pre-game lobby events.
  Parameters:
    - tournamentCode (string): The unique code for the tournament.
  Returns:
    - eventList (array): A list of lobby events, each with timestamp, eventType, and summonerId.
  Example Response:
    {
      "eventList": [
        {
          "timestamp": "1234567890000",
          "eventType": "PracticeGameCreatedEvent",
          "summonerId": "12345678"
        },
        {
          "timestamp": "1234567890000",
          "eventType": "PlayerJoinedGameEvent",
          "summonerId": "12345678"
        }
      ]
    }
```

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

### Get Current Player Account Info

Source: https://developer.riotgames.com/docs/lol/index

Retrieves the logged-in player's account details using an access token. Supports requests to different regional clusters (Americas, Europe, Asia).

```curl
curl --location --request GET 'https://americas.api.riotgames.com/riot/account/v1/accounts/me' --header 'Authorization: Bearer {accessToken}'
curl --location --request GET 'https://europe.api.riotgames.com/riot/account/v1/accounts/me' --header 'Authorization: Bearer {accessToken}'
curl --location --request GET 'https://asia.api.riotgames.com/riot/account/v1/accounts/me' --header 'Authorization: Bearer {accessToken}'
```

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

### RSO Integration Process

Source: https://developer.riotgames.com/docs/lol/index

Explains Riot Sign On (RSO) integration, which allows players to link their Riot Account to other applications, and details the prerequisite of obtaining a production key.

```APIDOC
RSO Integration:
  - Riot Sign On (RSO) allows players to safely link their Riot Account to other applications.
  - Access is only available to developers with Production Level API Keys.

Getting a Production Key:
  - Prerequisite for RSO integration.
  - Create a key at https://developer.riotgames.com after reading policies.
  - Riot will contact developers via in-app messaging upon approval to initiate RSO integration.
```

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

### Enable Replay API Configuration

Source: https://developer.riotgames.com/docs/lol/index

Instructions on how to enable the Replay API by modifying the game client's configuration file. This involves adding a specific line to the `game.cfg` file.

```cfg
[General]
EnableReplayApi=1
```

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

### Riot Games RSO Integration

Source: https://developer.riotgames.com/docs/lol/index

Explains the Riot Single Sign-On (RSO) integration process for developers. Covers obtaining a production key and implementing RSO for user authentication within applications.

```APIDOC
RSO Integration:
  - Getting a Production Key: Steps to acquire a production API key for RSO.
  - Implementing RSO: Guidance on integrating RSO into applications for authentication.
```

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

### Tournaments API Methods Overview

Source: https://developer.riotgames.com/docs/lol/index

This section provides an overview of the available methods in the Tournaments API. For detailed information on parameters, usage, and return values, refer to the official API Reference page.

```APIDOC
Tournaments API Methods:

- Access to the Tournaments API provides several new methods that can be viewed on the [API Reference page](https://developer.riotgames.com/apis).
- Explore every method to get more information on actual usage including the format and description of parameters you can supply.
- See the diagram below for a full overview of all methods and their functionality:
```

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

### Mimic Server Callback with cURL

Source: https://developer.riotgames.com/docs/lol/index

This snippet demonstrates how to use cURL to simulate the HTTP POST request that League of Legends servers send to a tournament provider's callback URL when a game finishes. It includes setting the callback URL, the HTTP method, the content type, and the request body.

```bash
curl <callback_url> -X POST -H "Content-Type: application/json" -d '<response_body>'
```

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

### Data Dragon Asset and Version Information

Source: https://developer.riotgames.com/docs/lol/index

Provides links to download League of Legends game data and assets from Data Dragon, including compressed tarballs for different patches and a versions file for checking Data Dragon build compatibility.

```APIDOC
Data Dragon Latest Download:
https://ddragon.leagueoflegends.com/cdn/dragontail-15.16.1.tgz

Data Dragon Patch 10.10 Download (ZIP format):
https://ddragon.leagueoflegends.com/cdn/dragontail-10.10.5.zip

Data Dragon Versions File:
https://ddragon.leagueoflegends.com/api/versions.json

Data Dragon Realms File (e.g., NA region):
https://ddragon.leagueoflegends.com/realms/na.json
```

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

### Interpreting Champion Spell Tooltips

Source: https://developer.riotgames.com/docs/lol/index

Explains how to interpret placeholders within champion spell tooltips. Placeholders like {{ eN }} and {{ aN }}/{{ fN }} are used to represent dynamic values.

```javascript
// Example of {{ eN }} placeholder interpretation
/* Amumu's Bandage Toss */
"tooltip": "Launches a bandage in a direction. If it hits an enemy unit, Amumu pulls himself to them, dealing {{ e1 }} <scaleAP>(+{{ a1 }})</scaleAP> magic damage and stunning for {{ e2 }} second.",
"effectBurn": [
  null,
  "80/130/180/230/280",
  "1",
  "1350",
  ...
]

// Example of {{ aN }} or {{ fN }} placeholder interpretation
/* Amumu's Bandage Toss */
"tooltip": "Launches a bandage in a direction. If it hits an enemy unit, Amumu pulls himself to them, dealing {{ e1 }} <scaleAP>(+{{ a1 }})</scaleAP> magic damage and stunning for {{ e2 }} second.",
"vars": [
  {
    "key": "a1",
    "link": "spelldamage",
    "coeff": [
      0.7
    ]
  }
]
```

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

### Riot Games League Client API

Source: https://developer.riotgames.com/docs/lol/index

Information regarding the League Client API, which allows interaction with the League of Legends client. Includes details on accessing game client functionalities.

```APIDOC
League Client API:
  - Game Client API: Accessing functionalities within the game client.
    - Root Certificate/SSL Errors: Troubleshooting common SSL and certificate issues.
```

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

### Generating Tournament Codes Workflow

Source: https://developer.riotgames.com/docs/lol/index

This outlines the step-by-step process for generating tournament codes using the Tournaments API. It involves registering a provider, creating a tournament, and then generating codes with specific game settings.

```APIDOC
Generating Tournament Codes:

1. Use `/lol/tournament/v5/providers` API endpoint to register as a provider in specific region while also setting a URL to be used for receiving game results notifications (HTTP POST). Returns providerID.
2. Use `providerID` to register a tournament for given Tournament Provider. Receive `tournamentID` in return.
3. Use `tournamentID` to generate one or more tournament codes for a given tournament using specific game settings, such as map, spectator rules, or pick type.
   - A tournament code should only be used to create a single match. If you reuse a tournament code, the server callback will not return stats for each match.
   - The method to generate tournament codes will return up to 1,000 tournament codes at a time. If needed, additional calls to this method can be made to create additional tournament codes.
   - Stale or unused tournament codes may be purged after a period of inactivity.
```

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

### Champion Ability Asset Filename

Source: https://developer.riotgames.com/docs/lol/index

Explains how to find the filename for a champion's ability icons. The 'full' field within the 'image' object in the 'spells' array of a champion's data file provides the asset's filename.

```json
/* Anivia (id: 34) */
"spells": [
  {
    "id": "FlashFrost",
    "name": "Flash Frost",
    "description": "Anivia brings her wings together and summons a sphere of ice that flies towards her opponents, chilling and damaging anyone in its path. When the sphere explodes it does moderate damage in a radius, stunning anyone in the area.",
    "image": {
      "full": "FlashFrost.png",
      "sprite": "spell0.png",
      "group": "spell",
      "x": 192,
      "y": 144,
      "w": 48,
      "h": 48
    }
  },
  ...
```

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

### League of Legends Game Types

Source: https://developer.riotgames.com/docs/lol/index

Details the different game types, such as 'CUSTOM_GAME', with corresponding descriptions.

```json
[
  {
    "gameType": "CUSTOM_GAME",
    "description": "Custom games"
  },
  ...
]
```

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

### League of Legends Queue IDs

Source: https://developer.riotgames.com/docs/lol/index

Lists Queue IDs used to specify the type of match played. Includes queue ID, map, description, and notes. Note the distinction between ARURF and Pick URF.

```json
[
  {
    "queueId": 0,
    "map": "Custom games",
    "description": null,
    "notes": null
  },
  ...
]
```

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

### Riot Games API: Game Client API - Swagger/OpenAPI Specs

Source: https://developer.riotgames.com/docs/lol/index

URLs to retrieve the Swagger v2 and OpenAPI v3 specifications for the Game Client API. These specs define the available endpoints and data structures for interacting with the game client locally.

```APIDOC
Swagger v2 Spec:
  URL: https://127.0.0.1:2999/swagger/v2/swagger.json

OpenAPI v3 Spec:
  URL: https://127.0.0.1:2999/swagger/v3/openapi.json
```

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

### Stat Naming Conventions

Source: https://developer.riotgames.com/docs/lol/index

Explains the naming conventions for in-game statistics, including modifiers, rune-specific stats, and how flat vs. percentage stats are calculated and displayed. It also notes stacking behavior for certain stats like Tenacity.

```text
Mod stands for modifier.
An "r" at the beginning of the stat means those stats can be found on runes.
Displaying flat vs. percentage vs. per 5 etc. is case-by-case. it will always be the same for a given stat. For example, PercentAttackSpeedMod will always be multiplied by 100 and displayed it as a percentage.
Stats are called flat if you add them together, and percent if you multiply them together.
Tenacity from an item does NOT stack but tenacity from a rune DOES stack.
```

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

### Tournament API Overview

Source: https://developer.riotgames.com/docs/lol/index

Details the functionality of the Tournament API, which allows developers to manage custom game lobbies for tournaments. It covers registering providers, generating tournament codes, receiving game results via callbacks, and querying match data.

```APIDOC
Tournament API:

Functionality:
1. Register tournament providers and tournaments in a specific region/shard and its callback URL.
2. Generate tournament codes for a given tournament.
3. Receive game results via automatic callback (HTTP POST) from League of Legends servers upon game completion.
4. Use match identifier (matchID) from callbacks to retrieve full stats for a match.
5. Retrieve end-of-game data using a tournament code if a callback is missed.
6. Query pre-game lobby player activity events for a specific tournament code.

Key Concepts:
- Tournament Codes: Facilitate quick and easy player entry into private custom game lobbies with preset settings.
- Callbacks: Automatic HTTP POST requests to a specified URL upon completion of a tournament code-enabled game, containing results.
```

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

### Riot Games API Policy Overview

Source: https://developer.riotgames.com/docs/lol/index

This section details the core principles and restrictions for developers working with Riot Games APIs. It covers legal compliance, intellectual property usage, and prohibited product types.

```APIDOC
Developer API Policy:

General and Game Policies:
  - Developers must adhere to general and game-specific policies.
  - Compliance with Terms of Use and Legal Notices is mandatory.

Prohibited Actions:
  - Violating laws.
  - Creating games using Riot's Intellectual Property (IP) without authorization.
  - Implementing cryptocurrencies or blockchain features.
  - Acting as a data broker between Riot's API and third parties.
  - Creating products that closely resemble Riot's games in style or function.

Permitted IP Assets:
  - Press kit assets (e.g., logos, trademarks) must be used minimally and only when essential for product value.
  - Game-Specific static data.

Required Legal Boilerplate:
  - Products must display: "[Your Product Name] is not endorsed by Riot Games and does not reflect the views or opinions of Riot Games or anyone officially involved in producing or managing Riot Games properties. Riot Games and all associated properties are trademarks or registered trademarks of Riot Games, Inc."

Registration:
  - Products serving players must be registered, with descriptions and metadata kept up-to-date.

Monetization:
  - Prohibited:
    - Betting or gambling functionality.
  - Requirements:
    - Product must be registered and have 'Approved' or 'Acknowledged' status.
    - Must include a free tier (can include advertising).
    - Content must be transformative if charging players.
      - Transformative value: Adding new information, aesthetics, insights, or understandings.
  - Acceptable Monetization Methods:
    - Subscriptions, donations, crowdfunding.
    - Entry fees for tournaments.
    - Currencies not exchangeable back into fiat.
  - Restrictions:
    - Monetization cannot gouge players or be unfair, as determined by Riot.
    - Contact Riot Games via the Developer Portal for monetization platform approval.

Security:
  - Account Sharing:
    - Do not share Riot Games account information.
  - API Key Usage:
    - Do not use a Production API key for multiple projects; one product per key.
    - Use SSL/HTTPS when accessing APIs to protect API keys.
    - API keys must not be included in distributed binaries.
    - Share API keys only with teammates, preferably through group ownership in the Developer Portal.
```

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

### Active Player Abilities

Source: https://developer.riotgames.com/docs/lol/index

Fetches detailed information about the active player's abilities, including their level, display name, internal ID, and raw descriptions.

```APIDOC
GET https://127.0.0.1:2999/liveclientdata/activeplayerabilities
Description: Get Abilities for the active player.
Response Body Example:
{
    "E": {
        "abilityLevel": 0,
        "displayName": "Molten Shield",
        "id": "AnnieE",
        "rawDescription": "GeneratedTip_Spell_AnnieE_Description",
        "rawDisplayName": "GeneratedTip_Spell_AnnieE_DisplayName"
    },
    "Passive": {
        "displayName": "Pyromania",
        "id": "AnniePassive",
        "rawDescription": "GeneratedTip_Passive_AnniePassive_Description",
        "rawDisplayName": "GeneratedTip_Passive_AnniePassive_DisplayName"
    },
    "Q": {
        "abilityLevel": 0,
        "displayName": "Disintegrate",
        "id": "AnnieQ",
        "rawDescription": "GeneratedTip_Spell_AnnieQ_Description",
        "rawDisplayName": "GeneratedTip_Spell_AnnieQ_DisplayName"
    },
    "R": {
        "abilityLevel": 0,
        "displayName": "Summon: Tibbers",
        "id": "AnnieR",
        "rawDescription": "GeneratedTip_Spell_AnnieR_Description",
        "rawDisplayName": "GeneratedTip_Spell_AnnieR_DisplayName"
    },
    "W": {
        "abilityLevel": 0,
        "displayName": "Incinerate",
        "id": "AnnieW",
        "rawDescription": "GeneratedTip_Spell_AnnieW_Description",
        "rawDisplayName": "GeneratedTip_Spell_AnnieW_DisplayName"
    }
}
```

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

### All Players List

Source: https://developer.riotgames.com/docs/lol/index

Retrieves a list of all players currently in the game, including their champion, level, position, items, and other relevant statistics.

```APIDOC
GET https://127.0.0.1:2999/liveclientdata/playerlist
Description: Retrieve the list of heroes in the game and their stats.
Response Body Example:
[
    {
        "championName": "Annie",
        "isBot": false,
        "isDead": false,
        "items": [...],
        "level": 1,
        "position": "MIDDLE",
        "rawChampionName": "game_character_displayname_Annie",
        "respawnTimer": 0.0,
        "runes": {...},
        "scores": {...},
        "skinID": 0,
        "summonerName": "Riot Tuxedo",
        "riotId": "Riot Tuxedo#TXC1",
        "riotIdGameName": "Riot Tuxedo",
        "riotIdTagLine": "TXC1",
        "summonerSpells": {...},
        "team": "ORDER"
    },
    ...
]
```

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

### Riot Games API: Player Identification Transition

Source: https://developer.riotgames.com/docs/lol/index

Details the transition from Summoner Names to Riot IDs for player identification in League of Legends and Teamfight Tactics. Explains how to update applications to use Riot IDs (game name + tag line) and recommends using PUUID or summonerID for filtering player data.

```APIDOC
Deprecated Endpoints:
  - GET /lol/summoner/v4/summoners/by-name/{summonerName}
  - GET /tft/summoner/v1/summoners/by-name/{summonerName}
  (These endpoints are deprecated but can still be used to convert Summoner Names to PUUID or summonerID. Discouraged for future use.)

Obtaining PUUID and summonerID from Riot ID:
  - ACCOUNT-V1: GET /riot/account/v1/accounts/by-riot-id/{gameName}/{tagLine}
    (Retrieves PUUID using game name and tag line.)
  - SUMMONER-V4: GET /lol/summoner/v4/summoners/by-puuid/{encryptedPUUID}
    (Retrieves summoner data, including summonerID, by PUUID.)

Obtaining Riot ID from PUUID:
  - ACCOUNT-V1: GET /riot/account/v1/accounts/by-puuid/{puuid}
    (Fetches account information (gameName + tagLine) by PUUID.)

Obtaining Riot ID from summonerID:
  - SUMMONER-V4: GET /lol/summoner/v4/summoners/{encryptedSummonerId}
    (Retrieves summoner data by summonerID, which can be used to obtain the corresponding PUUID.)
```

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

### Champion Spell Costs

Source: https://developer.riotgames.com/docs/lol/index

Demonstrates how spell costs (mana, energy, health) are represented in champion data. Mana/energy costs are in 'cost' and 'costBurn', while health costs are in 'effect' and 'effectBurn'. The 'resource' field indicates the type of cost.

```json
/* Soraka's Astral Infusion */
"resource": "10% Max Health, {{ cost }} Mana",
"cost": [ 20, 25, 30, 35, 40 ],
"costBurn": "20/25/30/35/40"
```

```json
/* Shen's Vorpal Blade */
"resource": "{{ cost }} Energy",
"cost": [ 60, 60, 60, 60, 60 ],
"costBurn": "60"
```

```json
/* Dr. Mundo's Infected Cleaver */
"resource": "{{ e3 }} Health",
"cost": [ 0, 0, 0, 0, 0 ],
"costBurn": "0",
"effect": [
  null,
  [ 80, 130, 180, 230, 280 ],
  [ 15, 18, 21, 23, 25 ],
  [ 50, 60, 70, 80, 90 ],
  [ 40, 40, 40, 40, 40 ],
  [ 2, 2, 2, 2, 2 ]
],
"effectBurn": [
  "",
  "80/130/180/230/280",
  "15/18/21/23/25",
  "50/60/70/80/90",
  "40",
  "2"
]
```

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

### Riot Games API Policy and Registration

Source: https://developer.riotgames.com/docs/lol/index

Details the developer API policy for Riot Games, including registration requirements, monetization guidelines, security measures, and game integrity principles. It outlines the terms of use for accessing and utilizing Riot Games' developer APIs.

```APIDOC
Developer API Policy:
  - Registration: Process for obtaining developer access.
  - Monetization: Guidelines for monetizing applications using Riot Games APIs.
  - Security: Best practices for securing API keys and user data.
  - Game Integrity: Rules to maintain fair play and game balance.
  - Tournament Policies: Specific rules for tournament-related API usage.
```

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

### Data Dragon Individual Champion Data

Source: https://developer.riotgames.com/docs/lol/index

Retrieves detailed static data for a specific champion, including lore, tips, stats, and spells. The URL requires the champion's name.

```APIDOC
GET https://ddragon.leagueoflegends.com/cdn/{version}/data/{language}/champion/{ChampionName}.json

Example:
GET https://ddragon.leagueoflegends.com/cdn/15.16.1/data/en_US/champion/Aatrox.json
```

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

### Summoner Names to Riot IDs Conversion

Source: https://developer.riotgames.com/docs/lol/index

Explains the process of converting summoner names to Riot IDs, including obtaining PUUID and summonerID from a Riot ID, and vice versa. Covers handling summoner names after migration.

```APIDOC
Summoner Names to Riot IDs:
  - Obtaining PUUID and summonerID from RiotID: Details the API calls or methods to retrieve unique identifiers.
  - Obtaining Riot ID from PUUID: How to get Riot ID using the PUUID.
  - Obtaining Riot ID from summonerID: How to get Riot ID using the summonerID.
  - Summoner Names Post Migration: Information on how summoner names are handled after system updates.
```

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

### Data Dragon Languages File

Source: https://developer.riotgames.com/docs/lol/index

Retrieves a list of all supported languages for Data Dragon localized files. This JSON file contains language codes and their corresponding language names.

```APIDOC
GET https://ddragon.leagueoflegends.com/cdn/languages.json

Response Body:
[
  "cs_CZ",
  "el_GR",
  "pl_PL",
  "ro_RO",
  "hu_HU",
  "en_GB",
  "de_DE",
  "es_ES",
  "it_IT",
  "fr_FR",
  "ja_JP",
  "ko_KR",
  "es_MX",
  "es_AR",
  "pt_BR",
  "en_US",
  "en_AU",
  "ru_RU",
  "tr_TR",
  "ms_MY",
  "en_PH",
  "en_SG",
  "th_TH",
  "vi_VN",
  "id_ID",
  "zh_MY",
  "zh_CN",
  "zh_TW"
]
```

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

### Champion Passive Asset Filename

Source: https://developer.riotgames.com/docs/lol/index

Shows how to retrieve the filename for a champion's passive ability icon. The 'full' field within the 'passive.image' object in the champion's data file contains the asset's filename.

```json
/* Anivia (id: 34) */
"passive": {
  "name": "Rebirth",
  "description": "Upon dying, Anivia will revert into an egg. If the egg can survive for six seconds, she is gloriously reborn.",
  "image": {
    "full": "Anivia_P.png",
    "sprite": "passive0.png",
    "group": "passive",
    "x": 240,
    "y": 0,
    "w": 48,
    "h": 48
    }
  }
```

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

### Summoner Name Migration

Source: https://developer.riotgames.com/docs/lol/index

Details the temporary accessibility of Summoner Names endpoints post-migration, the assignment of random UUIDs for new summoners, and advises developers to refactor applications to remove reliance on summoner names.

```APIDOC
Summoner Names Post Migration:
  - Endpoints remain accessible but are no longer player-facing.
  - Temporary measure to avoid disrupting existing APIs.
  - Summoners created after transition will be assigned a random uuidv4 generated string.
  - Developers are strongly advised to refactor applications to remove reliance on the summoner names field.
  - Summoner names will be removed from the API in future releases.

Example RiotID Input:
  (No specific example provided in text, but implies a structured format for Riot IDs)

Related Information:
  - FAQ for Summoner Name to Riot ID: https://developer.riotgames.com/docs/summoner-name-to-riot-id-faq
```

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

### Riot Games API Routing Values

Source: https://developer.riotgames.com/docs/lol/index

Provides platform and regional routing values for directing API requests to the correct host. These values are crucial for ensuring requests are properly routed to the underlying services.

```APIDOC
Platform Routing Values:
Platform | Host
---|---
BR1 | br1.api.riotgames.com
EUN1 | eun1.api.riotgames.com
EUW1 | euw1.api.riotgames.com
JP1 | jp1.api.riotgames.com
KR | kr.api.riotgames.com
LA1 | la1.api.riotgames.com
LA2 | la2.api.riotgames.com
NA1 | na1.api.riotgames.com
OC1 | oc1.api.riotgames.com
TR1 | tr1.api.riotgames.com
RU | ru.api.riotgames.com
PH2 | ph2.api.riotgames.com
SG2 | sg2.api.riotgames.com
TH2 | th2.api.riotgames.com
TW2 | tw2.api.riotgames.com
VN2 | vn2.api.riotgames.com

Regional Routing Values:
Region | Host
---|---
AMERICAS | americas.api.riotgames.com
ASIA | asia.api.riotgames.com
EUROPE | europe.api.riotgames.com
SEA | sea.api.riotgames.com
```

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

### Player Main Runes

Source: https://developer.riotgames.com/docs/lol/index

Retrieves the primary and secondary runes for a player, identified by their Riot ID. Includes details about the keystone, primary rune tree, and secondary rune tree.

```APIDOC
GET https://127.0.0.1:2999/liveclientdata/playermainrunes?riotId=
Retrieve the basic runes of any player.
```

```JSON
{
    "keystone": {
        "displayName": "Electrocute",
        "id": 8112,
        "rawDescription": "perk_tooltip_Electrocute",
        "rawDisplayName": "perk_displayname_Electrocute"
    },
    "primaryRuneTree": {
        "displayName": "Domination",
        "id": 8100,
        "rawDescription": "perkstyle_tooltip_7200",
        "rawDisplayName": "perkstyle_displayname_7200"
    },
    "secondaryRuneTree": {
        "displayName": "Sorcery",
        "id": 8200,
        "rawDescription": "perkstyle_tooltip_7202",
        "rawDisplayName": "perkstyle_displayname_7202"
    }
}
```

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

### Item Asset URL

Source: https://developer.riotgames.com/docs/lol/index

Provides the URL structure for accessing item images. The item ID is appended to the URL, and a list of item IDs can be found in the item data file.

```url
https://ddragon.leagueoflegends.com/cdn/15.16.1/img/item/1001.png
```

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

### Riot Games Routing Values

Source: https://developer.riotgames.com/docs/lol/index

Provides information on platform and regional routing values used for API requests. This is crucial for directing requests to the correct Riot Games servers based on player region or platform.

```APIDOC
Routing Values:
  - Platform Routing Values: Identifiers for different game platforms (e.g., PC, Mobile).
  - Regional Routing Values: Identifiers for various geographical regions (e.g., NA, EUW, KR).
```

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

### Minimap Asset URL

Source: https://developer.riotgames.com/docs/lol/index

Provides the URL structure for accessing minimap images. The map ID is appended to the URL, and a list of map IDs can be found in the Map Names section of Game Constants.

```url
https://ddragon.leagueoflegends.com/cdn/6.8.1/img/map/map11.png
```

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

### League of Legends Maps

Source: https://developer.riotgames.com/docs/lol/index

Provides Map IDs used to identify the map on which a match was played. Each entry contains 'mapId', 'mapName', and optional 'notes'.

```json
[
  {
    "mapId": 1,
    "mapName": "Summoner's Rift",
    "notes": "Original Summer variant"
  },
  ...
]
```

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

### League of Legends Seasons

Source: https://developer.riotgames.com/docs/lol/index

Provides a list of season IDs used to identify when a match was played. Each entry includes an 'id' and the 'season' name.

```json
[
  {
    "id": 0,
    "season": "PRESEASON 3"
  },
  ...
]
```

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

### Player Items

Source: https://developer.riotgames.com/docs/lol/index

Retrieves the list of items currently equipped by a player, identified by their Riot ID. Each item includes properties like display name, item ID, count, and slot.

```APIDOC
GET https://127.0.0.1:2999/liveclientdata/playeritems?riotId=
Retrieve the list of items for the player.
```

```JSON
[
    {
        "canUse": true,
        "consumable": false,
        "count": 1,
        "displayName": "Warding Totem (Trinket)",
        "itemID": 3340,
        "price": 0,
        "rawDescription": "game_item_description_3340",
        "rawDisplayName": "game_item_displayname_3340",
        "slot": 6
    },
    ...
]
```

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

### Riot Games Data Dragon API

Source: https://developer.riotgames.com/docs/lol/index

Details the Data Dragon API, which provides access to game data and assets for League of Legends. Includes information on retrieving versions, regions, champions, items, and other game-related data.

```APIDOC
Data Dragon API:
  - Versions: Endpoints to get the latest game data versions.
  - Regions: Information on available game regions.
  - Data & Assets: Access to various game assets.
    - Champions: Data for all champions.
    - Items: Data for all in-game items.
    - Other: Additional game-related data.
```

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

### Profile Icon Asset URL

Source: https://developer.riotgames.com/docs/lol/index

Provides the URL structure for accessing profile icon images. The profile icon ID is appended to the URL.

```url
https://ddragon.leagueoflegends.com/cdn/15.16.1/img/profileicon/685.png
```

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

### Champion Spell Effect Fields

Source: https://developer.riotgames.com/docs/lol/index

Illustrates the difference between the 'effect' and 'effectBurn' fields in champion spell data. 'effect' provides values per level, while 'effectBurn' is a string of all values.

```json
"effect": [
  null,
  [ 120, 150, 180, 210, 240 ],
  [ 50, 70, 90, 110, 130 ],
  [ 25, 35, 45, 55, 65 ],
  [ 0.2, 0.2, 0.2, 0.2, 0.2 ],
  [ 50, 60, 70, 80, 90 ]
],
"effectBurn": [
  "",
  "120/150/180/210/240",
  "50/70/90/110/130",
  "25/35/45/55/65",
  "0.2",
  "50/60/70/80/90"
]
```

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

### Champion Skin Numbering

Source: https://developer.riotgames.com/docs/lol/index

Illustrates how skin numbers are associated with champion assets. The 'num' field within the 'skins' array in a champion's data file corresponds to the number used in asset filenames.

```json
/* Aatrox (id: 266) */
"skins": [
  {
    "id": 266000,
    "name": "default",
    "num": 0
  },
  {
    "id": 266001,
    "name": "Justicar Aatrox",
    "num": 1
  },
  {
    "id": 266002,
    "name": "Mecha Aatrox",
    "num": 2
  }
]
```

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

### Game Events

Source: https://developer.riotgames.com/docs/lol/index

Retrieves a list of all events that have occurred during the current game. Events include an ID, name, and timestamp.

```APIDOC
GET https://127.0.0.1:2999/liveclientdata/eventdata
Get a list of events that have occurred in the game.
```

```JSON
{
    "Events": [
        {
            "EventID": 0,
            "EventName": "GameStart",
            "EventTime": 0.0325561985373497
        },
        ...
    ]
}
```