ASCII - Asciimatics - 如何在代码中实现效果/屏幕

Question

几个帖子前有人建议我研究 Python 的 Asciimatics 库。我正在尝试解决它，使用：

• 样本 - https://github.com/peterbrittain/asciimatics/tree/master/samples
• 文档 - https://asciimatics.readthedocs.io/en/stable/

然而，由于我是新手，我仍然对其中一些非常基本的东西感到有些困惑。我知道，通过使用效果数组，您可以创建代码层，根据它们在数组中的位置覆盖屏幕上的信息。他们拥有的索引号越小，来自他们的信息就越低（不那么明显）。

以及我想要使用它的代码。目标是将墙和脚印放在顶层，蓝色圆圈放在底部。代码部分工作，所以你仍然可以享受我的可视化：

# Programs generate exit point along the wall, then spawn bot in random location. 
#He will move around and look for the exit, using different tools. 
#7.0 - Program randomly moves from starting point and makes 9 different steps. 
#It is forbidden for it to step in same place more than one.
#7.1 - Program not only moves, but also interact with the walls. 
#It will not move on any wall or other forbidden point that can be added to the list.
#7.2 - Added circle around the bot that travels with him

from asciimatics.screen import Screen
import os
import random
import math
import time

os.system('mode con: cols=51')


def exit_point():
    ''' Randomly select the wall, where exit point will be.
    Then select one random point along the line(wall) and create there exit point'''
    global exitX
    global exitY

    wall = random.randint(1,4)

    if wall == 1:
        exitX = random.randint(1,49)
        exitY = 0
    elif wall == 2:
        exitX = 49
        exitY = random.randint(1,49)
    elif wall == 3:
        exitX = random.randint(1,49)
        exitY = 49
    elif wall == 4:
        exitX = 0
        exitY = random.randint(1,49)


def start_point():
    ''' Select coordinates for starting point inside the wall zone,
    which is smaller by one then wall size, so it will not spawn it on the wall.'''
    global startX
    global startY

    startX = random.randint(2,48)
    startY = random.randint(2,48)


def setup(screen):
    ''' Creates wall image from #.  Red # represents Exit. 
    Then create starting point and spawn our hero @.'''
    screen.fill_polygon([[(0, 0), (50, 0), (50, 50), (0, 50)],[(1, 1), (49, 1), (49, 49), (1, 49)]])
    exit_point()
    screen.print_at("#", exitX, exitY, 1, 1)
    start_point()
    screen.print_at("@", startX, startY, 2, 1)
    screen.refresh()
    input()


def move(screen):
    ''' - First program will re-create walls, exit point and spawn our hero @.
        - Then the wall is defined as array of points. Points are added to big, 
        global list of forbidden points, where no move can be made
        - To the same list, starting point is added
        - '''

    #bring back setup screen, waste of code but more intuiative
    screen.fill_polygon([[(0, 0), (50, 0), (50, 50), (0, 50)],[(1, 1), (49, 1), (49, 49), (1, 49)]])
    screen.print_at("#", exitX, exitY, 1, 1)
    screen.print_at("@", startX, startY, 2, 1)

    #list of points where new point can not be created
    forbidden_place = []
    wall = []
    for i in range(49):
        point = [i,0]
        wall.append(point)          #wall no. 1
        point = [49,i]          
        wall.append(point)          #wall no. 2
        point = [i,49]          
        wall.append(point)          #wall no. 3
        point = [0,i]           
        wall.append(point)          #wall no. 4

    forbidden_place = wall

    #Add starting point to the forbidden points list
    point = [startX,startY]
    forbidden_place.append(point)

    #moves and looking around animation
    moves = 1
    while moves < 500:  

        #radius around our here where it will see things. Right now it's nothing else like visualisatios. 
        radius = 10
        for i in range(radius):
            XL = -(round(math.sqrt(radius*radius-i*i)))     #XL - X left, for X points on left side of the circle.
            XR =  (round(math.sqrt(radius*radius-i*i)))     #XR - X right, for X points on right side of the circle.
            Y = i                                           #iterated after Y coordinate and calculate X for left and right

            YU =  (round(math.sqrt(radius*radius-i*i)))     #YU - Y up, for Y points on the topside of the circle.
            YD = -(round(math.sqrt(radius*radius-i*i)))     #YD - Y down, for Y points on the downside of the circle.
            X = i                                           #iterated after X coordinate and calculate Y for top and bottom


            if moves > 1:           
                #if is here, otherwise it will use exit point and delete points in circle around it 
                #this part inide the if will clear last points of the radius light, 
                #by using point where hero was one move before
                screen.print_at(" ",  XR + forbidden_place[-2][0], Y  + forbidden_place[-2][1], 4, 1)
                screen.print_at(" ",  XL + forbidden_place[-2][0], Y  + forbidden_place[-2][1], 4, 1)
                #fill all holes after first two lines of the code, by making same circle, but rotated by 90deg
                screen.print_at(" ",  X + forbidden_place[-2][0],  YU + forbidden_place[-2][1], 4, 1)
                screen.print_at(" ",  X + forbidden_place[-2][0],  YD + forbidden_place[-2][1], 4, 1)

                screen.print_at(" ",  XR + forbidden_place[-2][0], -Y  + forbidden_place[-2][1], 4, 1)
                screen.print_at(" ",  XL + forbidden_place[-2][0], -Y  + forbidden_place[-2][1], 4, 1)
                #fill all holes after first two lines of the code, by making same circle, but rotated by 90deg
                screen.print_at(" ", -X + forbidden_place[-2][0],   YU + forbidden_place[-2][1], 4, 1)
                screen.print_at(" ", -X + forbidden_place[-2][0],   YD + forbidden_place[-2][1], 4, 1)  

            screen.print_at("+",  XR + forbidden_place[-1][0], Y  + forbidden_place[-1][1], 4, 1)
            screen.print_at("+",  XL + forbidden_place[-1][0], Y  + forbidden_place[-1][1], 4, 1)       
            screen.print_at("+",  X + forbidden_place[-1][0],  YU + forbidden_place[-1][1], 4, 1)
            screen.print_at("+",  X + forbidden_place[-1][0],  YD + forbidden_place[-1][1], 4, 1)

            screen.print_at("+",  XR + forbidden_place[-1][0], -Y  + forbidden_place[-1][1], 4, 1)
            screen.print_at("+",  XL + forbidden_place[-1][0], -Y  + forbidden_place[-1][1], 4, 1)      
            screen.print_at("+", -X + forbidden_place[-1][0],   YU + forbidden_place[-1][1], 4, 1)
            screen.print_at("+", -X + forbidden_place[-1][0],   YD + forbidden_place[-1][1], 4, 1)      

        #refresh wall visualisation, otherwise it would be 'eaten' by light. 
        #This part will be deleted after I learn how to use effects/scenes
        screen.fill_polygon([[(0, 0), (50, 0), (50, 50), (0, 50)],[(1, 1), (49, 1), (49, 49), (1, 49)]])
        screen.print_at("#", exitX, exitY, 1, 1)    

        #this part will generate movement points for our here. 
        #It will do it's best to not step in same place twice. So here will most likely stuck at some point. 
        #In future, there will be more logic that will allow him to move over his steps, if no other way is possible.
        moveX = forbidden_place[-1][0] + random.randint(-1,1)
        if moveX == forbidden_place[-1][0]:     
            moveY = forbidden_place[-1][1] + random.randrange(-1,2,2)   #select between -1 and 1, but not 0
        else:
            moveY = forbidden_place[-1][1] + random.randint(-1,1)       #select between -1 and 1, including 0
        point = [moveX,moveY]
        if point not in forbidden_place: 
            forbidden_place.append(point)
            screen.print_at(".", forbidden_place[-2][0], forbidden_place[-2][1], 2, 1) #footprint of the hero
            screen.print_at("@", moveX, moveY , 3, 1)                                  #hero's current position
            moves = moves + 1
        else:
            moveX = forbidden_place[-1][0]  #if point is already on the list, to prevent it overwrite variable moveX and moveY
            moveY = forbidden_place[-1][1]  #the program will clear it, by assigning it to last legit value from trace list,
        time.sleep(0.1)
        screen.refresh()
    input()

Screen.wrapper(setup)
Screen.wrapper(move)
input()

Answer 1

这完全取决于您如何实现新效果... 简而言之，您需要一种清除旧图像的策略。

为您的应用程序制作动画的最佳方式是使用double-buffering 并重新绘制每个新图像。这是 asciimatics 中使用的技术，用于在重绘屏幕时防止伪影。不幸的是，它不会在您交换缓冲区（刷新时）时清除屏幕，因此您需要自己执行此操作（在 v1.x 中）。完成后，您可以根据需要绘制叠加层，如果有帮助，可以使用单独的效果。

例如，如果您将墙设置为底部 Effect 并使其清除整个屏幕以及绘制墙壁，那么您的其他 Effect 只需绘制当前图像而不清除旧图像。