Demo entry 1958446

tipe

   

Submitted by anonymous on Jun 19, 2015 at 13:15
Language: Python 3. Code size: 25.6 kB.

from math import sqrt, ceil, pow
from random import random
from matplotlib.pyplot import figure, title, plot, legend, show

class DonneeExpo():
    """
    Module de lissage exponentielle. Ceci permet de déterminer facilement des vitesses au cours du temps
    Attributs :
        - a     : Paramètre du lissage
        - m     : Moyenne sans compter les derniers 0 ajoutés
        - mv    : Moyenne actuelle
        - tab   : Historique brut
        - tabv  : Historique des derniers 0
        - lis   : Lissage
        - lisv  : Lissage depuis qu'il n'y a que des 0 ajoutés
    """
     
    def __init__(self, a, tab = []):
        self.a = a
        self.m = 0
        self.mv = 0
        self.tab = []
        self.tabv = []
        self.lis = []
        self.lisv = []
        for x in (tab):    
            self.append(x)
         
    def append(self, x):
        """Ajoute une valeur au module de donées"""
        
        if x == 0:
            self.mv *= self.a
            self.lisv.append(self.mv)
            self.tabv.append(0)
        else:
            self.m = self.m*self.a + (1 - self.a)*x
            self.lis.append(self.m)
            self.tab.append(x)
            self.mv = self.m
            self.tabv = []
            self.lisv = []
        
class DonneeMoy():
    """
    Module de lissage par régression d'ordre 1
    Attributs :
        - r     : Taille de la fenêtre
        - m0    : Moyenne arythmétique des points
        - m1    : Moyenne par régression d'ordre 1
        - mem   : Liste des r dernières valeurs
        - ind   : Indice indicant le dernier point dans mem
        - tab   : Historique
        - lis   : Lissage
    """
     
    def __init__(self, r, tab = []):
        self.r = r
        self.m0 = 0
        self.m1 = 0
        self.mem = [0]*r
        self.ind = 0
        self.tab = []
        self.lis = []
        for x in (tab):    
            self.append(x)
         
    def append(self, x):
        """Ajoute une valeur au module de données"""
        
        self.tab.append(x)
        y = self.mem[self.ind]
        r = self.r
        self.m1 += ((4*r-2)*x + 2*y - 6*self.m0)/(r*(r+1))
        self.m0 += (x-y)/r
        self.lis.append(self.m1)
        self.mem[self.ind] = x
        self.ind = (self.ind + 1)%r

class Objet():
    """
    Définie la structure d'objet.
    Attributs :
        - time          : Temps nécessaire pour fabriquer un objet
        - cost          : Cout de production d'un objet
        - ingredient    : Objets nécessaires pour la fabrication
        - qte           : Quantité nécessaire pour chaque ingredient
        - basePrice     : Prix de référence de l'objet sur lequel se base le consommateur
        - id            : Identifiant de l'objet
        - entProd       : Liste des entreprises fabriquant l'objet
        - entBuy        : Liste des entreprises achetant l'objet  
    """

    nbre = 0

    def __init__(self, time, cost, base, ingredient = [], qte = []):
        self.time = time
        self.cost = cost
        self.ingredient = ingredient
        self.qte = qte
        self.basePrice = base
        self.id = Objet.nbre
        Objet.nbre += 1

        self.entProd = []
        self.entBuy = []

    def addProduction(self, ent):
        """Ajoute une entreprise de production"""
        self.entProd.append(ent)

    def addPurchaser(self, ent):
        """Ajoute une entreprise qui achète l'objet"""
        self.entBuy.append(ent)
        
class Entreprise():
    """
    Définie la structure d'entreprise
    Attributs:
        - id            : Identifiant de l'entreprise
        - x             : Abscisse de l'entreprise (position)
        - y             : Ordonéée de l'entreprise (position)
        - capacity      : Capacité de stockage
        - fund          : Argent
        - cost          : Couts de maintenance - Salaires - Taxes
        - gestion       : Fonction de gestion
        - buyList       : Liste des objets que l'entreprise est suceptible d'acheter
        - sellList      : Liste des objets que l'entreprise vend
        - produit       : Objet que l'entreprise produit
        - stock         : Liste des différents stocks de l'entreprise
        - price         : Prix
        - faillite      : Indicateur vallant True si et seulement si l'entreprise a fait faillite
        
        - vitIde        : Vitesse idéale de vente
        - vitEnt        : Vitesse de rentrée de marchandises
        - vitSor        : Vitesse de sortie de marchandises
        - minPrice      : Prix minimum pour ne pas vendre à perte
        - moyBuyPrice   : Prix moyen d'achat
        - commandSell   : Liste des commandes à honorer
        - commandBuy    : Liste des commandes passées à d'autres entreprises
        - limitStock    : Limite de stocks imposés à chaque objet
        - attente       : Temps avant que toutes les commandes soient honorés
        - lisSor        : Module de lissage de la vitesse de sortie
        - lisEnt        : Module de lissage de la vitesse d'entrée
        - lisFund       : Module de lissage de l'argent
        - lisPrice      : Module de lissage des prix
        - stockEnt      : Quantité rentrée pendant un tour
        - stockSor      : Quantité sortie pendant un tour
        - timeEnt       : Temps depuis la dernière rentrée
        - timeSor       : Temps depuis la dernière sortie
    """
    
    nbre = 0
    
    def __init__(self, x, y, capacity, fund, cost, gestion): 
        self.id = Entreprise.nbre
        self.x = x
        self.y = y
        self.capacity = capacity
        self.fund = fund
        self.cost = cost
        self.gestion = gestion
        self.buyList = []
        self.sellList = []
        self.produit = None
        self.stock = [0]*Objet.nbre
        self.price = [0]*Objet.nbre
        self.faillite = False
        
        self.vitIde = [0]*Objet.nbre
        self.vitEnt = [0]*Objet.nbre
        self.vitSor = [0]*Objet.nbre
        self.minPrice = [0]*Objet.nbre
        self.moyBuyPrice = [0]*Objet.nbre
        self.commandSell = []
        self.commandBuy = []
        self.limitStock = [0]*Objet.nbre
        self.attente = 0
        self.lisSor = [DonneeExpo(0.999) for i in range(Objet.nbre)]
        self.lisEnt = [DonneeExpo(0.999) for i in range(Objet.nbre)]
        self.lisFund = DonneeMoy(100)
        self.lisPrice = [DonneeMoy(100) for i in range(Objet.nbre)]
        self.stockSor = [0]*Objet.nbre
        self.stockEnt = [0]*Objet.nbre
        self.timeSor = [0]*Objet.nbre
        self.timeEnt = [0]*Objet.nbre
        
        Entreprise.nbre += 1
        
    def temps(self, ent):
        """Temps d'une livraison entre deux entreprises"""
        return ceil(sqrt((self.x - ent.x)**2 + (self.y - ent.y)**2) * 2)
        
class Magasin(Entreprise):
    """
    Définie la structure de magasin.
    Un magasin achète des matières premières pour les revendre à des particuliers
    """
    
    def __init__(self, x, y, capacity, fund, cost, gestion, listObj, price):
        Entreprise.__init__(self, x, y, capacity, fund, cost, gestion)
        self.buyList = listObj
        self.sellList = listObj
        
        n = len(listObj)
        for i in range(n):
            o = listObj[i]
            self.price[o.id] = price[i]
            self.vitIde[o.id] = 1/o.time
            self.limitStock[o.id] = self.capacity/n
            o.addPurchaser(self)
            
class Usine(Entreprise):
    """
    Définie la structure d'usine.
    Une usine produit à partir de ressources déja existantes
    """
    
    def __init__(self, x, y, capacity, fund, cost, gestion, produit, price):
        Entreprise.__init__(self, x, y, capacity, fund, cost, gestion)
        self.produit = produit
        self.buyList = produit.ingredient[:]
        self.sellList = [produit]
        
        for o in self.buyList:
            o.addPurchaser(self)
        
        produit.addProduction(self)
        self.price[produit.id] = price
        self.vitIde[produit.id] = 1/produit.time
            
    def devis(self, ent, qte):
        """Produit un devis donnant le prix et le temps nécessaire pour livrer une quantité donnée"""
        p = self.price[self.produit.id]
        t = self.temps(ent)
        q = 0
        if(self.attente != 0):
            q = qte
        else:
            q = max(0, qte - self.stock[self.produit.id])
        t += self.attente + q*(self.produit.time)
        return (p, t)
        
    def newCommand(self, ent, qte):
        """Prend note d'une nouvelle commande"""
        c = {"ent" : ent, "qte" : qte, "price" : self.price[self.produit.id]}
        self.commandSell.append(c)
        q = qte
        if self.attente == 0:
            q = max(0, qte - self.stock[self.produit.id])
        self.attente += q * self.produit.time
            
            
class Producteur(Entreprise):
    """
    Définie la structure de producteur.
    Un producteur produit des matières premières
    """
    
    def __init__(self, x, y, capacity, fund, cost, gestion, produit, price):
        Entreprise.__init__(self, x, y, capacity, fund, cost, gestion)
        self.sellList = [produit]
        self.produit = produit
        self.price[produit.id] = price
        produit.addProduction(self)
        
    def devis(self, ent, qte):
        p = self.price[self.produit.id]
        t = self.temps(ent)
        q = 0
        if(self.attente != 0):
            q = qte
        else:
            q = max(0, qte - self.stock[self.produit.id])
        t += self.attente + q*(self.produit.time)
        return (p, t)
        
    def newCommand(self, ent, qte):
        c = {"ent" : ent, "qte" : qte, "price" : self.price[self.produit.id]}
        self.commandSell.append(c)
        q = qte
        if self.attente == 0:
            q = max(0, qte - self.stock[self.produit.id])
        self.attente += q * self.produit.time
        
class Action():
    """
    Définie la structure d'action.
    Une action est le seul moyen pour une entreprise d'influer sur son stock, son argent
    Attributs :
        - t     : Temps avant que l'action ne se termine
        - data  : Donnée nécessaires pour exécuter l'action
        - rem   : Comandes à exécuter à la fin de l'action
    """
    
    def __init__(self, t, data, ini, rem):
        self.t = t
        self.data = data
        self.rem = rem
        
        ini(data)
        
    def __del__(self):
        self.rem(self.data)
        
    def decremente(self):
        self.t -= 1
        
class World():
    """
    Structure représentant l'environnement des entreprise
    Attributs :
        - ent   : Liste des entreprises de l'économie
        - obj   : Liste des objets de l'économie
        - act   : Liste des actions en cours
        - t     : Nombre de tours effectués
        - te    : Nombre de tours à vide effectués
    """
    
    ent = []
    obj = []
    act = []
    t = 0
    te = 0
    
    def init():
        World.ent = []
        World.obj = []
        World.act = []
        World.t = 0
        Entreprise.nbre = 0
        Objet.nbre = 0
        
    def addObjet(time, cost, base, ingredient = [], qte = []):
        """Ajoute un objet au monde"""
        World.obj.append(Objet(time, cost, base, [World.obj[j] for j in ingredient], qte))
        
    def addMagasin(x, y, capacity, fund, cost, gestion, listObj, price):
        """Ajoute un magasin au monde"""
        World.ent.append(Magasin(x, y, capacity, fund, cost, gestion, [World.obj[j] for j in listObj], price))
        
    def addUsine(x, y, capacity, fund, cost, gestion, produit, price):
        """Ajoute une usine au monde"""
        World.ent.append(Usine(x, y, capacity, fund, cost, gestion, World.obj[produit], price))
        
    def addProducteur(x, y, capacity, fund, cost, gestion, produit, price):
        """Ajoute un producteur au monde"""
        World.ent.append(Producteur(x, y, capacity, fund, cost, gestion, World.obj[produit], price))
        
    def makeTour():
        """Effectue un tour"""
        World.t += 1
        
        #Avancement des actions
        l = World.act[:]
        q = []
        while l != []:
            a = l.pop(0)
            a.decremente()
            if a.t == 0:
                del(a)
            else:
                q.append(a)
        World.act = q
        
        #Gestion des entreprises
        for e in World.ent:
            if not(e.faillite):
                if type(e) == Magasin:
                    World.sellCustomer(e)
                if not(World.taxe(e)):
                    World.setFaillite(e)
                e.gestion(e)
        
    def makeEmptyTour():
        """Effectue un tour à vide (à fonds et prix constants"""
        World.te += 1
        
        #Sauvegarde des fonds et des prix
        f = [World.ent[i].fund for i in range(Entreprise.nbre)]
        p = [World.ent[i].price[:] for i in range(Entreprise.nbre)]
        
        #Avancement des actions
        l = World.act[:]
        q = []
        while l != []:
            a = l.pop(0)
            a.decremente()
            if a.t == 0:
                del(a)
            else:
                q.append(a)
        World.act = q
        
        #Gestion des entreprises
        for e in World.ent:
            if not(e.faillite):
                if type(e) == Magasin:
                    World.sellCustomer(e)
                if not(World.taxe(e)):
                    World.setFaillite(e)
                e.gestion(e)
        
        #Restauration des fonds et des prix
        for i in range(Entreprise.nbre):
            World.ent[i].fund = f[i]
            World.ent[i].price = p[i]
                
    def loop(p):
        """Effectue plusieurs tours"""
        for j in range(p):
            World.makeTour()
            
    def loopEmpty(p):
        """Effectue plusieurs tours à vide"""
        for j in range(p):
            World.makeEmptyTour()
            
    def makeSimulation(empty, time):
        """Lance la simulation et affiche les courbes de résultats"""
        World.loopEmpty(empty)
        World.loop(time)
        World.plotWorld()
                
    def sellCustomer(ent):
        """Simule l'action des consommateurs"""
        for o in ent.buyList:
            p = ent.price[o.id]
            b = o.basePrice
            m = pow(10, 1 - (p/b))
            qte = (1 + 3*random())*m/2
            qte = min(qte, ent.stock[o.id])
            ent.stock[o.id] -= qte
            ent.stockSor[o.id] += qte
            ent.fund += p*qte
            
    def taxe(ent):
        """Simule les couts de maintenance, les salaires et les taxes"""
        if(ent.fund < ent.cost):
            return False
        else:
            ent.fund -= ent.cost
            return True
            
    def setFaillite(ent):
        """Met en faillite une entreprise"""
        ent.faillite = True
        
    def deliver(ent1, ent2, qte, price):
        """Initialise l'action de livraison"""
        data = {"ent1" : ent1, "ent2" : ent2, "qte" : qte, "price" : price}
        a = Action(ent1.temps(ent2), data, actionDeliverIni, actionDeliverRem)
        World.act.append(a)
        
    def product(ent, qte):
        """Initialise l'action de production"""
        data = {"ent" : ent, "qte" : qte}
        a = Action(1, data, actionProductionIni, actionProductionRem)
        World.act.append(a)
        
    def plotWorld():
        """Affiche les courbes"""
        fig = figure()
        fig.subplots_adjust(hspace = 0.2)

        #courbes des fonds
        figure1 = fig.add_subplot(221)
        title("fond")
        for e in World.ent:
            plot(e.lisFund.lis[World.te:], label=("ent" + str(e.id)))
        legend()
        
        #courbes des prix
        figure2 = fig.add_subplot(222)
        title("prix")
        for e in World.ent:
            for o in e.sellList:
                plot(e.lisPrice[o.id].lis[World.te:], label=("ent" + str(e.id) + "- obj" + str(o.id)))
        legend()

        #courbes des vitesses de sortie
        figure3 = fig.add_subplot(223)
        title("vitesse sortante")
        for e in World.ent:
            for o in e.sellList:
                plot((e.lisSor[o.id].lis + e.lisSor[o.id].lisv)[World.te:], label=("ent" + str(e.id) + "- obj" + str(o.id)))
        legend()

        #courbes des vitesses d'entrée 
        figure4 = fig.add_subplot(224)
        title("vitesse entrante")
        for e in World.ent:
            for o in e.sellList:
                plot((e.lisEnt[o.id].lis + e.lisEnt[o.id].lisv)[World.te:], label=("ent" + str(e.id) + "- obj" + str(o.id)))
        legend()
        show()
        
def actionDeliverIni(data):
    """initialise la livraison"""
    e1 = data["ent1"]
    qte = data["qte"]
    obj = e1.produit
    
    e1.stock[obj.id] -= qte
    e1.stockSor[obj.id] += qte
    
def actionDeliverRem(data):
    """Termine la livraison"""
    e1 = data["ent1"]
    e2 = data["ent2"]
    qte = data["qte"]
    p = data["price"]
    obj = e1.produit
    
    e1.fund += p*qte
    e2.fund -= p*qte
    e2.stock[obj.id] += qte
    e2.stockEnt[obj.id] += qte
    e2.commandBuy.remove(obj)
    e2.moyBuyPrice[obj.id] = (e2.stock[obj.id]/qte - 1)*e2.moyBuyPrice[obj.id] + (e2.stock[obj.id]/qte)*p
    
def actionProductionIni(data):
    """Initialise la production"""
    e = data["ent"]
    qte = data["qte"]
    obj = e.produit
    p = obj.cost
    
    for j in range(len(obj.ingredient)):
        e.stock[obj.ingredient[j].id] -= qte * obj.qte[j]
    e.fund -= p*qte
    
def actionProductionRem(data):
    """Termine la production"""
    e = data["ent"]
    qte = data["qte"]
    obj = e.produit
    
    e.stock[obj.id]  += qte
    e.stockEnt[obj.id] += qte
        
def gestionPriceMagasin(ent, a, b):
    """Gestion des prix des magasins"""
    vs = sum(ent.vitSor)
    c = ent.cost
    for o in ent.sellList:
        j = o.id
        v = ent.vitSor[j]
        m = ent.moyBuyPrice[j]
        vi = len(o.entProd)/(len(o.entBuy)*o.time)
        vi = b*vi
        p = (v - vi)/vi
        ent.vitIde[j] = vi
        if vs != 0:
            ent.minPrice[j] = (v/vs)*c + m
        else:
            ent.minPrice[j] = c + m
        ent.price[j] *= 1 + a*p
        ent.price[j] = max(ent.minPrice[j], ent.price[j])
        
def gestionPriceUsine(ent, a, b):
    """Gestion des prix des usines"""
    vs = sum(ent.vitSor)
    c = ent.cost
    o = ent.produit
    j = o.id
    v = ent.vitSor[j]
    m = ent.moyBuyPrice[j]
    vi = min([len(ing.entProd)/(len(ing.entBuy)*ing.time) for ing in o.ingredient])
    vi = min(vi, 1/o.time)
    vi = b*vi
    p = (v - vi)/vi
    ent.vitIde[j] = vi
    if vs != 0:
        ent.minPrice[j] = (v/vs)*c + m
    else:
        ent.minPrice[j] = c + m
    ent.price[j] *= 1 + a*p
    ent.price[j] = max(ent.minPrice[j], ent.price[j])
        
def gestionPriceProducteur(ent, a, b):
    """Gestion des prix des producteurs"""
    vs = sum(ent.vitSor)
    c = ent.cost
    o = ent.produit
    j = o.id
    m = o.cost
    v = ent.vitSor[j]
    vi = b/(o.time)
    p = (v - vi)/vi
    ent.vitIde[j] = vi
    ent.minPrice[j] = (c/vi) + m
    ent.price[j] *= 1 + a*p
    ent.price[j] = max(ent.minPrice[j], ent.price[j])

def gestionDeliver(ent):
    """Gestion des livraisons"""
    l = ent.commandSell
    obj = ent.produit
    while(l != [] and ent.stock[obj.id] >= l[0]["qte"] ):
        c = l.pop(0)
        World.deliver(ent, c["ent"], c["qte"], c["price"])
        del(c)
                
def gestionStockMagasin(ent, alpha):
    """Gestion des stocks des magasins"""
    sv = sum(ent.vitSor)
    for o in ent.buyList:
        j = o.id
        if sv != 0:
            ent.limitStock[j] = ent.capacity*(ent.vitSor[j]/sv)
        if not(o in ent.commandBuy):
            qte = ent.limitStock[j]
            m = o.entProd
            n = len(m)
            if n != 0:
                p = []
                t = []
                for i in range(n):
                    a, b = m[i].devis(ent, qte)
                    p.append(a)
                    t.append(b)
                p0 = sum(p)/n
                t0 = sum(t)/n
                k = 0
                r = a*(p[0]/p0)**2 + (t[0]/t0)**2
                for i in range(n):
                    s = alpha*(p[i]/p0)**2 + (t[i]/t0)**2
                    if r > s:
                        k = i
                        r = s
                qte = min(ent.fund/p[k], qte)
                p1, t1 = m[k].devis(ent, 0)
                a = (t[k] - t1)/ent.limitStock[j]
                b = t1
                v = ent.vitSor[j]
                se = ent.limitStock[j] + v*b - qte*(1 - v*a)
                if(ent.stock[j] <= se):
                    ent.commandBuy.append(o)
                    m[k].newCommand(ent, qte)
                    
def gestionStockUsine(ent, alpha):
    """Gestion des stocks des usines"""
    sv = sum(ent.produit.qte)
    for jo in range(len(ent.buyList)):
        o = ent.buyList[jo]
        j = o.id
        ent.limitStock[j] = (ent.capacity - ent.stock[ent.produit.id])*(ent.produit.qte[j]/sv)
        if not(o in ent.commandBuy) and ent.limitStock[j] != 0:
            qte = ent.limitStock[j]
            m = o.entProd
            n = len(m)
            if n != 0:
                p = []
                t = []
                for i in range(n):
                    a, b = m[i].devis(ent, qte)
                    p.append(a)
                    t.append(b)
                p0 = sum(p)/n
                t0 = sum(t)/n
                k = 0
                r = a*(p[0]/p0)**2 + (t[0]/t0)**2
                for i in range(n):
                    s = alpha*(p[i]/p0)**2 + (t[i]/t0)**2
                    if r > s:
                        k = i
                        r = s
                qte = min(ent.fund/p[k], qte)
                p1, t1 = m[k].devis(ent, 0)
                a = (t[k] - t1)/ent.limitStock[j]
                b = t1
                v = ent.produit.qte[jo]/ent.produit.time
                se = ent.limitStock[j] + v*b - qte*(1 - v*a)
                if(ent.stock[j] <= se):
                    ent.commandBuy.append(o)
                    m[k].newCommand(ent, qte)
                
def gestionProduction(ent):
    """Geston de la production"""
    p = ent.produit
    if(ent.capacity > ent.stock[p.id]):
        pr = min(ent.capacity - ent.stock[p.id], 1/ent.produit.time)
        l = ent.produit.ingredient
        q = ent.produit.qte
        for i in range(len(l)):
            pr = min(pr, ent.stock[l[i].id]/q[i])
        if ent.commandSell == []:
            pr = min(pr, ent.vitSor[p.id])
        if pr != 0:
            World.product(ent, pr)
            
def gestionStat(ent):
    """Gestion des données de l'entreprise"""
    ent.attente = max(ent.attente - 1, 0)
    
    for j in range(Objet.nbre):
        if ent.stockSor[j] != 0:
            x = ent.stockSor[j]/ent.timeSor[j]
            for i in range(ent.timeSor[j]):
                ent.lisSor[j].append(x)
            ent.timeSor[j] = 1
            ent.stockSor[j] = 0
        else:
            ent.lisSor[j].append(0)
            ent.timeSor[j] +=1
        if ent.stockEnt[j] != 0:
            x = ent.stockEnt[j]/ent.timeEnt[j]
            for i in range(ent.timeEnt[j]):
                ent.lisEnt[j].append(x)
            ent.timeEnt[j] = 1
            ent.stockEnt[j] = 0
        else:
            ent.lisEnt[j].append(0)
            ent.timeEnt[j] +=1
        ent.vitSor[j] = ent.lisSor[j].mv
        ent.vitEnt[j] = ent.lisEnt[j].mv
        ent.lisPrice[j].append(ent.price[j])
    ent.lisFund.append(ent.fund)
    
def gestionMagasin(ent):
    """Gestion des magasins"""
    gestionStat(ent)
    gestionStockMagasin(ent, 5)
    gestionPriceMagasin(ent, 0.3, 0.95)
    
def gestionUsine(ent):
    """Gestion des usines"""
    gestionStat(ent)
    gestionStockUsine(ent, 5)
    gestionProduction(ent)
    gestionPriceUsine(ent, 0.3, 0.95)
    gestionDeliver(ent)
    
def gestionProducteur(ent):
    """Gestion des producteurs"""
    gestionStat(ent)
    gestionProduction(ent)
    gestionPriceProducteur(ent, 0.3, 0.95)
    gestionDeliver(ent)
    
##Exemple de simulation

World.init()

World.addObjet(0.2, 5, 10)
World.addObjet(0.2, 2, 17, [0], [1])

World.addProducteur(1, 1, 2000, 20000, 5, gestionProducteur, 0, 7)
World.addProducteur(1, 1, 2000, 20000, 5, gestionProducteur, 0, 7)
World.addProducteur(1, 1, 2000, 20000, 5, gestionProducteur, 0, 7)

World.addUsine(2, 2, 1000, 20000, 5, gestionUsine, 1, 13)
World.addUsine(2, 2, 1000, 20000, 5, gestionUsine, 1, 13)
World.addUsine(2, 2, 1000, 20000, 5, gestionUsine, 1, 13)

World.addMagasin(3, 3, 500, 20000, 5, gestionMagasin, [1], [17])
World.addMagasin(3, 3, 500, 20000, 5, gestionMagasin, [1], [17])
World.addMagasin(3, 3, 500, 20000, 5, gestionMagasin, [1], [17])

World.makeSimulation(1000, 10000)

This snippet took 0.04 seconds to highlight.

Back to the Entry List or Home.

Delete this entry (admin only).