mengenzunahme aus zwei zeiten + zunahme/h

[glkgereon]

hi

ich hab einen timer, und jede sekunde soll eine menge, die jede stunde um eine bestimmte menge steigt hochgezählt werden

ich wollte das so machen:

Delphi-Quellcode:

procedure TForm1.Timer2Timer(Sender: TObject);
var jetzt:TDatetime;
begin
  jetzt:=now;
  t_da:=t_da+round(t_prod/(jetzt-lasttime));
  lasttime:=now;
end;

also, jetzt-lasttime is die zeit die seit dem letzten aufruf vergangen ist....

t_da soll die menge repräsentieren

die division:
t_prod ist die zunahme pro stunde *24 -> pro tag
geteilt durch
die verbrauchte zeit in tagen


aber die werte sind viel zu groß, wo ist der fehler?

[fiasko]

Du mußt das Multiplizieren, Bsp:

für 12h -> TDateTime ist 0.5 -> t_prod*24*0.5 = t_prod*12
das sollte dann klappen

[glkgereon]

also statt dem

t_da:=t_da+round(t_prod/(jetzt-lasttime)); das
t_da:=t_da+round(jetzt-lasttime)*t_prod*24*12; richtig so?

[fiasko]

Ne, das war doch nur ein Rechenbeispiel um dir zu verdeutlichen wie es richtig geht.

Code:

t_da:=t_da+round(t_prod*(jetzt-lasttime));

sollte dann die richtige Formel sein.

[edit]
Ah, das Mißverständnis liegt bei meiner ersten Formel, dort wollte ich eigentlich t_proh statt t_prod schreiben
[/edit]

[glkgereon]

aber der wert si komisch, denn wenn ich meine werte geladen hab, dann springt der wert einal um roesig viel, und dann is ende

ich poste mal mehr von meinem code...

Delphi-Quellcode:

var
  Form1: TForm1;
  needed, lasttime:TDateTime;
  m_da, k_da, t_da:integer;
  m_need, k_need, t_need:integer;
  m_prod, k_prod, t_prod:integer;
  longestres, tobuild:string;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var
  m_needed, k_needed, t_needed:TDateTime;
begin
  //werte einlesen
  tobuild:=LabeledEdit2.Text;
  m_prod:=Spin_h_metall.Value;
  k_prod:=Spin_h_kristall.Value;
  t_prod:=Spin_h_tritium.Value;
  m_need:=Spin_needed_metall.Value;
  k_need:=Spin_needed_kristall.Value;
  t_need:=Spin_needed_tritium.Value;
  m_da:=Spin_da_metall.Value;
  k_da:=Spin_da_kristall.Value;
  t_da:=Spin_da_tritium.Value;

  //längste spanne ausrechnen
  m_needed:=(m_need-m_da)/m_prod;
  k_needed:=(k_need-k_da)/k_prod;
  t_needed:=(t_need-t_da)/t_prod;
  //größte zeitspanne
  if (m_needed>k_needed) and (m_needed>t_needed)
  then  begin
        needed:=m_needed;
        longestres:='Metall';
        end
  else if (k_needed>m_needed) and (k_needed>t_needed)
  then  begin
        needed:=k_needed;
        longestres:='Kristall';
        end
  else if (t_needed>m_needed) and (t_needed>k_needed)
  then  begin
        needed:=t_needed;
        longestres:='Tritium';
        end;
  //timer
  Timer1.Enabled:=true;
end;

procedure TForm1.Timer1Timer(Sender: TObject);
begin
  needed:=needed-(1/24/60/60);
  LabeledEdit1.Text:=timetostr(needed);
end;

procedure TForm1.Button3Click(Sender: TObject);
var temp:TStringList;
begin
  temp:=TStringList.Create;
  temp.Add(inttostr(m_prod));
  temp.Add(inttostr(k_prod));
  temp.Add(inttostr(t_prod));
  temp.Add(inttostr(m_da));
  temp.Add(inttostr(k_da));
  temp.Add(inttostr(t_da));
  temp.Add(inttostr(m_need));
  temp.Add(inttostr(k_need)); 
  temp.Add(inttostr(t_need));
  temp.Add(tobuild);
  temp.Add(timetostr(lasttime));
  temp.SaveToFile('data.dat');
  temp.Free;
end;

procedure TForm1.Button2Click(Sender: TObject);
var
  temp:TStringList;
begin
  temp:=TStringList.Create;
  try
    temp.LoadFromFile('Data.dat');
    //auslesen
    m_prod:=strtoint(temp[0]);
    k_prod:=strtoint(temp[1]);
    t_prod:=strtoint(temp[2]);
    m_da:=strtoint(temp[3]);
    k_da:=strtoint(temp[4]);
    t_da:=strtoint(temp[5]);
    m_need:=strtoint(temp[6]);
    k_need:=strtoint(temp[7]);
    t_need:=strtoint(temp[8]);
    tobuild:=temp[9];
    lasttime:=strtotime(temp[10]);
  
    //in spinedits rein
    Spin_h_metall.Value:=m_prod;
    Spin_h_kristall.Value:=k_prod;
    Spin_h_tritium.Value:=t_prod;
    Spin_needed_metall.Value:=m_need;
    Spin_needed_kristall.Value:=k_need;
    Spin_needed_tritium.Value:=t_need;
    Spin_da_metall.Value:=m_da;
    Spin_da_kristall.Value:=k_da;
    Spin_da_tritium.Value:=t_da;
    LabeledEdit2.Text:=tobuild;
  except
    Application.MessageBox('Bitte erst speichern...','Erst speichern');
  end;
  temp.Free;
end;

procedure TForm1.Timer2Timer(Sender: TObject);
var jetzt:TDatetime;
begin
  jetzt:=now;
//Hierum gehts
  //m_da:=m_da+round((jetzt-lasttime)*24*m_prod);
  //k_da:=k_da+round((jetzt-lasttime)*24*k_prod);
  //t_da:=t_da+round((jetzt-lasttime)*t_prod);
  t_da:=t_da+round(t_prod*(jetzt-lasttime));
  lasttime:=now;
  Spin_da_metall.Value:=m_da;
  Spin_da_kristall.Value:=k_da;
  Spin_da_tritium.Value:=t_da;
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  lasttime:=now;
end;

so, die ganzen spins sind spineditt, wo die werte eingetragen werden

spin_h für produktion
spin_da für bestand
spin_needed für benötigt
jeweils in metall, kristall, tritium

dann jeweils variablen dazu

weiss einer wie ichs besser/einfacher machen könnte?


so, nun zu ,meiner frage: kann es sein das ein fehler beim laden der zeit kommt?

das am anfang noch tage dabeisind, oder sowas?


EDIT: Mann nehme time!!! es funzt mit time

danke schonmal

kann man den quelltr4xt noch einfacher/übersichtlicher machen?

[fiasko]

Zitat von glkbkk:

aber der wert si komisch, denn wenn ich meine werte geladen hab, dann springt der wert einal um roesig viel, und dann is ende

Ich würde erstmal

lasttime:=now; in der Timer2Timer Methode durch

lasttime:=jetzt; ersetzen, ansonsten geht dir Zeit flöten.

In welchen Timerintervallen läuft denn der Timer2? Vielleicht ist das einfach zu kurz, so das t_da ab einem gewissen Punkt immer zur gleichen Ganzzahl gerundet wird -> entweder Timer Intervall erhöhen oder desser die *_da zu Fließkommazahlen machen und nur zu Ausgabe runden.

Dann würde ich mir überlegen ob das mit der Redundanz so gut ist. Du hast einmal die noch benötigte Zeit needed - auf der anderen Seite wartest du bis genügen Materialien da sind. Da wird es aber Abweichungen geben, da du ja rundest...

[glkgereon]

ja, ich setzt lasttime ma auf jetzt, gute idee

Zitat:

In welchen Timerintervallen läuft denn der Timer2? Vielleicht ist das einfach zu kurz, so das t_da ab einem gewissen Punkt immer zur gleichen Ganzzahl gerundet wird -> entweder Timer Intervall erhöhen oder desser die *_da zu Fließkommazahlen machen und nur zu Ausgabe runden.

Dann würde ich mir überlegen ob das mit der Redundanz so gut ist. Du hast einmal die noch benötigte Zeit needed - auf der anderen Seite wartest du bis genügen Materialien da sind. Da wird es aber Abweichungen geben, da du ja rundest...

timer 2 läuft in 5s-intervallen, wollt ich aber auf 1s verkürzen...

*_da nach extended.... wär zu überlegen, wird getestet!!

was is redundanz???

die rundungsfehler werden nach den genannten verbesserungen minimal sein...
....hoffe ich

[fiasko]

Zitat von glkbkk:

was is redundanz???

Du hast die Zeit wie lange noch "gebaut" werden muß einmal durch das needed explizit gegeben und implizit durch die *_prod und *_needed Werte (also kannst das zu jedem Zeitpunkt daraus neu ausrechnen). Redundanz ist i.A. zu Datenhaltung plöd, weil das meist Speicherplatzverschwendung und zu inkonsistenz führen kann (dafür macht es evtl. die Geschwindigkeit schneller, weil man weniger aufwendig rechnen muß wenn man beide Werte oft brauch).

Bei dir könnte dann vorallem eine inkonsistenz zwischen der needed Zeit und dem produzierten Rohstoffen entstehen, je nachdem wie groß deine wirklichen Zahlenwerte dann sind ist das vielleicht garnicht so ersichtlich...