Commit: 91713c1dc67da570da5aeb04c457b85ec405a34f - ikemen_go (git)

Go で書き直した Ikemen

Commit MetaInfo

• Revision: 91713c1dc67da570da5aeb04c457b85ec405a34f (tree)
• Time: 2016-12-23 00:00:47
• Author: SUEHIRO <supersuehiro@user...>
• Commiter: SUEHIRO

Log Message

リダイレクトやエクスプロードのところを書いた

Change Summary

• delete: .gitignore
• modified: build.sh
• modified: get.sh
• modified: run.sh
• modified: src/bytecode.go
• modified: src/char.go
• modified: src/compiler.go
• modified: src/image.go

Incremental Difference

--- a/.gitignore
+++ /dev/null
@@ -1,5 +0,0 @@
-/chars
-/data
-/go
-/sound
-/stages

--- a/build.sh
+++ b/build.sh
@@ -1,5 +1,3 @@
 #!/bin/sh
-GOPATH=$PWD/go
-export GOPATH
+export GOPATH=$PWD/go
 GOOS=windows GOARCH=amd64 CGO_ENABLED=1 go build -o ikemen ./src
-go clean ./src

--- a/get.sh
+++ b/get.sh
@@ -1,6 +1,5 @@
 #!/bin/sh
-GOPATH=$PWD/go
-export GOPATH
+export GOPATH=$PWD/go
 go get -u github.com/yuin/gopher-lua
 go get -u github.com/go-gl/glfw/v3.2/glfw
 go get -u github.com/go-gl/gl/v2.1/gl

--- a/run.sh
+++ b/run.sh
@@ -1,6 +1,4 @@
 #!/bin/sh
-GOPATH=$PWD/go
-export GOPATH
+export GOPATH=$PWD/go
 go fmt ./src/*.go
-# godoc -src ./src .* > godoc.txt
 go run ./src/*.go

--- a/src/bytecode.go
+++ b/src/bytecode.go
@@ -634,7 +634,6 @@ func (_ BytecodeExp) blor(v1 *BytecodeValue, v2 BytecodeValue) {
 	v1.SetB(v1.ToB() || v2.ToB())
 }
 func (be BytecodeExp) run(c *Char, scpn int) BytecodeValue {
-	sys.bcStack.Clear()
 	orgc := c
 	for i := 1; i <= len(be); i++ {
 		switch be[i-1] {
@@ -668,6 +667,69 @@ func (be BytecodeExp) run(c *Char, scpn int) BytecodeValue {
 			fallthrough
 		case OC_jmp:
 			i += int(*(*int32)(unsafe.Pointer(&be[i]))) + 4
+		case OC_parent:
+			if c = c.parent(); c != nil {
+				i += 4
+				continue
+			}
+			sys.bcStack.Push(BytecodeSF())
+			i += int(*(*int32)(unsafe.Pointer(&be[i]))) + 4
+		case OC_root:
+			if c = c.root(); c != nil {
+				i += 4
+				continue
+			}
+			sys.bcStack.Push(BytecodeSF())
+			i += int(*(*int32)(unsafe.Pointer(&be[i]))) + 4
+		case OC_helper:
+			if c = c.helper(sys.bcStack.Pop().ToI()); c != nil {
+				i += 4
+				continue
+			}
+			sys.bcStack.Push(BytecodeSF())
+			i += int(*(*int32)(unsafe.Pointer(&be[i]))) + 4
+		case OC_target:
+			if c = c.target(sys.bcStack.Pop().ToI()); c != nil {
+				i += 4
+				continue
+			}
+			sys.bcStack.Push(BytecodeSF())
+			i += int(*(*int32)(unsafe.Pointer(&be[i]))) + 4
+		case OC_partner:
+			if c = c.partner(sys.bcStack.Pop().ToI()); c != nil {
+				i += 4
+				continue
+			}
+			sys.bcStack.Push(BytecodeSF())
+			i += int(*(*int32)(unsafe.Pointer(&be[i]))) + 4
+		case OC_enemy:
+			if c = c.enemy(sys.bcStack.Pop().ToI()); c != nil {
+				i += 4
+				continue
+			}
+			sys.bcStack.Push(BytecodeSF())
+			i += int(*(*int32)(unsafe.Pointer(&be[i]))) + 4
+		case OC_enemynear:
+			if c = c.enemynear(sys.bcStack.Pop().ToI()); c != nil {
+				i += 4
+				continue
+			}
+			sys.bcStack.Push(BytecodeSF())
+			i += int(*(*int32)(unsafe.Pointer(&be[i]))) + 4
+		case OC_playerid:
+			if c = c.playerid(sys.bcStack.Pop().ToI()); c != nil {
+				i += 4
+				continue
+			}
+			sys.bcStack.Push(BytecodeSF())
+			i += int(*(*int32)(unsafe.Pointer(&be[i]))) + 4
+		case OC_p2:
+			if c = c.p2(); c != nil {
+				i += 4
+				continue
+			}
+			sys.bcStack.Push(BytecodeSF())
+			i += int(*(*int32)(unsafe.Pointer(&be[i]))) + 4
 		case OC_int8:
 			sys.bcStack.Push(BytecodeInt(int32(int8(be[i]))))
 			i++
@@ -768,10 +830,13 @@ func (be BytecodeExp) run(c *Char, scpn int) BytecodeValue {
 		case OC_animtime:
 			sys.bcStack.Push(BytecodeInt(c.animTime()))
 		case OC_animelemtime:
-			sys.bcStack.Push(BytecodeInt(c.animElemTime(sys.bcStack.Pop().ToI())))
+			*sys.bcStack.Top() = BytecodeInt(c.animElemTime(sys.bcStack.Top().ToI()))
+		case OC_stateno:
+			sys.bcStack.Push(BytecodeInt(c.stateNo()))
 		case OC_ex_:
 			be.run_ex(c, scpn, &i)
 		default:
+			println(be[i-1])
 			unimplemented()
 		}
 		c = orgc
@@ -783,6 +848,9 @@ func (be BytecodeExp) run_ex(c *Char, scpn int, i *int) {
 	switch be[*i-1] {
 	case OC_ex_matchover:
 		sys.bcStack.Push(BytecodeBool(sys.matchOver()))
+	default:
+		println(be[*i-1])
+		unimplemented()
 	}
 }
 func (be BytecodeExp) evalF(c *Char, scpn int) float32 {
@@ -865,6 +933,9 @@ func (scb StateControllerBase) run(c *Char, ps *int32,
 		}
 	}
 	*ps = scb.persistent
+	if len(sys.bcStack) != 0 {
+		unimplemented()
+	}
 	return true
 }
 
@@ -1341,6 +1412,399 @@ func (sc ctrlSet) Run(c *Char, ps *int32) bool {
 	return false
 }
 
+type explod StateControllerBase
+
+const (
+	explod_ownpal byte = iota
+	explod_remappal
+	explod_id
+	explod_facing
+	explod_vfacing
+	explod_pos
+	explod_random
+	explod_postype
+	explod_velocity
+	explod_accel
+	explod_scale
+	explod_bindtime
+	explod_removetime
+	explod_supermove
+	explod_supermovetime
+	explod_pausemovetime
+	explod_sprpriority
+	explod_ontop
+	explod_shadow
+	explod_removeongethit
+	explod_trans
+	explod_anim
+	explod_angle
+	explod_yangle
+	explod_xangle
+	explod_ignorehitpause
+)
+
+func (sc explod) Run(c *Char, ps *int32) bool {
+	var e *Explod
+	var i int
+	rp := [2]int32{-1, 0}
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		if e == nil {
+			e, i = c.newExplod()
+			if e == nil {
+				return false
+			}
+		}
+		switch id {
+		case explod_ownpal:
+			e.ownpal = exp[0].evalB(c, sc.playerNo)
+		case explod_remappal:
+			rp[0] = exp[0].evalI(c, sc.playerNo)
+			if len(exp) > 1 {
+				rp[1] = exp[1].evalI(c, sc.playerNo)
+			}
+		case explod_id:
+			e.id = Max(0, exp[0].evalI(c, sc.playerNo))
+		case explod_facing:
+			if exp[0].evalI(c, sc.playerNo) < 0 {
+				e.relativef = -1
+			} else {
+				e.relativef = 1
+			}
+		case explod_vfacing:
+			if exp[0].evalI(c, sc.playerNo) < 0 {
+				e.vfacing = -1
+			} else {
+				e.vfacing = 1
+			}
+		case explod_pos:
+			e.offset[0] = exp[0].evalF(c, sc.playerNo)
+			if len(exp) > 1 {
+				e.offset[1] = exp[1].evalF(c, sc.playerNo)
+			}
+		case explod_random:
+			rndx := exp[0].evalF(c, sc.playerNo)
+			e.offset[0] += RandF(-rndx, rndx)
+			if len(exp) > 1 {
+				rndy := exp[1].evalF(c, sc.playerNo)
+				e.offset[1] += RandF(-rndy, rndy)
+			}
+		case explod_postype:
+			e.postype = PosType(exp[0].evalI(c, sc.playerNo))
+			e.setPos(c)
+		case explod_velocity:
+			e.velocity[0] = exp[0].evalF(c, sc.playerNo)
+			if len(exp) > 1 {
+				e.velocity[1] = exp[1].evalF(c, sc.playerNo)
+			}
+		case explod_accel:
+			e.accel[0] = exp[0].evalF(c, sc.playerNo)
+			if len(exp) > 1 {
+				e.accel[1] = exp[1].evalF(c, sc.playerNo)
+			}
+		case explod_scale:
+			e.scale[0] = exp[0].evalF(c, sc.playerNo)
+			if len(exp) > 1 {
+				e.scale[1] = exp[1].evalF(c, sc.playerNo)
+			}
+		case explod_bindtime:
+			e.bindtime = exp[0].evalI(c, sc.playerNo)
+		case explod_removetime:
+			e.removetime = exp[0].evalI(c, sc.playerNo)
+		case explod_supermove:
+			if exp[0].evalB(c, sc.playerNo) {
+				e.supermovetime = -1
+			} else {
+				e.supermovetime = 0
+			}
+		case explod_supermovetime:
+			e.supermovetime = exp[0].evalI(c, sc.playerNo)
+		case explod_pausemovetime:
+			e.pausemovetime = exp[0].evalI(c, sc.playerNo)
+		case explod_sprpriority:
+			e.sprpriority = exp[0].evalI(c, sc.playerNo)
+		case explod_ontop:
+			e.ontop = exp[0].evalB(c, sc.playerNo)
+			if e.ontop {
+				e.sprpriority = 0
+			}
+		case explod_shadow:
+			e.shadow[0] = exp[0].evalI(c, sc.playerNo)
+			if len(exp) > 1 {
+				e.shadow[1] = exp[1].evalI(c, sc.playerNo)
+				if len(exp) > 2 {
+					e.shadow[2] = exp[2].evalI(c, sc.playerNo)
+				}
+			}
+		case explod_removeongethit:
+			e.removeongethit = exp[0].evalB(c, sc.playerNo)
+		case explod_trans:
+			e.alpha = [2]int32{exp[0].evalI(c, sc.playerNo),
+				exp[1].evalI(c, sc.playerNo)}
+			if len(exp) > 2 {
+				e.alpha[0] = Max(0, Min(255, e.alpha[0]))
+				e.alpha[1] = Max(0, Min(255, e.alpha[1]))
+			}
+		case explod_anim:
+			e.anim = c.getAnim(exp[1].evalI(c, sc.playerNo),
+				exp[0].evalB(c, sc.playerNo))
+		case explod_angle:
+			e.angle = exp[0].evalF(c, sc.playerNo)
+		case explod_yangle:
+			exp[0].run(c, sc.playerNo)
+		case explod_xangle:
+			exp[0].run(c, sc.playerNo)
+		case explod_ignorehitpause:
+			e.ignorehitpause = exp[0].evalB(c, sc.playerNo)
+		}
+		return true
+	})
+	c.insertExplodEx(i, rp[0], rp[1])
+	return false
+}
+
+type modifyExplod explod
+
+func (sc modifyExplod) Run(c *Char, ps *int32) bool {
+	eid := int32(-1)
+	var expls []*Explod
+	rp := [2]int32{-1, 0}
+	eachExpl := func(f func(e *Explod)) {
+		for _, e := range expls {
+			f(e)
+		}
+	}
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case explod_remappal:
+			rp[0] = exp[0].evalI(c, sc.playerNo)
+			if len(exp) > 1 {
+				rp[1] = exp[1].evalI(c, sc.playerNo)
+			}
+		case explod_id:
+			eid = exp[0].evalI(c, sc.playerNo)
+		default:
+			if len(expls) == 0 {
+				expls = c.getExplods(eid)
+				if len(expls) == 0 {
+					return false
+				}
+				eachExpl(func(e *Explod) {
+					if e.ownpal {
+						c.remapPalSub(e.palfx, 1, 1, rp[0], rp[1])
+					}
+				})
+			}
+			switch id {
+			case explod_facing:
+				if exp[0].evalI(c, sc.playerNo) < 0 {
+					eachExpl(func(e *Explod) { e.relativef = -1 })
+				} else {
+					eachExpl(func(e *Explod) { e.relativef = 1 })
+				}
+			case explod_vfacing:
+				if exp[0].evalI(c, sc.playerNo) < 0 {
+					eachExpl(func(e *Explod) { e.vfacing = -1 })
+				} else {
+					eachExpl(func(e *Explod) { e.vfacing = 1 })
+				}
+			case explod_pos:
+				x := exp[0].evalF(c, sc.playerNo)
+				eachExpl(func(e *Explod) { e.offset[0] = x })
+				if len(exp) > 1 {
+					y := exp[1].evalF(c, sc.playerNo)
+					eachExpl(func(e *Explod) { e.offset[1] = y })
+				}
+			case explod_random:
+				rndx := exp[0].evalF(c, sc.playerNo)
+				rndx = RandF(-rndx, rndx)
+				eachExpl(func(e *Explod) { e.offset[0] += rndx })
+				if len(exp) > 1 {
+					rndy := exp[1].evalF(c, sc.playerNo)
+					rndy = RandF(-rndy, rndy)
+					eachExpl(func(e *Explod) { e.offset[1] += rndy })
+				}
+			case explod_postype:
+				pt := PosType(exp[0].evalI(c, sc.playerNo))
+				eachExpl(func(e *Explod) {
+					e.postype = pt
+					e.setPos(c)
+				})
+			case explod_velocity:
+				x := exp[0].evalF(c, sc.playerNo)
+				eachExpl(func(e *Explod) { e.velocity[0] = x })
+				if len(exp) > 1 {
+					y := exp[1].evalF(c, sc.playerNo)
+					eachExpl(func(e *Explod) { e.velocity[1] = y })
+				}
+			case explod_accel:
+				x := exp[0].evalF(c, sc.playerNo)
+				eachExpl(func(e *Explod) { e.accel[0] = x })
+				if len(exp) > 1 {
+					y := exp[1].evalF(c, sc.playerNo)
+					eachExpl(func(e *Explod) { e.accel[1] = y })
+				}
+			case explod_scale:
+				x := exp[0].evalF(c, sc.playerNo)
+				eachExpl(func(e *Explod) { e.scale[0] = x })
+				if len(exp) > 1 {
+					y := exp[1].evalF(c, sc.playerNo)
+					eachExpl(func(e *Explod) { e.scale[1] = y })
+				}
+			case explod_bindtime:
+				t := exp[0].evalI(c, sc.playerNo)
+				eachExpl(func(e *Explod) { e.bindtime = t })
+			case explod_removetime:
+				t := exp[0].evalI(c, sc.playerNo)
+				eachExpl(func(e *Explod) { e.removetime = t })
+			case explod_supermove:
+				if exp[0].evalB(c, sc.playerNo) {
+					eachExpl(func(e *Explod) { e.supermovetime = -1 })
+				} else {
+					eachExpl(func(e *Explod) { e.supermovetime = 0 })
+				}
+			case explod_supermovetime:
+				t := exp[0].evalI(c, sc.playerNo)
+				eachExpl(func(e *Explod) { e.supermovetime = t })
+			case explod_pausemovetime:
+				t := exp[0].evalI(c, sc.playerNo)
+				eachExpl(func(e *Explod) { e.pausemovetime = t })
+			case explod_sprpriority:
+				t := exp[0].evalI(c, sc.playerNo)
+				eachExpl(func(e *Explod) { e.sprpriority = t })
+			case explod_ontop:
+				t := exp[0].evalB(c, sc.playerNo)
+				eachExpl(func(e *Explod) {
+					e.ontop = t
+					if e.ontop {
+						e.sprpriority = 0
+					}
+				})
+			case explod_shadow:
+				r := exp[0].evalI(c, sc.playerNo)
+				eachExpl(func(e *Explod) { e.shadow[0] = r })
+				if len(exp) > 1 {
+					g := exp[1].evalI(c, sc.playerNo)
+					eachExpl(func(e *Explod) { e.shadow[1] = g })
+					if len(exp) > 2 {
+						b := exp[2].evalI(c, sc.playerNo)
+						eachExpl(func(e *Explod) { e.shadow[2] = b })
+					}
+				}
+			case explod_removeongethit:
+				t := exp[0].evalB(c, sc.playerNo)
+				eachExpl(func(e *Explod) { e.removeongethit = t })
+			case explod_trans:
+				s, d := exp[0].evalI(c, sc.playerNo), exp[1].evalI(c, sc.playerNo)
+				if len(exp) > 2 {
+					s = Max(0, Min(255, s))
+					d = Max(0, Min(255, d))
+				}
+				eachExpl(func(e *Explod) { e.alpha = [2]int32{s, d} })
+			case explod_angle:
+				a := exp[0].evalF(c, sc.playerNo)
+				eachExpl(func(e *Explod) { e.angle = a })
+			case explod_yangle:
+				exp[0].run(c, sc.playerNo)
+			case explod_xangle:
+				exp[0].run(c, sc.playerNo)
+			}
+		}
+		return true
+	})
+	return false
+}
+
+type posSet StateControllerBase
+
+const (
+	posSet_x byte = iota
+	posSet_y
+	posSet_z
+)
+
+func (sc posSet) Run(c *Char, ps *int32) bool {
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case posSet_x:
+			c.setX(exp[0].evalF(c, sc.playerNo))
+		case posSet_y:
+			c.setY(exp[0].evalF(c, sc.playerNo))
+		case posSet_z:
+			exp[0].run(c, sc.playerNo)
+		}
+		return true
+	})
+	return false
+}
+
+type posAdd posSet
+
+func (sc posAdd) Run(c *Char, ps *int32) bool {
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case posSet_x:
+			c.addX(exp[0].evalF(c, sc.playerNo))
+		case posSet_y:
+			c.addY(exp[0].evalF(c, sc.playerNo))
+		case posSet_z:
+			exp[0].run(c, sc.playerNo)
+		}
+		return true
+	})
+	return false
+}
+
+type velSet posSet
+
+func (sc velSet) Run(c *Char, ps *int32) bool {
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case posSet_x:
+			c.setXV(exp[0].evalF(c, sc.playerNo))
+		case posSet_y:
+			c.setYV(exp[0].evalF(c, sc.playerNo))
+		case posSet_z:
+			exp[0].run(c, sc.playerNo)
+		}
+		return true
+	})
+	return false
+}
+
+type velAdd posSet
+
+func (sc velAdd) Run(c *Char, ps *int32) bool {
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case posSet_x:
+			c.addXV(exp[0].evalF(c, sc.playerNo))
+		case posSet_y:
+			c.addYV(exp[0].evalF(c, sc.playerNo))
+		case posSet_z:
+			exp[0].run(c, sc.playerNo)
+		}
+		return true
+	})
+	return false
+}
+
+type velMul posSet
+
+func (sc velMul) Run(c *Char, ps *int32) bool {
+	StateControllerBase(sc).run(c, ps, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case posSet_x:
+			c.mulXV(exp[0].evalF(c, sc.playerNo))
+		case posSet_y:
+			c.mulYV(exp[0].evalF(c, sc.playerNo))
+		case posSet_z:
+			exp[0].run(c, sc.playerNo)
+		}
+		return true
+	})
+	return false
+}
+
 type hitDef StateControllerBase
 
 const (
@@ -1352,9 +1816,9 @@ func (sc hitDef) Run(c *Char, ps *int32) bool {
 		switch id {
 		case hitDef_:
 		}
-		unimplemented()
 		return true
 	})
+	unimplemented()
 	return false
 }
 

--- a/src/char.go
+++ b/src/char.go
@@ -663,6 +663,47 @@ func (ai *AfterImage) setupPalFX() {
 	}
 }
 
+type Explod struct {
+	id             int32
+	bindtime       int32
+	scale          [2]float32
+	time           int32
+	removeongethit bool
+	removetime     int32
+	velocity       [2]float32
+	accel          [2]float32
+	sprpriority    int32
+	postype        PosType
+	offset         [2]float32
+	relativef      int32
+	pos            [2]float32
+	facing         int32
+	vfacing        int32
+	shadow         [3]int32
+	supermovetime  int32
+	pausemovetime  int32
+	anim           *Animation
+	ontop          bool
+	alpha          [2]int32
+	ownpal         bool
+	playerId       int32
+	bindId         int32
+	ignorehitpause bool
+	angle          float32
+	oldPos         [2]float32
+	newPos         [2]float32
+	palfx          *PalFX
+}
+
+func (e *Explod) clear() {
+	*e = Explod{id: IErr, scale: [2]float32{1, 1}, removetime: -2,
+		postype: PT_P1, relativef: 1, facing: 1, vfacing: 1,
+		alpha: [2]int32{-1, 0}, playerId: -1, bindId: -1, ignorehitpause: true}
+}
+func (e *Explod) setPos(c *Char) {
+	unimplemented()
+}
+
 type Projectile struct {
 	hitdef        HitDef
 	id            int32
@@ -738,6 +779,8 @@ type Char struct {
 	size          CharSize
 	hitdef        HitDef
 	pos           [2]float32
+	drawPos       [2]float32
+	oldPos        [2]float32
 	vel           [2]float32
 	standby       bool
 	pauseMovetime int32
@@ -1105,3 +1148,92 @@ func (c *Char) animElemTime(e int32) int32 {
 	unimplemented()
 	return 0
 }
+func (c *Char) newExplod() (*Explod, int) {
+	unimplemented()
+	return nil, 0
+}
+func (c *Char) getExplods(id int32) []*Explod {
+	unimplemented()
+	return nil
+}
+func (c *Char) remapPalSub(pfx *PalFX, sg, sn, dg, dn int32) {
+	unimplemented()
+}
+func (c *Char) insertExplodEx(i int, rpg, rpn int32) {
+	unimplemented()
+}
+func (c *Char) getAnim(n int32, ffx bool) *Animation {
+	unimplemented()
+	return nil
+}
+func (c *Char) setPosX(x float32) {
+	if c.pos[0] != x {
+		c.pos[0] = x
+		unimplemented()
+	}
+}
+func (c *Char) setPosY(y float32) {
+	c.pos[1] = y
+}
+func (c *Char) setX(x float32) {
+	c.oldPos[0], c.drawPos[0] = x, x
+	c.setPosX(x)
+}
+func (c *Char) setY(y float32) {
+	c.oldPos[1], c.drawPos[1] = y, y
+	c.setPosY(y)
+}
+func (c *Char) addX(x float32) {
+	c.setX(c.pos[0] + x)
+}
+func (c *Char) addY(y float32) {
+	c.setY(c.pos[1] + y)
+}
+func (c *Char) addXV(xv float32) {
+	c.vel[0] += xv
+}
+func (c *Char) addYV(yv float32) {
+	c.vel[1] += yv
+}
+func (c *Char) mulXV(xv float32) {
+	c.vel[0] *= xv
+}
+func (c *Char) mulYV(yv float32) {
+	c.vel[1] *= yv
+}
+func (c *Char) parent() *Char {
+	unimplemented()
+	return nil
+}
+func (c *Char) root() *Char {
+	unimplemented()
+	return nil
+}
+func (c *Char) helper(id int32) *Char {
+	unimplemented()
+	return nil
+}
+func (c *Char) target(id int32) *Char {
+	unimplemented()
+	return nil
+}
+func (c *Char) enemy(n int32) *Char {
+	unimplemented()
+	return nil
+}
+func (c *Char) enemynear(n int32) *Char {
+	unimplemented()
+	return nil
+}
+func (c *Char) playerid(id int32) *Char {
+	unimplemented()
+	return nil
+}
+func (c *Char) p2() *Char {
+	unimplemented()
+	return nil
+}
+func (c *Char) stateNo() int32 {
+	unimplemented()
+	return 0
+}

--- a/src/compiler.go
+++ b/src/compiler.go
@@ -505,8 +505,75 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string) (BytecodeValue,
 	var bv1, bv2, bv3 BytecodeValue
 	var n int32
 	var be BytecodeExp
+	var opc OpCode
 	var err error
 	switch c.token {
+	case "root", "parent", "helper", "target", "partner",
+		"enemy", "enemynear", "playerid":
+		switch c.token {
+		case "parent":
+			opc = OC_parent
+			c.token = c.tokenizer(in)
+		case "root":
+			opc = OC_root
+			c.token = c.tokenizer(in)
+		default:
+			switch c.token {
+			case "helper":
+				opc = OC_helper
+			case "target":
+				opc = OC_target
+			case "partner":
+				opc = OC_partner
+			case "enemy":
+				opc = OC_enemy
+			case "enemynear":
+				opc = OC_enemynear
+			case "playerid":
+				opc = OC_playerid
+			}
+			c.token = c.tokenizer(in)
+			if c.token == "(" {
+				c.token = c.tokenizer(in)
+				if bv1, err = c.expBoolOr(out, in); err != nil {
+					return BytecodeSF(), err
+				}
+				if err := c.kakkotojiru(in); err != nil {
+					return BytecodeSF(), err
+				}
+				c.token = c.tokenizer(in)
+				out.appendValue(bv1)
+			} else {
+				switch opc {
+				case OC_helper, OC_target:
+					out.appendValue(BytecodeInt(-1))
+				case OC_partner, OC_enemy, OC_enemynear:
+					out.appendValue(BytecodeInt(0))
+				case OC_playerid:
+					return BytecodeSF(), Error("playeridの次に'('がありません")
+				}
+			}
+		}
+		if c.token != "," {
+			return BytecodeSF(), Error(",がありません")
+		}
+		c.token = c.tokenizer(in)
+		bv1, err = c.expValue(&be1, in)
+		if err != nil {
+			return BytecodeSF(), err
+		}
+		be1.appendValue(bv1)
+		out.appendJmp(opc, int32(len(be1)))
+		out.append(be1...)
+		return BytecodeSF(), nil
+	case "(":
+		c.token = c.tokenizer(in)
+		if bv, err = c.expBoolOr(&be1, in); err != nil {
+			return BytecodeSF(), err
+		}
+		if err := c.kakkotojiru(in); err != nil {
+			return BytecodeSF(), err
+		}
 	case "-":
 		if len(*in) > 0 && (((*in)[0] >= '0' && (*in)[0] <= '9') || (*in)[0] == '.') {
 			c.token += c.tokenizer(in)
@@ -613,6 +680,21 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string) (BytecodeValue,
 		}
 		out.append(OC_jsf8, OpCode(len(be)))
 		out.append(be...)
+	case "animelemtime":
+		if c.tokenizer(in) != "(" {
+			return BytecodeSF(), Error(c.token + "の次に'('がありません")
+		}
+		c.token = c.tokenizer(in)
+		if bv1, err = c.expBoolOr(out, in); err != nil {
+			return BytecodeSF(), err
+		}
+		if err := c.kakkotojiru(in); err != nil {
+			return BytecodeSF(), err
+		}
+		out.appendValue(bv1)
+		out.append(OC_animelemtime)
+	case "stateno":
+		out.append(OC_stateno)
 	default:
 		println(c.token)
 		unimplemented()
@@ -1040,7 +1122,7 @@ func (c *Compiler) fullExpression(in *string, vt ValueType) (BytecodeExp,
 	return be, nil
 }
 func (c *Compiler) parseSection(lines []string, i *int,
-	sctrl func(name, data string) error) (IniSection, error) {
+	sctrl func(name, data string) error) (IniSection, bool, error) {
 	is := NewIniSection()
 	_type, persistent, ignorehitpause := true, true, true
 	for ; *i < len(lines); (*i)++ {
@@ -1075,7 +1157,7 @@ func (c *Compiler) parseSection(lines []string, i *int,
 				if sys.ignoreMostErrors {
 					continue
 				}
-				return nil, Error(name + "が重複しています")
+				return nil, false, Error(name + "が重複しています")
 			}
 			if sctrl != nil {
 				switch name {
@@ -1101,14 +1183,14 @@ func (c *Compiler) parseSection(lines []string, i *int,
 					}
 				}
 				if err := sctrl(name, data); err != nil {
-					return nil, err
+					return nil, false, err
 				}
 			} else {
 				is[name] = data
 			}
 		}
 	}
-	return is, nil
+	return is, !ignorehitpause, nil
 }
 func (c *Compiler) stateSec(is IniSection, f func() error) error {
 	if err := f(); err != nil {
@@ -1139,8 +1221,8 @@ func (c *Compiler) stateParam(is IniSection, name string,
 	}
 	return nil
 }
-func (c *Compiler) scAdd(sc *StateControllerBase, id byte,
-	data string, vt ValueType, numArg int, topbe ...BytecodeExp) error {
+func (c *Compiler) exprs(data string, vt ValueType,
+	numArg int) ([]BytecodeExp, error) {
 	bes := []BytecodeExp{}
 	for n := 1; n <= numArg; n++ {
 		var be BytecodeExp
@@ -1151,13 +1233,21 @@ func (c *Compiler) scAdd(sc *StateControllerBase, id byte,
 			be, err = c.fullExpression(&data, vt)
 		}
 		if err != nil {
-			return err
+			return nil, err
 		}
 		bes = append(bes, be)
 		if c.token != "," {
 			break
 		}
 	}
+	return bes, nil
+}
+func (c *Compiler) scAdd(sc *StateControllerBase, id byte,
+	data string, vt ValueType, numArg int, topbe ...BytecodeExp) error {
+	bes, err := c.exprs(data, vt, numArg)
+	if err != nil {
+		return err
+	}
 	sc.add(id, append(topbe, bes...))
 	return nil
 }
@@ -1175,6 +1265,125 @@ func (c *Compiler) paramValue(is IniSection, sc *StateControllerBase,
 	}
 	return nil
 }
+func (c *Compiler) paramPostye(is IniSection, sc *StateControllerBase,
+	id byte) error {
+	return c.stateParam(is, "postype", func(data string) error {
+		if len(data) == 0 {
+			return Error("値が指定されていません")
+		}
+		var pt PosType
+		if len(data) >= 2 && strings.ToLower(data[:2]) == "p2" {
+			pt = PT_P2
+		} else {
+			switch strings.ToLower(data)[0] {
+			case 'p':
+				pt = PT_P1
+			case 'f':
+				pt = PT_F
+			case 'b':
+				pt = PT_B
+			case 'l':
+				pt = PT_L
+			case 'r':
+				pt = PT_R
+			case 'n':
+				pt = PT_N
+			default:
+				return Error(data + "が無効な値です")
+			}
+		}
+		sc.add(id, sc.iToExp(int32(pt)))
+		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 {
+		if len(data) == 0 {
+			return Error("値が指定されていません")
+		}
+		tt := TT_default
+		data = strings.ToLower(data)
+		switch data {
+		case "none":
+			tt = TT_none
+		case "add1":
+			tt = TT_add1
+		case "sub":
+			tt = TT_sub
+		default:
+			_error := false
+			if afterImage {
+				if len(data) >= 3 && data[:3] == "add" {
+					tt = TT_add
+				} else {
+					_error = true
+				}
+			} else {
+				switch data {
+				case "default":
+					tt = TT_default
+				case "add":
+					tt = TT_add
+				case "addalpha", "alpha":
+					tt = TT_alpha
+				default:
+					_error = true
+				}
+			}
+			if _error && (!afterImage || !sys.ignoreMostErrors) {
+				return Error(data + "が無効な値です")
+			}
+		}
+		var exp []BytecodeExp
+		if !afterImage && (tt == TT_alpha || tt == TT_add1) {
+			b := false
+			if err := c.stateParam(is, prefix+"alpha", func(data string) error {
+				b = true
+				bes, err := c.exprs(data, VT_Int, 2)
+				if err != nil {
+					return err
+				}
+				exp = make([]BytecodeExp, 3) // 長さ3にする
+				exp[0] = bes[0]
+				if len(bes) < 2 {
+					if tt == TT_add1 {
+						exp[1].appendValue(BytecodeInt(128))
+					} else {
+						exp[1].appendValue(BytecodeInt(255))
+					}
+				} else {
+					exp[1] = bes[1]
+				}
+				return nil
+			}); err != nil {
+				return err
+			}
+			if !b {
+				if tt == TT_add1 {
+					exp = sc.iToExp(255, 128)
+				} else {
+					exp = sc.iToExp(-1, 0)
+				}
+			}
+		} else {
+			switch tt {
+			case TT_none:
+				exp = sc.iToExp(255, 0)
+			case TT_add:
+				exp = sc.iToExp(255, 255)
+			case TT_add1:
+				exp = sc.iToExp(255, 128)
+			case TT_sub:
+				exp = sc.iToExp(1, 255)
+			default:
+				exp = sc.iToExp(-1, 0)
+			}
+		}
+		sc.add(id, exp)
+		return nil
+	})
+}
 func (c *Compiler) stateDef(is IniSection, sbc *StateBytecode) error {
 	return c.stateSec(is, func() error {
 		sc := newStateControllerBase(c.playerNo)
@@ -1343,19 +1552,19 @@ func (c *Compiler) hitBySub(is IniSection, sc *StateControllerBase) error {
 	return nil
 }
 func (c *Compiler) hitBy(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return hitBy(*sc), c.stateSec(is, func() error {
 		return c.hitBySub(is, sc)
 	})
 }
 func (c *Compiler) notHitBy(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return notHitBy(*sc), c.stateSec(is, func() error {
 		return c.hitBySub(is, sc)
 	})
 }
 func (c *Compiler) assertSpecial(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return assertSpecial(*sc), c.stateSec(is, func() error {
 		foo := func(data string) error {
 			switch data {
@@ -1428,7 +1637,7 @@ func (c *Compiler) assertSpecial(is IniSection, sbc *StateBytecode,
 	})
 }
 func (c *Compiler) playSnd(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return playSnd(*sc), c.stateSec(is, func() error {
 		f := false
 		if err := c.stateParam(is, "value", func(data string) error {
@@ -1505,19 +1714,19 @@ func (c *Compiler) changeStateSub(is IniSection,
 	return nil
 }
 func (c *Compiler) changeState(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return changeState(*sc), c.stateSec(is, func() error {
 		return c.changeStateSub(is, sc)
 	})
 }
 func (c *Compiler) selfState(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return selfState(*sc), c.stateSec(is, func() error {
 		return c.changeStateSub(is, sc)
 	})
 }
 func (c *Compiler) tagIn(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return tagIn(*sc), c.stateSec(is, func() error {
 		if err := c.paramValue(is, sc, "stateno",
 			tagIn_stateno, VT_Int, 1, true); err != nil {
@@ -1537,14 +1746,14 @@ func (c *Compiler) tagIn(is IniSection, sbc *StateBytecode,
 	})
 }
 func (c *Compiler) tagOut(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return tagOut(*sc), c.stateSec(is, func() error {
 		sc.add(tagOut_, nil)
 		return nil
 	})
 }
 func (c *Compiler) destroySelf(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return destroySelf(*sc), c.stateSec(is, func() error {
 		if err := c.paramValue(is, sc, "recursive",
 			destroySelf_recursive, VT_Bool, 1, false); err != nil {
@@ -1570,19 +1779,19 @@ func (c *Compiler) changeAnimSub(is IniSection,
 	return nil
 }
 func (c *Compiler) changeAnim(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return changeAnim(*sc), c.stateSec(is, func() error {
 		return c.changeAnimSub(is, sc)
 	})
 }
 func (c *Compiler) changeAnim2(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return changeAnim2(*sc), c.stateSec(is, func() error {
 		return c.changeAnimSub(is, sc)
 	})
 }
 func (c *Compiler) helper(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return helper(*sc), c.stateSec(is, func() error {
 		if err := c.stateParam(is, "helpertype", func(data string) error {
 			if len(data) == 0 {
@@ -1608,34 +1817,7 @@ func (c *Compiler) helper(is IniSection, sbc *StateBytecode,
 		}); err != nil {
 			return err
 		}
-		if err := c.stateParam(is, "postype", func(data string) error {
-			if len(data) == 0 {
-				return Error("値が指定されていません")
-			}
-			var pt PosType
-			if len(data) >= 2 && strings.ToLower(data[:2]) == "p2" {
-				pt = PT_P2
-			} else {
-				switch strings.ToLower(data)[0] {
-				case 'p':
-					pt = PT_P1
-				case 'f':
-					pt = PT_F
-				case 'b':
-					pt = PT_B
-				case 'l':
-					pt = PT_L
-				case 'r':
-					pt = PT_R
-				case 'n':
-					pt = PT_N
-				default:
-					return Error(data + "が無効な値です")
-				}
-			}
-			sc.add(helper_postype, sc.iToExp(int32(pt)))
-			return nil
-		}); err != nil {
+		if err := c.paramPostye(is, sc, helper_postype); err != nil {
 			return err
 		}
 		if err := c.paramValue(is, sc, "ownpal",
@@ -1718,24 +1900,221 @@ func (c *Compiler) helper(is IniSection, sbc *StateBytecode,
 	})
 }
 func (c *Compiler) powerAdd(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return powerAdd(*sc), c.stateSec(is, func() error {
 		return c.paramValue(is, sc, "value", powerAdd_value, VT_Int, 1, true)
 	})
 }
 func (c *Compiler) ctrlSet(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return ctrlSet(*sc), c.stateSec(is, func() error {
 		return c.paramValue(is, sc, "value", ctrlSet_value, VT_Bool, 1, true)
 	})
 }
+func (c *Compiler) explodSub(is IniSection,
+	sc *StateControllerBase) error {
+	if err := c.paramValue(is, sc, "remappal",
+		explod_remappal, VT_Int, 2, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "id",
+		explod_id, VT_Int, 1, false); err != nil {
+		return err
+	}
+	if err := c.paramPostye(is, sc, explod_postype); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "facing",
+		explod_facing, VT_Int, 1, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "vfacing",
+		explod_vfacing, VT_Int, 1, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "pos",
+		explod_pos, VT_Float, 2, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "random",
+		explod_random, VT_Float, 2, false); err != nil {
+		return err
+	}
+	f := false
+	if err := c.stateParam(is, "vel", func(data string) error {
+		f = true
+		return c.scAdd(sc, explod_velocity, data, VT_Float, 2)
+	}); err != nil {
+		return err
+	}
+	if !f {
+		if err := c.paramValue(is, sc, "velocity",
+			explod_velocity, VT_Float, 2, false); err != nil {
+			return err
+		}
+	}
+	if err := c.paramValue(is, sc, "accel",
+		explod_accel, VT_Float, 2, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "scale",
+		explod_scale, VT_Float, 2, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "bindtime",
+		explod_bindtime, VT_Int, 1, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "removetime",
+		explod_removetime, VT_Int, 1, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "supermove",
+		explod_supermove, VT_Bool, 1, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "supermovetime",
+		explod_supermovetime, VT_Int, 1, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "pausemovetime",
+		explod_pausemovetime, VT_Int, 1, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "sprpriority",
+		explod_sprpriority, VT_Int, 1, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "ontop",
+		explod_ontop, VT_Bool, 1, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "shadow",
+		explod_shadow, VT_Int, 3, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "removeongethit",
+		explod_removeongethit, VT_Bool, 1, false); err != nil {
+		return err
+	}
+	if err := c.paramTrans(is, sc, "", explod_trans, false); err != nil {
+		return err
+	}
+	return nil
+}
+func (c *Compiler) explod(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase, ihp bool) (StateController, error) {
+	return explod(*sc), c.stateSec(is, func() error {
+		if err := c.paramValue(is, sc, "ownpal",
+			explod_ownpal, VT_Bool, 1, false); err != nil {
+			return err
+		}
+		if err := c.explodSub(is, sc); err != nil {
+			return err
+		}
+		if err := c.stateParam(is, "anim", func(data string) error {
+			fflg := false
+			if len(data) > 0 && strings.ToLower(data)[0] == 'f' {
+				fflg = true
+				data = data[1:]
+			}
+			return c.scAdd(sc, explod_anim, data, VT_Int, 1,
+				sc.iToExp(Btoi(fflg))...)
+		}); err != nil {
+			return err
+		}
+		if err := c.paramValue(is, sc, "angle",
+			explod_angle, VT_Float, 1, false); err != nil {
+			return err
+		}
+		if err := c.paramValue(is, sc, "yangle",
+			explod_yangle, VT_Float, 1, false); err != nil {
+			return err
+		}
+		if err := c.paramValue(is, sc, "xangle",
+			explod_xangle, VT_Float, 1, false); err != nil {
+			return err
+		}
+		if ihp && !sc.ignorehitpause {
+			sc.add(explod_ignorehitpause, sc.iToExp(0))
+		}
+		return nil
+	})
+}
+func (c *Compiler) modifyExplod(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase, _ bool) (StateController, error) {
+	return modifyExplod(*sc), c.stateSec(is, func() error {
+		if err := c.explodSub(is, sc); err != nil {
+			return err
+		}
+		if err := c.paramValue(is, sc, "angle",
+			explod_angle, VT_Float, 1, false); err != nil {
+			return err
+		}
+		if err := c.paramValue(is, sc, "yangle",
+			explod_yangle, VT_Float, 1, false); err != nil {
+			return err
+		}
+		if err := c.paramValue(is, sc, "xangle",
+			explod_xangle, VT_Float, 1, false); err != nil {
+			return err
+		}
+		return nil
+	})
+}
+func (c *Compiler) posSetSub(is IniSection,
+	sc *StateControllerBase) error {
+	if err := c.paramValue(is, sc, "x",
+		posSet_x, VT_Float, 1, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "y",
+		posSet_y, VT_Float, 1, false); err != nil {
+		return err
+	}
+	if err := c.paramValue(is, sc, "z",
+		posSet_z, VT_Float, 1, false); err != nil {
+		return err
+	}
+	return nil
+}
+func (c *Compiler) posSet(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase, _ bool) (StateController, error) {
+	return posSet(*sc), c.stateSec(is, func() error {
+		return c.posSetSub(is, sc)
+	})
+}
+func (c *Compiler) posAdd(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase, _ bool) (StateController, error) {
+	return posAdd(*sc), c.stateSec(is, func() error {
+		return c.posSetSub(is, sc)
+	})
+}
+func (c *Compiler) velSet(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase, _ bool) (StateController, error) {
+	return velSet(*sc), c.stateSec(is, func() error {
+		return c.posSetSub(is, sc)
+	})
+}
+func (c *Compiler) velAdd(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase, _ bool) (StateController, error) {
+	return velAdd(*sc), c.stateSec(is, func() error {
+		return c.posSetSub(is, sc)
+	})
+}
+func (c *Compiler) velMul(is IniSection, sbc *StateBytecode,
+	sc *StateControllerBase, _ bool) (StateController, error) {
+	return velMul(*sc), c.stateSec(is, func() error {
+		return c.posSetSub(is, sc)
+	})
+}
 func (c *Compiler) hitDefSub(is IniSection,
 	sc *StateControllerBase) error {
 	unimplemented()
 	return nil
 }
 func (c *Compiler) hitDef(is IniSection, sbc *StateBytecode,
-	sc *StateControllerBase) (StateController, error) {
+	sc *StateControllerBase, _ bool) (StateController, error) {
 	return hitDef(*sc), c.stateSec(is, func() error {
 		return c.hitDefSub(is, sc)
 	})
@@ -1770,7 +2149,7 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 		}
 		existInThisFile[n] = true
 		i++
-		is, err := c.parseSection(lines, &i, nil)
+		is, _, err := c.parseSection(lines, &i, nil)
 		if err != nil {
 			return errmes(err)
 		}
@@ -1789,12 +2168,12 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 			i++
 			sc := newStateControllerBase(c.playerNo)
 			var scf func(is IniSection, sbc *StateBytecode,
-				sc *StateControllerBase) (StateController, error)
+				sc *StateControllerBase, ihp bool) (StateController, error)
 			var triggerall []BytecodeExp
 			allUtikiri := false
 			var trigger [][]BytecodeExp
 			var trexist []int8
-			is, err := c.parseSection(lines, &i, func(name, data string) error {
+			is, ihp, err := c.parseSection(lines, &i, func(name, data string) error {
 				switch name {
 				case "type":
 					switch data {
@@ -1826,6 +2205,20 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 						scf = c.powerAdd
 					case "ctrlset":
 						scf = c.ctrlSet
+					case "explod":
+						scf = c.explod
+					case "modifyexplod":
+						scf = c.modifyExplod
+					case "posset":
+						scf = c.posSet
+					case "posadd":
+						scf = c.posAdd
+					case "velset":
+						scf = c.velSet
+					case "veladd":
+						scf = c.velAdd
+					case "velmul":
+						scf = c.velMul
 					case "hitdef":
 						scf = c.hitDef
 					default:
@@ -1961,7 +2354,7 @@ func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 			if len(texp) > 0 {
 				sc.add(SCID_trigger, sc.beToExp(texp))
 			}
-			sctrl, err := scf(is, sbc, sc)
+			sctrl, err := scf(is, sbc, sc, ihp)
 			if err != nil {
 				return errmes(err)
 			}

--- a/src/image.go
+++ b/src/image.go
@@ -13,6 +13,17 @@ import (
 	"unsafe"
 )
 
+type TransType int32
+
+const (
+	TT_default TransType = iota
+	TT_none
+	TT_add
+	TT_alpha
+	TT_add1
+	TT_sub
+)
+
 type Texture uint32
 
 func textureFinalizer(t *Texture) {