Wallstreet Simulation 32 Bit

Wallstreet Simulation will be a Linux-Economy-Simulation game (first stock companies will be available) -- It'll be as realistic as possible.

Currently it is developed with Kylix OE. Currently code works with Delphi PE, but the Delphi PE license isn't GPL. I don't know, if it fits Delphi PE license, if code is maintenanced for Delphi PE also, it maybe could be instutional or indirect profit?

Readme-File for Wallstreet-Simulation Developers

by Stephan Struckmann

Wallstreet Simulation will be a simulation game. Project master is Stephan Struckmann (my humple self) so far. I had written a similar game in the 1990ies with Delphi 1.0. Also this old one was modular (better became modular), which means that Plugins and additional game-modes could be installed. The word "became" is the characteristic term for the spaghetti-code of that old project - I started it to learn programming Windows under TurboPascal 1.0 for Windows, because I had no development tool for my favorite operating system OS/2. I tried to make a shareware-version around my matriculation. Then at the university I didn't find enough time for the far necessary re-engineering (porting to at least 32-Bit-Windows maybe to Linux and OS/2, interation of net-abilities, recode the application kernel, etc.)

Now I've nearly finished my first studies - probably I'll do another more mathematical. And Borland came up with Kylix OE. So I decided to iniate a new open source project - maybe some enthuasiastic programmer will join me.

Ok -- The specification of the game so far:

• Simulation of economical proceedings
  • found stock companies
  • control their parameters like production, prices, PR, and so on
  • become shareholder: After the Foundation the player who founded gets 50 % of the shares, then the competitors may buy the rest until it is again at the one who had founded
  • the value of the shares relates to the value of the stock company
  • Shares that no player bought belong to virtual players who always sell them if a player wants to buy; he can of couse buy other players shares too. The virtual players always sell to a fair price (calculated from the value of the company) -- real players can demand what they want.
  • founding a stock company is expensive (depends on the branch), maybe the player has to borrow money from the bank (mortgages have to be paid; if a player can't do that he has to go to prison the longer the more debits)
  • of course therefore he has the shares (but not equally the same value, because mashines had to be bought)
  • the first companies always have monopol but other players may found another firm in the same branch; then the whole calculation of the sale changes much:

    Factors of the salefunction s	Monopol	Compete
    Price p ---------- = p mean price	--	s(p) ~ c2*[cos(c1*p) + 1] c1*p IN [0; PI] or any other similar function?
    Price ----------- = p performance (depends on costs for production...)	s(p) ~ p	maybe the same with another c2 or just zero
    po = public opinion = f(public relation)	s(po) ~ po	(#Competitors) s(po) ~ po^
    holidays	optional no sale (production may be set to zero on holidays or optional completely deactivated), depends on branch
    ...

  • Public opinion can be influenced by:
    • PR
    • Headlines (optionally for fun)
    • extreme selling or buying shares
    • time (people forget about You without PR)
    • changes in brand (new name, etc.)
  • Parameters like PR-fund can be set up after 51% (or optionally another amount) of the shares vote for it (players who have shares have to vote about propositions the current player makes)
• Round-concept / Network:
  • Calculations are made after a round
  • rounds last a certain time or number of actions (or combinations)
  • rounds can be ended if a player wants to manually
  • Network: No rounds are necessary - calculations after a certain time. It must be found out, if peer to peer or C/S works better. The data is currently stored by VarManager.bpl that can be adapted to other forms of object-commuication.

• Fun

• Optionally player can for fun call phone numbers - a thief for instance who steals a competitors money, but maybe prison waits...
• the same with random actions like newspapers headlines that can take influence on the parameters or the money of one or more players, or maybe one of the players has to go to prison because she did some ugly things with her secretary (so that he never will try to seduce his boss again)

• Class-concept:

• Look in bplWLLClasses.so / WLLClasses.bpl; it should be possible to add other classes (besides stock companies limited partnerships, etc.)

• The many optional things should be set up before a game is started, but regarding the network idea it may sensable to join running games.
• after a certain amount of rounds (or calculations or time), the game is over and the winner is calculated - highscores have to be complex because of the many options that can be set up
• Of course there should be different chart components (I've made a x/y-diagram-component yet) -- maybe a special mode with a display for the sales-function
• Graphics and sound should be there (it's a game, even if it is complex) -- maybe optional (a text-client could be reasonable, especially for network-games)
• maybe a component could be developed, that offers real shares for their real prices (but of course bought virtually)

Look at bplFormmanager.so / Formmanager.bpl for the Framework's kernel (it is inspired by an article in the great programers magazine "toolbox": http://www.toolbox-mag.de/). bplStruckFrame.so / StruckFrame.bpl contains framework and Plugins should put an entry in the main menu or whereever the want to hook.

I would be happy, if someone joins, who knows more about the forecast-methods for economical facts. Someone with skills in designing the shell of the game would be great. Also porting the whole thing to other OS and writing interfaces for other programing-languages should be thought about. Translation to other languages (I speak natively German as You can see; my spelling is terrific and my style ...) could help.

There are many similar games but less OpenSource. And I try to make it realistic. A friend of mine doesn't use Linux because he likes simluation games like Alpha Centauri or Civ. I think there should be more games for Linux (and not only more action games).

Kylix could help; it is GPL - so I think it is ok to use it. Unfortunately the IDE is really instable. The Free Pascal Lazarus project will bring another RAD-IDE for Linux, OS/2, AmigaOS, many others and even Win. A little WYSIWYG can improve CASE as we could see with Delphi. Of course it seduces people to write dirty programs but that is no reason not to use it for writing proper programs. And: As I mentioned in introduction: spaghetti code is also possible with Turbo Pascal for Windows 1.0!

So if You like the idea of the game and don't hate pascal programmers or Borland (in case You do: Feel free to port it to GNU!):

Everybody is welcome!

Stephan Struckmann
stephan.struckmann@gmx.de
ICQ: 129576343
http://struckmann.hypermart.net/

Class-Tree:

(so far)

TComponent      ---        TPerson        ---        TGesellschaft        --- TAG
                                                                          --- TBank
                                          ---        TEinzelperson        --- TSpieler
                                          ---        TStaat
                ---        TWertstueck

Translation of the (German) classnames: (SORRY!!)

If objects need to relate to other classes, they should define a ClassType:

type
        TPersonClass        =        class of TPerson;

Later they may create instances like following:

var        aClass : TPersonClass;

proceudre PersonFactory;
var        aPerson: TPerson;

begin
        aPerson := aClass.Create
        { ... }
end;

Which brings the advantage that the Class for TPerson can inherit to TGreatPerson and the code aPerson := aClass.Create mustn't be changed:

unit GreatPersonUnit;

interface

uses Person;

type         TGreatPerson = class(TPerson)
                // some changes against parentclass
        end;

implementation

// ...

initialization
        aClass := TGreatPerson;
end.

Now it's enough only to "use" GreatPersonUnit and the rest of the Codeunit will work with TGreatPerson instead of TPerson.

About the Framework:

All Plugins / Modules must be coded as (borland) packages BPL (DLL's or SO's with certain interface routines, that are automatically inserted by the Compiler) so far. These provide easier data interchange between modules (even Classes can be defined in modules - used extensively by Compiletime-Packages: All Components come in packages but can also be compiled as the here used runtime packages).

These must dynamically use the runtime package FormManager.bpl and register in Initialization part with RegForm. They also must deregister with DeRegForm on removal. Take a look at PluginTemplate for more information that can be used as a template for plugins in the Delphi object repository. They must contain a Form derived from TMyForm (FormManagerUnit), which should be hidden all the time. Probably TMyForm will be in future a child of TComponent or so instead of TForm. Please code, if You like!

That's it so far. Thank You for Your interest,

Stephan Struckmann

Finally the current TODO:

TODO

targets, that must be implemented soon

ERRORS AFTER PORTING TO Kylix/Linux:
====================================
Reorganize the Sources: Parts that don't depend on CLX/VCL shouldn't be
stored twice (in Kylix AND Delphi tree).  This I consider important, because
else WllClasses-develpment may split; at the moment they exist twice but
are nearly the same for Kylix and Delphi.

Error on leaving program (exception in CLX -- well, probably my fault ;-)
	---- fixed
Build something like the COFF-component for ELF to
  recognize loadable packages. (Maybe they should be CRC'ed first, at least
  under Windows - under Linux it should be more complicated to replace them,
  but - of course - not impossible)
Package manager has to be completed in Linux
Versionnumbers in Linux files

What about DragAndDock under Linux/CLX?
	Obviously missing, think about implementing this...

When it works under Linux, it should be re-ported to Windows
using great FreeCLX for better code consistency.

"Real" programing
=================
Complete chart component (currently X/Y/Z-function plot - works under
Linux and Win)

Complete COFF component (many ideas; first: does it work with all
DLL's / EXE's?)

VarManager:
===========
Storing interface, persistant VarListe (File / maybe Registry?)
Net interface for these globals

a lot of testing, especially the cleanup

FormManager:
============
Replace TMyForm by TMyPackage or so

writing a tool, that generates raw package-sources - an assistant
for developers
Interface in C++ to enable developers writing packages in that
language (currently only Kylix is supported)

FURTHER TARGETS:

targets, that may be implemented in future

-----

Projektseite bei SourceForge.Net Meine Homepage