To clarify, I'm trying to calc Value/Share, not Price/Share. I get that Price/Share gets modified by difficulty, other stocks owned and % of remaining stock.

Total Value seems to be: Base Value + Cash + Resources + Structures + Patents - (Debt * Debt Multiplier)

But I can't figure out the conversion from Total Value -> Value/Share. It should be a simple division by 100k but more is going on.

When you buy someone out, you get their Base/Structures but you don't get their Cash/Resources/Debt. If someone has low Cash/Resources and high Debt, their stock becomes a really attractive buy since your buying their Base/Structures for pennies on the dollar. Buying someone with high Cash/Resources and low Debt is far more painful since your paying a 100% multiple for Cash/Resources that your not going to get. Maybe, because we don't know how to accurately calculate Value/Share.

If someone buys your stock, what's the best way to defend yourself against a takeover? Pay down your debt? Maintain high Cash/Resources? Buy your own stock? Buy their stock? Buy someone else's stock at a lower multiple?

Important questions that I at least don't yet know how to answer.

Something is definitely wrong. Last game I played, I bought about half of TruXPixels stock. When he bought his own stock back from me his stock price jumped from about $20/share to over $100/share in a matter of seconds. The game also temporarily calculated him somehow gaining over 9m cash in the transaction.

Cash: http://i.imgur.com/eeYqGTf.jpg

Graph: http://i.imgur.com/0Ddgth8.jpg

Here's the code. Let me know if this helps answer the question.

public void updateBaseSharePrice(bool bForce)
{
if (!isAlive())
{
return;
}

int iTotalValue = calculateTotalStockValue(true);

const int STOCK_STEPS = (1000 * Constants.STOCK_MULTIPLIER);

int iNewValue = 0;

if (iTotalValue > 0)
{
// XXX test this...

while (iTotalValue > 0)
{
int iChange = Math.Min(STOCK_STEPS, iTotalValue);

iNewValue += iChange;
iTotalValue -= iChange;

iTotalValue *= 3;
iTotalValue /= 4;
}
}
else
{
iNewValue = iTotalValue;
}

if (game().isGameOption(GameOptionType.MARATHON_MODE))
{
iNewValue *= 2;
}

iNewValue /= 100;

iNewValue = Math.Max(iNewValue, 0);

if (getBaseSharePrice() != iNewValue)
{
if (bForce || (Math.Abs(getBaseSharePrice() - iNewValue) < (Constants.STOCK_MULTIPLIER / 10)))
{
miBaseSharePrice = iNewValue;
}
else
{
miBaseSharePrice = ((getBaseSharePrice() * 9) + iNewValue) / 10;
}

makeDirty();
}
}

also, updateBaseSharePrice() gets called very tick (usually a second)

STOCK_MULTIPLIER is 1000.

As for reply#4, I'm really baffled. I assume there is not a replay of that game?

iNewValue is not the new share price. Look at the code again.

iNewValue is incremented by STOCK_STEPS for every multiple of STOCK_STEPS that iTotalValue exceeds while iTotalValue is depreciated by 1/4th at each step.  So, if STOCK_STEPS is 100,000 (maybe it is 10k or 1mil, we don't know for sure here), then for every (let's say) 100k in value you have, iNewValue is incremented by 100k and the remaining total value gets depreciated by 25%. This gives a heavier depreciation on values which are much higher than 100k. So, for example, the amounts over 600k would be depreciated by 25% at least 6 times. This is a huge depreciation factor. It probably should be 10% or maybe even 5%. This is why the stock buyouts are so screwed up at the end and why level 2 and 3 HQ players can buy out level 5 HQ players. All the extra value the level 5 players have is being heavily depreciated vs the value that the level 2 and 3 HQ players have. 

But, moving on...

Once we get through the loop, iNewValue is a discounted representation of the total value. The stock is 10 buckets of 1000 shares. So, that is 10,000 shares total. However, the price point is based on 1000 shares, so the price point is 1/10th of the depreciated company value. After we divide iNewValue by 100, it represents 1/100th of the whole company, which is an order of magnitude less expensive than the desired breakdown. But, look at the code which follows...

iNewValue /= 100;

iNewValue = Math.Max(iNewValue, 0);

if (getBaseSharePrice() != iNewValue)
{
   if (bForce || (Math.Abs(getBaseSharePrice() - iNewValue) < (Constants.STOCK_MULTIPLIER / 10)))
   {
      miBaseSharePrice = iNewValue;
   }
   else
   {
      miBaseSharePrice = ((getBaseSharePrice() * 9) + iNewValue) / 10;
   }

   makeDirty();
}

Presumably, iNewValue would equal getBaseSharePrice() for all ticks where nothing has changed in terms of the numbers. That implies that getBaseSharePrice() is returning a number which is 1/100th of the value of the company. Assuming the two numbers no longer match, an update is in order. When it updates, it updates miBaseSharePrice by taking 9/10ths of getBaseSharePrice() and 1/10th of iNewValue and adding them together. So, we are using 1/10th of 1/100th of the newly calculated and depreciated company value and 9/10th of getBaseSharePrice() to arrive at our new baseSharePrice. At least, that's what it looks like to me. Which is why 100k in cash only changes the value of your company by pennies. The original baseSharePrice makes up the bulk of the number.

If this is true, it doesn't make sense.  At the very least, the loss of value in stock price after the buyout should also have the lag, rather than be instantly lost.  There should be no loss in stock price associated with acquisition.  

In the real world, the mere announcement of an acquisition causes the stock price to rise in value before any deal is finalized.