(first time actually asking a question here, so forgive my etiquette blunders)
Base Situation: I have multiple images that can move around the screen.
Simple Solution #1:
The main loop would step over the array of objects, tell each one to move itself, then tell the view to refresh itself [self.view setNeedsDisplay]. The view would then get the array and step over it and draw the objects at their point on the screen.
Very simple sample project that puts 200 arrows in a NSArray and moves them around here.
Simple Solution #2:
I then started to experiment with having the objects have their own view as a property.
When the objects were added to the main NSArray, the views were added to the main drawing view. [self.view addSubView:newThing.view].
The main loop would step over the objects and tell them to move. Within the object class, the move would cause the view’s frame.origin to move which would result in them moving on the main view.
This also has the advantage that the objects can add subviews to their image if needed, like particle effects or related subviews.
The disadvantage is that it seems to be putting more view-like code into the model and hides some of the view effort.
Simple sample project here.
Note: Both sample projects are drawing far more things that I expect will be needed in my real simulator.
My “Question?”
Solution #2 led to much cleaner looking code, and doing some short analysis indicates there does not seem to be much performance or memory difference until I get to thousands of objects then the drawing version saves a good bit of memory overhead. But even at 400 objects it is not all that much extra memory to hold all those views.
Is there some reason I should not use Solution #2 that I am missing? Is it ok to “break” VMC a bit by having the model be a bit smarter about what it will be eventually drawing?
You can probably get around the MVC violation by adding another layer between the objects and the views, with objects that know both the model objects and the views and tell the views to move if something changes.
Solution #2 requires vastly more memory and computing, especially if you have a lot of objects. It also gives you less control over the drawing, which may be a problem if you want to have special effects. For this reason, at least for games, it is typically not used. But in the end, if it really does make your life easier and you are happy with the performance, there is no reason not to pick it.
Still, it may be a good idea to look at Core Animation. It allows you to implement a similar pattern (then each object has its own layer instead of a view), but is faster and more flexible for special effects.