Discussion :

[Timothy142857]

Bonjour à tous,

développeur de profession, je travaille actuellement sur un projet perso de jeu de stratégie/gestion.
Je chercher à écrire une fonction pour une certaine fonctionnalité, mais je galère de base pour l'algo.


Je vais tenter d'expliquer ce que je veux faire:


J'ai une certaine réserve de céréales qui contient un volume V de céréales

J'ai une production de céréales qui est donc en unité volume/temps

J'ai un certain nombre de soldats nb qui ont chacun une conso qui est aussi un volume/temps

Chaque soldat vaut un certain montant de céréales = valeurCC

la production de céréales, valeurCC et la conso des soldats sont des constantes

La balance globale du coup équivaut à: balance = production - nb * conso

Le temps avant que le volume n'atteigne 0 est donc: V / balance

Ma formule va justement concerner cette étape suivante de quand le volume de céréales est à 0 ou presque


J'ai décidé que lorsque le stock de céréales est totalement vide, un soldat meure (nb = nb - 1) et la valeurCC du soldat vient s'ajouter au stock
Le stock qui était de 0 contient donc après la mort par la famine d'un soldat de sa valeurCC

Ce nouveau stock de céréales va donc s'écouler légèrement moins vite.

Et cela continue jusqu'à ce que la balance revienne a 0



Voila en gros ce que je souhaite essayer de calculer xD


Sous forme pseudo-code ça donnera quelque chose comme ça:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
const valeurCC, prod, conso;
var nbSoldats, stockInitial, time;
 
 
function getResultOverTime(nbSoldats, stockInitial, time){
   //return nbSoldatsStillAlive, newStock
}

Je vous remercie d'avoir pris le temps de lire, et suis ouvert à tout conseil ou autre pour me montrer la voie. Si vous avez envie de me donner tout le pseudo code déjà fonctionnel, ça me va aussi

[tbc92]

Si le nombre de soldats initial n'est pas énorme (moins de 50) Je verrais bien un truc récursif, pour se faire plaisir..

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
fct ( nbre_soldats, stock, time , duree0)
duree = stock / (nbre_soldats * conso)   // Pas très clair,  je crois que j'ai oublié un truc : le réservoir se remplit  via PRODUCTION
si time > duree alors 
   stock000 = ValeurCC
   renvoyer fct ( nbre_soldats-1, stock000, time-duree, duree0+duree)
sinon
   renvoyer (nbre_soldats,  duree0 + duree)
fin

Cette fonction se rappelle elle-même autant de fois que nécessaire ( à chaque fois qu'un soldat meurt ). Donc on peut être limité par la taille de la pile d'appels.

Ca peut se réécrire autrement, sans récursivité s'il le faut, avec une boucle WHILE

[anapurna]

salut

RCVm3 => "Reserve"
PCVm3_Tps => "Production"
Soldat => "Soldat"
NbSoldat => "Nb Soldat"

ConsoSoldaVm3_Tps => "Conso Soldat"

si ton equation doit etre a zero

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
Balance    = PCVm3_Tps -(NbSoldat *ConsoSoldaVm3_Tps) =>  0    = PCVm3_Tps -(NbSoldat *ConsoSoldaVm3_Tps)
=> (NbSoldat *ConsoSoldaVm3_Tps) = PCVm3_Tps

=> on sais que la produtction est stable quand

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

NbSoldatEquilibre  = PCVm3_Tps /ConsoSoldaVm3_Tps

jusque là on ne touche pas aux reserves

on considère que l’équation est a l’équilibre
si le nombre de soldat est plus important les resserves vont commencer a être entamer
comme la réserve ne bouges pas tu sais que le nb de soldat pour un laps de temps donnée
ne pourra pas excéder NbSoldaRes = RCVm3/ConsoSoldaVm3_Tps dans ce cas là tu détermine ne nombre de temps qu'il te reste
pour un soldat
ou a l'inverse le nombre de soldat pour un temps donnée

dans ton cas on peut ne s'occuper que de la réserve le reste pouvant être a l’équilibre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
reserve :=  RCVm3;
TANSQUE reserve > 0 FAIRE
begin
   NbSoldaRes =   reserve/ConsoSoldaVm3_Tps
   SI NbSoldatEquilibre < NbSoldat Alors 
   FAIRE
       NBSoldSup = NbSoldat-NbSoldatEquilibre ; 
       SI NBSoldSup > NbSoldaRes Alors 
         NbSoldat = NbSoldat- (NBSoldSup-NbSoldaRes)
      FinSI   
       reserve = reserve -(NBSoldSup*ConsoSoldaVm3_Tps)
       SI   reserve < 0 ALORS 
          reserve = 0;
       FinSI
   FinSI
end;

[pseudocode]

Je reprend l'idée de @tbc92 sur la fonction récursive.

La formulation naïve est simple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
fct (nbSoldats, stockInitial, time) {
  balance = production - nbSoldats*conso
  StockFinal = stockInitial + time*balance
  return nbSoldats, StockFinal
}

Si ce calcul donne un StockFinal positif (ou nul), alors c'est qu'on avait une balance positive ou alors qu'on avait assez de stock pour nourrir tous les soldats.
Si ce calcul donne un StockFinal négatif, alors on doit gérer plus finement le passage à zéro du stock.

Le moment où le stock est vide est tel que StockFinal=0 => stockInitial+T0*balance=0 => T0=-stockInitial/balance
A ce moment précis "T0", on perd un soldat et on augmente le stock (qui était à zéro) de ValeurCC.

On se retrouve alors avec le problème de départ mais avec des valeurs différentes:
Un soldat en moins, un stockInital de ValeurCC et une échelle de temps qui commence à T0.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
fct (nbSoldats, stockInitial, time) {
  balance = production - nbSoldats * conso
  StockFinal = stockInitial + time*balance
  if (StockFinal >=0 ) return nbSoldats, StockFinal
 
  T0=-stockInitial/balance
  return fct(nbSoldats-1, ValeurCC, time-T0)
}