Update index.html

index.html

@@ -270,31 +270,89 @@
     }
   }
 
-  function placeOrder(side, qty){
-    qty = Math.floor(Number(qty));
-    if (!Number.isFinite(qty) || qty <= 0) return;
-    if (!Number.isFinite(state.price) || state.price <= 0) return;
-
-    const cost = qty * state.price;
-
-    if (side === "BUY") {
-      if (state.cash < cost + COMMISSION) return;
-      const totalVal = state.shares * state.avgCost + cost;
-      state.shares += qty;
-      state.avgCost = state.shares > 0 ? (totalVal / state.shares) : 0;
-      state.cash -= (cost + COMMISSION);
+function placeOrder(side, qty){
+  qty = Math.floor(Number(qty));
+  if (!Number.isFinite(qty) || qty <= 0) return;
+  if (!Number.isFinite(state.price) || state.price <= 0) return;
+
+  const tradeShares = (side === "BUY") ? qty : -qty; // SELL is negative shares
+  const px = state.price;
+
+  // Cash flow: buying spends cash, selling receives cash
+  // cashDelta = - (tradeShares * price) - commission
+  // (if tradeShares is negative => -(-qty*px) = +qty*px)
+  const cashDelta = -(tradeShares * px) - COMMISSION;
+
+  // Optional: simple leverage guard (to avoid infinite short)
+  // e.g. require equity stays above 0 after the trade
+  // We'll compute after updating state, and revert if violates.
+  const old = { cash: state.cash, shares: state.shares, avgCost: state.avgCost };
+
+  // Update cash
+  state.cash += cashDelta;
+
+  // Update position + avgCost (handles long<->flat<->short)
+  const prevShares = state.shares;
+  const newShares = prevShares + tradeShares;
+
+  // Helper: same direction means both >=0 or both <=0 (excluding 0)
+  const sameDir =
+    (prevShares > 0 && newShares > 0) ||
+    (prevShares < 0 && newShares < 0);
+
+  if (newShares === 0) {
+    state.shares = 0;
+    state.avgCost = 0;
+  } else if (prevShares === 0) {
+    // Opening a new position (long or short)
+    state.shares = newShares;
+    state.avgCost = px;
+  } else if (sameDir) {
+    // Increasing position in the same direction => weighted average price
+    // weights are absolute sizes
+    const totalAbs = Math.abs(prevShares) + Math.abs(tradeShares);
+    const avg = (Math.abs(prevShares) * state.avgCost + Math.abs(tradeShares) * px) / totalAbs;
+    state.shares = newShares;
+    state.avgCost = avg;
+  } else {
+    // Reducing/closing/reversing: avgCost stays the same if partially reduced;
+    // if reversed beyond zero, new avgCost becomes entry price of the remainder.
+    state.shares = newShares;
+
+    const reducedToZeroOrBeyond =
+      (prevShares > 0 && newShares < 0) || (prevShares < 0 && newShares > 0);
+
+    if (reducedToZeroOrBeyond) {
+      // Position flipped direction; remaining shares have new entry at px
+      state.avgCost = px;
     } else {
-      if (state.shares < qty) return;
-      state.shares -= qty;
-      state.cash += (cost - COMMISSION);
-      if (state.shares === 0) state.avgCost = 0;
+      // Still same original direction but smaller size; keep avgCost
+      // (avgCost unchanged)
     }
+  }
+
+  // Record order
+  state.orders.push({ side, qty, price: px, day: state.day, ts: Date.now() });
+
+  // Recalc equity and (optional) enforce margin rule
+  recalcEquity();
 
-    state.orders.push({ side, qty, price: state.price, day: state.day, ts: Date.now() });
+  // Simple margin guard (optional but strongly recommended):
+  // disallow trades that make equity negative
+  if (state.equity <= 0) {
+    // revert
+    state.cash = old.cash;
+    state.shares = old.shares;
+    state.avgCost = old.avgCost;
     recalcEquity();
-    render();
+    state.orders.pop();
+    return;
   }
 
+  render();
+}
+
+
   function resetLocal(){
     state.cash = INITIAL_CASH;
     state.shares = 0;