ゲームを作りたい人のための ソースコード集

私がその日作った短めのソースを簡単な解説とともに載せていきます
ゲーム制作初心者にとって参考になるかもしれないソースが多いです





二次元マップのスクロール

マップチップを並べた画面内を移動するアルゴリズムです

キャラクターはマスに捉われない動き方をします

 


csz=32:cszh=csz/2
gmw=640/csz:gmh=480/csz        ;画面に表示されるマス数
mpw=gmw*2:mph=gmh*2        ;マップ全体のマス数
gmwmx=mpw*csz:gmhmx=mph*csz    ;マップ全体の大きさ
dim mpdt,mpw,mph
repeat 600
    mpdt(rnd(mpw-2)+1,rnd(mph-2)+1)=1
loop
;マップチップ
buffer 2,csz*3,csz:celdiv 2,csz,csz,cszh,cszh
boxf:x=0
color 1:boxf x,0,x+csz-1,csz:x+csz
color 255,255,255:boxf x,0,x+csz-1,csz:x+csz
color 255:circle x,0,x+csz-1,csz
gsel 0
gmode 2
plx=cszh:ply=cszh
*main
    color:boxf
    getkey k37,37
    getkey k38,38
    getkey k39,39
    getkey k40,40
    if k37{
        plx-4
    }
    if k38{
        ply-4
    }
    if k39{
        plx+4
    }
    if k40{
        ply+4
    }
    plx=limit(plx,cszh,gmwmx-cszh)
    ply=limit(ply,cszh,gmhmx-cszh)
    ;表示
    gstx=limit(plx-csz*gmw/2,0,csz*mpw-csz*gmw)
    gsty=limit(ply-csz*gmh/2,0,csz*mph-csz*gmh)
    sx=gstx/csz-1:sy=gsty/csz-1
    ix=gstx¥csz:iy=gsty¥csz
    repeat gmh+2:j=cnt
        repeat gmw+2:i=cnt
            tx=sx+i:ty=sy+j
            if 0<=tx&tx<mpw&0<=ty&ty<mph{
                pos (i-1)*csz+cszh-ix,(j-1)*csz+cszh-iy
                celput 2,mpdt(tx,ty)
            }
        loop
    loop
    pos plx-gstx,ply-gsty:celput 2,2
    redraw:await 17:redraw 0
    goto *main

0
    posted by higashijugem 21:37comments(0)|-|





    あみだくじ

    あみだくじ表を自動で作成するプログラムです



    cmx=20    ;横線の数
    rmx=5    ;平行線の数
    randomize
    dim linedt,cmx,rmx
    cnm=0
    repeat
        if cnm>=cmx:break
        x=rnd(cmx):y=rnd(rmx)
        if linedt(x,y)=0{
            setflg=0
            if y=0{
                dir=0
            }else:if y=rmx-1{
                dir=1
            }else{
                dir=rnd(2)
            }
            if dir=0{
                if linedt(x,y+1)=0{
                    linedt(x,y)=1
                    linedt(x,y+1)=-1
                    setflg=1
                }
            }else{
                if linedt(x,y-1)=0{
                    linedt(x,y)=-1
                    linedt(x,y-1)=1
                    setflg=1
                }
            }
            if setflg{
                cnm++
            }
        }
        await
    loop
    sx=120:sy=80
    inlr=100
    inlc=16
    repeat rmx:y=cnt
        line sx,sy-inlc,sx,sy+(cmx+1)*inlc
        repeat cmx:x=cnt
            if linedt(x,y)=1{
                ty=sy+x*inlc
                line sx,ty,sx+inlr,ty
            }
        loop
        sx+inlr
    loop

    0
      posted by higashijugem 22:13comments(0)|-|





      慣性の法則

      慣性の法則のプログラムです

      十字キーを押すことで物体を移動させます

       

       

      cx=320.0
      cy=240.0
      mv=0.1
      vis=0.02
      cmx=0.0
      cmy=0.0
      angle=0
      cszh=16
      gw=640:gh=480
      *main
          color:boxf:color 255,255,255
          getkey k37,37
          getkey k38,38
          getkey k39,39
          getkey k40,40
          angle=0:kpush=0
          if k37{
              angle+180:kpush++
          }
          if k38{
              angle+90:kpush++
          }
          if k40{
              angle+270:kpush++
          }
          if k39{
              if k40{
                  angle+360
              }else{
                  angle+0
              }
              kpush++
          }
          if kpush>0{
              angle/kpush
              cmx+=cos(deg2rad(angle))*mv
              cmy-=sin(deg2rad(angle))*mv
          }else{
              cmx-=vis*cmx
              cmy-=vis*cmy
          }
          cx+=cmx
          cy+=cmy
          ;バウンド
          if cx<cszh{        ;左壁
              cx=0f+cszh
              cmx=-cmx
          }
          if cx>gw-cszh{    ;右壁
              cx=0f+gw-cszh
              cmx=-cmx
          }
          if cy<cszh{        ;上壁
              cy=0f+cszh
              cmy=-cmy
          }
          if cy>gh-cszh{    ;下壁
              cy=0f+gh-cszh
              cmy=-cmy
          }
          color 255,255,255
          circle cx-cszh,cy-cszh,cx+cszh,cy+cszh
          redraw:await 17:redraw 0
          goto *main

      0
        posted by higashijugem 19:16comments(0)|-|





        落下と上昇

        落下と上昇を組み合わせたアルゴリズムです

        そのままでは物体が落ちていくだけですが、上キーを押すことで上昇させることができます

         


        vy=0.0        ;速度
        ay=0.0        ;加速度
        vis=0.05    ;粘性抵抗係数
        grav=0.8    ;重力

        chx=320.0
        chy=240.0
        border=480
        chcsz=24:chcszh2=chcsz/2
        fallflg=1
        *main
            color:boxf
            getkey k38,38
            if k38{
                if fallflg=0{
                    ay=0.0
                    vy=0.0
                    chy-=1.0
                }
                fallflg=1
                ay=-grav+(vis*(-vy))
            }else{
                if fallflg=1{
                    ay=grav-(vis*vy)
                }
            }
            vy+ay
            chy+vy
            if chy>=border{
                chy=border
                fallflg=0
            }
            color 255,255,255
            boxf chx-chcszh2,chy-chcsz,chx+chcszh2,chy
            redraw:await 17:redraw 0
            goto *main

        0
          posted by higashijugem 19:10comments(0)|-|





          縄張りアルゴリズム

          一定の範囲内に進入した場合のみ、キャラクターを追いかけるプログラムです

           

           

          #enum e_i_sflg=0
          #enum e_i_stype
          #enum e_i_rsensx
          #enum e_i_rsensy
          #enum e_i_rsenslen
          #enum e_i_target
          #enum e_d_sx=0
          #enum e_d_sy
          #enum e_d_srad
          #enum e_d_sspd
          pirad2=M_PI*2

          spsum=2
          steer=0.01
          dim i_shipdt,6,spsum
          ddim d_shipdt,4,spsum
          i_shipdt(0,0)=1,0
          d_shipdt(0,0)=600.0, 400.0, deg2rad(220), 0.5
          i_shipdt(0,1)=1,1,300,320,200,-1
          d_shipdt(0,1)=300.0, 320.0, deg2rad(0), 0.0

          *main
              color 255,255,255:boxf:color
              repeat spsum:spid=cnt
                  if i_shipdt(e_i_sflg,spid){
                      rad=d_shipdt(e_d_srad,spid)
                      spd=d_shipdt(e_d_sspd,spid)
                      d_shipdt(e_d_sx,spid)+=cos(rad)*spd
                      d_shipdt(e_d_sy,spid)+=sin(rad)*spd
                      if i_shipdt(e_i_stype,spid)=0{
                          color ,,255
                      }else{    ;相手のなわばりアルゴリズム
                          rsx=0f+i_shipdt(e_i_rsensx,spid)
                          rsy=0f+i_shipdt(e_i_rsensy,spid)
                          len=0f+i_shipdt(e_i_rsenslen,spid)
                          ;なわばり範囲
                          color:circle rsx-len,rsy-len,rsx+len,rsy+len,0
                          espx=d_shipdt(e_d_sx,spid)
                          espy=d_shipdt(e_d_sy,spid)
                          esprad=d_shipdt(e_d_srad,spid)
                          espspd=d_shipdt(e_d_sspd,spid)
                          losid=-1
                          if i_shipdt(e_i_target,spid)>=0{
                              fspx=d_shipdt(e_d_sx,i_shipdt(e_i_target,spid))
                              fspy=d_shipdt(e_d_sy,i_shipdt(e_i_target,spid))
                              tlen=sqrt(powf(rsx-fspx,2)+powf(rsy-fspy,2))
                              if len>tlen{
                                  i_shipdt(e_i_target,spid)=-1
                              }
                          }
                          if i_shipdt(e_i_target,spid)<0{
                              repeat spsum:tspid=cnt
                                  if spid!=tspid&i_shipdt(e_i_stype,tspid)=0{
                                      fspx=d_shipdt(e_d_sx,tspid)
                                      fspy=d_shipdt(e_d_sy,tspid)
                                      tlen=sqrt(powf(rsx-fspx,2)+powf(rsy-fspy,2))
                                      if len>tlen{
                                          len=tlen
                                          losid=tspid
                                          d_shipdt(e_d_sspd,spid)=0.8
                                      }
                                  }
                              loop
                          }
                          if losid>=0{    ;縄張り内に侵入者
                              i_shipdt(e_i_target,spid)=losid
                              rot2=atan(fspy-espy,fspx-espx)
                              rot1=esprad
                              ;下の行をアンコメントするとどこまでも追いかける
                              ;i_shipdt(e_i_rsenslen,spid)=999999
                          }else{    ;侵入者が縄張り外に出た場合
                              tlen=sqrt(powf(rsx-espx,2)+powf(rsy-espy,2))
                              if tlen>10{    ;ほぼ中心地に戻る
                                  rot2=atan(rsy-espy,rsx-espx)
                                  rot1=esprad
                              }else{
                                  d_shipdt(e_d_sspd,spid)=0.0
                              }
                          }
                          ;ターゲットの進行方向と、ターゲットから見た標的の角度差
                          rad=rot2-rot1
                          ;方向の値が0〜円周率に収まるようにする
                          if rad>M_PI:rad-pirad2
                          if rad<-M_PI:rad+pirad2
                          if rad>steer{d_shipdt(e_d_srad,spid)+steer}
                          if rad<-steer{d_shipdt(e_d_srad,spid)-steer}
                          color 255
                      }
                      x=d_shipdt(e_d_sx,spid):y=d_shipdt(e_d_sy,spid)
                      circle x-10,y-10,x+10,y+10
                  }
              loop
              redraw:await 17:redraw 0
              goto *main

          0
            posted by higashijugem 12:10comments(0)|-|





            迎撃アルゴリズム

            キャラクターの接触ポイントを予測し、それに基づいた行動をさせるアルゴリズムです

             


            #enum e_i_sflg=0
            #enum e_i_stype
            #enum e_d_sx=0
            #enum e_d_sy
            #enum e_d_srad
            #enum e_d_sspd
            pirad2=M_PI*2

            spsum=2
            steer=0.01
            dim i_shipdt,2,spsum
            ddim d_shipdt,4,spsum
            i_shipdt(0,0)=1,0
            d_shipdt(0,0)=600.0, 400.0, deg2rad(220), 0.5
            i_shipdt(0,1)=1,1
            d_shipdt(0,1)=50.0, 420.0, deg2rad(0), 0.8

            *main
                color 255,255,255:boxf:color
                repeat spsum:spid=cnt
                    if i_shipdt(e_i_sflg,spid){
                        rad=d_shipdt(e_d_srad,spid)
                        spd=d_shipdt(e_d_sspd,spid)
                        d_shipdt(e_d_sx,spid)+=cos(rad)*spd
                        d_shipdt(e_d_sy,spid)+=sin(rad)*spd
                        x=d_shipdt(e_d_sx,spid):y=d_shipdt(e_d_sy,spid)
                        if i_shipdt(e_i_stype,spid)=0{
                            color ,,255
                        }else{    ;相手の迎撃アルゴリズム
                            len=999999.0
                            espx=d_shipdt(e_d_sx,spid)
                            espy=d_shipdt(e_d_sy,spid)
                            esprad=d_shipdt(e_d_srad,spid)
                            espspd=d_shipdt(e_d_sspd,spid)
                            losid=-1
                            repeat spsum:tspid=cnt
                                if spid!=tspid&i_shipdt(e_i_stype,tspid)=0{
                                    fspx=d_shipdt(e_d_sx,tspid)
                                    fspy=d_shipdt(e_d_sy,tspid)
                                    tlen=sqrt(powf(espx-fspx,2)+powf(espy-fspy,2))
                                    if len>tlen{
                                        len=tlen
                                        losid=tspid
                                    }
                                }
                            loop
                            if losid>=0{
                                fspx=d_shipdt(e_d_sx,losid)
                                fspy=d_shipdt(e_d_sy,losid)
                                fsprad=d_shipdt(e_d_srad,losid)
                                fspspd=d_shipdt(e_d_sspd,losid)
                                fax=cos(fsprad)*fspspd:fay=sin(fsprad)*fspspd
                                eax=cos(esprad)*espspd:eay=sin(esprad)*espspd
                                vrx=fax-eax:vry=fay-eay
                                srx=fspx-espx:sry=fspy-espy
                                tc=sqrt(srx*srx+sry*sry)/sqrt(vrx*vrx+vry*vry)
                                stx=fspx+fax*tc:sty=fspy+fay*tc
                                ;予測衝突地点
                                color:circle stx-10,sty-10,stx+10,sty+10,0
                                rot2=atan(sty-espy,stx-espx)
                                rot1=esprad
                                ;ターゲットの進行方向と、ターゲットから見た標的の角度差
                                rad=rot2-rot1
                                ;方向の値が0〜円周率に収まるようにする
                                if rad>M_PI:rad-pirad2
                                if rad<-M_PI:rad+pirad2
                                if rad>steer{d_shipdt(e_d_srad,spid)+steer}
                                if rad<-steer{d_shipdt(e_d_srad,spid)-steer}
                            }
                            color 255
                        }
                        circle x-10,y-10,x+10,y+10
                    }
                loop
                redraw:await 17:redraw 0
                goto *main

            0
              posted by higashijugem 21:51comments(0)|-|





              LOSアルゴリズム

              キャラクターの追跡アルゴリズムです

              直線する青を赤色が追いかけます

               


              #enum e_i_sflg=0
              #enum e_i_stype
              #enum e_d_sx=0
              #enum e_d_sy
              #enum e_d_srad
              #enum e_d_sspd
              pirad2=M_PI*2

              spsum=2
              steer=0.01
              dim i_shipdt,2,spsum
              ddim d_shipdt,4,spsum
              i_shipdt(0,0)=1,0
              d_shipdt(0,0)=600.0, 400.0, deg2rad(220), 0.5
              i_shipdt(0,1)=1,1
              d_shipdt(0,1)=50.0, 420.0, deg2rad(0), 0.8

              *main
                  color 255,255,255:boxf:color
                  repeat spsum:spid=cnt
                      if i_shipdt(e_i_sflg,spid){
                          rad=d_shipdt(e_d_srad,spid)
                          spd=d_shipdt(e_d_sspd,spid)
                          d_shipdt(e_d_sx,spid)+=cos(rad)*spd
                          d_shipdt(e_d_sy,spid)+=sin(rad)*spd
                          x=d_shipdt(e_d_sx,spid):y=d_shipdt(e_d_sy,spid)
                          if i_shipdt(e_i_stype,spid)=0{
                              color ,,255
                          }else{    ;相手の追跡アルゴリズム
                              len=999999.0
                              espx=d_shipdt(e_d_sx,spid)
                              espy=d_shipdt(e_d_sy,spid)
                              esprad=d_shipdt(e_d_srad,spid)
                              losid=-1
                              repeat spsum:tspid=cnt
                                  if spid!=tspid&i_shipdt(e_i_stype,tspid)=0{
                                      fspx=d_shipdt(e_d_sx,tspid)
                                      fspy=d_shipdt(e_d_sy,tspid)
                                      tlen=sqrt(powf(espx-fspx,2)+powf(espy-fspy,2))
                                      if len>tlen{
                                          len=tlen
                                          losid=tspid
                                      }
                                  }
                              loop
                              if losid>=0{
                                  fspx=d_shipdt(e_d_sx,losid)
                                  fspy=d_shipdt(e_d_sy,losid)
                                  rot2=atan(fspy-espy,fspx-espx)
                                  rot1=esprad
                                  ;ターゲットの進行方向と、ターゲットから見た標的の角度差
                                  rad=rot2-rot1
                                  ;方向の値が0〜円周率に収まるようにする
                                  if rad>M_PI:rad-pirad2
                                  if rad<-M_PI:rad+pirad2
                                  if rad>steer{d_shipdt(e_d_srad,spid)+steer}
                                  if rad<-steer{d_shipdt(e_d_srad,spid)-steer}
                              }
                              color 255
                          }
                          circle x-10,y-10,x+10,y+10
                      }
                  loop
                  redraw:await 17:redraw 0
                  goto *main

              0
                posted by higashijugem 20:12comments(0)|-|





                三次元極座標

                三次元の球面上に点を描写するプログラムです

                原点から一定の距離にランダムで点を配置します

                 

                #include "d3m.hsp"
                #const double CAMERA_R 180
                #const double PI 3.1415
                randomize
                r=60.0
                camera_phi=PI/3.0
                camera_theta=0.0
                old_mx=0
                old_my=0
                d3mkparticle 0,255,255,255

                sum=120
                dim x,sum
                dim y,sum
                dim z,sum
                repeat sum    ;球面上にパーティクル配置
                    rad0=deg2rad(rnd(360))
                    rad1=deg2rad(rnd(360))
                    ;曲座標を求める式
                    x(cnt)=r*sin(rad0)*cos(rad1)
                    y(cnt)=r*sin(rad0)*sin(rad1)
                    z(cnt)=r*cos(rad0)
                loop
                *main
                    color:boxf:color 255,255,255
                    ok1=k1:getkey k1,1:tk1=k1^ok1&k1
                    gosub *move_camera
                    gosub *draw
                    redraw:await 17:redraw 0
                    goto *main

                *draw        ;座標軸とパーティクルの描写
                    color 255:d3line -r,0,0,r,0,0
                    color ,255:d3line 0,-r,0,0,r,0
                    color ,,255:d3line 0,0,-r,0,0,r
                    gmode 5, , , 255
                    repeat sum
                        d3particle 0, x(cnt), y(cnt), z(cnt), 5
                    loop
                    return
                *move_camera    ;ドラッグでカメラ視点移動
                    if k1{
                        if ok1{
                            camera_theta += 0.01 * ( old_mx - ginfo_mx )
                            camera_phi   = limitf( camera_phi + 0.01 * ( old_my - ginfo_my ), 0.01, PI - 0.01 )
                        }
                        old_mx = ginfo_mx
                        old_my = ginfo_my
                    }
                    d3vrotate camera_x, camera_y, camera_z, 0, 0, CAMERA_R, 0, 1, 0, camera_phi
                    d3vrotate camera_x, camera_y, camera_z, camera_x, camera_y, camera_z, 0, 0, 1, camera_theta
                    d3setcam  camera_x, camera_y, camera_z
                    return

                0
                  posted by higashijugem 16:46comments(0)|-|





                  点同士を繋ぐ線

                  点と点の間に直線を描写するプログラムです

                  点同士をドラッグすることで線を引けます


                  randomize
                  areal=20
                  sum=10
                  dim ptcct,sum,sum
                  cctnum=0
                  dim ptxy,2,sum
                  repeat sum
                      ptxy(0,cnt)=rnd(640),rnd(480)
                  loop
                  setid=-1
                  *main
                      mux=mousex:muy=mousey
                      ok1=k1:getkey k1,1:tk1=k1^ok1&k1:rk1=k1^ok1&ok1
                      color 255,255,255:boxf:color
                      if tk1{    ;点をクリック
                          repeat sum
                              len=sqrt(powf(mux-ptxy(0,cnt),2)+powf(muy-ptxy(1,cnt),2))
                              if len<=areal{
                                  setid=cnt
                                  break
                              }
                          loop
                      }
                      if k1{
                          if setid>=0{    ;別の点にドラッグすることでラインを描写
                              repeat sum
                                  len=sqrt(powf(mux-ptxy(0,cnt),2)+powf(muy-ptxy(1,cnt),2))
                                  if len<=areal{
                                      if cnt!=setid{
                                          ptcct(cnt,setid)=1
                                          ptcct(setid,cnt)=1
                                          setid=cnt
                                          break
                                      }
                                  }
                              loop
                          }
                      }else{
                          setid=-1
                      }
                      ;点描写
                      repeat sum
                          x=ptxy(0,cnt):y=ptxy(1,cnt)
                          circle x-10,y-10,x+10,y+10
                      loop
                      ;ライン描写
                      repeat sum-1:j=cnt
                          repeat sum-(j+1),j+1:i=cnt
                              if ptcct(i,j)=1{
                                  sx=ptxy(0,i):sy=ptxy(1,i)
                                  gx=ptxy(0,j):gy=ptxy(1,j)
                                  line gx,gy,sx,sy
                              }
                          loop
                      loop
                      redraw:await 17:redraw 0
                      goto *main

                  0
                    posted by higashijugem 22:34comments(0)|-|





                    一日ゲームNo.17「PolyhedronSuffle」

                    一日ゲーム第十七弾

                     

                    カップシャッフルゲームの三次元版みたいなものです

                    多面体の角の一つが黄色くなっており、クリックするとランダムに移動します

                    移動先をクリックすれば正解し、次のステージに進めます

                    全5ステージです

                     

                    ダウンロード

                    ソースコード

                     

                    0
                      posted by higashijugem 15:46comments(0)|-|





                      一日ゲームNo.16「打斬張」

                      一日ゲーム第十六弾

                      少し複雑なじゃんけんゲームです

                       

                      打(赤)は斬(緑)に強く、斬(緑)は張(青)に強く、張(青)は打(赤)に強いです

                      「並び替え」・・・個体の並び替えを行います。先頭の五体のみ戦闘に参加させられます

                      「交配」・・・二つの個体を組み合わせます。ステータスは組み合わせた個体のステータスからランダムで決定します

                      「解雇」・・・個体を削除します。

                       

                      ダウンロード

                      ソースコード

                       

                       

                      0
                        posted by higashijugem 17:33comments(0)|-|





                        一日ゲームNo.15「円迷路」

                        一日ゲーム第十五弾

                        一風変わった迷路ゲームです

                         

                        白い線がルートで、サークルの外側がゴールになります

                        操作キーは十字キーのみです

                         

                        ダウンロード

                        ソースコード

                        ※10/31修正

                         

                        0
                          posted by higashijugem 18:47comments(0)|-|





                          一日ゲームNo.14「KnightJumper」

                          久々の一日ゲーム、第十四弾です

                           

                          チェスのナイトのような動きをするキャラクターを操作し、ステージをクリアしていきます

                          キャラクターが移動するごとにマスが減っていくので、身動きが取れなくなる前にゴール(青枠のマス)までたどり着く必要があります

                          また、キャラクターがいるマスと移動先のマスが二段以上差がある場合は移動できません

                          マップ上には攻略に役立つアイテム(紫のマス)があります、上手く活用して攻略を有利に進めてください

                           

                          操作方法

                          マップ上をクリック・・・移動

                          アイテム名をクリック・・・アイテムを使用

                           

                          gキーを押すことでゲームオーバー、その時点でのクリアステージ数が表示されます

                          ※10/24 システムを調整しました

                           

                          ダウンロード

                          ソースコード

                           

                           

                          0
                            posted by higashijugem 19:14comments(0)|-|





                            壁の透過

                            壁の向こう側にいるキャラクターがいる場合、キャラと壁が重なる部分を半透明で表示するプログラムです

                             

                             

                            ;壁の透過
                            #enum d_main=0
                            #enum d_wallwd
                            #enum d_maskchip
                            #enum d_chip
                            #enum d_bb0
                            #enum d_bb1
                            #enum d_maskwd
                            #include "gdi32.as"
                            #const SRCINVERT $00660046
                            csz=64
                            ;チップ画像
                            buffer d_chip,csz*3,csz*2:celdiv d_chip,csz,csz
                            color:boxf:x=0:y=0
                            color 255:circle x,y,x+csz-1,y+csz-1:y+csz    ;キャラ
                            color ,,255:boxf x,y,x+csz-1,y+csz-1:y+csz    ;壁
                            ;チップの黒白画像を作成
                            x1=csz:x2=csz*2
                            ty=0
                            repeat 2
                                repeat csz:j=cnt
                                    repeat csz:i=cnt
                                        pget i,ty+j
                                        cl=ginfo(16)+ginfo(17)+ginfo(18)
                                        if cl>0{
                                            color 1
                                            pset x1+i,ty+j
                                            color 255,255,255
                                            pset x2+i,ty+j
                                        }
                                    loop
                                loop
                                ty+csz
                            loop
                            ;マップ作成
                            mc=11:mr=8
                            gw=mc*csz:gh=mr*csz
                            dim mapdt,mc,mr
                            repeat 24
                                x=rnd(mc):y=rnd(mr)
                                mapdt(x,y)=1
                            loop
                            buffer d_bb0,gw,gh    ;XOR用1
                            hdc0=hdc
                            buffer d_bb1,gw,gh    ;XOR用2
                            hdc1=hdc
                            buffer d_wallwd,gw*2,gh    ;壁表示用
                            buffer d_maskwd,gw,gh    ;重複範囲用
                            ;処理開始
                            screen d_main,gw,gh
                            repeat
                                mux=mousex:muy=mousey
                                gsel d_bb0:color 255,255,255:boxf
                                gsel d_bb1:color 255,255,255:boxf
                                gsel d_wallwd:color:boxf
                                gsel d_maskwd:color 255,255,255:boxf
                                ;障害物の画像とマスク画像を描写
                                gsel d_wallwd
                                gmode 2
                                gsel d_bb1
                                gmode 2
                                repeat mr:j=cnt
                                    repeat mc:i=cnt
                                        if mapdt(i,j){
                                            gsel d_bb1
                                            x=csz*i:y=csz*j
                                            pos x,y:celput d_chip,1*3+1
                                            gsel d_wallwd
                                            pos x,y:celput d_chip,1*3
                                            pos x+gw,y:celput d_chip,1*3+2
                                        }
                                    loop
                                loop
                                ;XORコピーを用いて重なる範囲を取得する
                                BitBlt hdc0,0,0,gw,gh,hdc1,0,0,$00660046
                                gsel d_bb1
                                pos mux,muy:celput d_chip,0*3+2
                                BitBlt hdc0,0,0,gw,gh,hdc1,0,0,$00660046
                                ;重複範囲を半透明にする
                                gsel d_maskwd:color 128,128,128:boxf
                                gmode 6,,,255:gcopy d_bb0,,,gw,gh
                                ;壁表示用バッファに作成した重複範囲を重ねる
                                gsel d_wallwd
                                pos gw,0:gcopy d_maskwd,,,gw,gh
                                ;メイン画像に表示
                                gsel 0
                                gmode 2
                                color 255,255,255:boxf
                                x=mux:y=muy
                                pos x,y:celput d_chip,0*3
                                gmode 7,,,125
                                pos 0,0:gcopy d_wallwd,,,gw,gh
                                redraw:await:redraw 0
                            loop

                            0
                              posted by higashijugem 08:16comments(0)|-|





                              重ならないように円を配置ver2

                              円が重なり合わないように描写するプログラムその2です

                              円の配置チェックを二次元マップのマスで行います
                              青色の場合はクリックすることで配置可能、赤色の場合はすでに置かれた円と重なっているので配置できません

                               


                              gw=640:gh=480
                              mcsz=16
                              cw=gw/mcsz:ch=gh/mcsz
                              dim mapdt,cw,ch    ;マップデータ

                              len=5
                              repeat
                                  ok1=k1:getkey k1,1:tk1=k1^ok1&k1
                                  mcx=mousex/mcsz:mcy=mousey/mcsz
                                  mapsetflg=0
                                  if tk1{
                                      if overflg=0{    ;重なっていたら配置できないようにする
                                          mapsetflg=1
                                      }                ;if文をコメントアウトで配置可能
                                  }
                                  overflg=0
                                  repeat len*2+1,mcy-len:c1=cnt
                                      repeat len*2+1,mcx-len
                                          if 0<=cnt&cnt<cw&0<=c1&c1<ch{
                                              dis=0+sqrt(powf(mcx-cnt,2)+powf(mcy-c1,2))
                                              if dis<len{
                                                  if mapdt(cnt,c1){    ;配置された円と重なっている
                                                      overflg=1
                                                  }
                                                  if mapsetflg{    ;マップに配置
                                                      mapdt(cnt,c1)=1
                                                  }
                                              }
                                          }
                                      loop
                                  loop
                                  color 255,255,255:boxf
                                  repeat ch:c1=cnt
                                      repeat cw
                                          x=cnt*mcsz:y=c1*mcsz
                                          if mapdt(cnt,c1){
                                              color
                                              boxf x,y,x+mcsz-1,y+mcsz-1
                                          }
                                          dis=0+sqrt(powf(mcx-cnt,2)+powf(mcy-c1,2))
                                          if dis<len{
                                              if overflg{
                                                  color 255
                                              }else{
                                                  color ,,255
                                              }
                                              boxf x,y,x+mcsz-1,y+mcsz-1
                                          }
                                      loop
                                  loop
                                  redraw:await 17:redraw 0
                              loop

                              0
                                posted by higashijugem 12:46comments(0)|-|





                                重ならないように円を配置

                                円が重なり合わないように描写するプログラムです

                                青色の場合はクリックすることで配置可能、赤色の場合はすでに置かれた円と重なっているので配置できません

                                 


                                crmax=10
                                dim crdt,4,crmax    ;円データ
                                len=50
                                repeat
                                    mux=mousex:muy=mousey
                                    ok1=k1:getkey k1,1:tk1=k1^ok1&k1
                                    color 255,255,255:boxf
                                    mapsetflg=0
                                    if tk1{
                                        mapsetflg=1
                                    }
                                    overflg=0
                                    color
                                    repeat crmax    ;配置円の描写と、配置円との重なりがないかチェック
                                        if crdt(0,cnt){
                                            tx=crdt(1,cnt):ty=crdt(2,cnt):tlen=crdt(3,cnt)
                                            dis=sqrt(powf(mux-tx,2)+powf(muy-ty,2))
                                            if dis<=tlen+len{
                                                overflg=1
                                            }
                                            circle tx-tlen,ty-tlen,tx+tlen,ty+tlen
                                        }
                                    loop
                                    if overflg=0{    ;重なっていなければ
                                        if mapsetflg{    ;円を配置可能
                                            repeat crmax
                                                if crdt(0,cnt)=0{
                                                    crdt(0,cnt)=1,mux,muy,len
                                                    break
                                                }
                                            loop
                                        }
                                        mapsetflg=0
                                        color ,,255
                                    }else{
                                        color 255
                                    }
                                    circle mux-len,muy-len,mux+len,muy+len
                                    redraw:await 17:redraw 0
                                loop

                                0
                                  posted by higashijugem 12:42comments(0)|-|





                                  ジャパニーズアトラクタ

                                  ジャパニーズアトラクタ(Japanese attractor)はローレンツアトラクタと同時期に作られたカオスです

                                  Bの値を変えることで形を変えられます

                                   


                                  k=0.1    ;定数
                                  B=12.0    ;定数
                                  x=0.0    ;X座標
                                  y=0.0    ;Y座標
                                  n=10000    ;繰り返し回数
                                  bn=800    ;微分の項数
                                  dt=2.0*M_PI/bn
                                  t=0.0    ;時間
                                  kw=100    ;横倍率
                                  kh=15    ;縦倍率
                                  boxf:color 255,255,255
                                  repeat n
                                      repeat bn
                                          t=t+dt
                                          xx=x+dt*y;
                                          yy=y+dt*(-k*y-powf(x,3)+B*cos(t));
                                          x=xx;
                                          y=yy;
                                      loop
                                      pset x*kw,y*kh+240
                                      await
                                  loop
                                  title"stop"

                                  0
                                    posted by higashijugem 18:48comments(0)|-|





                                    ローレンツアトラクタ

                                    ローレンツアトラクタを描写するプログラムです

                                    三次元上に描写して、立体的に見えるようにしました

                                     

                                     

                                    #include "d3m.hsp"
                                    #define global sgm 10.0
                                    #define global r 28.0
                                    #define global b 8.0/3.0
                                    ;ローレンツ方程式の関数
                                    #module
                                    #defcfunc m_f double x,double y
                                        return sgm*(-x + y)
                                    #defcfunc m_g double x,double y,double z
                                        return r*x - y - x*z
                                    #defcfunc m_h double x,double y,double z
                                        return -b*z + x*y
                                    #global
                                    ddim ps,3    ;現在位置
                                    ddim nps,3    ;描写位置
                                    ddim k,3,4
                                    ddim calc,3
                                    dt=0.01    ;時間
                                    n=5000    ;繰り返し回数
                                    kd=20    ;拡大率
                                    repeat
                                        ct++
                                        redraw 0
                                        color:boxf:color 255,255,255
                                        ;カメラを回転させる
                                        d3setcam cos(0.04*ct)*1500,sin(0.04*ct)*1500,cos(0.03*ct)*1000,,,500
                                        ps=1.0,1.0,1.0
                                        d3initlineto
                                        repeat n:i=cnt
                                            ;4次ルンゲクッタ法
                                            k(0,0)=dt*m_f(ps(0),ps(1))
                                            k(1,0)=dt*m_g(ps(0),ps(1),ps(2))
                                            k(2,0)=dt*m_h(ps(0),ps(1),ps(2))
                                        
                                            k(0,1)=dt*m_f(ps(0)+k(0,0)/2,ps(1)+k(1,0)/2)
                                            k(1,1)=dt*m_g(ps(0)+k(0,0)/2,ps(1)+k(1,0)/2,ps(2)+k(2,0)/2)
                                            k(2,1)=dt*m_h(ps(0)+k(0,0)/2,ps(1)+k(1,0)/2,ps(2)+k(2,0)/2)
                                            
                                            k(0,2)=dt*m_f(ps(0)+k(0,1)/2,ps(1)+k(1,1)/2)
                                            k(1,2)=dt*m_g(ps(0)+k(0,1)/2,ps(1)+k(1,1)/2,ps(2)+k(2,1)/2)
                                            k(2,2)=dt*m_h(ps(0)+k(0,1)/2,ps(1)+k(1,1)/2,ps(2)+k(2,1)/2)
                                            
                                            k(0,3)=dt*m_f(ps(0)+k(0,2),ps(1)+k(1,2))
                                            k(1,3)=dt*m_g(ps(0)+k(0,2),ps(1)+k(1,2),ps(2)+k(2,2))
                                            k(2,3)=dt*m_h(ps(0)+k(0,2),ps(1)+k(1,2),ps(2)+k(2,2))
                                            repeat 3
                                                nps(cnt)=ps(cnt)+(k(cnt,0)+k(cnt,1)*2.0+k(cnt,2)*2.0+k(cnt,3))/6.0
                                                ps(cnt)=nps(cnt)
                                            loop
                                            ;描写
                                            d3lineto nps(0)*kd,nps(1)*kd,nps(2)*kd
                                        loop
                                        redraw
                                        await
                                    loop

                                    0
                                      posted by higashijugem 15:54comments(0)|-|





                                      オブジェクトのドラッグver3

                                      オブジェクトをドラッグ&ドロップするプログラムです

                                      複数の図形をそれぞれ移動させたり大きさを変えたりできます

                                       


                                      randomize
                                      objmax=5
                                      dim objdt,5,objmax
                                      repeat objmax
                                          objdt(0,cnt)=cnt
                                          x=rnd(390):y=rnd(260)
                                          objdt(0,cnt)=x,y
                                          objdt(2,cnt)=x+rnd(100)+50,y+rnd(80)+40
                                      loop
                                      repeat
                                          mux=mousex:muy=mousey
                                          ok1=k1
                                          getkey k1,1
                                          tk1=k1^ok1&k1
                                          if tk1{
                                              ;図形の辺や角をクリックする
                                              id=-1:type=0
                                              repeat objmax
                                                  ltx=objdt(0,cnt)
                                                  lty=objdt(1,cnt)
                                                  rbx=objdt(2,cnt)
                                                  rby=objdt(3,cnt)
                                                  if ltx-8<=mux&mux<=rbx+8&lty-8<=muy&muy<rby+8{
                                                      id=cnt
                                                      if abs(mux-ltx)<8{
                                                          type|%0001
                                                      }
                                                      if abs(muy-lty)<8{
                                                          type|%0010
                                                      }
                                                      if abs(mux-rbx)<8{
                                                          type|%0100
                                                      }
                                                      if abs(muy-rby)<8{
                                                          type|%1000
                                                      }
                                                      if type=0{
                                                          type|%1111
                                                      }
                                                      sltx=mux-objdt(0,cnt)
                                                      slty=muy-objdt(1,cnt)
                                                      srbx=mux-objdt(2,cnt)
                                                      srby=muy-objdt(3,cnt)
                                                      break
                                                  }
                                                  if id>=0:break
                                              loop
                                          }
                                          if k1{
                                              if id>=0{
                                                  ;伸ばしたり縮めたりする
                                                  if type&%0001{
                                                      objdt(0,id)=mux-sltx
                                                  }
                                                  if type&%0010{
                                                      objdt(1,id)=muy-slty
                                                  }
                                                  if type&%0100{
                                                      objdt(2,id)=mux-srbx
                                                  }
                                                  if type&%1000{
                                                      objdt(3,id)=muy-srby
                                                  }
                                              }
                                          }
                                          ;描写
                                          color 255,255,255:boxf:color
                                          repeat objmax
                                              ltx=objdt(0,cnt)
                                              lty=objdt(1,cnt)
                                              rbx=objdt(2,cnt)
                                              rby=objdt(3,cnt)
                                              boxf ltx,lty,rbx,rby
                                          loop
                                          redraw:await 17:redraw 0
                                      loop

                                      0
                                        posted by higashijugem 06:49comments(0)|-|





                                        マウスによるオブジェクトのサイズ変更

                                        ダイアログボックスのように、辺や角をドラッグすることで大きさを変えるプログラムです

                                        画面内の図形のサイズをマウスで変更することができます

                                         


                                        randomize
                                        ;オブジェクトデータ
                                        dim objdt,4
                                        x=rnd(490):y=rnd(360)
                                        objdt(0)=x,y
                                        objdt(2)=x+rnd(100)+50,y+rnd(80)+40

                                        repeat
                                            mux=mousex:muy=mousey
                                            ok1=k1
                                            getkey k1,1
                                            tk1=k1^ok1&k1
                                            if tk1{
                                                ;図形の辺や角をクリックする
                                                type=0
                                                ltx=objdt(0)
                                                lty=objdt(1)
                                                rbx=objdt(2)
                                                rby=objdt(3)
                                                if abs(mux-ltx)<8{
                                                    type|%0001
                                                }
                                                if abs(muy-lty)<8{
                                                    type|%0010
                                                }
                                                if abs(mux-rbx)<8{
                                                    type|%0100
                                                }
                                                if abs(muy-rby)<8{
                                                    type|%1000
                                                }
                                                sltx=mux-objdt(0)
                                                slty=muy-objdt(1)
                                                srbx=mux-objdt(2)
                                                srby=muy-objdt(3)
                                            }
                                            if k1{
                                                if type>0{
                                                    ;伸ばしたり縮めたりする
                                                    if type&%0001{
                                                        objdt(0)=mux-sltx
                                                    }
                                                    if type&%0010{
                                                        objdt(1)=muy-slty
                                                    }
                                                    if type&%0100{
                                                        objdt(2)=mux-srbx
                                                    }
                                                    if type&%1000{
                                                        objdt(3)=muy-srby
                                                    }
                                                }
                                            }
                                            ;描写
                                            color 255,255,255:boxf:color
                                            ltx=objdt(0)
                                            lty=objdt(1)
                                            rbx=objdt(2)
                                            rby=objdt(3)
                                            boxf ltx,lty,rbx,rby
                                            redraw:await 17:redraw 0
                                        loop

                                        0
                                          posted by higashijugem 07:38comments(0)|-|





                                          ダメージアニメーション

                                          RPGでよくある、キャラクターに攻撃を当てたり回復したりすると数字が出てくるアニメを作成しました

                                          画面上の物体をクリックすることでアニメが実行されます

                                           

                                           

                                          ;オブジェクト生成
                                          csz=20
                                          buffer 2,csz,csz:celdiv 2,csz,csz,csz/2,csz/2
                                          color ,255,255:boxf
                                          dim emyxy,2,3
                                          x=220:y=280
                                          repeat 3
                                              emyxy(0,cnt)=x,y
                                              x+100
                                          loop
                                          ;背景バッファ
                                          buffer 1
                                          boxf
                                          repeat 3
                                              pos emyxy(0,cnt),emyxy(1,cnt)
                                              celput 2,0
                                          loop
                                          ;ダメージアニメーション
                                          dim dmganidt,6,50
                                          repeat 50
                                              dmganidt(4,cnt)=50
                                          loop
                                          ;処理開始
                                          gsel 0
                                          repeat
                                              mux=mousex:muy=mousey
                                              ok1=k1
                                              getkey k1,1
                                              tk1=k1^ok1&k1
                                              if tk1{
                                                  pshnum=-1
                                                  repeat 3
                                                      ltx=emyxy(0,cnt)-csz/2
                                                      lty=emyxy(1,cnt)-csz/2
                                                      rbx=emyxy(0,cnt)+csz/2
                                                      rby=emyxy(1,cnt)+csz/2
                                                      ;オブジェクトをクリックしたかどうか判定
                                                      if ltx<=mux&mux<rbx&lty<=muy&muy<rby{
                                                          pshnum=cnt
                                                          break
                                                      }
                                                  loop
                                                  ;クリックしたらダメージアニメーションを作成
                                                  if pshnum>=0{
                                                      repeat 50
                                                          if dmganidt(0,cnt)=0{
                                                              dmganidt(0,cnt)=1
                                                              dmganidt(1,cnt)=emyxy(0,pshnum)
                                                              dmganidt(2,cnt)=emyxy(1,pshnum)-10
                                                              dmganidt(3,cnt)=0
                                                              dmganidt(5,cnt)=rnd(100)
                                                              break
                                                          }
                                                      loop
                                                  }
                                              }
                                              ;描写処理
                                              gmode 0:pos 0,0:gcopy 1,,,640,480
                                              color 255
                                              repeat 50
                                                  if dmganidt(0,cnt){
                                                      x=dmganidt(1,cnt)
                                                      y=dmganidt(2,cnt)-dmganidt(3,cnt)
                                                      pos x,y:mes""+dmganidt(5,cnt)
                                                      dmganidt(3,cnt)++
                                                      if dmganidt(3,cnt)>dmganidt(4,cnt){
                                                          dmganidt(0,cnt)=0
                                                      }
                                                  }
                                              loop
                                              redraw:await 17:redraw 0
                                          loop

                                          0
                                            posted by higashijugem 07:52comments(0)|-|





                                            視界フィルター

                                            最初は真っ暗で何も見えないマップを移動することで、プレイヤーの周辺の地形が見えるようになるプログラムです

                                            マウスカーソルを移動させることで見える範囲が広がっていきます

                                             


                                            gw=640:gh=480
                                            mc=64:mr=48
                                            mw=gw/mc:mh=gh/mr
                                            dim mlight,mc,mr    ;光源データ
                                            repeat mr:j=cnt
                                                repeat mc:i=cnt
                                                    mlight(i,j)=255
                                                loop
                                            loop

                                            buffer 2    ;フィルターバッファ
                                            buffer 1    ;背景バッファ
                                            repeat 100
                                                x=rnd(gw):y=rnd(gh):h=rnd(192)
                                                hsvcolor h,255,255
                                                boxf x,y,x+20,y+20
                                            loop

                                            px=0f+gw/2:py=0f+gh/2
                                            gosub *lightdraw
                                            gsel 0
                                            repeat
                                                mux=mousex:muy=mousey
                                                if abs(px)!=mux|abs(py)!=muy{
                                                    rad=atan(muy-py,mux-px)
                                                    px+=cos(rad)*0.5
                                                    py+=sin(rad)*0.5
                                                    gosub *lightdraw
                                                }
                                                gmode 0
                                                pos 0,0:gcopy 1,,,gw,gh
                                                gmode 6,,,255
                                                pos 0,0:gcopy 2,,,gw,gh
                                                redraw:await 17:redraw 0
                                            loop

                                            *lightdraw
                                                gsel 2
                                                repeat mr:j=cnt
                                                    cy=j*mh
                                                    ay=cy+mh/2
                                                    repeat mc:i=cnt
                                                        cx=i*mw
                                                        ax=cx+mw/2
                                                        den=powf(px-ax,2)+powf(py-ay,2)
                                                        h=limit(den/4-256,0,255)
                                                        if mlight(i,j)>h{
                                                            color h,h,h:boxf cx,cy,cx+mw,cy+mh
                                                            mlight(i,j)=h
                                                        }
                                                    loop
                                                loop
                                                gsel 0
                                                return

                                            0
                                              posted by higashijugem 21:43comments(0)|-|





                                              スピログラフ

                                              スピログラフを描写するプログラムです

                                               

                                               

                                              #const wid 600    ;画面の横幅
                                              #const hei 600    ;画面の縦幅

                                              #include "gdi32.as"
                                              #const SRCINVERT $00660046

                                              screen 0,wid,hei,0
                                              buffer 1,wid,hei,0    ;裏画面

                                              gsel 0
                                              color 255,255,255: boxf
                                              hdc0=hdc
                                              gsel 1
                                              hdc1=hdc
                                              gsel 0

                                              fcenx=int(wid/2) : fceny=int(hei/2)
                                              d=0
                                              rad=deg2rad(d)
                                              rcw=100.0    ;定円の半径
                                              rch=100.0
                                              rm=44.0        ;動円の半径
                                              rd=110.0    ;描画点の半径
                                              sx=(rcw-rm)*cos(rad)+rd*cos((rcw-rm)/rm*rad)+fcenx
                                              sy=(rch-rm)*sin(rad)-rd*sin((rch-rm)/rm*rad)+fceny
                                              tx=sx:ty=sy
                                              randomize
                                              redraw 0
                                              repeat
                                                  d++
                                                  rad=deg2rad(d)
                                                  gsel 1        ;裏画面に描画する
                                                  color:boxf    ;裏画面を真っ黒にクリア
                                                  color 255,255,255
                                                  nx=(rcw-rm)*cos(rad)+rd*cos((rcw-rm)/rm*rad)+fcenx
                                                  ny=(rch-rm)*sin(rad)-rd*sin((rch-rm)/rm*rad)+fceny
                                                  x=fcenx,fcenx,0+tx,0+nx
                                                  y=fceny,fceny,0+ty,0+ny
                                                  gsquare -1,x,y
                                                  gosub *xor_copy
                                                  tx=nx:ty=ny
                                                  if absf(sx-tx)+absf(sy-ty)<1{
                                                      break
                                                  }
                                                  gsel 0
                                                  redraw:await 1:redraw 0
                                              loop
                                              gsel 0
                                              redraw 1
                                              stop

                                              *xor_copy
                                                  ;裏画面の内容をメイン画面にxorコピー
                                                  BitBlt hdc0,0,0,wid,hei,hdc1,0,0,SRCINVERT
                                                  return

                                              0
                                                posted by higashijugem 07:31comments(0)|-|





                                                トロコイド曲線

                                                トロコイド (trochoid) とは、円をある曲線(円や直線はその特殊な場合)に沿って滑らないように転がしたとき、その円の内部または外部の点が描く曲線のことです。

                                                直線上を円が通ることで作られる線を「トロコイド」または「余擺線(よはいせん)」、

                                                動円が定円の内側を通ることで作られる線を「内トロコイド」、

                                                動円が定円の外側を通ることで作られる線を「外トロコイド」と呼びます

                                                 

                                                 

                                                d=0            ;角度
                                                rcw=100.0    ;定円の半径
                                                rch=100.0
                                                rm=60.0        ;動円の半径
                                                rd=100.0    ;描画点の半径
                                                fcenx=320    ;x軸の中心点
                                                fceny=240    ;y軸の中心点

                                                buffer 2:boxf:color 1
                                                gsel
                                                repeat
                                                    gsel 2
                                                    d++
                                                    rad=deg2rad(d)
                                                    ;内トロコイド
                                                    x=(rcw-rm)*cos(rad)+rd*cos((rcw-rm)/rm*rad)+fcenx
                                                    y=(rch-rm)*sin(rad)-rd*sin((rch-rm)/rm*rad)+fceny
                                                    ;外トロコイド
                                                    ;x=(rcw+rm)*cos(rad)-rd*cos((rcw+rm)/rm*rad)+fcenx
                                                    ;y=(rch+rm)*sin(rad)-rd*sin((rch+rm)/rm*rad)+fceny
                                                    if cnt=0{
                                                        line x,y,x,y
                                                    }else{
                                                        line x,y
                                                    }
                                                    
                                                    ;以下は描写処理
                                                    gsel:pget 3200:boxf:color
                                                    color 200,200,200
                                                    circle fcenx-rcw,fceny-rch,fcenx+rcw,fceny+rch,0    ;定円
                                                    
                                                    color
                                                    circle x-2,y-2,x+2,y+2            ;描写点
                                                    
                                                    gmode 2:gcopy 2,,,640,480
                                                    redraw:await 1:redraw 0
                                                loop

                                                0
                                                  posted by higashijugem 07:30comments(0)|-|





                                                  テイラー展開

                                                  自然対数の底(ネイピア数)をテイラー展開を用いて求めるプログラムです。

                                                   

                                                   

                                                  gerr=0.0    ;誤差(error)

                                                  x=1.0        ;入力
                                                  num=20.0    ;項数
                                                  prc=0.0001    ;精度(precision)

                                                  seq=1.0        ;一般項
                                                  sum=seq        ;総和
                                                  val=expf(x)    ;自然対数の底
                                                  ;テイラー展開の計算
                                                  repeat num,1:k=cnt
                                                      seq*=x/k            ;漸化式
                                                      sum+=seq            ;加算
                                                      gerr=absf(sum-val)    ;誤差
                                                      if gerr<prc{break}    ;誤差の判定
                                                  loop
                                                  mes""+sum    ;テイラー展開による値
                                                  mes""+val    ;関数による値
                                                  mes""+gerr    ;誤差

                                                  0
                                                    posted by higashijugem 13:43comments(0)|-|





                                                    Pendulum Waves

                                                    糸の長さを少しずつ変えた振り子を複数同時に動かしたプログラムです

                                                    振り子の周期により様々な波が作り出されることから「Pendulum Waves」と呼ばれます

                                                     


                                                    #module pendulum
                                                        #deffunc pen_init double m_d,double m_angle,double m_x,double m_y,int m_n
                                                            n=m_n
                                                            ddim len,n
                                                            ddim fx,n
                                                            ddim fy,n
                                                            ddim angle,2,n
                                                            ddim ppos,2,n    ;球の位置

                                                            m=1000.0    ;重さ
                                                            g=9.81        ;重力
                                                            dt=0.001    ;時間
                                                            
                                                            i=0
                                                            repeat n,45
                                                                l=4000000.0*g/powf(2.0*M_PI*cnt,2)
                                                                len(i)=l
                                                                fx(i)=m_x
                                                                fy(i)=m_y
                                                                angle(0,i)=m_angle,m_angle
                                                                pen_setpos i
                                                                i++
                                                            loop
                                                            return
                                                        #deffunc pen_setpos int m_i
                                                            ppos(0,m_i)=len(m_i)*sin(angle(0,m_i))+fx(m_i)
                                                            ppos(1,m_i)=len(m_i)*cos(angle(0,m_i))+fy(m_i)
                                                            return
                                                        #deffunc pen_getpos array r_arr,int m_i
                                                            r_arr(0,m_i)=ppos(0,m_i),ppos(1,m_i)
                                                            return
                                                        #deffunc pen_newAngle int m_i    ;振り子の角度
                                                            angle(1,m_i)+=dt*(-m*g/len(m_i)*sin(angle(0,m_i)))
                                                            angle(0,m_i)+=angle(1,m_i)*dt
                                                            return
                                                    #global

                                                    #module graphic
                                                        #deffunc gra_init    ;初期化
                                                            gw=640        ;画面の横幅
                                                            gh=480        ;画面の縦幅
                                                            pnum=60        ;球の総数
                                                            spd=5
                                                            pen_init 400,-M_PI/4,gw/2,0,pnum
                                                            return
                                                        #deffunc gra_update        ;描写
                                                            color 255,255,255:boxf 0,0,gw,gh:color
                                                            repeat pnum:i=cnt
                                                                repeat spd
                                                                    pen_newAngle i
                                                                loop
                                                            loop
                                                            repeat pnum:i=cnt
                                                                pen_setpos i
                                                            loop
                                                            ddim p,2,pnum
                                                            repeat pnum:i=cnt
                                                                pen_getpos p,i
                                                                color 200,200,200:line gw/2,0,p(0,i),p(1,i)
                                                                hsvcolor cnt*3,255,255:circle p(0,i)-8,p(1,i)-8,p(0,i)+8,p(1,i)+8
                                                            loop
                                                            return
                                                    #global

                                                    gra_init
                                                    repeat
                                                        gra_update
                                                        redraw:await 17:redraw 0
                                                    loop

                                                    0
                                                      posted by higashijugem 11:48comments(0)|-|





                                                      残像

                                                      残像を表現したプログラムです

                                                      マウスを動かすことで尾を引くような残像を発生させます

                                                       


                                                      r=16
                                                      color:boxf
                                                      repeat
                                                          mux=mousex:muy=mousey
                                                          gmode 3,,,1        ;半透明合成コピー
                                                          color:grect 320,240,0,640,480    ;半透明合成塗りつぶし
                                                          color 255,255
                                                          circle mux-r,muy-r,mux+r,muy+r    ;物体描写
                                                          redraw:await 1:redraw 0
                                                      loop

                                                      0
                                                        posted by higashijugem 11:32comments(0)|-|





                                                        振り子

                                                        単振り子を描写するプログラムです。

                                                        振り子とは、糸で垂らして左右に揺れ動く物体を指します。

                                                         


                                                        #module pendulum
                                                            #deffunc pen_init double m_d,double m_alpha,double m_x,double m_y
                                                                fx=m_x
                                                                fy=m_y
                                                                len=m_d
                                                                ddim angle,2
                                                                angle=m_alpha,m_alpha
                                                                ddim ppos,2    ;球の位置
                                                                pen_setpos

                                                                m=1000.0    ;重さ
                                                                g=9.81        ;重力
                                                                dt=0.001    ;時間
                                                                return
                                                            #deffunc pen_setpos
                                                                ppos(0)=len*sin(angle(0))+fx
                                                                ppos(1)=len*cos(angle(0))+fy
                                                                return
                                                            #deffunc pen_getpos array r_arr
                                                                r_arr=ppos(0),ppos(1)
                                                                return
                                                            #deffunc pen_newAngle    ;振り子の角度
                                                                angle(1)+=dt*(-m*g/len*sin(angle(0)))
                                                                angle(0)+=angle(1)*dt
                                                                return
                                                        #global

                                                        #module graphic
                                                            #deffunc gra_init    ;初期化
                                                                gw=640
                                                                gh=480
                                                                pen_init 400,-M_PI/4,gw/2,0
                                                                return
                                                            #deffunc gra_update        ;描写
                                                                color 255,255,255:boxf 0,0,gw,gh:color
                                                                repeat 5
                                                                    pen_newAngle
                                                                loop
                                                                pen_setpos
                                                                ddim p,2
                                                                pen_getpos p
                                                                line gw/2,0,p(0),p(1)
                                                                circle p(0)-8,p(1)-8,p(0)+8,p(1)+8
                                                                return
                                                        #global

                                                        gra_init
                                                        repeat
                                                            gra_update
                                                            await 17
                                                        loop

                                                        0
                                                          posted by higashijugem 10:39comments(0)|-|





                                                          自動で近づき攻撃するオブジェクト

                                                          対象に対して一定の距離まで近づき、そこから遠距離攻撃を行うオブジェクトを作成するプログラムです

                                                          マウスカーソルに近づいて、弾か矢みたいなものを飛ばしてます

                                                           

                                                           

                                                          ;ユニットデータ
                                                          ddim unitdt,5
                                                          unitdt(0)=1.0    ;生存フラグ
                                                          unitdt(1)=320.0    ;X座標
                                                          unitdt(2)=240.0    ;Y座標
                                                          unitdt(3)=0.5    ;移動スピード
                                                          unitdt(4)=0.0    ;方向
                                                          ;銃データ
                                                          dim gundt,5
                                                          gundt(0)=60        ;射程距離
                                                          gundt(1)=0        ;インターバル現在値
                                                          gundt(2)=50        ;インターバル最大値
                                                          ;弾丸データ
                                                          bulletmax=100
                                                          ddim bulletdt,7,bulletmax:bulletid=0
                                                          ;処理開始
                                                          repeat
                                                              color 255,255,255:boxf:color
                                                              mux=mousex:muy=mousey
                                                              den=sqrt(powf(mux-unitdt(1),2)+powf(muy-unitdt(2),2))
                                                              if den>gundt(0){    ;射程距離まで近づく
                                                                  if gundt(1){
                                                                      gundt(1)--
                                                                  }
                                                                  rad=atan(muy-unitdt(2),mux-unitdt(1))
                                                                  unitdt(4)=rad
                                                                  unitdt(1)=cos(unitdt(4))*unitdt(3)+unitdt(1)
                                                                  unitdt(2)=sin(unitdt(4))*unitdt(3)+unitdt(2)
                                                              }else{        ;攻撃
                                                                  if gundt(1){
                                                                      gundt(1)--
                                                                  }else{
                                                                      repeat bulletmax,bulletid:id=cnt
                                                                          if id>=bulletmax{id=0}
                                                                          if bulletdt(0,id)<1.0{
                                                                              rad=atan(muy-unitdt(2),mux-unitdt(1))
                                                                              bulletdt(0,id)=1.0        ;生存フラグ
                                                                              bulletdt(1,id)=unitdt(1)    ;X座標
                                                                              bulletdt(2,id)=unitdt(2)    ;Y座標
                                                                              bulletdt(3,id)=rad        ;移動方向
                                                                              bulletdt(4,id)=1.0        ;移動スピード
                                                                              bulletdt(5,id)=150.0    ;持続時間
                                                                              bulletid=id+1
                                                                              break
                                                                          }
                                                                      loop
                                                                      gundt(1)=gundt(2)
                                                                  }
                                                              }
                                                              ;弾丸の処理
                                                              repeat bulletmax
                                                                  if bulletdt(0,cnt)>=1.0{
                                                                      bulletdt(5,cnt)--
                                                                      if bulletdt(5,cnt)<1.0{
                                                                          bulletdt(0,cnt)=0.0
                                                                      }else{
                                                                          bulletdt(1,cnt)=cos(bulletdt(3,cnt))*bulletdt(4,cnt)+bulletdt(1,cnt)
                                                                          bulletdt(2,cnt)=sin(bulletdt(3,cnt))*bulletdt(4,cnt)+bulletdt(2,cnt)
                                                                          x=bulletdt(1,cnt):y=bulletdt(2,cnt)
                                                                          circle x-2,y-2,x+2,y+2
                                                                      }
                                                                  }
                                                              loop
                                                              x=unitdt(1):y=unitdt(2)
                                                              circle x-4,y-4,x+4,y+4
                                                              redraw:await 17:redraw 0
                                                          loop

                                                           

                                                          0
                                                            posted by higashijugem 22:44comments(0)|-|





                                                            近づくと出現するオブジェクト

                                                            範囲内に入るとオブジェクトが作成されるプログラムです

                                                            黒い円の中にマウスカーソルを持ってくると、赤い円の範囲内にオブジェクトが現れ、近づいていきます

                                                             

                                                             

                                                            ;中心の範囲データ
                                                            dim origindt,5
                                                            origindt=320,240,30,120
                                                            ;オブジェクトデータ
                                                            objmax=100
                                                            ddim objdt,5,objmax
                                                            objtmax=50
                                                            objtnum=0
                                                            repeat
                                                                mux=mousex:muy=mousey
                                                                den1=sqrt(powf(origindt(0)-mux,2)+powf(origindt(1)-muy,2))
                                                                len=origindt(2)
                                                                if den1<=origindt(3){
                                                                    ;一定の間隔で作成される
                                                                    if objtnum{
                                                                        objtnum--
                                                                    }else{
                                                                        repeat objmax
                                                                            if objdt(0,cnt)<1.0{
                                                                                objdt(0,cnt)=1.0
                                                                                objdt(1,cnt)=0f+rnd(len)-len/2+origindt(0)
                                                                                objdt(2,cnt)=0f+rnd(len)-len/2+origindt(1)
                                                                                break
                                                                            }
                                                                        loop
                                                                        objtnum=objtmax
                                                                    }
                                                                }
                                                                ;描写
                                                                color 255,255,255:boxf
                                                                x=origindt(0):y=origindt(1):r1=origindt(2):r2=origindt(3)
                                                                color 255:circle x-r1,y-r1,x+r1,y+r1,0
                                                                color:circle x-r2,y-r2,x+r2,y+r2,0
                                                                repeat objmax
                                                                    if objdt(0,cnt)>=1.0{
                                                                        den2=sqrt(powf(objdt(1,cnt)-mux,2)+powf(objdt(2,cnt)-muy,2))
                                                                        if den2<2{
                                                                            ;消滅
                                                                            objdt(0,cnt)=0.0
                                                                        }else{
                                                                            ;移動
                                                                            rad=atan(muy-objdt(2,cnt),mux-objdt(1,cnt))
                                                                            objdt(1,cnt)+cos(rad)
                                                                            objdt(2,cnt)+sin(rad)
                                                                            dx=objdt(1,cnt):dy=objdt(2,cnt)
                                                                            circle dx-2,dy-2,dx+2,dy+2
                                                                        }
                                                                    }
                                                                loop
                                                                redraw:await 17:redraw 0
                                                            loop

                                                            0
                                                              posted by higashijugem 11:18comments(0)|-|