2026年10月1日木曜日

師匠の難題９

以前疑似アルファのタイル転送を作った後、いろいろ弄っていて気付いた点を二つほど。

関数テーブルもどき
うーん？ Python が内部でＣ言語が走っているってのはなんとなく聞いていたのですが…なら関数テーブルを作れないかな？と、思ったらクラスのメンバー関数を辞書登録する方法が見つかりまして。ただ、流石に１ドット打つごとに文字列をキーとした検索を行っていたら重すぎると思っていたら、数字でもできると判り試してみました…

ソースここから

import pyxel

SCREEN_SIZE_W = 160
SCREEN_SIZE_H = 120
CENTER_X = 80
CENTER_Y = 60
EMPTY = -32767

ALPHA_NON       = 0
ALPHA_HALF_1    = 1
ALPHA_HALF_2    = 2
ALPHA_QUARTER_1 = 3
ALPHA_QUARTER_2 = 4
ALPHA_QUARTER_3 = 5
ALPHA_QUARTER_4 = 6

my_table = (
       0,   6,  13,  19,  25,  31,  37,  43,  49,  55,  60,  66,  71,  76,  81,  86,
      91,  95,  99, 103, 106, 110, 113, 116, 118, 121, 122, 124, 126, 127, 127, 128,
     128, 128, 127, 127, 126, 124, 122, 121, 118, 116, 113, 110, 106, 103,  99,  95,
      91,  86,  81,  76,  71,  66,  60,  55,  49,  43,  37,  31,  25,  19,  13,   6,
       0,  -6, -13, -19, -25, -31, -37, -43, -49, -55, -60, -66, -71, -76, -81, -86,
     -91, -95, -99,-103,-106,-110,-113,-116,-118,-121,-122,-124,-126,-127,-127,-128,
    -128,-128,-127,-127,-126,-124,-122,-121,-118,-116,-113,-110,-106,-103,- 99, -95,
     -91, -86, -81, -76, -71, -66, -60, -55, -49, -43, -37, -31, -25, -19, -13,  -6,
       0,   6,  13,  19,  25,  31,  37,  43,  49,  55,  60,  66,  71,  76,  81,  86,
      91,  95,  99, 103, 106, 110, 113, 116, 118, 121, 122, 124, 126, 127, 127, 128
   )

def my_sin(angle,r):
    angle &= 127
    return r * my_table[angle]>>7
    
def my_cos(angle,r):
    angle &= 127
    angle += 32
    return r * my_table[angle]>>7

class VBresenham:
    
    def __init__(self):
        self.l_side = 0
        self.s_side = 0
        
        # horizonatial side is longer
        self.b_long_hs = True

        # Direction (1 or -1)
        self.dct_x = 1
        self.dct_y = 1

        self.counter = 0
        self.adder_x = 0
        self.adder_y = 0
        
        self.start_x = 0
        self.start_y = 0

    # start x,y terminus x,y
    def setup(self,s_x,s_y,t_x,t_y):
        
        self.b_long_hs = True
        self.dct_x = 1
        self.dct_y = 1
        self.counter = 0
        self.adder_x = 0
        self.adder_y = 0

        self.start_x = s_x
        self.start_y = s_y
        
        if (s_x > t_x):
            self.l_side = s_x - t_x
            self.dct_x = -1
        else:
            self.l_side = t_x - s_x

        if (s_y > t_y):
            self.s_side = s_y - t_y
            self.dct_y = -1
        else:
            self.s_side = t_y - s_y
            
        if (self.s_side > self.l_side):
            # swap
            self.s_side,self.l_side = self.l_side,self.s_side
            self.b_long_hs = False

        self.l_side += 1
        self.s_side += 1
        return self.l_side

    def step(self):
        self.counter += self.s_side
        i = self.counter - self.l_side
        
        ret_x = self.start_x+self.adder_x
        ret_y = self.start_y+self.adder_y

        if self.b_long_hs:
            self.adder_x += self.dct_x
            if i >= 0:
                self.counter = i
                self.adder_y += self.dct_y
        else:
            self.adder_y += self.dct_y
            if i >= 0:
                self.counter = i
                self.adder_x += self.dct_x
                
        return ret_x,ret_y

class Bresenham:
    
    def __init__(self):
        self.l_side = 0
        self.s_side = 0
        self.counter = 0
        self.adder = 0
        
        # Src side is longer
        self.b_long_ss = True

    def setup(self,Dest_side,Src_side):
        self.counter = 0
        self.adder = 0
        
        if Dest_side > Src_side:
            self.b_long_ss = False
            self.l_side = Dest_side+1
            self.s_side = Src_side+1
            return self.l_side
            
        self.b_long_ss = True
        self.l_side = Src_side+1
        self.s_side = Dest_side+1
        return self.s_side
        
    def step(self):
        ret = self.adder
        
        if self.b_long_ss:
            self.counter += self.s_side
            i = self.counter - self.l_side
            if i >= 0:
                self.counter = i
                self.adder += 1
        else:
            while self.counter <= self.l_side:
                self.adder += 1
                self.counter += self.s_side
                
            self.counter -= self.l_side

        return ret

class LineBuffer:
    def __init__(self):
        self.l = 0 # left
        self.r = 0 # right

        # 始点
        self.src_sx = 0
        self.src_sy = 0
        
        # 終点
        self.src_tx = 0
        self.src_ty = 0

class RollBlt:
    
    def __init__(self):
        self.buff = []
        for i in range(SCREEN_SIZE_H):
            self.buff.append(LineBuffer())

        self.top = 0
        self.bottom = 0

        self.vbre = VBresenham()
        self.bre  = Bresenham()

        self.once  = True

        self.tile = {
            ALPHA_NON       :self._non,
            ALPHA_HALF_1    :self._half1,
            ALPHA_HALF_2    :self._half2,
            ALPHA_QUARTER_1 :self._quarter1,
            ALPHA_QUARTER_2 :self._quarter2,
            ALPHA_QUARTER_3 :self._quarter3,
            ALPHA_QUARTER_4 :self._quarter4,
        }

    def setup(self):
        pass

    # タイル転送用内部関数群
    def _non(self,x,y,u,v):
        pyxel.blt(x, y, 0, u, v, 1, 1)

    def _half1(self,x,y,u,v):
        if x&1 == y&1:
            pyxel.blt(x, y, 0, u, v, 1, 1)

    def _half2(self,x,y,u,v):
        if x&1 != y&1:
            pyxel.blt(x, y, 0, u, v, 1, 1)

    def _quarter1(self,x,y,u,v):
        if (x&1) + (y&1)==0:
            pyxel.blt(x, y, 0, u, v, 1, 1)

    def _quarter2(self,x,y,u,v):
        if ((x+1)&1) + (y&1)==0:
            pyxel.blt(x, y, 0, u, v, 1, 1)

    def _quarter3(self,x,y,u,v):
        if (x&1) + ((y+1)&1)==0:
            pyxel.blt(x, y, 0, u, v, 1, 1)

    def _quarter4(self,x,y,u,v):
        if (x&1) + (y&1)==2:
            pyxel.blt(x, y, 0, u, v, 1, 1)
    
    # 原点座標中央位置補正コピー    
    def blt_c(self,dest_x, dest_y, bank, src_x, src_y, src_w, src_h, angle, scale_w=128, scale_h=128,alpha=ALPHA_NON):
        h = src_h * scale_h >> 8
        w = src_w * scale_w >> 8
        
        x = dest_x - my_sin(angle,h) - my_sin(angle+32,w)
        y = dest_y - my_cos(angle,h) - my_cos(angle+32,w)
        self.blt(x, y, bank, src_x, src_y, src_w, src_h, angle, scale_w, scale_h, alpha)
        
    def blt(self,dest_x, dest_y, bank, src_x, src_y, src_w, src_h, angle, scale_w=128, scale_h=128, alpha=ALPHA_NON):

        # 角度のまるめ
        angle &= 127

        # 原点から見た縦方向の端の座標
        h = src_h * scale_h >> 7
        tv_x = my_sin(angle,h-1)+dest_x
        tv_y = my_cos(angle,h-1)+dest_y

        # 原点から見た横方向の端の座標
        w = src_w * scale_w >> 7
        th_x = my_sin(angle+32,w-1)+dest_x
        th_y = my_cos(angle+32,w-1)+dest_y
        
        # ４頂点と比較し上下の座標を求める
        self.top = dest_y
        if tv_y < self.top:
            self.top = tv_y
        if th_y < self.top:
            self.top = th_y
        if (tv_y + th_y - dest_y) < self.top:
            self.top = tv_y + th_y - dest_y
        if self.top < 0:
            self.top = 0

        self.bottom = dest_y
        if tv_y > self.bottom:
            self.bottom = tv_y
        if th_y > self.bottom:
            self.bottom = th_y
        if (tv_y + th_y - dest_y) > self.bottom:
            self.bottom = tv_y + th_y - dest_y
        if self.bottom > (SCREEN_SIZE_H-1):
            self.bottom = SCREEN_SIZE_H-1

        # テーブル初期化
        for y in range (self.top, self.bottom+1):
            self.buff[y].l = EMPTY
            self.buff[y].r = EMPTY

        # 画像縦方向処理
        reg = self.vbre.setup(dest_x,dest_y,tv_x,tv_y)
        self.bre.setup(src_h-1,reg-1)

        match angle:
            # 垂直にコピーする時は縦方向の処理を行わない
            case a if a == 32 or a == 96:
                pass
                
            case a if a < 32:
                
                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_y = self.bre.step()

                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:
                        
                        if self.buff[y].l == EMPTY:
                            self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x
                        self.buff[y].src_sy = src_y + add_src_y
                    
                    x = x - dest_x + th_x
                    y = y - dest_y + th_y

                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].r = x
                        #pyxel.pset(x,y,6)
                        
                        self.buff[y].src_tx = src_x + src_w-1
                        self.buff[y].src_ty = src_y + add_src_y

            case a if a < 64:

                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_y = self.bre.step()
                    
                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x
                        self.buff[y].src_ty = src_y + add_src_y
                        
                    x = x - dest_x + th_x
                    y = y - dest_y + th_y
                    
                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].l == EMPTY:
                            self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x + src_w-1
                        self.buff[y].src_sy = src_y + add_src_y
            
            case a if a < 96:

                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_y = self.bre.step()
                    
                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].r == EMPTY:
                            self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x
                        self.buff[y].src_ty = src_y + add_src_y
                    
                    x = x - dest_x + th_x
                    y = y - dest_y + th_y
                    
                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x + src_w-1
                        self.buff[y].src_sy = src_y + add_src_y

            case _:

                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_y = self.bre.step()
                
                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x
                        self.buff[y].src_sy = src_y + add_src_y

                    x = x - dest_x + th_x
                    y = y - dest_y + th_y
                    
                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].r == EMPTY:
                            self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x + src_w-1
                        self.buff[y].src_ty = src_y + add_src_y

        # 画像横方向処理
        reg = self.vbre.setup(dest_x,dest_y,th_x,th_y)
        self.bre.setup(src_w-1,reg-1)

        match angle:
            # 水平にコピーする時は横方向の処理を行わない
            case a if angle == 0 or angle == 64:
                pass
                
            case a if a < 32:
                
                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_x = self.bre.step()
                    
                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].l == EMPTY:
                            self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x + add_src_x
                        self.buff[y].src_sy = src_y
                    
                    x = x - dest_x + tv_x
                    y = y - dest_y + tv_y

                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x + add_src_x
                        self.buff[y].src_ty = src_y + src_h-1
                
            case a if a < 64:

                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_x = self.bre.step()
                
                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x + add_src_x
                        self.buff[y].src_sy = src_y
                    
                    x = x - dest_x + tv_x
                    y = y - dest_y + tv_y

                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].r == EMPTY:
                            self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x + add_src_x
                        self.buff[y].src_ty = src_y + src_h-1

            case a if a < 96:

                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_x = self.bre.step()

                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].r == EMPTY:
                            self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x + add_src_x
                        self.buff[y].src_ty = src_y
                    
                    x = x - dest_x + tv_x
                    y = y - dest_y + tv_y

                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x + add_src_x
                        self.buff[y].src_sy = src_y + src_h-1

            case _:
                
                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_x = self.bre.step()
                    
                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x + add_src_x
                        self.buff[y].src_ty = src_y
                    
                    x = x - dest_x + tv_x
                    y = y - dest_y + tv_y

                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].l == EMPTY:
                            self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x + add_src_x
                        self.buff[y].src_sy = src_y + src_h-1

        # バッファを基に転送を行う

        for y in range (self.top, self.bottom+1):
            reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,
                                  self.buff[y].src_tx,self.buff[y].src_ty)
            self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)
            
            u,v = self.vbre.step()
            new_src = self.bre.step()               
            old_src = new_src

            for x in range (self.buff[y].l,self.buff[y].r+1):
                new_src = self.bre.step()
                for step_src in range (old_src, new_src):
                    u,v = self.vbre.step()
                old_src = new_src
                
                # 画面左右端処理
                if x < 0:
                    continue
                if x >= SCREEN_SIZE_W:
                    break
                
                self.tile[alpha](x,y,u,v)
                #pyxel.pset(x,y,pyxel.images[0].pget(sx,sy))

class App:

    def __init__(self):
        # 画面サイズ 160x120 で初期化
        pyxel.init(SCREEN_SIZE_W, SCREEN_SIZE_H, title="RollBlt")
        self.add_x = 0
        pyxel.load("yajirushi.pyxres")

        self.rb = RollBlt()
        
        self.angle  = 0
        self.angle2 = 0

        pyxel.run(self.update, self.draw)

    def update(self):
        self.angle += 1
        self.angle &= 127
        
        self.angle2 -= 1
        self.angle2 &= 127

    def draw(self):
        # 画面を黒（色番号0）でクリア
        pyxel.cls(0)
        
        #self.rb.blt(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, 16,512,512)
        self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle,512,512)

        #self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle,scale_w=64,scale_h=64)
        #self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle,scale_w=256,scale_h=256)
        """
        self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle,scale_w=512,scale_h=512, alpha=ALPHA_HALF_1)
        self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle2,scale_w=512,scale_h=512, alpha=ALPHA_HALF_2)
        """
        """
        self.rb.blt_c(CENTER_X-30, CENTER_Y-20, 0, 0, 0, 32, 16, self.angle,scale_w=512,scale_h=512, alpha=ALPHA_QUARTER_1)
        self.rb.blt_c(CENTER_X-30, CENTER_Y+20, 0, 0, 0, 32, 16, self.angle2,scale_w=512,scale_h=512, alpha=ALPHA_QUARTER_4)
        self.rb.blt_c(CENTER_X+30, CENTER_Y-20, 0, 0, 0, 32, 16, self.angle,scale_w=512,scale_h=512, alpha=ALPHA_QUARTER_2)
        self.rb.blt_c(CENTER_X+30, CENTER_Y+20, 0, 0, 0, 32, 16, self.angle2,scale_w=512,scale_h=512, alpha=ALPHA_QUARTER_3)
        """

App()


ソースここまで

微妙に三角関数テーブルを修正していたり、描画部を変えていたりしますが、基本的には前回と出力結果は変わりません。
ただ、実際に１ドットずつ画像を転送する部分を関数テーブルに分けた事でソースコードは大分短くなっています。
気になる実行速度の鈍化ですが、思ったよりも重くない様子…
いや、１ドット打つごとに遅くなるので数万回のオーバーヘッドがかかっており、確実に遅くはなっているハズなのですがそれでも影響がないと言う事は機材が進歩したって事ですかね。


点描に変えてみたら
ふと、１ドット毎に Blt 関数使っているなら１ドット毎に元画像のパレット取得して、転送先に１ドットずつ描画した方が早くない？と、思ってやってみたのですが…

たとえばココを…

    def _non(self,x,y,u,v):
        pyxel.blt(x, y, 0, u, v, 1, 1)


こうする

    def _non(self,x,y,u,v):
        col = pyxel.images[0].pget(u, v)
        pyxel.pset(x,y,col)


めちゃくちゃ遅い
どういうわけだか Pyxel に関して言えば１ドット毎に blt 命令を繰り返す事に対して１ドット毎に pget-pset を繰り返す方が断然遅い。
自動的に画面が拡大される仕様上、Blt の方は内部的にハードウェアを使った拡大を行っている可能性は高いのだが…ここまであからさまに処理落ちが起きるとは思っていなかったので意外でした。これだと実際にゲームで使用する際に多用されるパレット０の時は透過させるといった処理を組むととても重いのでは…と思いました。
投稿者 時刻: 0 件のコメント:
ラベル:

2026年9月28日月曜日

対あり終了

最後まで作画が崩れなかったのは強力な提供による潤沢な資金ゆえですかね。正直超人バトルに片足つっこんでてコレで対戦人口増えるかな？とは思いましたが。

個人的には満足でした
以前ウメハラが撮影協力してくれるのか～って書いたら、レッツゴージャスティーンな展開はあっても流石にゲームが違いすぎて操作は無くて、その次の回で著書の引用として協力に名前が出てましたね。
９０年代に格ゲーやっていた人間的には差し合いと飛び込みの読み合いくらいしか判りませんし、ゲージの管理やら行動の三すくみやらが出て来ると時代の違いについていけませんが楽しめました。
あと、モブの解像度がいちいち高いのも面白かったですね。

あと、最終話
「恋しさとせつなさと心強さと」
…リアルタイムで映画館に観に行ったっスよ。世界一かっこいいベガのスライディングが見れる映画です。映画館でもらったマスコットは誰だったかな…３０年以上前なので流石に忘れましたわ。
小室哲哉は昨年のジークアクスの「BEYOND THE TIME」に続いて２年連続起用ですか。９０年代はこの人の時代でしたからねえ、私くらいの世代には刺さりますわ。

二期は来るんですかね？
提供的に、ギルティや鉄拳もやっていないと不味い気はするのですが、原作はミリも知らんので判りません。
終わり方的には続けられる感じでしたがこのまま終わっても綺麗だし…って感じですかね。
投稿者 時刻: 0 件のコメント:
ラベル:

2026年9月26日土曜日

ＣＰＵガチャ

久しぶりに秋葉に行きまして、いつも行っているのに何も買わないのもどうかな？と、思ってパレットタウンアキバの店頭に置いてあるＣＰＵガチャ（４００円）を回したのですよ。
曰く Intel CPU が入っているとの事で、まあ Celeron あたりだろうと思っていたのですが…

Xeon かよ

ちなみにどの程度の性能かと言いますと…４世代 Core i7 4770 からグラフィック性能を無くして計算能力を８掛けにした代わりに、消費電力を５％くらい落としたような物。
ソケット形状も同じであり、差し替え可能…（ただし、i7 4770 に対して２年古いＣＰＵなので規格が古い部分も割とある）。
以前 Xeon を使った格安ゲームマシンを組んでいましたが、同様にレトロなゲームを遊ぶデスクトップを１．５万円程度で組むなら選択肢に入らなくは無いです、今更ＤＤＲ３メモリでゲームマシンを組むならば。
※若しくは LGA1150 ソケットのデスクトップ（ミニＰＣとか）に載せて完全に画像出力を棄てた NAS として使用すれば画像出力処理が無い分結構高速に動きます…外部接続で初期化できるだけの技量があればの話ですが。

…流石にガチャにサーバー用ＣＰＵが入っているとは思いませんでした。
正月の福袋も凄かったですが（今もモデリングに使っています）やっぱ良いセンスしてますわ。
投稿者 時刻: 0 件のコメント:
ラベル:

2026年9月25日金曜日

少女と学園城クリア

どうやらバットエンドの動画だけ取得できていないようですが、それ以外はあらかた取得した模様。
…いや、紅魔郷じゃないのかよ？と言われそうですが、あれのＥＸを攻略しようと思ったら老眼の私には半年以上かかりますので。
このゲームは以前言っていたスプリングセールで買ったゲームではあったのですよ…。
本来ゴールデンウィークにやる予定だったのですが、いろいろとゴタゴタがありまして…かといって盆は盆でいろいろと…
このまま引きずるのも嫌だなと思ってイージーモードでシルバーウィークに一気にやったのですが４日かかりました…いや、マップ広すぎだって…。

概要
…まあ、一番目を引くのは「世界観が透き通っている」と評されるキャラデザ。
ジャンルはメトロイドバニアで色んな「ウケる」ゲームや要素を投入して作ったソフト…です。メトロイドバニア系はエンダーリリーズ以来ですね…そう言えばマグノリアも買ったのですが手が付けられていません。


ざっくりとした感想
色々な要素を混ぜ込んでいて、暗に何を参考にしたかを暗示する展示も作中にあったりします（メトロイド／悪魔城ドラキュラ／ポータル…）。
所謂インディゲームな訳でそれは良いのですが…

足すのは良いけどちゃんと割ろう

というのが全体を通した感想でしたかねえ。いろんな意味で「好きな物を盛り込みまくった」けどまとまりにかけていました。

良い点
…じっくりと感想を書くと悪い点を並べてしまうので、まずは良い点を。

キャラデザ
人を選ぶキャラデザだと思いますが…ひとまずウケる画ではあると思います。

音楽
基本的に邪魔にならないＢＧＭです。耳に残るほどの良曲は無いものの煩わしいと感じる事もありません。探索ゲーなので主張が激しいと辛いですからねえ…まあ、元祖の悪魔城ドラキュラはＢＧＭで世界観作ってましたが。

キャラの動き
主人公を筆頭に敵キャラもちゃんとモデリングされよく動きます。

お話
メトロイドバニア系はゴシックホラーかＳＦホラーになるか、それらをバッサリ切り捨てたコミカル系が多いのですが…
実の所硬派なＳＦをコミカルで覆い隠している…といった感じで、後期のロックマンみたいなアンバランスさに挑戦しています。
無難にしなかった製作姿勢は褒めるべきでしょう。


ねっとりとした感想※がっつりネタバレします

お話
このゲームのお話の大部分は探索中に拾う読み物を読む事で察する事ができるようになっていまして…２０１８年にクリアしたアースドーンなんかも読み物で世界観を知るゲームだったと思いますが、ゲーム内ではあまり語られません…なんせ、主人公の正体が謎の中心なのであまり語れないのですよね…

割と中国産のゲームにありがちですが、ポストアポカリプス前後あたりの世界で、舞台となるカーメル学園は外界と隔絶された世界。で、この学園自体は地球人が住める環境があるという惑星カーメルを目指す宇宙船として作られていた…という設定。
近年ではナインソールが巨大宇宙船による移住の話だったような。

まあ、それだけならありがちなのですが、移住先の星の観測中に時間の流れのおかしい「あの惑星」を発見。とんでもなく早く時間が動いたり止まっていたりしたそうですが…
文明の変化に飢えていた「あの惑星」の生命体が「扉（本当に巨大な扉の形をした物体がある謎の空間）」を介してて接触してきて（ベタなＳＦのように戦争を仕掛けて来たのでは無く、興味本位だったらしい）星間移動の研究が急転。
まず、この惑星の時間にとらわれない「時性流体」がミ〇フスキー粒子並になんでもできるシロモノで、時間を止める／進める／ループさせる事が可能。研究する時間をループさせて、常に最善の結果だけを出し続ければ最高の未来が作れる…と、思ったのだが…
通常の人類では時間をループさせてもそれを認識できず同じ日を続けるだけで結果が変わらないので、時間を行き来できる時性流生命体を使役して次のループへ結果を引き継がせようと画策。
しかし、この時性流生命体は紫色の不定形有機生物で知性はあるもののコミュニケーションすらままならないシロモノだった…
時間を超越できる割に器具に封入できたりはする不思議な生物で人型に近づけるほどコミュニケーションが取りやすくなる事までは判明したのだが…

読み物によると、ある色を見せてからダメージを与え、別の色を見せてから餌を与える…といった動物の学習実験のような所からスタートしたらしいので、人類と会話出来て制御すらできるようになるまでは相当遠大な計画だったようです。
ちなみに、この時の実験中の生命体は最終ステージの敵として出て来るので、マイルドな表現をしたスペースホラーだったりします。
最終的には明示はされないものの、難病だった初代校長の娘と時性流生命体を融合（この時娘の人格は無くなってしまったらしい）して主人公が出来たらしいです。

で、良い結果の未来へ導く人格を持たせる必要があったため、学園全体をループする時間で包んで舞台装置とし、人の役に立つと得票できる生徒会長選挙に主人公を半ば強制的に参加させ、成長を促した…というのがこのゲームのざっくりとしたストーリー。

ループした時間の中に居る一般生徒達はループを実感できないのですが、一部勘づいている生徒やロボット等も居まして…中にはループを実感できるようになってしまい、４０年分以上ものループを繰り返した娘も居たりします。


惜しい点：演出
さて、お話を念頭に考えればお気楽な学園物を被った壮大なＳＦなのですが…
それなら学園物は極力コメディに走って、所々不穏な影が…という演出をすれば良い…ハズなんですけど、どちらの演出もちょっと弱いのですよねえ…
モブキャラに至るまでモデリングしたのなら「逃げた食材を集めて来てくれ」ってサブクエの時等は逃げる食材と追っかけるモブのカットでも挿入すれば生活感が出たハズですが、全体的にモブは動きません。
どうやらボーンを組んでいない固定オブジェクトのようでモブキャラ達が決まったポーズのままずっと動かないのですよ。
ファミコンの村人だって歩き回るくらいはしてますからさすがにココはどうにかして欲しかったですね。

夢の残骸？カジキ＆フィッシュヘッド
この手のゲームのお約束であるライバルキャラ＆ライバル軍団…のハズなのですが。
主人公と同じ技を使い、主人公をライバル視するカジキの被り物をしているカジキさん。
実のところは人助けをして回っており、助けられた生徒達がファンクラブ的に立ち上げたのが魚類の被り物をした人型敵キャラ集団フィッシュヘッド。
ただ、フィッシュヘッドのボスと８人の中核メンバー以外は狂信者化して各地で暴れているという設定。
…最初にカジキを観た時は別の時間軸の主人公か、ロックマンのブルース（ロックマンより一つ型番が古いプロトタイプのような存在）的なキャラかと思っていましたが…
ネタバレをすれば、主人公のコピーとして作られたがテストの結果廃棄になった…というキャラ。自分の存在意義の為人助けをして回ったが最後は主人公に成り代わろうとして決闘する…という筋。

…なのですが不自然な点があって、ボス戦チュートリアルとして最序盤にフィッシュヘッドの闘技場でカジキと対戦になります。フィッシュヘッドはカジキの狂信者ですが、カジキから見たフィッシュヘッドは赤の他人なので妙な舞台設定です。これはやはり、カジキを筆頭にしたライバル軍団という設定だったお話を途中で変えたのかなあと。
※又、この闘技場だけはモブキャラがちゃんと動いていて、カジキ戦も背景のモブたちが動いて応援していたりします。

カジキは最初の闘技場以降登場せず、最終盤の隠しボスとして登場して先述の決闘を行うのですが…もっと頻繁に出た方が物語が良くなったのでは？と思えてなりませんでした。

惜しい点：マップの仕掛け／演出
この手のゲームでメトロイド系の探索だとあまりやりたくは無いですが、悪魔城系なら期待したいのがマップの大仕掛け。
なのですが、動きに制限の多い８ビット時代ならいざ知らず、２０２６年のゲームにしては直線的なマップ仕掛けが多い。所謂、真横や上下に動く即死罠ですね。
４０年前のファミコンでも悪魔城伝説の振り子渡り（そしてスーパーファミコンのシャンデリア渡り）等の曲線的なマップトラップはあるのですが、直線的な罠が多く、曲線的と言っても回転するレーザートラップくらいなのですよねえ…

このゲームボス、キャラの中には巨大ロボットとかも居るのですが…
メトロイドとかだとボス戦前のマップでボスが背景を飛び回っていたり、背景に残骸が転がっていたりという「匂わせ」が在るのもですが、そういった点が薄いんですよね。
もうちょっとココは盛り上げる所だろっ、とツッコむ部分は多かったです。キャラデザやグラフィックを頑張るなら見せる方の努力もしないと報われないなあと思いました。

割とダメな点：操作系
いろいろ詰め込み過ぎて整理しなかった結果大変な事になったのが操作系…
このゲーム、ジャンプやダッシュはもちろん、所謂フックロープアクション、パリィ、等もあるのですが全てを別のボタンに割り振っています。
唯一スキルパネルボタンだけ攻撃と同時押しで特殊攻撃が出るようになっていますが…
古いゲームのように左の十字キーで移動、右の親指だけでアクションという割り振りではありません。特に両手の人差し指で行う操作に慣れていないとどのボタンがどのアクションだったかが混乱しがちです。
結局、私は難易度をイージーにして、パリィと特殊攻撃を一切せず通常攻撃と強攻撃（フローバースト）のみでゴリ押ししてクリアしました。
ちなみにこの方法でもイージーなら体力０で敵に倒された事はクリアまでに１回だけでした。
慣れたらスタイリッシュにプレーできるのでしょうけど、方向キー＋ボタン系の操作の方がプレーに集中できる気がしてなりません。

又、デフォルトで移動に３Ｄスティックが割り振られているのですが…細かい操作が要求されるゲーム性と噛み合っていません。

マップデザイン的にやたらと難易度の高いジャンプの高度管理を求められるシーンが多いのですが、前述の操作の難解さでかなり大変でした。
エンダーリリーズとかでもこの手のジャンプアクションは苦労したのですが…正直操作手順を手に馴染ませる作業が楽しさより苦行感が強めでした（エンリリはこのテの操作も楽しめたという記憶があるのですが…）。
個人の感想…と言いたい所ですが、苦情が来たのか特に細かい操作が求められるアスレチックマップは発売日の翌日にショートカットできるように仕様変更されています。
※ただし、マップ踏破率１００％にするためにはアスレチックマップの途中にある隠し部屋等を見つけないといけない

この操作要る？
前述のテキスト読むメニューなのですが…
普通に考えると、十字キーで各項目にフォーカス、決定ボタンで選択した項目を十字キーで動かせる（ページ送りやテキストのスクロール等）、サブ項目があるなら更に選択して決定ボタン／キャンセルボタンで一つ前の項目に戻る…が、一般的な操作です。なんなら実家のテレビのリモコンですらこういった操作なのですが…

うーん？
一応、この操作では前述の操作のように各テキストを読む為にステップを踏まないといけないと言う操作をすっ飛ばしてアクセスできるという利点はありますが…
正直、こんなにサイドボタンやトリガー割り振る必要あったかなと。非常に操作しづらいです。そもそも順にステップを踏んで情報にアクセスする方法は人間が情報を系統立てて考える事と合致している為スタンダードになっている訳で、革新的というより素人感が出てしまっているという印象が強かったです。


全体を通すと
正に惜しいゲームです。一般的にインディーズと言えば一点豪華主義で「売り」を推してそれ以外を妥協するものですが、全体的にボリュームも十分あり企業レベルの物を仕上げて来ています。
いますが、それだけに「企業レベル」で見られてしまうと操作系の煩雑さはいただけないし、画の出来に対して演出面の弱さが「作りこめていない」と感じられます。
ラストバトルなんて、これまで倒したボスが味方してくれるという、お約束とは言え熱い展開があったりするのですが…文字送りが早くて読めない（オイオイ）なんて悲しいスベり方をしています。
クラウドファンディングで立ち上げたソフトらしいのですが、次回作からちゃんと作りこんだソフトを提供できるようになるのか…今後に期待な内容だと思いました。


蛇足
プレー中５時間近くハマって唯一攻略記事を見る事になったのがクレアさん…
人探しクエストを極限まで簡単にしたら返って難解になったという稀有な事例ではないでしょうか（ネット検索したらハマった人は結構いるらしい）。
発見時期が遅れた為、いきなり病気で倒れている所から始まった彼女のクエストなのですが…序盤で発見した場合は通常時の会話もある模様。
で、彼女は主人公にそっくりな上で同じく外部からの留学生あつかい。…つまり世界観の匂わせをするキャラだったようなのですよね。
最終的には主人公の同族では無く、学園の生徒ですらない（学園の生徒はある程度統制管理された強化人間だったりする）地球人というポジションらしいですが。
序盤で逢っていたら印象が変わったかもしれないので、コレも惜しいポイントでしたね。

考察：時性流生命体って結局なんだったんだろう？
もちろん明示はされていないのですが、考察できる点はいろいろあって…

  • アメーバみたいな見た目だが実は文字を持っていて、文明は停滞してしまっている
  • 人型に近付けるほど意思疎通が可能になる
  • 人類と融合できる（昆虫とも融合できるのだが）
  • 航空学部の生徒の会話の中に宇宙で生活をする事になり、地球に触れる事も通信する事も無くなったらそれは最早宇宙人では？という会話がある

…これ、人類の成れの果てでは？
時間を行き来できる生命体の為、遥か未来だか過去だかは不明ですが…生命体として行きつくところまで行ったのがこの時性流生命体なのでは？
ちなみに、学園ではいくら燃焼させても再生力が上回る為、燃料として時性流生命体を使っていたりします…主人公の同族に対してあんまりな仕打ちな気が…
又、扉を介して「あの惑星」に時性流体等を採掘しに行けば資源問題は解決できる等と書いてあるテキストもあり、考察通りであれば究極の人類の住む星である「あの惑星」を資源採取目的の属国扱いしている描写が割とあります。
そもそも、この「扉」の仕組みをちゃんと解明すれば巨大宇宙船を建造して移動などしなくても惑星カーネルをはじめどんな星にでも行ける訳で、けっこう間が抜けている気がしないでも無いです。

まあ、ネットで一番間が抜けているとツッコまれている点は

惑星間移住船なのに、女性しか居ない学園飛ばしたら一代で全滅して終わりだろ

と言う点なのですが、それはまあ、ゲームの方向性なので…ツッコんだら負けなのでしょう。
投稿者 時刻: 0 件のコメント:
ラベル:

2026年9月17日木曜日

円と三角のコリジョン

以前師匠の難題７の際にちょっと触れたカリング判定式…検索したらＣＧソフト系の解説で単に３Ｄ処理を軽減する判定…と解説されている記事が見つかりまして。そら、ＣＧツールの利用から考えれば理解する所はそこだけで良いのだけれども…と思って簡単なソースを書いてみました。

そもカリングとは
はい、巻くを意味するカールの動名詞です。それの判定式ですから…
３頂点が右に巻いているか、左に巻いているか、あるいはどちらでも無い（全て同一点もしくは直線状に並んでいる）かの判定に用いられます。
どちらでもなければ０、右／左なら正もしくは負の値を返すのですが…
どちらが右回りでどちらが左回りかは環境によるのでなんとも言えないです、DirectX と OprnGL でも違いましたし、ゲーム機とＣＧツールで齟齬が出た事もありました…すり合わせで地獄を見た記憶が…

カリング判定の計算式
(X1-Px)(Y2-Py)-(X2-Px)(Y1-Py)

えらく簡単です。やっている事は３次元の面法線を外積から求める計算から、必要な部分だけを抽出した計算式…らしいのですが、正直外積の理解がイマイチなので綺麗に説明できません。
ちなみに面法線とは Blender では水色に見えるコレ（面に垂直に立つ面の向いている方向を示すベクトル）の事で、コレが手前に向いているか奥に向いているかを抽出しています。

表示処理の軽減：裏面省略
サイコロのような立方体を考えた際、これを３角ポリゴンで表現するとして…

これらの表面に例えば右巻きのマークを描きます。
で、このサイコロを回してみたらどうなるか？を考えてみましょう。
裏面…というか手前側から観えない面は左巻きになりますよね。
ならば、逆巻になったポリゴンは見えないのだから描画処理を省略すれば良い…というのが裏面省略でした。
…が、最近は光の反射計算等を行っている場合もあるので単純に省略すれば良いと言うものでも無くなってきています。

又、応用として、右巻き／左巻きの面の境界になる辺を線で描画すると輪郭線ができるため、アニメ調のアウトライン処理を行う際にも用いられています。


表示処理の軽減：視界によるオブジェクト省略
この図を上からの俯瞰図ととらえ、三角の下の頂点を視点、三角を視野角の範囲とすると青く変色した×マークが視野角の範囲に入った物で、それ以外は見えていない物になります。
ならば見えていないオブジェクトを省略すれば処理を大きく省略できます。もちろん光の反射等もあるので（以下略

どう判定するのかと言えば…
視野の範囲の三頂点がどちら周りかを調べ…
判定する点と各辺の頂点がどちら周りになるのかを調べます。
これらが全て同じ方向に回転している場合、判定する頂点は三角の中にあると判ります。


視界の範囲…を三角で示しましたが「視界って距離依存だから三角ではなくないか？」という当然の疑問が出ます。はい、正確には円の判定を組み合わせて距離の判定も行います…


円の範囲判定

(Px-Ox)(Px-Ox)+(Py-Oy)(Py-Oy)

これを円の半径の二乗と比較します。式自体はピタゴラスの定理って奴ですね。
直角三角形の底辺の二乗と高さの二乗の値が斜辺の二乗の値に等しいという奴です。
この斜辺の二乗と半径の二乗を比較して半径の二乗の方が大きければ円の範囲内に入っている事になります。

より正確には斜辺の二乗の平方根が斜辺の長さになり（あたり前）、この値と半径の長さを比較すれば良いのだけど、平方根の計算は非常に重い処理である事と、二乗の場合必ず正の値になる為比較が用意である事、各値の絶対値の大小関係と二乗の大小関係が同じである事から二乗の値で比較を行います。


でもって二つの処理を重ねた物がこんな感じ

ソースここから

import pyxel
import random

SCREEN_SIZE_W = 320
SCREEN_SIZE_H = 240

OBJ_MAX = 100
RADIUS = 50

def JudgCircle(px,py,circle_x,circle_y,r):
    
    x = px - circle_x
    y = py - circle_y
    
    if r*r >= x*x+y*y:
        return True
    return False

def JudgCulling(px,py,ax,ay,bx,by):
    return (ax-px)*(by-py)-(bx-px)*(ay-py)

def JudgTriangle(px,py,ax,ay,bx,by,cx,cy):
    f = JudgCulling(ax,ay,bx,by,cx,cy)
    f1 = JudgCulling(px,py,ax,ay,bx,by)
    f2 = JudgCulling(px,py,bx,by,cx,cy)
    f3 = JudgCulling(px,py,cx,cy,ax,ay)
    
    if f == 0:
        return False

    if f < 0 and f1 < 0 and f2 < 0 and f3 < 0:
        return True

    if f > 0 and f1 > 0 and f2 > 0 and f3 > 0:
        return True

    return False

class Obj:
    def __init__(self):
        x = 0
        y = 0
        color = 2
    
class App:

    def __init__(self):
        # 画面サイズ 320x240 で初期化
        pyxel.init(SCREEN_SIZE_W, SCREEN_SIZE_H, title="judg")
        
        self.object = []
        for i in range(OBJ_MAX):
            self.object.append(Obj())
            self.object[i].x = random.randint(0,SCREEN_SIZE_W)
            self.object[i].y = random.randint(0,SCREEN_SIZE_H)
            self.object[i].color = 2
        
        pyxel.run(self.update, self.draw)

    def update(self):
        pass

    def draw(self):
        # 画面を黒（色番号0）でクリア
        pyxel.cls(0)
        
        mx = pyxel.mouse_x
        my = pyxel.mouse_y
        
        t1x = mx + int(RADIUS/2)
        t1y = my - RADIUS
        t2x = mx - int(RADIUS/2)
        t2y = my - RADIUS

        pyxel.circb(mx,my,RADIUS,15)
        
        pyxel.line(mx,my,t1x,t1y,15)
        pyxel.line(mx,my,t2x,t2y,15)
        pyxel.line(t1x,t1y,t2x,t2y,15)
        
        for i in range(OBJ_MAX):
            self.object[i].color = 2
            
            if JudgCircle(self.object[i].x,self.object[i].y,mx,my,RADIUS):
                if JudgTriangle(self.object[i].x,self.object[i].y,mx,my,t1x,t1y,t2x,t2y):
                    self.object[i].color = 3
            
            pyxel.line(self.object[i].x-5,self.object[i].y-5,
                       self.object[i].x+5,self.object[i].y+5,
                       self.object[i].color)
            pyxel.line(self.object[i].x+5,self.object[i].y-5,
                       self.object[i].x-5,self.object[i].y+5,
                       self.object[i].color)
App()

ソースここまで

…三角だけの時とそこまで変わらなくない？という気がしないでもないですが、オブジェクト表示そのものを省略できるならかなりの軽量化になりますし、
円の判定計算は観ての通り非常に軽いのでやっておいて損は無いと思います。


はい、そんなわけで円と三角のコリジョン判定式でした
ぶっちゃけた話、２Ｄアクションゲームの当たり判定のほとんどはこの二つの式で片付きます。昔はよく取り扱ったなあと思い、書いてみました。
投稿者 時刻: 0 件のコメント:
ラベル:

2026年9月15日火曜日

これはなつかしい

東方紅魔郷ＮＣ
Steam見たら懐かしいものが見えて思わず購入…
だいぶ前に、東方はＵＳＢ接続のＳＥＧＡコントローラーが壊れたため、当時エクストラを攻略中だった地霊殿を最後に引退した…と、書いていたのですが、今の私にはセガコン用コンバータと純正のセガコンがあるのですよ。
これならチョン避けできるはず…

初見でなんとかEasy咲夜さん倒せましたが…
多分、１５年ぶり位に紅魔郷をプレー
まず言えるのが画面がすごい見やすい。そして、意外と自機もボスもデカかったんだなあと思いました。
あと、３面あたりからぼちぼちピチュったのですが…。
咲夜さんの所で、やっと低速ボタンに気づく。そうか、ショットボタン押しっぱなしで低速になるのは後の作品だったかと。
あと、低速にならないと自分の当たり判定出ないから霊夢と言えどかすりが分かりづらい。

案外覚えているものもありまして
イージー名物のチルノの正面安地は健在。当時はバカの代名詞でした。

やっぱり避けられないメイド秘技
イージーでも２度も軌道が変わる。老眼のじじいに気合避けは無理ですがな。

…うーん頑張ってフランちゃん討伐までやろうかなあ…
地霊まではＥＸ攻略してたんですけどねえ…いかんせん体が当時の様に動きません、特に目が…

投稿者 時刻: 0 件のコメント:
ラベル:

2026年9月12日土曜日

師匠の難題８

〆たばかりだったのですが、前回アップしたソースを修正して一つ気づいた部分がありまして…
どうせやるならタイルコピーによる疑似アルファ処理を追加しようかな？と。
タイル処理による疑似アルファとはなんぞや？という話ですが、コレは９０年代に見られた処理で…以前行った大カプコン展でもちらっと紹介されてました。

５０％タイル

２５％タイル

はい、２×２ドットの範囲で転送するドットとしないドットを決める事で疑似的に半透明っぽく見せる処理です。
又、表示するドットをずらす事で重なりを表現する事も可能です…
こうしてみると、全て転送した時に比べて画像のノイジーさがあまり気にならなくなりますね…

コードはかなり冗長になりますので…定数定義の部分と RollBlt クラスのみ抜粋

ソースここから

import pyxel

SCREEN_SIZE_W = 160
SCREEN_SIZE_H = 120
CENTER_X = 80
CENTER_Y = 60
EMPTY = -32767

ALPHA_NON       = 0
ALPHA_HALF_1    = 1
ALPHA_HALF_2    = 2
ALPHA_QUARTER_1 = 3
ALPHA_QUARTER_2 = 4
ALPHA_QUARTER_3 = 5
ALPHA_QUARTER_4 = 6

中略：第７回参照

class RollBlt:
    
    def __init__(self):
        self.buff = []
        for i in range(SCREEN_SIZE_H):
            self.buff.append(LineBuffer())

        self.top = 0
        self.bottom = 0

        self.vbre = VBresenham()
        self.bre  = Bresenham()

    def setup(self):
        pass
    
    # 原点座標中央位置補正コピー    
    def blt_c(self,dest_x, dest_y, bank, src_x, src_y, src_w, src_h, angle, scale_w=128, scale_h=128,alpha=ALPHA_NON):
        h = src_h * scale_h >> 8
        w = src_w * scale_w >> 8
        
        x = dest_x - my_sin(angle,h) - my_sin(angle+32,w)
        y = dest_y - my_cos(angle,h) - my_cos(angle+32,w)
        self.blt(x, y, bank, src_x, src_y, src_w, src_h, angle, scale_w, scale_h, alpha)
        
    def blt(self,dest_x, dest_y, bank, src_x, src_y, src_w, src_h, angle, scale_w=128, scale_h=128, alpha=ALPHA_NON):

        # 角度のまるめ
        angle &= 127

        # 原点から見た縦方向の端の座標
        h = src_h * scale_h >> 7
        tv_x = my_sin(angle,h-1)+dest_x
        tv_y = my_cos(angle,h-1)+dest_y

        # 原点から見た横方向の端の座標
        w = src_w * scale_w >> 7
        th_x = my_sin(angle+32,w-1)+dest_x
        th_y = my_cos(angle+32,w-1)+dest_y
        
        # ４頂点と比較し上下の座標を求める
        self.top = dest_y
        if tv_y < self.top:
            self.top = tv_y
        if th_y < self.top:
            self.top = th_y
        if (tv_y + th_y - dest_y) < self.top:
            self.top = tv_y + th_y - dest_y
        if self.top < 0:
            self.top = 0

        self.bottom = dest_y
        if tv_y > self.bottom:
            self.bottom = tv_y
        if th_y > self.bottom:
            self.bottom = th_y
        if (tv_y + th_y - dest_y) > self.bottom:
            self.bottom = tv_y + th_y - dest_y
        if self.bottom > (SCREEN_SIZE_H-1):
            self.bottom = SCREEN_SIZE_H-1

        # テーブル初期化
        for y in range (self.top, self.bottom+1):
            self.buff[y].l = EMPTY
            self.buff[y].r = EMPTY

        # 画像縦方向処理
        reg = self.vbre.setup(dest_x,dest_y,tv_x,tv_y)
        self.bre.setup(src_h-1,reg-1)

        match angle:
            # 垂直にコピーする時は縦方向の処理を行わない
            case a if a == 32 or a == 96:
                pass
                
            case a if a < 32:
                
                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_y = self.bre.step()

                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:
                        
                        if self.buff[y].l == EMPTY:
                            self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x
                        self.buff[y].src_sy = src_y + add_src_y
                    
                    x = x - dest_x + th_x
                    y = y - dest_y + th_y

                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].r = x
                        #pyxel.pset(x,y,6)
                        
                        self.buff[y].src_tx = src_x + src_w-1
                        self.buff[y].src_ty = src_y + add_src_y

            case a if a < 64:

                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_y = self.bre.step()
                    
                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x
                        self.buff[y].src_ty = src_y + add_src_y
                        
                    x = x - dest_x + th_x
                    y = y - dest_y + th_y
                    
                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].l == EMPTY:
                            self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x + src_w-1
                        self.buff[y].src_sy = src_y + add_src_y
            
            case a if a < 96:

                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_y = self.bre.step()
                    
                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].r == EMPTY:
                            self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x
                        self.buff[y].src_ty = src_y + add_src_y
                    
                    x = x - dest_x + th_x
                    y = y - dest_y + th_y
                    
                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x + src_w-1
                        self.buff[y].src_sy = src_y + add_src_y

            case _:

                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_y = self.bre.step()
                
                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x
                        self.buff[y].src_sy = src_y + add_src_y

                    x = x - dest_x + th_x
                    y = y - dest_y + th_y
                    
                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].r == EMPTY:
                            self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x + src_w-1
                        self.buff[y].src_ty = src_y + add_src_y

        # 画像横方向処理
        reg = self.vbre.setup(dest_x,dest_y,th_x,th_y)
        self.bre.setup(src_w-1,reg-1)

        match angle:
            # 水平にコピーする時は横方向の処理を行わない
            case a if angle == 0 or angle == 64:
                pass
                
            case a if a < 32:
                
                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_x = self.bre.step()
                    
                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].l == EMPTY:
                            self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x + add_src_x
                        self.buff[y].src_sy = src_y
                    
                    x = x - dest_x + tv_x
                    y = y - dest_y + tv_y

                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x + add_src_x
                        self.buff[y].src_ty = src_y + src_h-1
                
            case a if a < 64:

                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_x = self.bre.step()
                
                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x + add_src_x
                        self.buff[y].src_sy = src_y
                    
                    x = x - dest_x + tv_x
                    y = y - dest_y + tv_y

                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].r == EMPTY:
                            self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x + add_src_x
                        self.buff[y].src_ty = src_y + src_h-1

            case a if a < 96:

                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_x = self.bre.step()

                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].r == EMPTY:
                            self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x + add_src_x
                        self.buff[y].src_ty = src_y
                    
                    x = x - dest_x + tv_x
                    y = y - dest_y + tv_y

                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x + add_src_x
                        self.buff[y].src_sy = src_y + src_h-1

            case _:
                
                for i in range (reg):
                    x,y = self.vbre.step()
                    add_src_x = self.bre.step()
                    
                    # MainSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        self.buff[y].r = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_tx = src_x + add_src_x
                        self.buff[y].src_ty = src_y
                    
                    x = x - dest_x + tv_x
                    y = y - dest_y + tv_y

                    # SubSide
                    if y >= 0 and y < SCREEN_SIZE_H:

                        if self.buff[y].l == EMPTY:
                            self.buff[y].l = x
                        #pyxel.pset(x,y,6)

                        self.buff[y].src_sx = src_x + add_src_x
                        self.buff[y].src_sy = src_y + src_h-1

        # バッファを基に転送を行う

        # タイル処理なし
        if alpha == ALPHA_NON:
            for y in range (self.top, self.bottom+1):
                reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)
                self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)
                
                sx,sy = self.vbre.step()
                old_src = 0
                new_src = 0

                for x in range (self.buff[y].l,self.buff[y].r+1):
                    new_src = self.bre.step()
                    for step_src in range (old_src, new_src):
                        sx,sy = self.vbre.step()
                    old_src = new_src
                    
                    # 画面左右端処理
                    if x < 0:
                        continue
                    if x >= SCREEN_SIZE_W:
                        break
                    
                    pyxel.blt(x, y, 0, sx, sy, 1, 1)

        # タイル処理５０％　１
        if alpha == ALPHA_HALF_1:
            for y in range (self.top, self.bottom+1):
                reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)
                self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)
                
                sx,sy = self.vbre.step()
                old_src = 0
                new_src = 0

                for x in range (self.buff[y].l,self.buff[y].r+1):
                    new_src = self.bre.step()
                    for step_src in range (old_src, new_src):
                        sx,sy = self.vbre.step()
                    old_src = new_src
                    
                    # 画面左右端処理
                    if x < 0:
                        continue
                    if x >= SCREEN_SIZE_W:
                        break
                        
                    if x&1 == y&1:
                        pyxel.blt(x, y, 0, sx, sy, 1, 1)

        # タイル処理５０％　２
        if alpha == ALPHA_HALF_2:
            for y in range (self.top, self.bottom+1):
                reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)
                self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)
                
                sx,sy = self.vbre.step()
                old_src = 0
                new_src = 0

                for x in range (self.buff[y].l,self.buff[y].r+1):
                    new_src = self.bre.step()
                    for step_src in range (old_src, new_src):
                        sx,sy = self.vbre.step()
                    old_src = new_src
                    
                    # 画面左右端処理
                    if x < 0:
                        continue
                    if x >= SCREEN_SIZE_W:
                        break
                        
                    if x&1 != y&1:
                        pyxel.blt(x, y, 0, sx, sy, 1, 1)

        # タイル処理２５％　１
        if alpha == ALPHA_QUARTER_1:
            for y in range (self.top, self.bottom+1):
                reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)
                self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)
                
                sx,sy = self.vbre.step()
                old_src = 0
                new_src = 0

                for x in range (self.buff[y].l,self.buff[y].r+1):
                    new_src = self.bre.step()
                    for step_src in range (old_src, new_src):
                        sx,sy = self.vbre.step()
                    old_src = new_src
                    
                    # 画面左右端処理
                    if x < 0:
                        continue
                    if x >= SCREEN_SIZE_W:
                        break
                        
                    if (x&1) + (y&1)==0:
                        pyxel.blt(x, y, 0, sx, sy, 1, 1)

        # タイル処理２５％　２
        if alpha == ALPHA_QUARTER_2:
            for y in range (self.top, self.bottom+1):
                reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)
                self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)
                
                sx,sy = self.vbre.step()
                old_src = 0
                new_src = 0

                for x in range (self.buff[y].l,self.buff[y].r+1):
                    new_src = self.bre.step()
                    for step_src in range (old_src, new_src):
                        sx,sy = self.vbre.step()
                    old_src = new_src
                    
                    # 画面左右端処理
                    if x < 0:
                        continue
                    if x >= SCREEN_SIZE_W:
                        break
                        
                    if ((x+1)&1) + (y&1)==0:
                        pyxel.blt(x, y, 0, sx, sy, 1, 1)

        # タイル処理２５％　３
        if alpha == ALPHA_QUARTER_3:
            for y in range (self.top, self.bottom+1):
                reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)
                self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)
                
                sx,sy = self.vbre.step()
                old_src = 0
                new_src = 0

                for x in range (self.buff[y].l,self.buff[y].r+1):
                    new_src = self.bre.step()
                    for step_src in range (old_src, new_src):
                        sx,sy = self.vbre.step()
                    old_src = new_src
                    
                    # 画面左右端処理
                    if x < 0:
                        continue
                    if x >= SCREEN_SIZE_W:
                        break
                        
                    if (x&1) + ((y+1)&1)==0:
                        pyxel.blt(x, y, 0, sx, sy, 1, 1)

        # タイル処理２５％　４
        if alpha == ALPHA_QUARTER_4:
            for y in range (self.top, self.bottom+1):
                reg = self.vbre.setup(self.buff[y].src_sx,self.buff[y].src_sy,self.buff[y].src_tx,self.buff[y].src_ty)
                self.bre.setup(reg-1,self.buff[y].r - self.buff[y].l)
                
                sx,sy = self.vbre.step()
                old_src = 0
                new_src = 0

                for x in range (self.buff[y].l,self.buff[y].r+1):
                    new_src = self.bre.step()
                    for step_src in range (old_src, new_src):
                        sx,sy = self.vbre.step()
                    old_src = new_src
                    
                    # 画面左右端処理
                    if x < 0:
                        continue
                    if x >= SCREEN_SIZE_W:
                        break
                        
                    if (x&1) + (y&1)==2:
                        pyxel.blt(x, y, 0, sx, sy, 1, 1)

class App:

    def __init__(self):
        # 画面サイズ 160x120 で初期化
        pyxel.init(SCREEN_SIZE_W, SCREEN_SIZE_H, title="RollBlt")
        self.add_x = 0
        pyxel.load("yajirushi.pyxres")

        self.rb = RollBlt()
        
        self.angle  = 0
        self.angle2 = 0

        pyxel.run(self.update, self.draw)

    def update(self):
        self.angle += 1
        self.angle &= 127
        
        self.angle2 -= 1
        self.angle2 &= 127

    def draw(self):
        # 画面を黒（色番号0）でクリア
        pyxel.cls(0)
        
        #self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle,scale_w=64,scale_h=64)
        #self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle,scale_w=256,scale_h=64)
        ##
        """
        self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle,scale_w=512,scale_h=512, alpha=ALPHA_HALF_1)
        self.rb.blt_c(CENTER_X, CENTER_Y, 0, 0, 0, 32, 16, self.angle2,scale_w=512,scale_h=512, alpha=ALPHA_HALF_2)
        """
        self.rb.blt_c(CENTER_X-30, CENTER_Y-20, 0, 0, 0, 32, 16, self.angle,scale_w=512,scale_h=512, alpha=ALPHA_QUARTER_1)
        self.rb.blt_c(CENTER_X-30, CENTER_Y+20, 0, 0, 0, 32, 16, self.angle2,scale_w=512,scale_h=512, alpha=ALPHA_QUARTER_4)
        self.rb.blt_c(CENTER_X+30, CENTER_Y-20, 0, 0, 0, 32, 16, self.angle,scale_w=512,scale_h=512, alpha=ALPHA_QUARTER_2)
        self.rb.blt_c(CENTER_X+30, CENTER_Y+20, 0, 0, 0, 32, 16, self.angle2,scale_w=512,scale_h=512, alpha=ALPHA_QUARTER_3)

App()


ソースここまで

各 ALPHA が if 文で括られていますが違いは Pyxel.Blt を呼ぶかの判定式のみ
ただ、再三書いている通り、ループの中に分岐を書くのでは無く、分岐の中にループを書かないと処理が重くなるのでこのような冗長な記述になります。
…というか、この４重アルファの時点で Celeron ２コアマシンでは処理落ちが始まるのですよ…以前、処理の遅さを感じられるからプログラミングの訓練にはロースペックマシンが良いと書いたのですが、いきなり実感する事になりました。
さすがにこれ以上の発展は…やり始めるとパレットモードで３Ｄモデルを表示するだのおかしな話になりますし、そうなると Python より C++ で書かせろという話になります。
いや、ゲーム自体を作れば…は流石に何年かかるか判りませんし…又なにかあったら追記するかもしれませんが、ひとまずこれでホントの締めになると思います。

投稿者 時刻: 0 件のコメント:
ラベル:
登録: 投稿 (Atom)