Commit: 604b73cbcf832bea49354e549884660530f7047e - ikemen_go (git)

Go で書き直した Ikemen

Commit MetaInfo

• Révision: 604b73cbcf832bea49354e549884660530f7047e (tree)
• l'heure: 2018-11-14 18:20:52
• Auteur: neatunsou <sisiy4excite@gmai...>
• Commiter: neatunsou

Message de Log

explodのspaceに対応
airのangleがfacingを参照していなかったのを修正
airのtimeが0だとスプライトを読み込まないようにした
ポーズ時にズームアウトが止まらないようにした
explodのScreen系のpostypeの挙動をMUGEN1.1基準に修正
screenposを修正
angleの処理をglrotateに変更

Change Summary

• modified: src/anim.go
• modified: src/bytecode.go
• modified: src/camera.go
• modified: src/char.go
• modified: src/common.go
• modified: src/compiler.go
• modified: src/render.go
• modified: src/stage.go
• modified: src/system.go

Modification

--- a/src/anim.go
+++ b/src/anim.go
@@ -463,7 +463,7 @@ func (a *Animation) UpdateSprite() {
 			a.time, a.newframe, a.current = 0, true, 0
 		}
 	}
-	if a.newframe && a.sff != nil {
+	if a.newframe && a.sff != nil && a.frames[a.current].Time != 0 {
 		a.spr = a.sff.GetSprite(a.curFrame().Group, a.curFrame().Number)
 	}
 	a.newframe, a.drawidx = false, a.current
@@ -634,20 +634,20 @@ func (a *Animation) pal(pfx *PalFX, neg bool) (p []uint32) {
 	}
 	return pfx.getFxPal(p, neg)
 }
-func (a *Animation) drawSub1(angle float32) (h, v, agl float32) {
+func (a *Animation) drawSub1(angle, facing float32) (h, v, agl float32) {
 	h, v = float32(a.frames[a.drawidx].H), float32(a.frames[a.drawidx].V)
 	agl = float32(float64(angle) * math.Pi / 180)
 	h *= a.scale_x
 	v *= a.scale_y
-	agl += a.angle
+	agl += a.angle * facing
 	return
 }
 func (a *Animation) Draw(window *[4]int32, x, y, xcs, ycs, xs, xbs, ys,
-	rxadd, angle, rcx float32, pfx *PalFX, old bool) {
+	rxadd, angle, rcx float32, pfx *PalFX, old bool, facing float32) {
 	if a.spr == nil || a.spr.Tex == nil {
 		return
 	}
-	h, v, angle := a.drawSub1(angle)
+	h, v, angle := a.drawSub1(angle, facing)
 	xs *= xcs * h
 	ys *= ycs * v
 	x = xcs*x + xs*(float32(a.frames[a.drawidx].X)+a.interpolate_offset_x)*(1/a.scale_x)
@@ -698,11 +698,12 @@ func (a *Animation) Draw(window *[4]int32, x, y, xcs, ycs, xs, xbs, ys,
 		trans, window, rcx, rcy, pfx)
 }
 func (a *Animation) ShadowDraw(x, y, xscl, yscl, vscl, angle float32,
-	pfx *PalFX, old bool, color uint32, alpha int32) {
+	pfx *PalFX, old bool, color uint32, alpha int32, facing float32) {
 	if a.spr == nil || a.spr.Tex == nil {
 		return
 	}
-	h, v, angle := a.drawSub1(angle)
+	h, v, angle := a.drawSub1(angle, facing)
+	angle = -angle
 	x += xscl * h * (float32(a.frames[a.drawidx].X) + a.interpolate_offset_x)
 	y += yscl * vscl * v * (float32(a.frames[a.drawidx].Y) + a.interpolate_offset_y)
 	var draw func(int32)
@@ -795,6 +796,7 @@ type SprData struct {
 	screen   bool
 	bright   bool
 	oldVer   bool
+	facing   float32
 }
 type DrawList []*SprData
 
@@ -849,7 +851,7 @@ func (dl DrawList) draw(x, y, scl float32) {
 					(y - s.pos[1])}
 		}
 		s.anim.Draw(&sys.scrrect, p[0], p[1], cs, cs, s.scl[0], s.scl[0],
-			s.scl[1], 0, s.angle, float32(sys.gameWidth)/2, s.fx, s.oldVer)
+			s.scl[1], 0, s.angle, float32(sys.gameWidth)/2, s.fx, s.oldVer, s.facing)
 		sys.brightness = ob
 	}
 }
@@ -910,8 +912,8 @@ func (sl ShadowList) draw(x, y, scl float32) {
 		s.anim.ShadowDraw(sys.cam.Offset[0]-(x-s.pos[0])*scl,
 			sys.cam.GroundLevel()+sys.cam.Offset[1]-sys.envShake.getOffset()-
 				(y+s.pos[1]*sys.stage.sdw.yscale-s.offsetY)*scl,
-			scl*s.scl[0], scl*-s.scl[1], sys.stage.sdw.yscale, -s.angle,
-			&sys.bgPalFX, s.oldVer, uint32(color), intensity)
+			scl*s.scl[0], scl*-s.scl[1], sys.stage.sdw.yscale, s.angle,
+			&sys.bgPalFX, s.oldVer, uint32(color), intensity, s.facing)
 	}
 }
 func (sl ShadowList) drawReflection(x, y, scl float32) {
@@ -937,7 +939,7 @@ func (sl ShadowList) drawReflection(x, y, scl float32) {
 		s.anim.Draw(&sys.scrrect, sys.cam.Offset[0]/scl-(x-s.pos[0]),
 			(sys.cam.GroundLevel()+sys.cam.Offset[1]-sys.envShake.getOffset())/scl-
 				(y+s.pos[1]-s.offsetY), scl, scl, s.scl[0], s.scl[0], -s.scl[1], 0,
-			-s.angle, float32(sys.gameWidth)/2, s.fx, s.oldVer)
+			-s.angle, float32(sys.gameWidth)/2, s.fx, s.oldVer, s.facing)
 	}
 }
 
@@ -988,6 +990,6 @@ func (a *Anim) Draw() {
 	if !sys.frameSkip {
 		a.anim.Draw(&a.window, a.x+float32(sys.gameWidth-320)/2,
 			a.y+float32(sys.gameHeight-240), 1, 1, a.xscl, a.xscl, a.yscl,
-			0, 0, 0, nil, false)
+			0, 0, 0, nil, false, 1)
 	}
 }

--- a/src/bytecode.go
+++ b/src/bytecode.go
@@ -1105,9 +1105,9 @@ func (be BytecodeExp) run(c *Char) BytecodeValue {
 		case OC_screenheight:
 			sys.bcStack.PushF(sys.screenHeight() / oc.localscl)
 		case OC_screenpos_x:
-			sys.bcStack.PushF(c.screenPosX())
+			sys.bcStack.PushF((c.screenPosX()) / oc.localscl)
 		case OC_screenpos_y:
-			sys.bcStack.PushF(c.screenPosY())
+			sys.bcStack.PushF((c.screenPosY()) / oc.localscl)
 		case OC_screenwidth:
 			sys.bcStack.PushF(sys.screenWidth() / oc.localscl)
 		case OC_selfanimexist:
@@ -2245,6 +2245,7 @@ const (
 	explod_xangle
 	explod_ignorehitpause
 	explod_bindid
+	explod_space
 )
 
 func (sc explod) Run(c *Char, _ []int32) bool {
@@ -2294,6 +2295,8 @@ func (sc explod) Run(c *Char, _ []int32) bool {
 			}
 		case explod_postype:
 			e.postype = PosType(exp[0].evalI(c))
+		case explod_space:
+			e.space = Space(exp[0].evalI(c))
 		case explod_velocity:
 			e.velocity[0] = exp[0].evalF(c)
 			if len(exp) > 1 {

--- a/src/camera.go
+++ b/src/camera.go
@@ -171,9 +171,10 @@ func (c *Camera) action(x, y *float32, leftest, rightest, lowest, highest,
 		sclMul = MinF(4.0/3, Pow((Pow(2, c.ZoomSpeed)+3)/Pow(2, c.ZoomSpeed)-
 			sclMul, 64))
 	}
-	if pause {
-		sclMul = 1
-	} else if sclMul > 1 {
+	//if pause {
+	//	sclMul = 1
+	//} else if sclMul > 1 {
+	if sclMul > 1 {
 		sclMul = (sclMul-1)*Pow(c.zoomdelay, 8) + 1
 		if tmp*sclMul > sys.xmax-sys.xmin {
 			sclMul = (sys.xmax - sys.xmin) / tmp

--- a/src/char.go
+++ b/src/char.go
@@ -80,6 +80,14 @@ const (
 	PT_N
 )
 
+type Space int32
+
+const (
+	Space_none Space = iota
+	Space_stage
+	Space_screen
+)
+
 type ClsnRect [][4]float32
 
 func (cr *ClsnRect) Add(clsn []float32, x, y, xs, ys float32) {
@@ -775,7 +783,7 @@ func (ai *AfterImage) recAndCue(sd *SprData, rec bool) {
 		img := &ai.imgs[(ai.imgidx-i)&63]
 		sys.sprites.add(&SprData{&img.anim, &ai.palfx[i/ai.framegap-1], img.pos,
 			img.scl, ai.alpha, sd.priority - 2, img.angle, img.ascl,
-			false, sd.bright, sd.oldVer}, 0, 0, 0, 0)
+			false, sd.bright, sd.oldVer, sd.facing}, 0, 0, 0, 0)
 	}
 	if rec {
 		ai.recAfterImg(sd)
@@ -793,6 +801,7 @@ type Explod struct {
 	accel          [2]float32
 	sprpriority    int32
 	postype        PosType
+	space          Space
 	offset         [2]float32
 	relativef      int32
 	pos            [2]float32
@@ -817,7 +826,7 @@ type Explod struct {
 
 func (e *Explod) clear() {
 	*e = Explod{id: IErr, scale: [...]float32{1, 1}, removetime: -2,
-		postype: PT_P1, relativef: 1, facing: 1, vfacing: 1, localscl: 1,
+		postype: PT_P1, relativef: 1, facing: 1, vfacing: 1, localscl: 1, space: Space_none,
 		alpha: [...]int32{-1, 0}, playerId: -1, bindId: -1, ignorehitpause: true}
 }
 func (e *Explod) setX(x float32) {
@@ -839,47 +848,69 @@ func (e *Explod) setPos(c *Char) {
 	lPos := func() {
 		e.setX(sys.cam.ScreenPos[0]/e.localscl + e.offset[0]/sys.cam.Scale)
 		e.setY(sys.cam.ScreenPos[1]/e.localscl + e.offset[1]/sys.cam.Scale)
+		if e.bindtime == 0 {
+			e.bindtime = 1
+		}
 	}
 	rPos := func() {
 		e.setX(sys.cam.ScreenPos[0]/e.localscl +
 			(float32(sys.gameWidth)/e.localscl + e.offset[0]/sys.cam.Scale))
 		e.setY(sys.cam.ScreenPos[1]/e.localscl + e.offset[1]/sys.cam.Scale)
-	}
-	switch e.postype {
-	case PT_P1:
-		pPos(c)
-	case PT_P2:
-		if p2 := sys.charList.enemyNear(c, 0, true); p2 != nil {
-			pPos(p2)
+		if e.bindtime == 0 {
+			e.bindtime = 1
 		}
-	case PT_F, PT_B:
-		e.facing = c.facing * float32(e.relativef)
-		// front と back はバインドの都合で left か right になおす
-		if c.facing > 0 && e.postype == PT_F || c.facing < 0 && e.postype == PT_B {
-			if e.postype == PT_B {
-				e.offset[0] *= -1
+	}
+	if e.space >= Space_stage {
+		e.postype = PT_N
+	}
+	if e.space <= Space_none {
+		switch e.postype {
+		case PT_P1:
+			pPos(c)
+		case PT_P2:
+			if p2 := sys.charList.enemyNear(c, 0, true); p2 != nil {
+				pPos(p2)
 			}
-			e.postype = PT_R
-			rPos()
-		} else {
-			// explod の postype = front はキャラの向きで pos が反転しない
-			if e.postype == PT_F && c.gi().ver[0] != 1 {
+		case PT_F, PT_B:
+			e.facing = c.facing * float32(e.relativef)
+			// front と back はバインドの都合で left か right になおす
+			if c.facing > 0 && e.postype == PT_F || c.facing < 0 && e.postype == PT_B {
+				if e.postype == PT_B {
+					e.offset[0] *= -1
+				}
+				e.postype = PT_R
+				rPos()
+			} else {
+				// explod の postype = front はキャラの向きで pos が反転しない
+				//if e.postype == PT_F && c.gi().ver[0] != 1 {
 				// 旧バージョンだと front は キャラの向きが facing に反映されない
+				// 1.1でも反映されてない模様
 				e.facing = float32(e.relativef)
+				//}
+				e.postype = PT_L
+				lPos()
 			}
-			e.postype = PT_L
+		case PT_L:
+			e.facing = float32(e.relativef)
 			lPos()
+		case PT_R:
+			e.facing = float32(e.relativef)
+			rPos()
+		case PT_N:
+			e.facing = float32(e.relativef)
+			e.setX(e.offset[0])
+			e.setY(e.offset[1])
+		}
+	} else {
+		switch e.space {
+		case Space_screen:
+			e.facing = float32(e.relativef)
+			lPos()
+		case Space_stage:
+			e.facing = float32(e.relativef)
+			e.setX(e.offset[0])
+			e.setY(e.offset[1])
 		}
-	case PT_L:
-		e.facing = float32(e.relativef)
-		lPos()
-	case PT_R:
-		e.facing = float32(e.relativef)
-		rPos()
-	case PT_N:
-		e.facing = float32(e.relativef)
-		e.setX(e.offset[0])
-		e.setY(e.offset[1])
 	}
 }
 func (e *Explod) matchId(eid, pid int32) bool {
@@ -916,14 +947,21 @@ func (e *Explod) update(oldVer bool, playerNo int) {
 		}
 	}
 	screen := false
+	if e.space == Space_screen || e.postype >= PT_L && e.postype != PT_N {
+		screen = true
+	}
 	if e.bindtime != 0 {
-		if e.postype == PT_N && e.bindId < 0 {
+		if e.space == Space_screen {
+			e.pos[0] = e.offset[0]
+			e.pos[1] = e.offset[1]
+			e.pos[0] -= float32(sys.gameWidth) / e.localscl / 2
+		} else if e.postype == PT_N && e.bindId < 0 {
 			e.pos[0] = e.offset[0]
 			e.pos[1] = e.offset[1]
+			e.bindtime = 0
 		} else if e.postype >= PT_L && e.postype != PT_N {
 			e.pos[0] = e.offset[0]
 			e.pos[1] = e.offset[1]
-			screen = true
 			if e.postype == PT_L {
 				e.pos[0] -= float32(sys.gameWidth) / e.localscl / 2
 			} else {
@@ -973,24 +1011,30 @@ func (e *Explod) update(oldVer bool, playerNo int) {
 	var epos = [2]float32{e.pos[0] * e.localscl, e.pos[1] * e.localscl}
 	sprs.add(&SprData{e.anim, pfx, epos, [...]float32{e.facing * e.scale[0] * e.localscl,
 		e.vfacing * e.scale[1] * e.localscl}, alp, e.sprpriority, agl, [...]float32{1, 1},
-		screen, playerNo == sys.superplayer, oldVer},
+		screen, playerNo == sys.superplayer, oldVer, e.facing},
 		e.shadow[0]<<16|e.shadow[1]&0xff<<8|e.shadow[0]&0xff, sdwalp, 0, 0)
 	if sys.tickNextFrame() {
 		if e.bindtime > 0 {
 			e.bindtime--
-			if screen && e.bindtime == 0 {
-				switch e.postype {
-				case PT_L:
-					for i := range e.pos {
-						e.pos[i] = sys.cam.ScreenPos[i] + e.offset[i]/sys.cam.Scale
-					}
-				case PT_R:
-					e.pos[0] = sys.cam.ScreenPos[0] +
-						(float32(sys.gameWidth)+e.offset[0])/sys.cam.Scale
-					e.pos[1] = sys.cam.ScreenPos[1] + e.offset[1]/sys.cam.Scale
-				}
-			}
 		}
+		//if screen && e.bindtime == 0 {
+		//	if e.space <= Space_none {
+		//		switch e.postype {
+		//		case PT_L:
+		//			for i := range e.pos {
+		//				e.pos[i] = sys.cam.ScreenPos[i] + e.offset[i]/sys.cam.Scale
+		//			}
+		//		case PT_R:
+		//			e.pos[0] = sys.cam.ScreenPos[0] +
+		//				(float32(sys.gameWidth)+e.offset[0])/sys.cam.Scale
+		//			e.pos[1] = sys.cam.ScreenPos[1] + e.offset[1]/sys.cam.Scale
+		//		}
+		//	} else if e.space == Space_screen {
+		//		for i := range e.pos {
+		//			e.pos[i] = sys.cam.ScreenPos[i] + e.offset[i]/sys.cam.Scale
+		//		}
+		//	}
+		//}
 		if act {
 			if e.bindtime == 0 {
 				e.oldPos = e.pos
@@ -1261,7 +1305,7 @@ func (p *Projectile) cueDraw(oldVer bool, playerNo int) {
 		sd := &SprData{p.ani, p.palfx, [...]float32{p.pos[0] * p.localscl, p.pos[1] * p.localscl},
 			[...]float32{p.facing * p.scale[0] * p.localscl, p.scale[1] * p.localscl}, [2]int32{-1},
 			p.sprpriority, 0, [...]float32{1, 1}, false, playerNo == sys.superplayer,
-			sys.cgi[playerNo].ver[0] != 1}
+			sys.cgi[playerNo].ver[0] != 1, p.facing}
 		p.aimg.recAndCue(sd, sys.tickNextFrame() && notpause)
 		sys.sprites.add(sd,
 			p.shadow[0]<<16|p.shadow[1]&255<<8|p.shadow[2]&255, 256, 0, 0)
@@ -2443,10 +2487,10 @@ func (c *Char) roundState() int32 {
 	}
 }
 func (c *Char) screenPosX() float32 {
-	return (c.pos[0] - sys.cam.ScreenPos[0]/c.localscl) * sys.cam.Scale
+	return (c.pos[0]*c.localscl - sys.cam.ScreenPos[0]) // * sys.cam.Scale
 }
 func (c *Char) screenPosY() float32 {
-	return (c.pos[1] - sys.cam.ScreenPos[1]/c.localscl) * sys.cam.Scale
+	return (c.pos[1]*c.localscl - sys.cam.ScreenPos[1]) // * sys.cam.Scale
 }
 func (c *Char) selfAnimExist(anim BytecodeValue) BytecodeValue {
 	if anim.IsSF() {
@@ -4454,7 +4498,7 @@ func (c *Char) cueDraw() {
 		sdf := func() *SprData {
 			sd := &SprData{c.anim, c.getPalfx(), pos,
 				scl, c.alpha, c.sprPriority, agl, c.angleScalse, false,
-				c.playerNo == sys.superplayer, c.gi().ver[0] != 1}
+				c.playerNo == sys.superplayer, c.gi().ver[0] != 1, c.facing}
 			if !c.sf(CSF_trans) {
 				sd.alpha[0] = -1
 			}

--- a/src/common.go
+++ b/src/common.go
@@ -580,7 +580,7 @@ func (l *Layout) DrawAnim(r *[4]int32, x, y, scl float32, ln int16,
 		a.Draw(r, x+l.offset[0], y+l.offset[1]+float32(sys.gameHeight-240),
 			scl, scl, l.scale[0]*float32(l.facing), l.scale[0]*float32(l.facing),
 			l.scale[1]*float32(l.vfacing),
-			0, 0, float32(sys.gameWidth-320)/2, nil, false)
+			0, 0, float32(sys.gameWidth-320)/2, nil, false, 1)
 	}
 }
 func (l *Layout) DrawText(x, y, scl float32, ln int16,

--- a/src/compiler.go
+++ b/src/compiler.go
@@ -2762,6 +2762,26 @@ func (c *Compiler) paramPostye(is IniSection, sc *StateControllerBase,
 		return nil
 	})
 }
+
+func (c *Compiler) paramSpace(is IniSection, sc *StateControllerBase,
+	id byte) error {
+	return c.stateParam(is, "space", func(data string) error {
+		if len(data) <= 1 {
+			return Error("値が指定されていません")
+		}
+		var sp Space
+		if len(data) >= 2 {
+			if strings.ToLower(data[:2]) == "st" {
+				sp = Space_stage
+			} else if strings.ToLower(data[:2]) == "sc" {
+				sp = Space_screen
+			}
+		}
+		sc.add(id, sc.iToExp(int32(sp)))
+		return nil
+	})
+}
+
 func (c *Compiler) paramTrans(is IniSection, sc *StateControllerBase,
 	prefix string, id byte, afterImage bool) error {
 	return c.stateParam(is, prefix+"trans", func(data string) error {
@@ -3443,6 +3463,9 @@ func (c *Compiler) explodSub(is IniSection,
 	if err := c.paramPostye(is, sc, explod_postype); err != nil {
 		return err
 	}
+	if err := c.paramSpace(is, sc, explod_space); err != nil {
+		return err
+	}
 	f := false
 	if err := c.stateParam(is, "vel", func(data string) error {
 		f = true

--- a/src/render.go
+++ b/src/render.go
@@ -232,10 +232,20 @@ func rmTileSub(w, h uint16, x, y float32, tl *[4]int32,
 		pers = AbsF(xbs) / AbsF(xts)
 	}
 	if agl != 0 {
-		kaiten(&x1, &y1, float64(agl), rcx, rcy, vs)
-		kaiten(&x2, &y2, float64(agl), rcx, rcy, vs)
-		kaiten(&x3, &y3, float64(agl), rcx, rcy, vs)
-		kaiten(&x4, &y4, float64(agl), rcx, rcy, vs)
+		//	kaiten(&x1, &y1, float64(agl), rcx, rcy, vs)
+		//	kaiten(&x2, &y2, float64(agl), rcx, rcy, vs)
+		//	kaiten(&x3, &y3, float64(agl), rcx, rcy, vs)
+		//	kaiten(&x4, &y4, float64(agl), rcx, rcy, vs)
+		if vs != 1 {
+			y1 = rcy + ((y - ys*float32(h)) - rcy)
+			y2 = y1
+			y3 = rcy + (y - rcy)
+			y4 = y3
+		}
+		gl.Translated(float64(rcx), float64(rcy), 0)
+		gl.Scaled(1, float64(vs), 1)
+		gl.Rotated(float64(agl/(math.Pi/180)), 0, 0, 1)
+		gl.Translated(float64(-rcx), float64(-rcy), 0)
 		drawQuads(x1, y1, x2, y2, x3, y3, x4, y4, r, g, b, a, pers)
 		return
 	}

--- a/src/stage.go
+++ b/src/stage.go
@@ -378,7 +378,7 @@ func (bg backGround) draw(pos [2]float32, scl, bgscl, lclscl float32,
 	rect[3] = int32(math.Floor(float64(startrect1 + (float32(rect[3]) * sys.heightScale * wscl[1]) - float32(rect[1]))))
 	bg.anim.Draw(&rect, x, y, sclx, scly, bg.xscale[0]*bgscl*(bg.scalestart[0]+xs)*xs3, xbs*bgscl*(bg.scalestart[0]+xs)*xs3, ys*(bg.scalestart[1]+ys2)*ys3,
 		xras*x/(AbsF(ys*ys3)*lscl[1]*float32(bg.anim.spr.Size[1]))*sclx_recip,
-		0, float32(sys.gameWidth)/2, &sys.bgPalFX, true)
+		0, float32(sys.gameWidth)/2, &sys.bgPalFX, true, 1)
 }
 
 type bgCtrl struct {

--- a/src/system.go
+++ b/src/system.go
@@ -3,10 +3,6 @@ package main
 import (
 	"bufio"
 	"fmt"
-	"github.com/go-gl/gl/v2.1/gl"
-	"github.com/go-gl/glfw/v3.2/glfw"
-	"github.com/timshannon/go-openal/openal"
-	"github.com/yuin/gopher-lua"
 	"io/ioutil"
 	"log"
 	"math"
@@ -15,6 +11,11 @@ import (
 	"strings"
 	"sync"
 	"time"
+
+	"github.com/go-gl/gl/v2.1/gl"
+	"github.com/go-gl/glfw/v3.2/glfw"
+	"github.com/timshannon/go-openal/openal"
+	"github.com/yuin/gopher-lua"
 )
 
 const (
@@ -776,7 +777,7 @@ func (s *System) action(x, y *float32, scl float32) (leftest, rightest,
 	if s.superanim != nil {
 		s.topSprites.add(&SprData{s.superanim, &s.superpmap, s.superpos,
 			[...]float32{s.superfacing, 1}, [2]int32{-1}, 5, 0, [2]float32{},
-			false, true, s.cgi[s.superplayer].ver[0] != 1}, 0, 0, 0, 0)
+			false, true, s.cgi[s.superplayer].ver[0] != 1, 1}, 0, 0, 0, 0)
 		if s.superanim.loopend {
 			s.superanim = nil
 		}