Sie sind nicht angemeldet.

Kampfbaumliga (Bundesliga - 2.Bundesliga usw.)

Zerri

  • »Zerri« ist der Autor dieses Themas

Wohnort: Azoren

Beruf: Abteilungsleiter/Wächter Gondals

  • Nachricht senden

1

Samstag, 20. Mai 2023, 22:13

Kampfbaumliga (Bundesliga - 2.Bundesliga usw.)

Hallo,

ich wollte mal aufgreifen ob man nicht eine Art Ligasystem der Aktivenkämpfe einführen kann?

Es gab vor Jahrzehnten mal ein Liga-System welches sich so aufstelle Bundesliga, Zweite Bundesliga und dann in die Bundesländer aufgeschlüsselt nach Spieleranzahl durch gruppiert. Mein System würde auf 32 Spieler in den Ligen jeweils basieren, diese kann man gut in einem Top 16 Turnier automatisiert Kämpfen lassen wo bei die letzten 8 immer um eine Turnier stufe absteigen und die ersten 8 jeder Liga aufsteigen würden. Ziel dieses System ist es aktives Kämpfen zusätzlich zubelohnen. Hierbei kann mnan erst einmal testweise eine implemntierung ausführen in der man schaut wie es bei den anderen ankommt. In der Zukunft kann man schauen ob man nicht durch bestimmte Erfolge bestimme Boni freischaltet bzw. zeitlich limitierte sachen freischaltet.

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

import random
def pair_players(players):
    random.shuffle(players)  # Zufällige Reihenfolge der Spielerliste

    pairs = []
    num_players = len(players)
    num_pairs = num_players // 2

    for i in range(num_pairs):
        pair = (players[i], players[i + num_pairs])
        pairs.append(pair)

    return pairs

def create_player_groups(players):
    num_groups = len(players) // 32
    player_groups = []

    for i in range(num_groups):
        group = players[i * 32:(i + 1) * 32]
        paired_players = pair_players(group)
        player_groups.append(paired_players)

    return player_groups

# Beispielaufruf
all_players = ['Spieler1', 'Spieler2', 'Spieler3', 'Spieler4', 'Spieler5', 'Spieler6', ...]  # Hier die Liste aller Spieler einfügen
player_groups = create_player_groups(all_players)

# Ausgabe der Spielergruppen
for i, group in enumerate(player_groups):
    print(f"Gruppe {i + 1}:")
    for pair in group:
        print(pair)     print()


S.o. das wäre in Code dieser kann um den faktor Level

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

import random
def pair_players(players):
    random.shuffle(players)  # Zufällige Reihenfolge der Spielerliste

    pairs = []
    num_players = len(players)
    num_pairs = num_players // 2

    for i in range(num_pairs):
        pair = (players[i], players[i + num_pairs])
        pairs.append(pair)

    return pairs

def create_player_groups(players):
    player_groups = {}
    
    for level in range(1, 301, 5):
        player_groups[level] = []
    
    for player in players:
        level = player['level']
        player_groups[level].append(player)

    final_groups = []
    
    for level in range(1, 301, 5):
        group = player_groups[level]
        num_players = len(group)
        
        if num_players >= 32:
            num_full_groups = num_players // 32
            remaining_players = num_players % 32
            
            for i in range(num_full_groups):
                full_group = group[i * 32:(i + 1) * 32]
                paired_players = pair_players(full_group)
                final_groups.append(paired_players)
            
            if remaining_players >= 2:
                partial_group = group[num_full_groups * 32:]
                paired_players = pair_players(partial_group)
                final_groups.append(paired_players)
    
    return final_groups

# Beispielaufruf
all_players = [
    {'name': 'Spieler1', 'level': 20},
    {'name': 'Spieler2', 'level': 25},
    {'name': 'Spieler3', 'level': 30},
    {'name': 'Spieler4', 'level': 35},
    {'name': 'Spieler5', 'level': 40},
    {'name': 'Spieler6', 'level': 45},
    # Fügen Sie weitere Spieler mit ihren entsprechenden Leveln hinzu
]

player_groups = create_player_groups(all_players)

# Ausgabe der Spielergruppen
for i, group in enumerate(player_groups):
    print(f"Gruppe {i + 1}:")
    for pair in group:
        print(pair)     print()


Wenn wir jetzt die aktivität hierbei bewerten

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

import random
def pair_players(players):
    random.shuffle(players)  # Zufällige Reihenfolge der Spielerliste

    pairs = []
    num_players = len(players)
    num_pairs = num_players // 2

    for i in range(num_pairs):
        pair = (players[i], players[i + num_pairs])
        pairs.append(pair)

    return pairs

def calculate_activity_factor(level):
    if level <= 100:
        return 1.0
    elif level <= 200:
        return 1.2
    else:
        return 1.5

def create_player_groups(players):
    player_groups = {}
    
    for level in range(1, 301, 5):
        player_groups[level] = []
    
    for player in players:
        level = player['level']
        activity_factor = calculate_activity_factor(level)
        player['activity_factor'] = activity_factor
        player_groups[level].append(player)

    final_groups = []
    
    for level in range(1, 301, 5):
        group = player_groups[level]
        num_players = len(group)
        
        if num_players >= 32:
            num_full_groups = num_players // 32
            remaining_players = num_players % 32
            
            for i in range(num_full_groups):
                full_group = group[i * 32:(i + 1) * 32]
                paired_players = pair_players(full_group)
                final_groups.append(paired_players)
            
            if remaining_players >= 2:
                partial_group = group[num_full_groups * 32:]
                paired_players = pair_players(partial_group)
                final_groups.append(paired_players)
    
    return final_groups

# Beispielaufruf
all_players = [
    {'name': 'Spieler1', 'level': 20},
    {'name': 'Spieler2', 'level': 80},
    {'name': 'Spieler3', 'level': 120},
    {'name': 'Spieler4', 'level': 180},
    {'name': 'Spieler5', 'level': 220},
    {'name': 'Spieler6', 'level': 280},
    # Fügen Sie weitere Spieler mit ihren entsprechenden Leveln hinzu
]

player_groups = create_player_groups(all_players)

# Ausgabe der Spielergruppen
for i, group in enumerate(player_groups):
    print(f"Gruppe {i + 1}:")
    for pair in group:
        print(pair)     print()


Kommen wir zu einem rellativ kleinen Code der in der performance es gut abdecken kann. (obrige codes ohne angabe auf gewähr das sie noch geDebug werden müssen)
Mein Items sind Rot und für die Levelklasse 1-1

Zerri

  • »Zerri« ist der Autor dieses Themas

Wohnort: Azoren

Beruf: Abteilungsleiter/Wächter Gondals

  • Nachricht senden

2

Samstag, 20. Mai 2023, 22:13

zweiter Teil 10.000 Zeichen sind :D

Final würde es mit einem aufstieg und absteige System so aussehen

Quellcode

 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

import random
def pair_players(players):
random.shuffle(players) # Zufällige Reihenfolge der Spielerliste

pairs = []
num_players = len(players)
num_pairs = num_players // 2

for i in range(num_pairs):
pair = (players[i], players[i + num_pairs])
pairs.append(pair)

return pairs

def calculate_activity_factor(level):
if level <= 100:
return 1.0
elif level <= 200:
return 1.2
else:
return 1.5

def create_player_groups(players):
player_groups = {}

for level in range(1, 301, 5):
player_groups[level] = []

for player in players:
level = player['level']
activity_factor = calculate_activity_factor(level)
player['activity_factor'] = activity_factor
player_groups[level].append(player)

final_groups = []

for level in range(1, 301, 5):
group = player_groups[level]
num_players = len(group)

if num_players >= 32:
num_full_groups = num_players // 32
remaining_players = num_players % 32

for i in range(num_full_groups):
full_group = group[i * 32:(i + 1) * 32]
paired_players = pair_players(full_group)
final_groups.append(paired_players)

if remaining_players >= 2:
partial_group = group[num_full_groups * 32:]
paired_players = pair_players(partial_group)
final_groups.append(paired_players)

return final_groups

def simulate_tournament(player_groups):
tournament_results = {}

for i, group in enumerate(player_groups):
group_results = []
for pair in group:
result = random.choice(['win', 'loss', 'draw']) # Simulieren Sie das Ergebnis des Spiels
group_results.append({'pair': pair, 'result': result})
tournament_results[i] = group_results

return tournament_results

def update_player_levels(all_players, tournament_results):
for group_results in tournament_results.values():
for game_result in group_results:
pair = game_result['pair']
result = game_result['result']

for player in pair:
if result == 'win':
player['level'] += 10
elif result == 'loss':
player['level'] -= 5
else:
player['level'] += 5

# Sortiere Spieler nach Level absteigend
all_players.sort(key=lambda x: x['level'], reverse=True)

# Die besten 8 Spieler steigen auf, die letzten 8 Spieler steigen ab
promoted_players = all_players[:8]
relegated_players = all_players[-8:]

# Aktualisiere Level der aufgestiegenen Spieler
for player in promoted_players:
player['level'] += 50

# Aktualisiere Level der abgestiegenen Spieler
for player in relegated_players:
player['level'] -= 50

return all_players

# Beispielaufruf
all_players = [
{'name': 'Spieler1', 'level': 20},
{'name': 'Spieler2', 'level': 80},
{'name': 'Spieler3', 'level': 120},
{'name': 'Spieler4', 'level': 180},
{'name': 'Spieler5', 'level': 220},
{'name': 'Spieler6', 'level': 280},
# Fügen Sie weitere Spieler mit ihren entsprechenden Leveln hinzu
]

player_groups = create_player_groups(all_players)

tournament_results = simulate_tournament(player_groups)

all_players = update_player_levels(all_players, tournament_results)

# Ausgabe der aktualisierten Spielerliste
for player in all_players: print(f"{player['name']}: Level {player['level']}")



Ich würde mich hierbei freuen wenn dies unterstüzung Erfahren würde. Weil so ein paar Medalien sehen doch immer gut aus.

Bei den Belohnungen kann man mit dem zehntel Wert der minimalsten dienststunde in Gold rechnen. Im endefekt will und forder ich nicht unbedingt FA/Errungenschaften o.ä. ich sähe es nur als zusatz um sein profil mit Medalien oder pokalen zu schmücken als eine Art Bild-gimick und nicht als Titel unbedingt. Fals man Titel hinzufügen kann dann so was wie 10-Facher NRW meiste in der x-ten NRW liga oder so :)

Natürlich nachteile für SW den Code oben korregieren und implementieren, performance einbuße ? Zeit und Kosten, gerne kann man über ein Finanzierungsmodel reden Monatlich Quartalsweise halbjährig oder jährlich was einen freischaltet hier teilzunehmen dabei Kosten=Nutzen abwägung zubetrachten.

Aber Betriebspädagogisch gesehen würde es uns allen spaß machen wieder mehr Ziele vor den Augen zuhaben ;-)
Mein Items sind Rot und für die Levelklasse 1-1

Chief Joseph

Moderator

  • »Chief Joseph« ist männlich

Wohnort: zu Hause

Beruf: Chief der Nez Perce

  • Nachricht senden

3

Sonntag, 21. Mai 2023, 04:52

mmh, das Problem ist, die Spieler sollen deinen Vorschlag verstehen, nicht der Progger.
Wenn du deinen Vorschlag Spielerfreundlicher machst wäre das also besser.

Ob etwas umgesetzt wird entscheiden wir Spieler, also müssen wir auch wissen was du meinst.
Der Progger kommt danach dran. Das du seine Arbeit übernommen hast mag ja hilfreich sein.
Aber zunächt sollte jeder verstehen was du meinst.

Erweise allen Kriegern Respekt,
aber krieche vor niemandem

Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von »Chief Joseph« (21. Mai 2023, 04:59)

Es hat sich bereits 1 registrierter Benutzer bedankt.

Benutzer, die sich für diesen Beitrag bedankt haben:

Thor von Venja (21.05.2023)

Zerri

  • »Zerri« ist der Autor dieses Themas

Wohnort: Azoren

Beruf: Abteilungsleiter/Wächter Gondals

  • Nachricht senden

4

Sonntag, 21. Mai 2023, 08:04

Zitat von »Chief Joseph«

mmh, das Problem ist, die Spieler sollen deinen Vorschlag verstehen, nicht der Progger.
Wenn du deinen Vorschlag Spielerfreundlicher machst wäre das also besser.

Ob etwas umgesetzt wird entscheiden wir Spieler, also müssen wir auch wissen was du meinst.
Der Progger kommt danach dran. Das du seine Arbeit übernommen hast mag ja hilfreich sein.
Aber zunächt sollte jeder verstehen was du meinst.
Also; für uns Spieler es werden Ligen generiert welche folgende Spieler Bedingungen haben:

1. Die Liga soll aus 32 Spielern maximal bestehen
2. Die ersten 8 können in eine höhere Liga aufsteigen, die letzten 8 steigen immer ab (es wird eine maximale Liga geben nach oben)
3. Es wird geschaut wie aktiv sind die spieler gewesen jenach aktivitätslevel(faktor) wird das bracket erstellt
4. Es wird auch geschaut welches Level habe ich und meine gegner es sollen möglichst ausgewogene Ligen entstehen(nicht das sich jemand der Level 300 ist so down pairt das er nur level 1er als gegner erhält)
5. Wir erhalten als Spieler bei den ersten 3 plätzen medalien und die anderen Anstecknadeln
6. Diese können als Accessoire dem profil hinzugefügt werden und weitere Titel kann man auswählen :)

Wie gesagt der Code könnte noch Bugs enthalten aber er deffeniert undgefähr meine Vorstellung ^^
Mein Items sind Rot und für die Levelklasse 1-1

Ähnliche Themen