this shit is it

econ/agents/base_aquire_agent.py

@@ -127,5 +127,6 @@ class Base_Aquire_Agent(BaseAgent,ABC):
     def reset(self, episode):
         #self.tqty=0
         self.qty_offset=0
+        self.expense_offset=0
         self.trades=[]
         return super().reset(episode)

econ/agents/base_distribution_agent.py

@@ -60,6 +60,8 @@ class Base_Distribution_Agent(BaseAgent,ABC):
         # Get exchange
         cx=self.exchanges[cx_id]
        
+        #if amount>=self.max_batch_qty:
+        #    amount=self.max_batch_qty
 
         if not self.business.inventory[self.resource]>=amount:
             return False # we dont have enough balance

econ/agents/price_believe_aquire.py

@@ -14,8 +14,8 @@ class Price_Believe_Aquire_Agent(Base_Aquire_Agent):
         self.price_believe = {i: 1 for i in range(len(self.exchanges))}
         self.open_orders = {i: [] for i in range(len(self.exchanges))}
         self.open_qty = 0
-        self.hp_threshold=0.25
-        self.lp_threshold=0.90
+        self.hp_threshold=0.70
+        self.lp_threshold=0.99
 
     def tick(self, tick, episode):
 
@@ -52,9 +52,11 @@ class Price_Believe_Aquire_Agent(Base_Aquire_Agent):
         return best_id
 
     def register_order(self, cx_id, order):
+        half=self.max_price_adj_rate/2
+        ran=random.randrange(-half,half)
         self.open_orders[cx_id].append({
             'id': order.order_id,
-            'lifetime': self.max_price_adj_rate,
+            'lifetime': self.max_price_adj_rate+ran,
             'leaves': order.leaves_qty
         })
         if order.leaves_qty != order.qty:

econ/agents/price_believe_distribute.py

@@ -7,15 +7,16 @@ class Price_Believe_Distribiute_Agent(Base_Distribution_Agent):
     Aquire agent with internal price believe system. 
     """
 
-    def __init__(self, simulation, business, resource, exchanges: list, lr, max_price_adj_rate) -> None:
+    def __init__(self, simulation, business, resource, exchanges: list, lr,at_sales, max_price_adj_rate) -> None:
         super().__init__(simulation, business, resource, exchanges)
         self.lr = lr
+        self.lr_at_sales=at_sales
         self.max_price_adj_rate = max_price_adj_rate
         self.price_believe = {i: 1 for i in range(len(self.exchanges))}
         self.open_orders = {i: [] for i in range(len(self.exchanges))}
         self.open_qty = 0
-        self.lp_threshold=0.10
-        self.hp_threshold=0.90
+        self.lp_threshold=0.05
+        self.hp_threshold=0.80
 
     def tick(self, step, episode):
 
@@ -50,9 +51,11 @@ class Price_Believe_Distribiute_Agent(Base_Distribution_Agent):
         return best_id
 
     def register_order(self, cx_id, order):
+        half=self.max_price_adj_rate/2
+        ran=random.randrange(-half,half)
         self.open_orders[cx_id].append({
             'id': order.order_id,
-            'lifetime': self.max_price_adj_rate,
+            'lifetime': self.max_price_adj_rate+ran,
             'leaves': order.leaves_qty
         })
         if order.leaves_qty != order.qty:
@@ -80,7 +83,7 @@ class Price_Believe_Distribiute_Agent(Base_Distribution_Agent):
                         modifier=1
                     elif succsess<=self.lp_threshold:
                         modifier=-1
-                    self.update_believe(cx_id, modifier)  # update price believe
+                    self.update_believe(cx_id,o.price, succsess)  # update price believe
                     self.collect_balance_from_cxs()
                     self.collect_resource_from_cxs(self.resource)
                     self.update_trades()
@@ -100,36 +103,33 @@ class Price_Believe_Distribiute_Agent(Base_Distribution_Agent):
                     # timeout
                     self.update_trades()
                     succsess=self.calc_order_success(cx,o)
-                    modifier=0
-                    if succsess>=self.hp_threshold:
-                        modifier=1
-                    elif succsess<=self.lp_threshold:
-                        modifier=-1
+                    
                     cx.cancel_order(i["id"])
                     self.collect_balance_from_cxs()
                     self.collect_resource_from_cxs(self.resource)
-                    self.update_believe(cx_id, modifier)
+                    self.update_believe(cx_id,o.price, succsess)
                     self.open_orders[cx_id].remove(i)
     def calc_order_success(self,cx, o):
         """
         Calculate how we should adjust the price belive
         """
         sold = o.qty-o.leaves_qty
-        soldperc=sold/o.qty
+        nsold=min(o.leaves_qty,cx.total_demand[self.resource])
         dem = cx.total_demand[self.resource]+sold
         if dem == 0:
             dem = 1
-        coverage = sold/dem
-        base_success=max([coverage,soldperc])
-        return base_success
+        score=sold-nsold
+        return score
 
-    def update_believe(self, cx_id, modifier):
+    def update_believe(self, cx_id, used_price, modifier):
         """
         Updates the believe based on the modifier.
         If positive will add lr to believe
         If negative will sub lr to believe
         """
-        self.price_believe[cx_id] += modifier*self.lr
+        
+        self.price_believe[cx_id]+=(modifier/self.lr_at_sales)*self.lr
+
         self.price_believe[cx_id] = round(self.price_believe[cx_id], 2)
         if self.price_believe[cx_id] < 1:
             self.price_believe[cx_id] = 1