It might be a good idea to tell us exactly what trouble you are having because, to me, from your description these are not complex components.

Honestly without much description of what type of projectiles you are having it is hard to describe a component and system that will match all your use cases will you be using simple raycast tests or physics simulated projectiles? Will there be ray guns? Or what? I don't know the limits of your technology or how it works.

A projectile for my game would be it's own entity which I would create from physics components and a projectile component. The projectile component would have stuff like initial velocity and who shot it and would notify it's creator when it hit something (probably with what it hit). So a 'firing component' would just be an entity link to create.

I always do AI in scripts which will access systems like path-finding and receive messages from the physics system when a collision occurs. So my script would just create the entity I wanted when it shot (after deciding to or receiving input (well after an animation maybe ).

The bullet example I think could be addressed using components (depending on how "differently" you want bullets to fire).

For more complex things, I attach scripts to the entity (via a Scripts component).They don't really keep the potential performance benefits of a component system (e.g. operating on all instances of particular data at once), but they also tend not to be as performance-critical anyway.

There are a number of ways to implement a component based entity system. The system I have been working on works a bit like this:

• Components provide the data/properties/attributes and can provide behavior.
  
• Components register their properties with the parent entity so other components can access common data (eg. physics/render both need access to transform data).
  
• Sub-systems manage and update the components.
  

For the majority of things you will already have a bunch of sub-systems that are part of the core engine (physics, rendering, animation, etc) and so a lot of your components plug into these systems nicely.

For your spaceship/bullet example you could try tackle the problem in a more generic way. What makes up a bullet? In the most basic sense it has some kind of visual representation along with some physical properties. You could therefore create a bullet entity that is made from a couple of components:

• TransformComponent
  
• PhysicsCapsuleComponent
  
• SpriteComponent or ModelComponent
  

For the above, the TransformComponent is there to provide the world/local transform that the physics/render systems can read/write too. The PhysicsCapsuleComponent is managed by the physics sub-system and it's attributes define the physical properties (velocity, acceleration, friction, collision mesh, etc) which the physics sub-system uses to simulate the object. The SpriteComponent or ModelComponent provides the visual representation and it is managed by the rendering sub-system.

The rendering components can be broken down even further but I find in most cases your components will generally map to an existing higher level sub-system, you just need to think in general terms of what actually makes up the object you're trying to create.

There is nothing wrong with the components of an entity having some behavior of their own, don't make complex logic and math computations on script, they tend to get expensive since they have to be interpreted, the best us of scripts is to connect different behaviors in a dynamic way. Don't overuse scripts.
Shooting is always going to be shooting, that is a behavior that you should implement in your code, deciding to shoot is something more dynamic that you may want to do through scripts.

As for the shooting pattern, its a matter of data, you can write as data a representation of the pattern, frequency, directions, speeds, projectile type. All this is data, not behavior, your behavior is shooting, which will receive this data and simply execute it, keeping track of time between shots and so on.

I would look at it this way. Your ship might have a Weaponry component, which holds the current weapons they can shoot (and possibly which one is active, if you can switch between them), as well as if its time to fire (set by AI System, or player's input system). In your Weapon system, it would create an entity based on the current firing weapon name. The entity could be built from loading an xml file (for that weapon's name) that describes the weapon's bullet's components (image, velocity, damage, number of pellets (if it spreads) etc.). If it's a special bullet, the Weapons system should know how to handle it

Just a thought.