#87310: "Burgle Bros - Loitering check"
Que s'est-il passé ? Merci de choisir ci-dessous
Que s'est-il passé ? Merci de choisir ci-dessous
Veuillez vérifier s'il existe déjà un rapport sur le même sujet
Si oui, veuillez VOTER pour ce rapport. Les rapports ayant le plus de votes auront la PRIORITÉ !
# | Status | Votes | Game | Type | Title | Last update |
---|
Description détaillée
• Merci de copier-coller le message d'erreur qui s'affiche à l'écran, s'il y a lieu.
Currently in Burgle Bros, the rules state you're not allowed to move "back and forth" in order to avoid drawing an event. However, it has been stated that this would be too difficult to code, and would result in false positives, and so (understandably), the devs focused on more productive things.
As a programmer myself, I spent some time analyzing the problem, as I knew I could tackle this, and I have the time to (unlike your devs :) ) and believe I have a draft solution which is a viable option as it:
1) doesn't result in false positives.
2) Simple coding logic changes to implement - nothing major, no redesign needed - you have all the info already, it's just a matter of gathering it up and using it properly.
3) flexible - so we can focus on the "simple"/obvious checks first .. and consider expanding to trickier ones later (if we want).
The logic is simple:
1) capture the current board "state" (everything, including tiles, hidden tiles, walls, player/guard positions, tools/loot positions, hack tokens .. alarms .. etc.) store it as a simple string (1 character per "item", ie Safe = "S", Walkway = "W", etc.)
2) boolean flag to indicate dice were rolled (ie safe, keypad, etc.) This provides a marker, as we won't compare board states beyond a dice roll. (think 1 move into a keypad, and failing the roll)
3) Compare latest board state with al previous ones up to a die roll event.
4) if any match, reject the move as "loitering" ..
• Veuillez expliquer ce que vous vouliez faire, ce que vous avez fait et ce qu'il s'est passé
• Quel est votre navigateur ?
Google Chrome v112
• SVP copiez / collez ici le texte affiché en anglais au lieu de votre langue. Si vous avez une capture d'écran de ce bug (pensez-y !), vous pouvez utiliser Imgur.com pour la télécharger et copier-coller le lien ici.
Currently in Burgle Bros, the rules state you're not allowed to move "back and forth" in order to avoid drawing an event. However, it has been stated that this would be too difficult to code, and would result in false positives, and so (understandably), the devs focused on more productive things.
As a programmer myself, I spent some time analyzing the problem, as I knew I could tackle this, and I have the time to (unlike your devs :) ) and believe I have a draft solution which is a viable option as it:
1) doesn't result in false positives.
2) Simple coding logic changes to implement - nothing major, no redesign needed - you have all the info already, it's just a matter of gathering it up and using it properly.
3) flexible - so we can focus on the "simple"/obvious checks first .. and consider expanding to trickier ones later (if we want).
The logic is simple:
1) capture the current board "state" (everything, including tiles, hidden tiles, walls, player/guard positions, tools/loot positions, hack tokens .. alarms .. etc.) store it as a simple string (1 character per "item", ie Safe = "S", Walkway = "W", etc.)
2) boolean flag to indicate dice were rolled (ie safe, keypad, etc.) This provides a marker, as we won't compare board states beyond a dice roll. (think 1 move into a keypad, and failing the roll)
3) Compare latest board state with al previous ones up to a die roll event.
4) if any match, reject the move as "loitering" ..
• Ce texte est-il disponible dans le système de traduction ? Si oui, a-t-il été traduit depuis plus de 24 heures ?
• Quel est votre navigateur ?
Google Chrome v112
• Merci d'expliquer votre suggestion de manière précise et concise, de façon à ce qu'il soit aussi simple que possible de comprendre ce que vous voulez dire.
Currently in Burgle Bros, the rules state you're not allowed to move "back and forth" in order to avoid drawing an event. However, it has been stated that this would be too difficult to code, and would result in false positives, and so (understandably), the devs focused on more productive things.
As a programmer myself, I spent some time analyzing the problem, as I knew I could tackle this, and I have the time to (unlike your devs :) ) and believe I have a draft solution which is a viable option as it:
1) doesn't result in false positives.
2) Simple coding logic changes to implement - nothing major, no redesign needed - you have all the info already, it's just a matter of gathering it up and using it properly.
3) flexible - so we can focus on the "simple"/obvious checks first .. and consider expanding to trickier ones later (if we want).
The logic is simple:
1) capture the current board "state" (everything, including tiles, hidden tiles, walls, player/guard positions, tools/loot positions, hack tokens .. alarms .. etc.) store it as a simple string (1 character per "item", ie Safe = "S", Walkway = "W", etc.)
2) boolean flag to indicate dice were rolled (ie safe, keypad, etc.) This provides a marker, as we won't compare board states beyond a dice roll. (think 1 move into a keypad, and failing the roll)
3) Compare latest board state with al previous ones up to a die roll event.
4) if any match, reject the move as "loitering" ..
• Quel est votre navigateur ?
Google Chrome v112
• Qu'était-il affiché à l'écran lorsque vous avez été bloqué·e (Écran vierge ? Une partie de l'interface de jeu ? Un message d'erreur ?)
Currently in Burgle Bros, the rules state you're not allowed to move "back and forth" in order to avoid drawing an event. However, it has been stated that this would be too difficult to code, and would result in false positives, and so (understandably), the devs focused on more productive things.
As a programmer myself, I spent some time analyzing the problem, as I knew I could tackle this, and I have the time to (unlike your devs :) ) and believe I have a draft solution which is a viable option as it:
1) doesn't result in false positives.
2) Simple coding logic changes to implement - nothing major, no redesign needed - you have all the info already, it's just a matter of gathering it up and using it properly.
3) flexible - so we can focus on the "simple"/obvious checks first .. and consider expanding to trickier ones later (if we want).
The logic is simple:
1) capture the current board "state" (everything, including tiles, hidden tiles, walls, player/guard positions, tools/loot positions, hack tokens .. alarms .. etc.) store it as a simple string (1 character per "item", ie Safe = "S", Walkway = "W", etc.)
2) boolean flag to indicate dice were rolled (ie safe, keypad, etc.) This provides a marker, as we won't compare board states beyond a dice roll. (think 1 move into a keypad, and failing the roll)
3) Compare latest board state with al previous ones up to a die roll event.
4) if any match, reject the move as "loitering" ..
• Quel est votre navigateur ?
Google Chrome v112
• Quelle partie des règles n'a pas été respectée par l'adaptation BGA
Currently in Burgle Bros, the rules state you're not allowed to move "back and forth" in order to avoid drawing an event. However, it has been stated that this would be too difficult to code, and would result in false positives, and so (understandably), the devs focused on more productive things.
As a programmer myself, I spent some time analyzing the problem, as I knew I could tackle this, and I have the time to (unlike your devs :) ) and believe I have a draft solution which is a viable option as it:
1) doesn't result in false positives.
2) Simple coding logic changes to implement - nothing major, no redesign needed - you have all the info already, it's just a matter of gathering it up and using it properly.
3) flexible - so we can focus on the "simple"/obvious checks first .. and consider expanding to trickier ones later (if we want).
The logic is simple:
1) capture the current board "state" (everything, including tiles, hidden tiles, walls, player/guard positions, tools/loot positions, hack tokens .. alarms .. etc.) store it as a simple string (1 character per "item", ie Safe = "S", Walkway = "W", etc.)
2) boolean flag to indicate dice were rolled (ie safe, keypad, etc.) This provides a marker, as we won't compare board states beyond a dice roll. (think 1 move into a keypad, and failing the roll)
3) Compare latest board state with al previous ones up to a die roll event.
4) if any match, reject the move as "loitering" ..
• La violation de règle est-elle visible dans le replay de la partie ? Si oui, à quel numéro de coup ?
• Quel est votre navigateur ?
Google Chrome v112
• Quelle action de jeu vouliez-vous faire ?
Currently in Burgle Bros, the rules state you're not allowed to move "back and forth" in order to avoid drawing an event. However, it has been stated that this would be too difficult to code, and would result in false positives, and so (understandably), the devs focused on more productive things.
As a programmer myself, I spent some time analyzing the problem, as I knew I could tackle this, and I have the time to (unlike your devs :) ) and believe I have a draft solution which is a viable option as it:
1) doesn't result in false positives.
2) Simple coding logic changes to implement - nothing major, no redesign needed - you have all the info already, it's just a matter of gathering it up and using it properly.
3) flexible - so we can focus on the "simple"/obvious checks first .. and consider expanding to trickier ones later (if we want).
The logic is simple:
1) capture the current board "state" (everything, including tiles, hidden tiles, walls, player/guard positions, tools/loot positions, hack tokens .. alarms .. etc.) store it as a simple string (1 character per "item", ie Safe = "S", Walkway = "W", etc.)
2) boolean flag to indicate dice were rolled (ie safe, keypad, etc.) This provides a marker, as we won't compare board states beyond a dice roll. (think 1 move into a keypad, and failing the roll)
3) Compare latest board state with al previous ones up to a die roll event.
4) if any match, reject the move as "loitering" ..
• Qu'essayez-vous de faire pour déclencher cette action de jeu ?
• Que se passe-t-il lorsque vous essayez de faire cela (message d'erreur, message de la barre d'état du jeu, ...) ?
• Quel est votre navigateur ?
Google Chrome v112
• À quelle étape de la partie le problème est-il apparu (quel était le texte d'instruction du jeu) ?
Currently in Burgle Bros, the rules state you're not allowed to move "back and forth" in order to avoid drawing an event. However, it has been stated that this would be too difficult to code, and would result in false positives, and so (understandably), the devs focused on more productive things.
As a programmer myself, I spent some time analyzing the problem, as I knew I could tackle this, and I have the time to (unlike your devs :) ) and believe I have a draft solution which is a viable option as it:
1) doesn't result in false positives.
2) Simple coding logic changes to implement - nothing major, no redesign needed - you have all the info already, it's just a matter of gathering it up and using it properly.
3) flexible - so we can focus on the "simple"/obvious checks first .. and consider expanding to trickier ones later (if we want).
The logic is simple:
1) capture the current board "state" (everything, including tiles, hidden tiles, walls, player/guard positions, tools/loot positions, hack tokens .. alarms .. etc.) store it as a simple string (1 character per "item", ie Safe = "S", Walkway = "W", etc.)
2) boolean flag to indicate dice were rolled (ie safe, keypad, etc.) This provides a marker, as we won't compare board states beyond a dice roll. (think 1 move into a keypad, and failing the roll)
3) Compare latest board state with al previous ones up to a die roll event.
4) if any match, reject the move as "loitering" ..
• Que se passe-t-il lorsque vous essayez de faire une action de jeu (message d'erreur, message de la barre d'état du jeu, ...) ?
• Quel est votre navigateur ?
Google Chrome v112
• Veuillez décrire le problème d'affichage. Si vous avez une capture d'écran de ce bug (pensez-y !), vous pouvez utiliser Imgur.com pour la télécharger et copier-coller le lien ici.
Currently in Burgle Bros, the rules state you're not allowed to move "back and forth" in order to avoid drawing an event. However, it has been stated that this would be too difficult to code, and would result in false positives, and so (understandably), the devs focused on more productive things.
As a programmer myself, I spent some time analyzing the problem, as I knew I could tackle this, and I have the time to (unlike your devs :) ) and believe I have a draft solution which is a viable option as it:
1) doesn't result in false positives.
2) Simple coding logic changes to implement - nothing major, no redesign needed - you have all the info already, it's just a matter of gathering it up and using it properly.
3) flexible - so we can focus on the "simple"/obvious checks first .. and consider expanding to trickier ones later (if we want).
The logic is simple:
1) capture the current board "state" (everything, including tiles, hidden tiles, walls, player/guard positions, tools/loot positions, hack tokens .. alarms .. etc.) store it as a simple string (1 character per "item", ie Safe = "S", Walkway = "W", etc.)
2) boolean flag to indicate dice were rolled (ie safe, keypad, etc.) This provides a marker, as we won't compare board states beyond a dice roll. (think 1 move into a keypad, and failing the roll)
3) Compare latest board state with al previous ones up to a die roll event.
4) if any match, reject the move as "loitering" ..
• Quel est votre navigateur ?
Google Chrome v112
• SVP copiez / collez ici le texte affiché en anglais au lieu de votre langue. Si vous avez une capture d'écran de ce bug (pensez-y !), vous pouvez utiliser Imgur.com pour la télécharger et copier-coller le lien ici.
Currently in Burgle Bros, the rules state you're not allowed to move "back and forth" in order to avoid drawing an event. However, it has been stated that this would be too difficult to code, and would result in false positives, and so (understandably), the devs focused on more productive things.
As a programmer myself, I spent some time analyzing the problem, as I knew I could tackle this, and I have the time to (unlike your devs :) ) and believe I have a draft solution which is a viable option as it:
1) doesn't result in false positives.
2) Simple coding logic changes to implement - nothing major, no redesign needed - you have all the info already, it's just a matter of gathering it up and using it properly.
3) flexible - so we can focus on the "simple"/obvious checks first .. and consider expanding to trickier ones later (if we want).
The logic is simple:
1) capture the current board "state" (everything, including tiles, hidden tiles, walls, player/guard positions, tools/loot positions, hack tokens .. alarms .. etc.) store it as a simple string (1 character per "item", ie Safe = "S", Walkway = "W", etc.)
2) boolean flag to indicate dice were rolled (ie safe, keypad, etc.) This provides a marker, as we won't compare board states beyond a dice roll. (think 1 move into a keypad, and failing the roll)
3) Compare latest board state with al previous ones up to a die roll event.
4) if any match, reject the move as "loitering" ..
• Ce texte est-il disponible dans le système de traduction ? Si oui, a-t-il été traduit depuis plus de 24 heures ?
• Quel est votre navigateur ?
Google Chrome v112
• Merci d'expliquer votre suggestion de manière précise et concise, de façon à ce qu'il soit aussi simple que possible de comprendre ce que vous voulez dire.
Currently in Burgle Bros, the rules state you're not allowed to move "back and forth" in order to avoid drawing an event. However, it has been stated that this would be too difficult to code, and would result in false positives, and so (understandably), the devs focused on more productive things.
As a programmer myself, I spent some time analyzing the problem, as I knew I could tackle this, and I have the time to (unlike your devs :) ) and believe I have a draft solution which is a viable option as it:
1) doesn't result in false positives.
2) Simple coding logic changes to implement - nothing major, no redesign needed - you have all the info already, it's just a matter of gathering it up and using it properly.
3) flexible - so we can focus on the "simple"/obvious checks first .. and consider expanding to trickier ones later (if we want).
The logic is simple:
1) capture the current board "state" (everything, including tiles, hidden tiles, walls, player/guard positions, tools/loot positions, hack tokens .. alarms .. etc.) store it as a simple string (1 character per "item", ie Safe = "S", Walkway = "W", etc.)
2) boolean flag to indicate dice were rolled (ie safe, keypad, etc.) This provides a marker, as we won't compare board states beyond a dice roll. (think 1 move into a keypad, and failing the roll)
3) Compare latest board state with al previous ones up to a die roll event.
4) if any match, reject the move as "loitering" ..
• Quel est votre navigateur ?
Google Chrome v112
Historique des rapports de bug
boardgamearena.com/forum/viewtopic.php?t=30165
In the linked .zip is a flowchart showing the logic, and it should be reasonable easy to fit into, and after some additionally games. and review, I think it should be reasonable robust.
Ajouter à ce rapport
- Un autre n° de table / n° de coup
- La touche F5 a-t-elle résolu le problème ?
- Le problème est-il apparu plusieurs fois ? À chaque fois ? Aléatoirement ?
- Si vous avez une capture d'écran de ce bug (pensez-y !), vous pouvez utiliser Imgur.com pour la télécharger et copier-coller le lien ici.