SuperStrict

TWurfel.Add 8,[3,1,4],[1,2,0]
TWurfel.Add 8,[3,1,4],[1,2,0]
TWurfel.Add 8,[4,4],[0,-1]

TWurfel.JetztWurfeln

Type TWurfel
	Global Liste:TList=New TList
	Field Nenner%, Oft%[8], Ergebnis%[8], Prozent#[8]
		
	Function Add(Nenner%, Oft%[],Ergebnis%[])
		Print "Nehme neuen Wuerfel auf"
		Local loc:TWurfel=New TWurfel
		loc.Nenner=Nenner
		loc.Oft=Oft
		loc.Ergebnis=Ergebnis
		loc.Berechne
		Liste.AddLast loc
		Print 	
	End Function


	Function JetztWurfeln()
		Local Nr%
		Print "J E T Z T   K O M B I N A T I O N E N   B E R E C H N E N "
		For Local loc:Twurfel=EachIn Liste
			nr=nr+1
			Print 
			Print nr + ". Wuerfel einbringen"
			loc.AddResults
		Next
	End Function 
	
	
	Method Berechne()
		For Local i%=0 To Oft.Length-1
		
			Local P#=Oft[i] 
			Prozent[i]=P/Nenner
			Print Prozent[i]
		Next
	End Method
	

	Method AddResults()
		TResult.ResetNeuListe
		For Local i%=0 To Oft.Length-1
			TResult.Add Prozent[i],Ergebnis[i]
		Next
		TResult.BerechneTable
		TResult.PackListe
	End Method
	
	
	
End Type 



Type TResult
	Field P#,E%
	Global AltListe:TList=New TList
	Global NeuListe:TList=New TList
	Global ZielListe:TList=New TList
	
		
	Function ResetNeuListe()
		Neuliste.Clear()
	End Function 
	
	
	Function Add (Prozent#,E%)
		Local loc:TResult=New TResult
		loc.P=Prozent
		loc.E=E
		NeuListe.AddLast loc
	End Function 

	
	Function BerechneTable()
		ZielListe.Clear()
		If AltListe.count()=0
			Print "STARTUP (weil 1.Wuerfel)"
				For Local neu:TResult = EachIn NeuListe
					Local ziel:TResult=New TResult
					ziel.E= neu.e
					ziel.P= neu.p
					ZielListe.AddLast Ziel
				Next
		Else
			Print "JEDER MIT JEDEM"
			For Local alt:TResult = EachIn AltListe
				For Local neu:TResult = EachIn NeuListe
					Local ziel:TResult=New TResult
					ziel.E=alt.E + neu.e
					ziel.P= alt.P*neu.p
					ZielListe.AddLast Ziel
				Next
			Next
		EndIf
	End Function
	
	
	Function PackListe()
		Local Anzahl%, Erfolg%
		Print ""
		Print "ZWISCHENERGEBNIS"
		For Local ziel:TResult = EachIn ZielListe
				Print "ERFOLG=" + ziel.E + "  Wahrscheinlichkeit=" + (Ziel.p*100) +"%"
		Next
		Print ""
		Print "---> Liste  straffen und zur Alt-Liste machen"
		AltListe.Clear()
		For Local ziel:TResult = EachIn ZielListe
			Local Erfolg%=0
			For Local vorher:TResult=EachIn AltListe
				If ziel.E = vorher.E
					Erfolg=1
					Print "zusammelegungserfolg bei" +vorher.E
					Vorher.P = Vorher.P + Ziel.P
				EndIf
			Next
			If Erfolg=0
				Anzahl=Anzahl+1
				AltListe.AddLast ziel
			EndIf
		Next
		Print " "
		Print "FINALES ERGEBNIS"
		For Local alt:TResult = EachIn AltListe
				Print "ERFOLG=" + alt.E + "  Wahrscheinlichkeit=" + (alt.p*100) +"%"
		Next
		Print "Anzahl der Kombinationen aktuell=" + Anzahl
		Print "_____________________________________________________________"
	End Function

End Type

SuperStrict
Const WINDICE:Int = 4
Const FAILDICE:Int = 4
Const SIDEPERDICE:Int = 8
Global StepSize:Int, shiftsize:Int

Global Successes:Int[] = [0 , 0 , 0 , 0 , 1 , 1 , 1 , 2]
Global Losses:Int[] = [0 , 0 , 0 , 0 , -1 , - 1 , - 1 , - 1]

Global minSuccesses:Int = 1

DebugLog "Winning Dice: " + WINDICE
DebugLog "Losing Dice: " + FAILDICE
DebugLog "Side per Dice: " + SIDEPERDICE
DebugLog "Minimum Successes required: " + minSuccesses
 
'Berechne die nächste Power of two für die Anzahl der Würfelseiten
For Local i:Int = 0 To 30
	If 2 ^ i >= SIDEPERDICE
		StepSize = 2 ^ i
		shiftsize = i
		Exit
	EndIf
Next

DebugLog "Stepsize: " + StepSize
	 
Global WerteTabelle:Int[stepsize ^ (WINDICE + FAILDICE)]

DebugLog "Array has "+ WerteTabelle.length + " elements."
'Fill the TABLE
For Local i:Int = 0 Until WerteTabelle.length
	WerteTabelle[i] = i
Next

'now, iterate through the table and count wins and losses. if at least min successes are reached, increase the counter.

Global Successcount:Int = 0
'debugstop
For Local i:Int = 0 Until Wertetabelle.length
	'chop the value into stepsize bits, right to left, and compare them with the win/lose tables.
	Local register:Int = Wertetabelle[i]
	Local sc:Int = 0
	For Local dicenumber:Int = 0 Until WINDICE+FAILDICE
		Local value:Int = register & (Stepsize - 1) 
		'winning dice?
		If dicenumber < WINDICE Then
			sc:+successes[value]
		Else
			sc:+losses[value]
		EndIf
		register = register Shr shiftsize
	Next
	If sc >= minsuccesses Then successcount:+ 1
		
Next
DebugLog successcount + " rolls with at least " + minsuccesses + " Success(es) found."
DebugLog "Propability of Success: " + ( (successcount * 1.0 / WerteTabelle.length) * 100) + "%"