I am writing a Kivy mobile web app, using python. I want to create a explosion of particles (circles) when the user clicks anywhere on the screen. 
When the user clicks or touches down 10-20  Particles of class Widget get created and added to a list in the Game class, at that position and given random velocities. Use Clock.schedule_event(self.update) to loop through the particles and update their position.
user
To create an explosion of particles in a Kivy mobile web app using Python, you can follow these steps:

1. Create a Particle class that inherits from the Widget class. This class should have properties such as position, velocity, and size.
2. In the Game class, create a list to store the particles that will be created when the user clicks the screen.
3. Create a function that will handle the click event. This function should create 10-20 instances of the Particle class at the position of the click, with random velocities.
4. Add the particles to the list created in step 2.
5. Create a function that will update the position of the particles. This function should loop through the list of particles and update their position based on their velocity.
6. Use the Clock.schedule_interval() function to call the update function at a set interval.

Here's some sample code to get you started:

```python
from kivy.app import App
from kivy.uix.widget import Widget
from kivy.graphics import Color, Ellipse
from kivy.clock import Clock
import random

class Particle(Widget):
    velocity_x = 0
    velocity_y = 0

    def update(self):
        self.pos = (self.pos[0] + self.velocity_x, self.pos[1] + self.velocity_y)

class Game(Widget):
    particles = []

    def on_touch_down(self, touch):
        for i in range(random.randint(10, 20)):
            particle = Particle(pos=touch.pos)
            particle.velocity_x = random.uniform(-10, 10)
            particle.velocity_y = random.uniform(-10, 10)
            self.particles.append(particle)
            self.add_widget(particle)

    def update(self, dt):
        for particle in self.particles:
            particle.update()

class MyApp(App):
    def build(self):
        game = Game()
        Clock.schedule_interval(game.update, 1.0 / 60.0)
        return game

if __name__ == '__main__':
    MyApp().run()
```
assistant
How can I customize the appearance of the particles? Can I change their color, size, or shape?
user
Yes, you can customize the appearance of the particles by modifying the `Particle` class. To change the color, size, or shape, you can use Kivy's canvas instructions within the `Particle` class. Here's an example of how to achieve this:

1. Import the necessary classes from `kivy.graphics`:
```python
from kivy.graphics import Ellipse, Rectangle, Line
```
Modify the `Particle` class to include a `canvas` instruction. You can set the particle's color, size, and shape within the `with self.canvas`: block:
```python
class Particle(Widget):
    velocity_x = 0
    velocity_y = 0

    def __init__(self, **kwargs):
        super(Particle, self).__init__(**kwargs)
        self.size = (random.randint(10, 40), random.randint(10, 40))  # Set the size of the particle
        with self.canvas:
            Color(random.random(), random.random(), random.random(), 1)  # Set the color of the particle
            # Choose one of the shapes below:
            Ellipse(pos=self.pos, size=self.size)  # Circular shape
            # Rectangle(pos=self.pos, size=self.size)  # Rectangular shape
            # Line(points=[self.x, self.y, self.x + self.width, self.y + self.height], width=2)  # Line shape

    def update(self):
        self.pos = (self.pos[0] + self.velocity_x, self.pos[1] + self.velocity_y)
```

In the example above, I've set the particle's size randomly within a specified range, assigned a random color, and provided three different shapes (Ellipse, Rectangle, and Line) that you can choose from. You can uncomment the desired shape and comment out the others.

Now, when you run the application, the particles should have customized appearances based on the modifications you made to the `Particle` class.
assistant