changed to GUI now
different sizes added, collision detection via Potentialfields between units added
added transparent attackrange
heavily weakened the potential-influence of playgroundlimits. only pretty high, if unit is pretty close to edge. also implemented a in-class forcevariable to save current force (especially important to remember last direction). some other little tweaks. summed up: units are behaving a little bit more realistic now. BUG: Probe not removed from unitlist, have to take a closer look to it.
Unit:
Tried to improve the AI a little bit further. Weak units wear too
fearful and ran away forever so I increased the attractive forces by the
factor of the value (minerals+gasToMinerals*gas) of the unit causing
this force. I also added some fear value to the BaseUnit class that can
be set to further individualize the unit behaviour.
One of the biggest problems currently is that units with low attack
range and dps behave stupid against units with high attack range and
dps. They should attack together in order to distribute the damage dealt
by the enemy unit among all units, instead at the moment one unit after
the other gets killed.
Scaling deleted as not needed anymore. Collision detection refined.
removed little bug
Fixed probe/drone/scv-bug, I simply forgot to call sortAndRemoveZombies with unitList0 *facepalm*
added now more units to the combat.txt. Now all units from units.txt, which are also in unit.h, are in combat.txt for all three races. i added a few TODOs to the Readme.txt in the data folder as well.
Now unitlists can be used as parameters for the program.
./bin/part2 -o -p listplayer1 -q listplayer2
-o is for using the output from part1. I extracted the output with the '>' operator in the command line.
Without -o, the main only accepts lists of units with spaces or newlines as seperators.

If nothing is specified, the program takes the hardcoded lists from the main.cpp

For now, player1 has to be zerg, player2 has to be protoss.
some adaptions to part1
Optimizer

Added Header file and implemented first necessary parts for the
Optimizer. The Idea is the following. We simply have a struct called
Genes embedded in the Unit-class, that contains two arrays containing
all parameters that are necessary to compute the forces caused by enemy
and friendly units. The functions that compute these forces dependent on
the Genes of a unit are implemented in the Optimizer-Header. In the
optimization these functions can be assigned to the mEnemyFunc and
mFriendFunc member variables of the Unit class. Then an objective
Function shall compute the effectiveness of the Unit with the its
current Genes, after running Microsimulations where it has to fight
against different types of enemy Units.

Note about the Genes struct:
In my opinion we need at least one byte for one type of the parameters
and two byte for the other two types (type one are weight factors of dps
and resources, type two constants and type three distance offsets), to
get a range of values for the parameters that is big enough.
Consequently a bitmask is not really suitable, and I think it makes more
sense to use one array of bytes (unsigned char) and another of two bytes
(unsigned short) as seen in the Unit class. But I explain in detail
which kind of parameters have which function in the force computation
and why.

TODO:
- The Objective Function (can be pretty simple, sth. like: Damage caused
to living enemies + 2*(health of killed enemies) + 1/2*(health of own
units, summed up for all simulations)
- The Optimizer class and all steps that are needed to implement the
Genetic Algorithm.
Genetic Algorithm
Added Genes-Header and implemented constructor for copy, mutation and
crossover in Genes struct
Just renaming and some simple bugfixes
Optimizer.h: Improved friend and enemy functions