#87310: "Burgle Bros - Loitering check"
Vad hände? Välj från alternativen nedan
Vad hände? Välj från alternativen nedan
Vänligen kontrollera om det redan finns en rapport om samma ämne
Om detta stämmer, RÖSTA på denna rapport. Rapporterna med flest röster har PRIORITET!
# | Status | Votes | Game | Type | Title | Last update |
---|
Detaljerad beskrivning
• Var vänlig klipp och klistra in felmeddelandet du ser på skärmen, om något.
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" ..
• Varsågod och förklara vad du ville göra, vad du gjorde och vad som hände
• Vad har du för webbläsare?
Google Chrome v112
• Var vänlig kopiera/klistra in texten på engelska istället för ditt eget språk. Om du har en skärmdump av denna buggen (vilket är bra), så kan du använda Imgur.com för att ladda upp den och kopiera/klistra in länken här.
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" ..
• Är denna text tillgänglig i översättningssystemet? Om den är det, var det mer än 24 timmar sedan den översattes?
• Vad har du för webbläsare?
Google Chrome v112
• Vänligen förklara ditt förslag exakt och koncist så att det är så enkelt som möjligt att förstå vad du menar.
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" ..
• Vad har du för webbläsare?
Google Chrome v112
• Vad visades på skärmen när du blockerades (Blank skärm? Del av spelets användargränssnitt? Felmeddelande?)?
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" ..
• Vad har du för webbläsare?
Google Chrome v112
• Vilken del av reglerna respekterades inte av BGA-adaptionen?
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" ..
• Är regelbrottet synligt i återuppspelning? Om ja, vilket nummer är det på draget?
• Vad har du för webbläsare?
Google Chrome v112
• Vilken spelhandling ville du göra?
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" ..
• Vad försöker du göra för att sätta igång denna spelmekaniken?
• Vad hände när du försökte göra det här (felmeddelande, meddelande i spelstatusrad, ...)?
• Vad har du för webbläsare?
Google Chrome v112
• På vilket steg i spelet kom felet (vad var den aktuella instruktionen från spelet)?
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" ..
• Vad hände när du försökte utföra en spelhandling (felmeddelande, meddelande i spelstatusrad, ...)?
• Vad har du för webbläsare?
Google Chrome v112
• Vänligen beskriv visningsproblemet. Om du har en skärmdump av denna buggen (vilket är bra), så kan du använda Imgur.com för att ladda upp den och kopiera/klistra in länken här.
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" ..
• Vad har du för webbläsare?
Google Chrome v112
• Var vänlig kopiera/klistra in texten på engelska istället för ditt eget språk. Om du har en skärmdump av denna buggen (vilket är bra), så kan du använda Imgur.com för att ladda upp den och kopiera/klistra in länken här.
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" ..
• Är denna text tillgänglig i översättningssystemet? Om den är det, var det mer än 24 timmar sedan den översattes?
• Vad har du för webbläsare?
Google Chrome v112
• Vänligen förklara ditt förslag exakt och koncist så att det är så enkelt som möjligt att förstå vad du menar.
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" ..
• Vad har du för webbläsare?
Google Chrome v112
Rapporthistorik
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.
Lägg till något till denna rapport
- Ett annat spelbords-ID / drag-ID
- Löste F5 problemet?
- Uppträdde problemet flera gånger? Varje gång? Slumpmässigt?
- Om du har en skärmdump av denna buggen (vilket är bra), så kan du använda Imgur.com för att ladda upp den och kopiera/klistra in länken här.