### Configuring and Starting a Konfetti Party

Source: https://github.com/danielmartinus/konfetti/blob/main/README.md

Provides an example of creating a Party object with various customizable options and then starting the confetti animation using a KonfettiView instance. This snippet illustrates common configurations for speed, spread, colors, emitter, and position.

```kotlin
Party(
    speed = 0f,
    maxSpeed = 30f,
    damping = 0.9f,
    spread = 360,
    colors = listOf(0xfce18a, 0xff726d, 0xf4306d, 0xb48def),
    emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(100),
    position = Position.Relative(0.5, 0.3)
)
viewKonfetti.start(party)
```

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

### Configure Confetti with PartyFactory in Java

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Demonstrates how to use the PartyFactory builder to define particle properties like speed, position, and shape. It includes examples for relative, absolute, and range-based positioning.

```java
import nl.dionsegijn.konfetti.core.Angle;
import nl.dionsegijn.konfetti.core.Party;
import nl.dionsegijn.konfetti.core.PartyFactory;
import nl.dionsegijn.konfetti.core.Position;
import nl.dionsegijn.konfetti.core.Rotation;
import nl.dionsegijn.konfetti.core.emitter.Emitter;
import nl.dionsegijn.konfetti.core.models.Shape;
import nl.dionsegijn.konfetti.core.models.Size;
import java.util.Arrays;
import java.util.concurrent.TimeUnit;

public class JavaExample {
    public void startConfetti(KonfettiView konfettiView) {
        Emitter emitter = new Emitter(100, TimeUnit.MILLISECONDS);
        Party party = new PartyFactory(emitter.max(100))
            .angle(Angle.TOP)
            .spread(45)
            .setSpeedBetween(30f, 50f)
            .setDamping(0.9f)
            .position(0.5, 1.0)
            .sizes(Size.SMALL, Size.MEDIUM, Size.LARGE)
            .colors(Arrays.asList(0xfce18a, 0xff726d, 0xf4306d, 0xb48def))
            .shapes(Arrays.asList(Shape.Square.INSTANCE, Shape.Circle.INSTANCE))
            .timeToLive(3000L)
            .fadeOutEnabled(true)
            .delay(0)
            .rotation(Rotation.Companion.enabled())
            .build();
        konfettiView.start(party);
    }
}
```

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

### Basic XML/Kotlin Konfetti Implementation

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Demonstrates how to start a basic confetti animation from an Activity or Fragment using XML layout and Kotlin. It initializes KonfettiView and triggers a party on a button click.

```kotlin
import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import nl.dionsegijn.konfetti.core.Party
import nl.dionsegijn.konfetti.core.Position
import nl.dionsegijn.konfetti.core.emitter.Emitter
import nl.dionsegijn.konfetti.xml.KonfettiView
import java.util.concurrent.TimeUnit

class MainActivity : AppCompatActivity() {
    private lateinit var konfettiView: KonfettiView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        konfettiView = findViewById(R.id.konfettiView)

        findViewById<Button>(R.id.btnCelebrate).setOnClickListener {
            val party = Party(
                speed = 0f,
                maxSpeed = 30f,
                damping = 0.9f,
                spread = 360,
                colors = listOf(0xfce18a, 0xff726d, 0xf4306d, 0xb48def),
                emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(100),
                position = Position.Relative(0.5, 0.3)
            )

            // Start the confetti animation
            konfettiView.start(party)
        }
    }
}
```

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

### KonfettiView Control Methods in Kotlin

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Provides examples of controlling the Konfetti animation lifecycle using various methods available on the KonfettiView. This includes starting single or multiple parties, checking animation status, and stopping or resetting the animation.

```kotlin
import nl.dionsegijn.konfetti.core.Party
import nl.dionsegijn.konfetti.core.emitter.Emitter
import nl.dionsegijn.konfetti.xml.KonfettiView
import java.util.concurrent.TimeUnit

// Assuming konfettiView is already initialized
val konfettiView: KonfettiView = findViewById(R.id.konfettiView)

val party = Party(
    spread = 360,
    colors = listOf(0xfce18a, 0xff726d, 0xf4306d, 0xb48def),
    emitter = Emitter(duration = 5, TimeUnit.SECONDS).perSecond(30)
)

// Start a single party
konfettiView.start(party)

// Start multiple parties at once (vararg)
konfettiView.start(party, party.copy(position = Position.Relative(0.3, 0.5)))

// Start from a list
konfettiView.start(listOf(party, party.copy(spread = 180)))

// Check if any animation is active
val isAnimating: Boolean = konfettiView.isActive()

// Get all active particle systems
val systems = konfettiView.getActiveSystems()

// Stop a specific party (particles disappear immediately)
konfettiView.stop(party)

// Stop gracefully (stop emitting, let existing particles finish)
konfettiView.stopGracefully()

// Reset completely (all particles disappear immediately)
konfettiView.reset()
```

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

### OnParticleSystemUpdateListener

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Interface for listening to particle system lifecycle events such as start and end.

```APIDOC
## OnParticleSystemUpdateListener

### Description
Allows developers to hook into the particle system lifecycle to track when animations start or finish.

### Methods
- **onParticleSystemStarted(view, party, activeSystems)**: Triggered when a new particle system begins.
- **onParticleSystemEnded(view, party, activeSystems)**: Triggered when a particle system finishes its emission.

### Implementation Example
```kotlin
konfettiView.onParticleSystemUpdateListener = object : OnParticleSystemUpdateListener {
    override fun onParticleSystemStarted(view: KonfettiView, party: Party, activeSystems: Int) {
        Log.d("Konfetti", "Started! Active systems: $activeSystems")
    }
    override fun onParticleSystemEnded(view: KonfettiView, party: Party, activeSystems: Int) {
        Log.d("Konfetti", "Ended! Active systems: $activeSystems")
    }
}
```
```

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

### Konfetti Update Listener in Kotlin

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Shows how to implement an update listener for the KonfettiView to track particle system start and end events. This allows logging or reacting to animation lifecycle changes.

```kotlin
import android.os.Bundle
import android.util.Log
import androidx.appcompat.app.AppCompatActivity
import nl.dionsegijn.konfetti.core.Party
import nl.dionsegijn.konfetti.core.emitter.Emitter
import nl.dionsegijn.konfetti.xml.KonfettiView
import nl.dionsegijn.konfetti.xml.listeners.OnParticleSystemUpdateListener
import java.util.concurrent.TimeUnit

class MainActivity : AppCompatActivity() {
    private lateinit var konfettiView: KonfettiView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        konfettiView = findViewById(R.id.konfettiView)

        // Set up listener for particle system events
        konfettiView.onParticleSystemUpdateListener = object : OnParticleSystemUpdateListener {
            override fun onParticleSystemStarted(
                view: KonfettiView,
                party: Party,
                activeSystems: Int
            ) {
                Log.d("Konfetti", "Started! Active systems: $activeSystems")
            }

            override fun onParticleSystemEnded(
                view: KonfettiView,
                party: Party,
                activeSystems: Int
            ) {
                Log.d("Konfetti", "Ended! Active systems: $activeSystems")
                if (activeSystems == 0) {
                    Log.d("Konfetti", "All animations complete!")
                }
            }
        }

        val party = Party(
            spread = 360,
            colors = listOf(0xfce18a, 0xff726d, 0xf4306d, 0xb48def),
            emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(100)
        )

        konfettiView.start(party)
    }
}
```

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

### KonfettiView Animation Control

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Methods to start, stop, and manage the lifecycle of confetti animations within the KonfettiView.

```APIDOC
## KonfettiView Control Methods

### Description
Controls the lifecycle of confetti animations, including starting, stopping, and checking the status of particle systems.

### Methods
- **start(party: Party)**: Starts a single confetti animation.
- **start(vararg parties: Party)**: Starts multiple confetti animations simultaneously.
- **start(parties: List<Party>)**: Starts a list of confetti animations.
- **isActive()**: Returns a boolean indicating if any animation is currently running.
- **getActiveSystems()**: Returns a list of all active particle systems.
- **stop(party: Party)**: Immediately stops a specific party.
- **stopGracefully()**: Stops emitting new particles but allows existing ones to finish.
- **reset()**: Clears all particles immediately.

### Usage Example
```kotlin
val party = Party(spread = 360, colors = listOf(0xfce18a, 0xff726d))
konfettiView.start(party)
if (konfettiView.isActive()) {
    konfettiView.stopGracefully()
}
```
```

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

### POST /party/start

Source: https://github.com/danielmartinus/konfetti/blob/main/README.md

Configures a new confetti party instance and triggers the animation.

```APIDOC
## POST /party/start

### Description
Configures the properties of a confetti burst and initiates the animation on the KonfettiView.

### Method
POST

### Endpoint
/party/start

### Parameters
#### Request Body
- **angle** (Int) - Optional - Direction in degrees (0-360). Default: 0.
- **spread** (Int) - Optional - Width of the burst in degrees. Default: 360.
- **speed** (Float) - Optional - Initial speed of particles. Default: 30f.
- **maxSpeed** (Float) - Optional - Maximum random speed. Default: 0f.
- **damping** (Float) - Optional - Speed reduction rate. Default: 0.9f.
- **size** (List<Size>) - Optional - List of particle sizes. Default: SMALL, MEDIUM, LARGE.
- **colors** (List<Int>) - Optional - List of hex color codes.
- **shapes** (List<Shape>) - Optional - List of shapes (Square, Circle).
- **timeToLive** (Long) - Optional - Duration in ms. Default: 2000.
- **fadeOutEnabled** (Boolean) - Optional - Enable fade out on expiry. Default: true.
- **position** (Position) - Optional - Spawn location coordinates.
- **delay** (Int) - Optional - Start delay in ms. Default: 0.
- **emitter** (EmitterConfig) - Required - Configuration for particle spawn rate and duration.

### Request Example
{
  "speed": 0.0,
  "maxSpeed": 30.0,
  "damping": 0.9,
  "spread": 360,
  "colors": [16540042, 16745069, 16003181, 11832559],
  "position": {"type": "relative", "x": 0.5, "y": 0.3}
}

### Response
#### Success Response (200)
- **status** (String) - Returns 'success' when the animation is triggered.
```

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

### Create Basic Party Configuration

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Define a basic Party object to control the emission of confetti particles. This snippet demonstrates both a continuous stream and a single burst configuration.

```kotlin
import nl.dionsegijn.konfetti.core.Party
import nl.dionsegijn.konfetti.core.emitter.Emitter
import java.util.concurrent.TimeUnit

val basicParty = Party(
    emitter = Emitter(duration = 5, TimeUnit.SECONDS).perSecond(30)
)

val burstParty = Party(
    emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(100)
)
```

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

### Configure Built-in Shapes

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Explains how to use standard Square, Circle, and Rectangle shapes within a Party configuration.

```kotlin
import nl.dionsegijn.konfetti.core.Party
import nl.dionsegijn.konfetti.core.emitter.Emitter
import nl.dionsegijn.konfetti.core.models.Shape
import java.util.concurrent.TimeUnit

// Mix of squares and circles (randomly selected)
val mixedShapesParty = Party(
    shapes = listOf(Shape.Square, Shape.Circle),
    emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(50)
)

// Rectangle with custom height ratio (0.0-1.0)
val rectangleParty = Party(
    shapes = listOf(Shape.Rectangle(heightRatio = 0.3f)),
    emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(50)
)
```

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

### Configure Emitter Particle Count

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Demonstrates how to emit a fixed number of particles over a specific duration using the Emitter class.

```kotlin
import nl.dionsegijn.konfetti.core.emitter.Emitter
import java.util.concurrent.TimeUnit

// Emit exactly 100 particles over 100 milliseconds (burst effect)
val burstEmitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(100)

// Emit 50 particles spread over 2 seconds
val spreadEmitter = Emitter(duration = 2, TimeUnit.SECONDS).max(50)
```

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

### Configure Emitter Rate

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Shows how to emit particles at a continuous rate per second for a specified duration.

```kotlin
import nl.dionsegijn.konfetti.core.emitter.Emitter
import java.util.concurrent.TimeUnit

// Emit 30 particles per second for 5 seconds (150 total)
val continuousEmitter = Emitter(duration = 5, TimeUnit.SECONDS).perSecond(30)

// Heavy rain effect: 100 particles per second for 10 seconds
val rainEmitter = Emitter(duration = 10, TimeUnit.SECONDS).perSecond(100)
```

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

### Size and Rotation Configuration

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Configure the physical properties of particles including size, mass, and rotation dynamics.

```APIDOC
## Size and Rotation Configuration

### Description
Sets the physical behavior and visual size of the particles.

### Method
Kotlin Class Initialization

### Endpoint
nl.dionsegijn.konfetti.core.models.Size / nl.dionsegijn.konfetti.core.Rotation

### Parameters
#### Request Body
- **sizeInDp** (Int) - Required - Visual size in density-independent pixels.
- **mass** (Float) - Optional - Affects gravity behavior.
- **rotation** (Rotation) - Optional - Configuration for 2D/3D spinning.

### Request Example
val rotation = Rotation(enabled = true, speed = 1.5f)

### Response
#### Success Response (200)
- **Party** (Object) - Party configuration updated with size and rotation properties.
```

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

### Handle Konfetti Animation Completion with Listener

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Demonstrates how to use OnParticleSystemUpdateListener to track when particle systems finish. This is useful for triggering callbacks once the animation is complete.

```kotlin
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import nl.dionsegijn.konfetti.compose.KonfettiView
import nl.dionsegijn.konfetti.compose.OnParticleSystemUpdateListener
import nl.dionsegijn.konfetti.core.Party
import nl.dionsegijn.konfetti.core.PartySystem
import nl.dionsegijn.konfetti.core.emitter.Emitter
import java.util.concurrent.TimeUnit

@Composable
fun CelebrationWithCallback(onComplete: () -> Unit) {
    val parties = remember {
        listOf(
            Party(
                spread = 360,
                colors = listOf(0xfce18a, 0xff726d, 0xf4306d, 0xb48def),
                emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(100)
            )
        )
    }

    KonfettiView(
        modifier = Modifier.fillMaxSize(),
        parties = parties,
        updateListener = object : OnParticleSystemUpdateListener {
            override fun onParticleSystemEnded(system: PartySystem, activeSystems: Int) {
                if (activeSystems == 0) {
                    onComplete()
                }
            }
        }
    )
}
```

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

### Implement Konfetti with Jetpack Compose and ViewModel

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Demonstrates how to trigger and manage confetti animations using a ViewModel and the KonfettiView composable. It handles state transitions between idle and active particle systems.

```kotlin
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.viewModels
import androidx.compose.foundation.layout.*
import androidx.compose.material.*
import androidx.compose.runtime.*
import androidx.compose.runtime.livedata.observeAsState
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.lifecycle.LiveData
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel
import nl.dionsegijn.konfetti.compose.KonfettiView
import nl.dionsegijn.konfetti.compose.OnParticleSystemUpdateListener
import nl.dionsegijn.konfetti.core.*
import nl.dionsegijn.konfetti.core.emitter.Emitter
import java.util.concurrent.TimeUnit

class KonfettiViewModel : ViewModel() {
    sealed class State {
        object Idle : State()
        class Started(val party: List<Party>) : State()
    }

    private val _state = MutableLiveData<State>(State.Idle)
    val state: LiveData<State> = _state

    fun explode() {
        _state.value = State.Started(listOf(
            Party(
                speed = 0f,
                maxSpeed = 30f,
                damping = 0.9f,
                spread = 360,
                colors = listOf(0xfce18a, 0xff726d, 0xf4306d, 0xb48def),
                emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(100),
                position = Position.Relative(0.5, 0.3)
            )
        ))
    }

    fun ended() {
        _state.value = State.Idle
    }
}

class ComposeActivity : ComponentActivity() {
    private val viewModel by viewModels<KonfettiViewModel>()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            val state: KonfettiViewModel.State by viewModel.state.observeAsState(KonfettiViewModel.State.Idle)

            when (val currentState = state) {
                KonfettiViewModel.State.Idle -> {
                    Column(modifier = Modifier.fillMaxSize(), verticalArrangement = Arrangement.Center, horizontalAlignment = Alignment.CenterHorizontally) {
                        Button(onClick = { viewModel.explode() }) { Text("Celebrate!") }
                    }
                }
                is KonfettiViewModel.State.Started -> {
                    KonfettiView(
                        modifier = Modifier.fillMaxSize(),
                        parties = currentState.party,
                        updateListener = object : OnParticleSystemUpdateListener {
                            override fun onParticleSystemEnded(system: PartySystem, activeSystems: Int) {
                                if (activeSystems == 0) viewModel.ended()
                            }
                        }
                    )
                }
            }
        }
    }
}
```

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

### Configure Custom Drawable Shapes

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Demonstrates loading custom Android drawables as confetti shapes using ImageUtil.

```kotlin
import android.graphics.drawable.Drawable
import androidx.appcompat.content.res.AppCompatResources
import nl.dionsegijn.konfetti.core.Party
import nl.dionsegijn.konfetti.core.emitter.Emitter
import nl.dionsegijn.konfetti.core.models.Shape
import nl.dionsegijn.konfetti.xml.image.ImageUtil
import java.util.concurrent.TimeUnit

val heartDrawable: Drawable = AppCompatResources.getDrawable(context, R.drawable.ic_heart)!!

val heartShape = ImageUtil.loadDrawable(
    drawable = heartDrawable,
    tint = true,
    applyAlpha = true
)

val customShapeParty = Party(
    shapes = listOf(Shape.Square, Shape.Circle, heartShape),
    colors = listOf(0xff0000, 0xff69b4, 0xff1493),
    emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(50)
)
```

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

### Configure Particle Sizes

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Configures particle visual size and mass properties to influence gravity and movement behavior.

```kotlin
import nl.dionsegijn.konfetti.core.Party
import nl.dionsegijn.konfetti.core.emitter.Emitter
import nl.dionsegijn.konfetti.core.models.Size
import java.util.concurrent.TimeUnit

val standardParty = Party(
    size = listOf(Size.SMALL, Size.MEDIUM, Size.LARGE),
    emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(50)
)

val customSize = Size(sizeInDp = 12, mass = 7f, massVariance = 0.3f)

val customSizeParty = Party(
    size = listOf(customSize, Size.SMALL),
    emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(50)
)
```

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

### Emitter Configuration

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Configure how particles are emitted using either a fixed maximum count (burst) or a continuous rate (per second).

```APIDOC
## Emitter Configuration

### Description
Controls the timing and quantity of particle emission.

### Method
Kotlin Class Initialization

### Endpoint
nl.dionsegijn.konfetti.core.emitter.Emitter

### Parameters
#### Request Body
- **duration** (Long) - Required - The total time for the emission.
- **timeUnit** (TimeUnit) - Required - The unit of time for the duration.
- **max** (Int) - Optional - Total number of particles to emit (Burst).
- **perSecond** (Int) - Optional - Rate of particles per second (Continuous).

### Request Example
val emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(100)

### Response
#### Success Response (200)
- **Emitter** (Object) - Configured emitter instance ready for a Party object.
```

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

### Implement Basic KonfettiView in Compose

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Displays a basic confetti animation using the KonfettiView composable. It defines a Party configuration with specific speed, damping, and color parameters.

```kotlin
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.runtime.remember
import androidx.compose.ui.Modifier
import nl.dionsegijn.konfetti.compose.KonfettiView
import nl.dionsegijn.konfetti.core.Party
import nl.dionsegijn.konfetti.core.Position
import nl.dionsegijn.konfetti.core.emitter.Emitter
import java.util.concurrent.TimeUnit

@Composable
fun CelebrationScreen() {
    val parties = remember {
        listOf(
            Party(
                speed = 0f,
                maxSpeed = 30f,
                damping = 0.9f,
                spread = 360,
                colors = listOf(0xfce18a, 0xff726d, 0xf4306d, 0xb48def),
                emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(100),
                position = Position.Relative(0.5, 0.3)
            )
        )
    }

    KonfettiView(
        modifier = Modifier.fillMaxSize(),
        parties = parties
    )
}
```

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

### Implement Festive Preset in Kotlin

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Creates a multi-burst upward explosion effect from the bottom center of the screen using a list of Party configurations.

```kotlin
fun festive(): List<Party> {
    val party = Party(
        speed = 30f,
        maxSpeed = 50f,
        damping = 0.9f,
        angle = Angle.TOP,
        spread = 45,
        size = listOf(Size.SMALL, Size.LARGE, Size.LARGE),
        shapes = listOf(Shape.Square, Shape.Circle),
        timeToLive = 3000L,
        rotation = Rotation(),
        colors = listOf(0xfce18a, 0xff726d, 0xf4306d, 0xb48def),
        emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(30),
        position = Position.Relative(0.5, 1.0)
    )
    return listOf(party, party.copy(speed = 55f, maxSpeed = 65f, spread = 10, emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(10)), party.copy(speed = 50f, maxSpeed = 60f, spread = 120, emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(40)), party.copy(speed = 65f, maxSpeed = 80f, spread = 10, emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(10)))
}
```

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

### Add Konfetti Dependencies

Source: https://github.com/danielmartinus/konfetti/blob/main/README.md

Include the necessary dependencies in your build.gradle file to use Konfetti in either Jetpack Compose or XML-based projects.

```groovy
dependencies {
    implementation 'nl.dionsegijn:konfetti-compose:2.0.5'
}
```

```groovy
dependencies {
    implementation 'nl.dionsegijn:konfetti-xml:2.0.5'
}
```

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

### Customize Party Properties

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Configure advanced particle behaviors such as speed, direction, rotation, and visual appearance using the Party configuration object.

```kotlin
import nl.dionsegijn.konfetti.core.Angle
import nl.dionsegijn.konfetti.core.Party
import nl.dionsegijn.konfetti.core.Position
import nl.dionsegijn.konfetti.core.Rotation
import nl.dionsegijn.konfetti.core.models.Shape
import nl.dionsegijn.konfetti.core.models.Size
import nl.dionsegijn.konfetti.core.emitter.Emitter
import java.util.concurrent.TimeUnit

val customParty = Party(
    angle = Angle.TOP,
    spread = 45,
    speed = 30f,
    maxSpeed = 50f,
    damping = 0.9f,
    size = listOf(Size.SMALL, Size.MEDIUM, Size.LARGE),
    colors = listOf(0xfce18a, 0xff726d, 0xf4306d, 0xb48def),
    shapes = listOf(Shape.Square, Shape.Circle),
    timeToLive = 3000L,
    fadeOutEnabled = true,
    position = Position.Relative(0.5, 1.0),
    rotation = Rotation(enabled = true, speed = 1f, variance = 0.5f, multiplier2D = 8f, multiplier3D = 1.5f),
    emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(30)
)
```

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

### Define KonfettiView in XML Layout

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Shows how to add the KonfettiView as an overlay within an existing XML layout structure. This allows the confetti to render on top of other UI components.

```xml
<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical"
        android:gravity="center">

        <Button
            android:id="@+id/btnCelebrate"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Celebrate!" />
    </LinearLayout>

    <nl.dionsegijn.konfetti.xml.KonfettiView
        android:id="@+id/konfettiView"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

</FrameLayout>
```

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

### Configure Particle Spawn Positions

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Set the origin point for confetti particles using either relative coordinates (0.0 to 1.0) or absolute pixel values.

```kotlin
import nl.dionsegijn.konfetti.core.Position

val centerPosition = Position.Relative(0.5, 0.5)
val topEdge = Position.Relative(0.0, 0.0).between(Position.Relative(1.0, 0.0))
val absolutePosition = Position.Absolute(100f, 200f)
val absoluteRange = Position.Absolute(0f, 0f).between(Position.Absolute(500f, 100f))
```

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

### Implement Explode Preset in Kotlin

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Generates a circular explosion effect originating from a specific center point on the screen.

```kotlin
fun explode(): List<Party> {
    return listOf(
        Party(
            speed = 0f,
            maxSpeed = 30f,
            damping = 0.9f,
            spread = 360,
            colors = listOf(0xfce18a, 0xff726d, 0xf4306d, 0xb48def),
            emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(100),
            position = Position.Relative(0.5, 0.3)
        )
    )
}
```

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

### Rain Preset

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Creates confetti falling from the top of the screen.

```APIDOC
## Rain Preset

Creates confetti falling from the top of the screen.

### Method
```kotlin
fun rain(): List<Party>
```

### Parameters
None

### Request Example
```kotlin
konfettiView.start(rain())
```

### Response
None

### Response Example
None
```

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

### Configure Particle Rotation

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Controls 2D spinning and 3D flipping rotation effects for confetti particles.

```kotlin
import nl.dionsegijn.konfetti.core.Party
import nl.dionsegijn.konfetti.core.Rotation
import nl.dionsegijn.konfetti.core.emitter.Emitter
import java.util.concurrent.TimeUnit

val rotatingParty = Party(
    rotation = Rotation.enabled(),
    emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(50)
)

val customRotationParty = Party(
    rotation = Rotation(
        enabled = true,
        speed = 1.5f,
        variance = 0.5f,
        multiplier2D = 8f,
        multiplier3D = 1.5f
    ),
    emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(50)
)
```

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

### Configure Confetti Party

Source: https://github.com/danielmartinus/konfetti/blob/main/README.md

Define the behavior and appearance of confetti using the Party object. This includes setting emitters, speeds, colors, and positioning.

```kotlin
Party(
    emitter = Emitter(duration = 5, TimeUnit.SECONDS).perSecond(30)
)
```

```kotlin
Party(
    speed = 0f,
    maxSpeed = 30f,
    damping = 0.9f,
    spread = 360,
    colors = listOf(0xfce18a, 0xff726d, 0xf4306d, 0xb48def),
    position = Position.Relative(0.5, 0.3),
    emitter = Emitter(duration = 100, TimeUnit.MILLISECONDS).max(100)
)
```

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

### Parade Preset

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Creates confetti streaming from both sides of the screen.

```APIDOC
## Parade Preset

Creates confetti streaming from both sides of the screen.

### Method
```kotlin
fun parade(): List<Party>
```

### Parameters
None

### Request Example
```kotlin
konfettiView.start(parade())
```

### Response
None

### Response Example
None
```

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

### KonfettiView Integration in XML Layout

Source: https://github.com/danielmartinus/konfetti/blob/main/README.md

Shows how to include a KonfettiView in an Android XML layout file. This allows for the display of confetti effects in traditional View-based Android UIs.

```xml
<nl.dionsegijn.konfetti.xml.KonfettiView
    android:id="@+id/konfettiView"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />
```

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

### KonfettiView Integration in Compose

Source: https://github.com/danielmartinus/konfetti/blob/main/README.md

Demonstrates how to add a KonfettiView to your Jetpack Compose UI. This view is responsible for rendering the confetti particles based on the provided party configurations.

```kotlin
KonfettiView(
    modifier = Modifier.fillMaxSize(),
    parties = state.party,
)
```

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

### Shape Configuration

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Define the visual appearance of particles using built-in shapes or custom drawables.

```APIDOC
## Shape Configuration

### Description
Defines the geometry or image source for the confetti particles.

### Method
Kotlin Class Initialization

### Endpoint
nl.dionsegijn.konfetti.core.models.Shape

### Parameters
#### Request Body
- **shapes** (List<Shape>) - Required - Collection of shapes to be used.
- **heightRatio** (Float) - Optional - For Rectangle shapes, defines the aspect ratio.

### Request Example
val party = Party(shapes = listOf(Shape.Square, Shape.Circle))

### Response
#### Success Response (200)
- **Party** (Object) - Party configuration updated with specified shapes.
```

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

### Create Parade Confetti Animation

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Configures a parade effect where confetti streams from both the left and right sides of the screen. It uses two Party objects with mirrored angles and positions to achieve the effect.

```kotlin
fun parade(): List<Party> {
    val party = Party(
        speed = 10f,
        maxSpeed = 30f,
        damping = 0.9f,
        angle = Angle.RIGHT - 45,
        spread = Spread.SMALL,
        colors = listOf(0xfce18a, 0xff726d, 0xf4306d, 0xb48def),
        emitter = Emitter(duration = 5, TimeUnit.SECONDS).perSecond(30),
        position = Position.Relative(0.0, 0.5)
    )

    return listOf(
        party,
        party.copy(
            angle = party.angle - 90,
            position = Position.Relative(1.0, 0.5)
        )
    )
}

konfettiView.start(parade())
```

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

### Create Rain Confetti Animation

Source: https://context7.com/danielmartinus/konfetti/llms.txt

Configures a rain effect where confetti falls from the entire width of the top of the screen. It uses a single Party object with a wide emitter position.

```kotlin
fun rain(): List<Party> {
    return listOf(
        Party(
            speed = 0f,
            maxSpeed = 15f,
            damping = 0.9f,
            angle = Angle.BOTTOM,
            spread = Spread.ROUND,
            colors = listOf(0xfce18a, 0xff726d, 0xf4306d, 0xb48def),
            emitter = Emitter(duration = 5, TimeUnit.SECONDS).perSecond(100),
            position = Position.Relative(0.0, 0.0).between(Position.Relative(1.0, 0.0))
        )
    )
}

konfettiView.start(rain())
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.