การจำลองความดันในการจำลองแบบของเหลวที่ใช้กริด

ฉันมีระบบน้ำที่ใช้ระบบกริด 2 มิติในเกม XNA ของฉันเรามีวิธีการใช้เซลลูลาร์ออโตมาตาเพื่อจำลองการตกของน้ำและการแพร่กระจาย

ตัวอย่างของน้ำที่ไหลลงมาตามทางลาด:

แต่ละแผ่นสามารถมีค่าของเหลว 0 ถึง 255 ค่าซึ่งเก็บไว้ในหน่วยไบต์ ฉันไม่ได้ใช้floatsระบบน้ำเก่าที่ฉันเคยทำ แต่มันเพิ่มภาวะแทรกซ้อนและมีผลการทำงานที่ยอดเยี่ยม

กระเบื้องน้ำแต่ละอัพเดตตัวเองด้วยชุดของกฎง่ายๆ:

1. หากไทล์ด้านล่างมีช่องว่างให้ย้ายมากที่สุดเท่าที่เป็นไปได้จากไทล์ปัจจุบันไปยังล่างสุด (Flow Down)
2. หากทั้งสองด้านนั้นไม่เหมือนกันและไม่เป็นศูนย์และทั้งสองจะผ่านได้เราจะได้ผลรวมของ 3 แผ่น (ซ้าย + ปัจจุบัน + ขวา) และหารด้วย 3 โดยปล่อยให้ส่วนที่เหลืออยู่บนแผ่นกลาง (ปัจจุบัน)
3. หากกฎข้างต้นให้ผลรวมเป็น 2 เราควรแบ่งไพ่ออกเป็นสองด้าน (1, 0, 1)
4. หากกฎ 2 ให้ 1 เป็นผลรวมให้เลือกด้านที่สุ่มเพื่อไหลเข้า
5. หากกฎ 2 ล้มเหลวเราควรตรวจสอบว่าด้านใดด้านหนึ่งสามารถผ่านได้และอีกด้านหนึ่งไม่ได้ หากเป็นจริงเราจะแบ่งไทล์ปัจจุบันออกเป็นสองส่วนสำหรับ 2 ไทล์

ฉันจะขยายตรรกะนี้เพื่อรวมความกดดันได้อย่างไร แรงดันจะทำให้ของเหลวเพิ่มขึ้นเหนือ "U-Bends" และเติมในช่องอากาศ

ตัวอย่างการล้มเหลวในปัจจุบัน:

น้ำควรไหลและทำให้เท่าเทียมกันในแต่ละด้านของ U-Bend นอกจากนี้ฉันได้สร้างวิธีการเพื่อค้นหาความลึกของบล็อกน้ำและดังนั้นจึงมีแรงกดดันมากน้อยเพียงใด ตอนนี้ฉันต้องสามารถใช้ตัวเลขเหล่านี้และนำไปใช้กับพื้นที่อื่น ๆ เพื่อทำให้ความดันเท่ากัน

โปรดทราบว่าฉันไม่เคยทำสิ่งนี้มาก่อน นี่เป็นเพียงแนวคิดที่จะช่วยได้ หรืออาจเป็นการหลอกลวงโดยสิ้นเชิง ฉันต้องการจัดการกับปัญหานี้มาตั้งแต่ Terraria แต่ตอนนี้ฉันไม่ได้ทำงานในเกมดังกล่าว

วิธีที่ฉันคิดว่าพยายามคือให้บล็อกน้ำผิวดิน ( บล็อกใด ๆ ที่มีน้ำอยู่ในนั้นและไม่มีบล็อกน้ำด้านบน) ค่าความดันเริ่มต้นเท่ากับ (หรือฟังก์ชั่นของ) ความสูงจากด้านล่างของโลก ค่าความดันโดยนัยของแผ่นกระเบื้องที่ใช้ไม่ได้คือMAX_PRESSURE(พูด 255) และสำหรับแผ่นกระเบื้องเปิดโล่งคือMIN_PRESSURE(0)

จากนั้นแรงดันจะถูกกระจายขึ้น / ลง / ด้านข้างจากกระเบื้องใด ๆ ที่มีแรงดันสูงกว่าไปยังกระเบื้องที่มีแรงดันลดลงในระหว่างการขีดแต่ละรูปแบบเซลลูลาร์ออโตมาตา ฉันต้องทำการจำลองที่แท้จริงเพื่อหาว่าจะให้เท่ากัน ความดันของบล็อกควรเท่ากับความดันโดยนัยบวกกับความดัน "เกิน" จากการทำให้เท่ากันรอบ ๆ (ดังนั้นคุณจะต้องเก็บแรงดันส่วนเกินนี้ไว้เท่านั้นไม่ใช่ความดันโดยนัย)

หากแผ่นพื้นผิวมีแรงดันมากกว่าความดันตามความสูงโดยนัยและหากกระเบื้องด้านบนมีพื้นที่ว่างสำหรับน้ำน้ำส่วนน้อยจะถูกเคลื่อนขึ้นด้านบน น้ำไหลลงเท่านั้นหากกระเบื้องทั้งสองมีห้องพักซึ่งมีความดันต่ำกว่าที่คาดไว้

นี่เป็นการจำลองความคิดคร่าวๆว่ายิ่งน้ำมี "แรงดัน" มากเท่าไหร่แรงดันก็ยิ่งมากขึ้นเท่านั้นถึงแม้ว่าค่าความดันจะแสดงถึงความสูงมากกว่าความดันที่เกิดขึ้นจริง (เนื่องจากแผ่นกระเบื้องที่สูงกว่า สิ่งนี้ทำให้ความดัน kinda sorta เหมือนhคำในสมการ (แต่ไม่ใช่จริง ๆ ):

P' = P + qgh

ผลก็คือถ้าแรงดันน้ำสูงกว่าความลึกของมันมันจะถูกดันขึ้น ควรหมายความว่าระดับน้ำในระบบปิดจะทำให้ความดันเท่ากันในทุกระดับความสูงเมื่อเวลาผ่านไป

ฉันไม่แน่ใจว่าจะจัดการกับหรือไม่ว่าใครจะต้องจัดการกับ "ฟองอากาศ" ที่จะสร้างขึ้น (ที่แผ่นกระเบื้องที่ไม่ใช่พื้นผิวจะมีปริมาณน้ำไม่เต็มเมื่อน้ำถูกผลักขึ้นไป) ฉันยังไม่แน่ใจเหมือนกันว่าคุณจะหลีกเลี่ยงความกดดันของน้ำที่ไม่เท่ากันในด้านใดด้านหนึ่งได้อย่างไรและหลังจากที่ทำเครื่องหมายว่าไม่เท่าเทียมกันในอีกด้านหนึ่งไปมา

ฉันสร้างระบบที่คล้ายกับระบบที่คุณใช้ในแบบ 3 มิติ ฉันมีวิดีโอสั้น ๆ แสดงให้เห็นถึงโครงสร้างที่เรียบง่ายของมันที่นี่และบล็อกโพสต์ที่นี่

นี่คือ gif เล็กน้อยที่ฉันสร้างขึ้นจากกลไกความดันที่อยู่ด้านหลังกำแพงที่มองไม่เห็น (เล่นด้วยความเร็วสูง):

ให้ฉันอธิบายข้อมูลที่เกี่ยวข้องเพื่อให้ทราบถึงคุณสมบัติบางอย่างของระบบ ในระบบปัจจุบันแต่ละบล็อกของน้ำมีดังต่อไปนี้ใน 2 ไบต์:

//Data2                          Data
//______________________________  _____________________________________
//|0    |0      |000   |000    |  |0        |0       |000      |000   |
//|Extra|FlowOut|Active|Largest|  |HasSource|IsSource|Direction|Height|
//------------------------------  -------------------------------------

• Height คือปริมาณน้ำในลูกบาศก์คล้ายกับความดันของคุณ แต่ระบบของฉันมีเพียง 8 ระดับ
• Directionเป็นทิศทางที่การไหลกำลังเกิดขึ้น เมื่อตัดสินใจว่าน้ำจะไหลไปทางใดมีแนวโน้มที่จะดำเนินต่อไปในทิศทางปัจจุบัน สิ่งนี้ยังใช้ในการย้อนกลับอย่างรวดเร็วติดตามการไหลกลับขึ้นไปที่คิวบ์ของแหล่งเมื่อจำเป็น
• IsSourceบ่งชี้ว่าคิวบ์นี้เป็นคิวบ์ต้นทางหมายความว่าคิวบ์ไม่เคยขาดน้ำ ใช้สำหรับแหล่งที่มาของแม่น้ำสปริง ฯลฯ ลูกบาศก์ทางด้านซ้ายใน gif ด้านบนเป็นคิวบ์ต้นทางตัวอย่างเช่น
• HasSourceบ่งชี้ว่าคิวบ์นี้เชื่อมต่อกับคิวบ์ต้นทางหรือไม่ เมื่อเชื่อมต่อกับแหล่งที่มาก้อนจะพยายามแตะแหล่งที่มาสำหรับน้ำมากขึ้นก่อนที่จะหาก้อนที่ไม่ใช่ "เต็ม" อื่น ๆ
• Largestบอก cube นี้ว่าการไหลที่ใหญ่ที่สุดระหว่างมันกับ cube ต้นทางคืออะไร ซึ่งหมายความว่าหากน้ำไหลผ่านช่องว่างแคบก็จะ จำกัด การไหลของลูกบาศก์นี้
• Activeเป็นเคาน์เตอร์ เมื่อคิวบ์นี้มีโฟลว์ที่กำลังไหลผ่านมันไปหรือจากคิวบ์นั้นแอคทีฟจะเพิ่มขึ้น มิฉะนั้นการใช้งานจะลดลงแบบสุ่ม เมื่อแอ็คทีฟชนศูนย์ (หมายถึงไม่แอ็คทีฟ) ปริมาณน้ำจะเริ่มลดลงในลูกบาศก์นี้ การกระทำประเภทนี้เช่นการระเหยหรือการแช่ลงบนพื้น ( ถ้าคุณมีกระแสคุณควรจะลดลง! )
• FlowOutบ่งชี้ว่าคิวบ์นี้เชื่อมต่อกับคิวบ์ที่อยู่บนขอบโลก เมื่อเส้นทางสู่ขอบของโลกที่ทำน้ำมีแนวโน้มที่จะเลือกเส้นทางนั้นมากกว่าที่อื่น ๆ
• Extra เป็นบิตพิเศษสำหรับใช้ในอนาคต

ตอนนี้เรารู้ข้อมูลแล้วให้ดูที่ภาพรวมระดับสูงของอัลกอริทึม แนวคิดพื้นฐานของระบบคือการจัดลำดับความสำคัญของการไหลลงและออก อย่างที่ฉันอธิบายในวิดีโอฉันทำงานจากล่างขึ้นบน น้ำแต่ละชั้นจะถูกประมวลผลทีละระดับในแกน y ก้อนสำหรับแต่ละระดับจะถูกประมวลผลแบบสุ่มแต่ละก้อนจะพยายามดึงน้ำจากแหล่งที่มาในแต่ละรอบ

Flow cubes ดึงน้ำจากแหล่งกำเนิดโดยทำตามทิศทางการไหลของมันสำรองจนกระทั่งถึง cube ต้นทางหรือ cube ที่ไม่มีพาเรนต์ การจัดเก็บทิศทางการไหลในแต่ละคิวบ์นั้นจะติดตามเส้นทางไปยังแหล่งข้อมูลได้ง่ายเช่นเดียวกับการข้ามผ่านรายการที่เชื่อมโยง

โค้ดหลอกสำหรับอัลกอริทึมมีดังนี้:

for i = 0 to topOfWorld //from the bottom to the top
   while flowouts[i].hasitems() //while this layer has flow outs
       flowout = removeRandom(flowouts[i]) //select one randomly
       srcpath = getPathToParent(flowout) //get the path to its parent
       //set cubes as active and update their "largest" value
       //also removes flow from the source for this flow cycle
       srcpath.setActiveAndFlux() 

//now we deal with regular flow
for i = 0 to topOfWorld //from the bottom to the top
    while activeflows[i].hasitems() //while this layer has water
        flowcube = removeRandom(activeflows[i]) //select one randomly
        //if the current cube is already full, try to distribute to immediate neighbors
        flowamt = 0
        if flowcube.isfull 
           flowamt = flowcube.settleToSurrounding
        else
           srcpath = getPathToParent(flowcube) //get the path to its parent
           flowamt = srcpath.setActiveAndFlux()
           flowcube.addflow(flowamt)

        //if we didn't end up moving any flow this iteration, reduce the activity
        //if activity is 0 already, use a small random chance of removing flow
        if flowamt == 0
           flowcube.reduceActive()

 refillSourceCubes()

กฎพื้นฐานสำหรับการขยายโฟลว์ที่ (เรียงตามลำดับความสำคัญ):

1. หากลูกบาศก์ด้านล่างมีน้ำน้อยลงให้ไหลลง
2. หากลูกบาศก์ที่อยู่ติดกันในระดับเดียวกันมีน้ำน้อยกว่าให้ไหลด้านข้าง
3. หากลูกบาศก์ด้านบนมีน้ำน้อยและลูกบาศก์แหล่งที่มาสูงกว่าลูกบาศก์ด้านบนให้ไหลขึ้น

ฉันรู้ว่ามันค่อนข้างสูง แต่มันก็ยากที่จะได้รับลงในรายละเอียดมากขึ้นโดยไม่ได้รับวิธีการลงรายละเอียด

ระบบนี้ทำงานได้ค่อนข้างดี ฉันสามารถเติมน้ำได้อย่างง่ายดายซึ่งล้นไปด้านนอกเพื่อดำเนินการต่อ ฉันสามารถเติมอุโมงค์รูปตัวยูตามที่คุณเห็นใน gif ด้านบน อย่างไรก็ตามอย่างที่ฉันพูดระบบไม่สมบูรณ์และฉันยังไม่ได้ทำทุกอย่าง ฉันไม่ได้ทำงานกับระบบการไหลมานาน (ฉันคิดว่ามันไม่จำเป็นสำหรับอัลฟ่าและฉันจะหยุดไว้) อย่างไรก็ตามปัญหาที่ฉันจัดการเมื่อฉันพักไว้ที่:

• สระว่ายน้ำ เมื่อได้รับสระน้ำขนาดใหญ่พอยน์เตอร์จากเด็กหนึ่งไปยังอีกคนหนึ่งนั้นดูราวกับเป็นบ้าที่บ้าคลั่งของสิ่งที่ลูกบาศก์สุ่มถูกเลือกให้ไหลไปในทิศทางใด เหมือนเติมอ่างอาบน้ำที่มีเส้นงี่เง่า เมื่อคุณต้องการระบายน้ำออกจากถังคุณควรทำตามเส้นทางของสายโง่กลับไปที่ต้นกำเนิด หรือคุณควรจะใช้สิ่งที่ใกล้เคียงที่สุด? ดังนั้นในสถานการณ์ที่ก้อนอยู่ในสระว่ายน้ำขนาดใหญ่พวกเขาควรจะละเลยการไหลของผู้ปกครองและดึงจากสิ่งที่อยู่เหนือพวกเขา ฉันมาพร้อมกับรหัสการทำงานขั้นพื้นฐานสำหรับเรื่องนี้ แต่ก็ไม่เคยมีทางออกที่สง่างามที่ฉันสามารถมีความสุขกับ

• พ่อแม่หลาย สตรีมลูกสามารถป้อนได้อย่างง่ายดายโดยผู้ปกครองมากกว่าหนึ่งสตรีม แต่เด็กที่มีตัวชี้ไปยังผู้ปกครองคนเดียวจะไม่ยอมให้สิ่งนั้น สิ่งนี้สามารถแก้ไขได้โดยใช้บิตมากพอที่จะยอมให้บิตสำหรับทิศทางพาเรนต์ที่เป็นไปได้ และมีแนวโน้มที่จะเปลี่ยนอัลกอริทึมเพื่อเลือกเส้นทางแบบสุ่มในกรณีที่มีผู้ปกครองหลายคน แต่ฉันไม่เคยไปถึงเพื่อทดสอบและดูว่ามีปัญหาอื่น ๆ

ฉันเห็นด้วยกับ Sean แต่ฉันจะทำมันต่างออกไปเล็กน้อย:

บล็อกจะสร้างแรงดันเท่ากับน้ำหนักของมันเอง (ปริมาณน้ำในนั้น) และใช้กับบล็อกด้านล่างและด้านข้าง ฉันไม่เห็นเหตุผลว่าทำไมตำแหน่งในโลกนี้จึงมีความเกี่ยวข้อง

ในแต่ละเห็บจะเคลื่อนย้ายน้ำจากแรงดันสูงไปยังแรงดันต่ำ แต่เคลื่อนที่เพียงเสี้ยวของน้ำที่จำเป็นในการทำให้เท่ากัน นอกจากนี้ยังสามารถผลักดันน้ำขึ้นมาได้หากแรงดันในบล็อกนั้นมากเกินไปสำหรับแรงดันที่ใช้ลงบนจัตุรัส

คุณจะได้รับลูปที่แรงดันน้ำไหลไปไกลเกินไปและต้องแก้ไข แต่เนื่องจากคุณไม่ได้เคลื่อนย้ายจำนวนน้ำทั้งหมดต่อเห็บสิ่งเหล่านี้จะทำให้ชื้น ฉันคิดว่าจริง ๆ แล้วมันเป็นเรื่องดีเพราะคุณจะได้รับผลกระทบจากคลื่นเมื่อน้ำท่วมในบริเวณที่คุณต้องการ

คุณสามารถเพิ่มกฎที่พยายามไปทางซ้ายหรือขวา (ผ่านกำแพง) ด้วยกระเบื้องจนกว่าคุณจะพบจุดที่ว่างโดยเริ่มจากชั้นที่อยู่ด้านล่าง หากคุณไม่สามารถหาได้ไทล์จะอยู่ในตำแหน่งปัจจุบัน หากคุณพบว่ากฎอื่นจะรับประกันการเปลี่ยนไทล์ย้าย (ถ้าจำเป็น)

เหตุใดคุณจึงไม่สามารถกำหนดบล็อกประเภทอื่นที่ทำหน้าที่เป็นแรงกดดันในการเคลื่อนที่ ดังนั้นเมื่อคุณใช้วิธีย้ายบล็อกน้ำตามปกติและตรวจสอบว่าสามารถเลื่อนขึ้นหรือไม่

ยิ่งไปกว่านั้นก็คือการเพิ่มคำจำกัดความอื่น ๆ ลงในบล็อกเหล่านั้นที่อนุญาตให้ผู้ใช้ป้อนจำนวนความดันต่อบล็อกเพิ่มความดันตามปริมาณของบล็อกน้ำที่เพิ่มเข้าไป