Delphi Based Pattern (pathing) Creation Application
I have a Pattern Creation Application that I have started writing but am busy with so many things I would like a Delphi Coder to finish it up. Think of this as a small CAD type program that makes points that the sprite will follow. All this program does is give the user easy ways to set up sets of points that make up a pattern.
All menus and icons are complete as well as basic screen layout, some dialogs, and most of the basic skeleton. The Pattern classes have all been completed so you are just building an editor to allow the user to easily set up data.
The toughest part will be letting the user edit points and endpoints with drag and drop. Everything else is pretty standard stuff.
This product is written in Delphi 6. The product will allow the user to create sequences of pattern (path step data) that sprites will follow. In addition the application will keep a set of pre-built segments that the user can easily add on (Circle, Square, Triangle) and also allow the user to take any pattern they are working on and copy it into the library as a segment. Helper functions exist in the pattern classes to make these options easier.
You can download the application and class at: <[url removed, login to view]>and examine the amount of work necessary to complete the project. Ample commenting has been embedded into the project to make it clear where I need work completed.
Version 1.0 of the ScriptG Pattern Editor with the following features:
* Create, Open, Save and Edit Project Files.
* Create, move (drag and Drop), edit, and delete pattern folders.
* Create, edit, move (drag and drop) delete patterns.
* Patterns will be stored in a Project file (extension .prj) that has folders and patterns in folders. Again, the pattern classes are all set up to store, load, and create these data types.
* Create points in the pattern using point tool, line tool (points between two endpoints), and spline tool (points between two spline points). Line and Spline tools will allow the user to adjust number of points (steps) to generate for each segment created.
* Create points by appending or inserting another preset or saved pattern. Presets will be a sizable circle, sizable square, and sizable triangle.
* Saved patterns are also called user define segments. In reality you will treat this as yet another pattern in a private collection of patterns.
* The pattern will be drawn on screen in real time using the following methods:
* * A Point will draw as a yellow pixel with a gray box around it.
* A Spline will draw as a series of yellow pixels with the start and end pixels having gray boxes around them.
* A line will draw as a series of yellow pixels with start and end pixels having gray boxes.
* Segments (pre-defined or user defined) will simply be a series of yellow pixels with gray boxes around them.
* A dark red line will connect all pixels from all types (spline, point, line, segment) so that the pattern has a “path?? through all points.
* The pattern will be scaled to the proper zoom selected.
* A gray box is a drag and drop point. That is, the user can left-click-hold on a gray box and drag it to another location. This will affect the path depending on what was dragged:
* * A Spline endpoint will cause all points in the spline to re-calculate and re-draw. This will happen AS THE USER MOVES THE MOUSE.
* A Line will cause all points in the line to re-calculate and redraw as the user moves the mouse.
* A point will cause the dark red lines from the prior and next points to redraw as the point is shifted.
* Points, splines, and lines will be drawn and can be edited by the following means:
* * A Point will
* The idea is that the points are what the sprite will physically follow while the dark red line indicates the overall path the points are traveling.
* The user library will be saved automatically whenever updated and automatically load when the application starts.
* Users enter data into the virtual drawing area. This is an imaginary area 2000 x 2000 pixels in size. This area is fixed in size. This allows the user to draw patterns that move on and off the video game’s visible screen area.
* Scroll Bars will allow the user to change the offset to the drawing area.
* The TImage component is the area where the user can draw pattern data. An X,Y offset to the virtual drawing area must be maintained and applied to pixels, lines, and splines.
* The TImage will have an adjustable rectangle, drawn in red, that shows the video game screen area. This rectangle will be called the Real Screen Rectangle. The rectangle will be centered as a default.
* All coordinates are based on the Real Screen Rectangle. That is, the upper left corner of the Real Screen Rectangle is considered 0,0 even though it is drawn in the center of a 2000 x2000 virtual area.
* The reason the Real Screen Rectangle is the basis for all coordinates is that playback of patterns occurs in a screen resolution different than what is being drawn in.
* All coordinates drawn are based on their position from the origin of the Real Screen Rectangle. That is, a point on the upper left corner of this rectangle is considered 0,0. A point above the rectangle will have a ??"Y coordinate. The reason for this is that patterns are replayed in the Real Screen Resolution using absolute coordinates.
* Game screen size can be one of the following selections: 1024 x 768, 800 x 600, 640 x 480.
* Drawing Square and pattern can be scaled (so user can see and edit a larger portion of the estimated game screen). Scales will be 200%, 100%, 75%, 50%, 25%. Pattern and game window visuals will need to adjust based on scale as well as input.
* Program must use TsgPattern classes for loading, saving, and storage of data. This is because the video game engine uses these same classes.
* Supports UNDO / REDO. This is pretty simple. A TsgPattern Bundle class has already been created to support snapshots of multiple patterns for multiple periods of time.
Windows 2000, XP