Commit: d8bc640e1564e1f073a8a643ad8a6d3fbe3c22af - ikemen_go (git)

Go で書き直した Ikemen

Commit MetaInfo

• Revisão: d8bc640e1564e1f073a8a643ad8a6d3fbe3c22af (tree)
• Hora: 2017-01-04 00:26:06
• Autor: SUEHIRO <supersuehiro@user...>
• Commiter: SUEHIRO

Mensagem de Log

スタンドアロンで動かすために必要な common1 を書いていく

Mudança Sumário

• modified: data/common1.cns.zss
• modified: src/bytecode.go
• modified: src/char.go
• modified: src/compiler.go
• modified: src/script.go
• modified: src/system.go

Diff

--- a/data/common1.cns.zss
+++ b/data/common1.cns.zss
@@ -6,6 +6,9 @@
 # ignorehitpause{} を含んでいる if も実行される
 # Explod は ignorehitpause を任意に指定できる
 # ignorehitpause persistent(2) if 1 {} ブロックの特性を複数指定 if は最後に
+# VarSet, VarAdd は使えない代わりに := による代入を含む式を書ける
+# 代入式は末尾に ; をつける
+
 
 [Statedef 0; type: S; physics: S;
  sprpriority: 0;]
@@ -15,7 +18,7 @@ if cond(Anim = 5, AnimTime = 0, Anim != 0) {
 if Time = 0 {
     VelSet{y: 0}
 }
-if Time = 4 || abs(vel x) < cond(MajorVersion = 1,
+if Time = 4 || abs(vel x) < ifelse(MajorVersion = 1,
     Const(movement.stand.friction.threshold), 2) {
     VelSet{x: 0}
 }
@@ -23,6 +26,7 @@ if !alive {
     ChangeState{value: 5050; ctrl: 0}
 }
 
+
 [Statedef 10; type: C; physics: C;
  anim: 10;]
 if Time = 0 {
@@ -35,6 +39,7 @@ if AnimTime = 0 {
     ChangeState{value: 11}
 }
 
+
 [Statedef 11; type: C; physics: C;
  anim: 11; sprpriority: 0;]
 if Anim = 6 && AnimTime = 0 {
@@ -44,12 +49,14 @@ if abs(vel x) < Const(movement.crouch.friction.threshold) {
     VelSet{x: 0}
 }
 
+
 [Statedef 12; type: S; physics: S;
  anim: 12;]
 if AnimTime = 0 {
     ChangeState{value: 0}
 }
 
+
 [Statedef 20; type: S; physics: S;
  sprpriority: 0;]
 if command = "holdback" {
@@ -67,3 +74,123 @@ if vel x > 0 {
     }
 }
 
+
+[Statedef 40; type: S; physics: S;
+ anim: 40; ctrl: 0; sprpriority: 1; facep2: 1;]
+if Time = 0 {
+    sysvar(1) := 0;
+}
+if command = "holdback" {
+    sysvar(1) := -1;
+} else if command = "holdfwd" {
+    sysvar(1) := 1;
+}
+if AnimTime = 0 {
+    if sysvar(1) = 0 {
+        VelSet{x: const(velocity.jump.neu.x)}
+    } else if sysvar(1) = 1 {
+        if prevstateno = 100 {
+            VelSet{x: const(velocity.runjump.fwd.x)}
+        } else {
+            VelSet{x: const(velocity.jump.fwd.x)}
+        }
+    } else {
+        VelSet{x: const(velocity.jump.back.x)}
+    }
+    VelSet{y: const(velocity.jump.y)}
+    ChangeState{value: 50; ctrl: 1}
+}
+
+
+[Statedef 45; type: A; physics: N;
+ ctrl: 0; velset: 0, 0;]
+ChangeAnim{value: ifelse(SelfAnimExist(44), 44, 41)}
+if Time = 0 {
+    sysvar(1) := 0;
+}
+if command = "holdback" {
+    sysvar(1) := -1;
+} else if command = "holdfwd" {
+    sysvar(1) := 1;
+}
+if Time = 2 {
+    if sysvar(1) = 0 {
+        VelSet{x: const(velocity.airjump.neu.x)}
+    } else if sysvar(1) = 1 {
+        VelSet{x: const(velocity.airjump.fwd.x)}
+    } else {
+        VelSet{x: const(velocity.airjump.back.x)}
+    }
+    VelSet{y: const(velocity.airjump.y)}
+    ChangeState{value: 50; ctrl: 1}
+}
+
+
+[Statedef 50; type: A; physics: A;]
+if Time = 0 {
+    sysvar(1) := 0;
+    ChangeAnim{value: cond((vel x) = 0, 41, ifelse((vel x) > 0, 42, 43))}
+}
+if Vel y > Const240p(-2) && SelfAnimExist(anim + 3) && anim = [41, 43] {
+    ChangeAnim{value: Anim + 3}
+}
+
+
+[Statedef 51; type: A; physics: A;]
+
+
+[Statedef 52; type: S; physics: S;
+ ctrl: 0; anim: 47;]
+if Time = 0 {
+    VelSet{y: 0}
+    PosSet{y: 0}
+} else if Time = 3 {
+    CtrlSet{value: 1}
+}
+if MajorVersion = 1 && abs(vel x) < Const(movement.stand.friction.threshold){
+    VelSet{x: 0}
+}
+if AnimTime = 0 {
+    ChangeState{value: 0; ctrl: 1}
+}
+
+
+[Statedef 100; type: S; physics: S;
+ anim: 100; sprpriority: 1;]
+VelSet{x: const(velocity.run.fwd.x)}
+AssertSpecial{flag: NoWalk; flag2: NoAutoTurn}
+if command != "holdfwd" {
+    ChangeState{value: 0}
+}
+
+
+[Statedef 105; type: A; physics: A;
+ ctrl: 0; anim: 105; sprpriority: 1;]
+if Time = 0 {
+    VelSet{x: const(velocity.run.back.x); y: const(velocity.run.back.y)}
+}else if Time = 2 {
+    CtrlSet{value: 1}
+}
+if Vel Y > 0 && Pos Y >= 0 {
+    ChangeState{value: 106}
+}
+
+
+[Statedef 106; type: S; physics: S;
+ ctrl: 0; anim: 47;]
+if MajorVersion = 1 && abs(vel x) < Const(movement.stand.friction.threshold) {
+    VelSet{x: 0}
+}
+if Time = 0 {
+    VelSet{y: 0}
+    PosSet{y: 0}
+} else if Time = 2 {
+    if MajorVersion = 1 {
+        MakeDust{pos: 0, 0; spacing: 1}
+    } else {
+        MakeDust{pos: -5, -2; spacing: 1}
+    }
+} else if Time = 7 {
+    ChangeState{value: 0; ctrl: 1}
+}
+

--- a/src/bytecode.go
+++ b/src/bytecode.go
@@ -953,6 +953,8 @@ func (be BytecodeExp) run(c *Char) BytecodeValue {
 			sys.bcStack.PushI(c.time())
 		case OC_alive:
 			sys.bcStack.PushB(c.alive())
+		case OC_ctrl:
+			sys.bcStack.PushB(c.canCtrl())
 		case OC_random:
 			sys.bcStack.PushI(Rand(0, 999))
 		case OC_roundstate:
@@ -1019,17 +1021,28 @@ func (be BytecodeExp) run(c *Char) BytecodeValue {
 			sys.bcStack.PushF(c.bottomEdge())
 		case OC_power:
 			sys.bcStack.PushI(c.getPower())
+		case OC_roundsexisted:
+			sys.bcStack.PushI(c.roundsExisted())
+		case OC_gametime:
+			sys.bcStack.PushI(sys.gameTime)
+		case OC_hitfall:
+			sys.bcStack.PushB(c.ghv.fallf)
 		case OC_ishelper:
 			*sys.bcStack.Top() = c.isHelper(*sys.bcStack.Top())
 		case OC_numhelper:
 			*sys.bcStack.Top() = c.numHelper(*sys.bcStack.Top())
-		case OC_roundsexisted:
-			sys.bcStack.PushI(c.roundsExisted())
 		case OC_teammode:
 			sys.bcStack.PushB(sys.tmode[c.playerNo&1] == TeamMode(be[i]))
 			i++
-		case OC_ctrl:
-			sys.bcStack.PushB(c.canCtrl())
+		case OC_statetype:
+			sys.bcStack.PushB(c.ss.sb.stateType == StateType(be[i]))
+			i++
+		case OC_movetype:
+			sys.bcStack.PushB(c.ss.sb.moveType == MoveType(be[i]))
+			i++
+		case OC_hitdefattr:
+			sys.bcStack.PushB(c.hitDefAttr(*(*int32)(unsafe.Pointer(&be[i]))))
+			i += 4
 		case OC_st_:
 			be.run_st(c, &i)
 		case OC_const_:
@@ -1459,6 +1472,13 @@ func (b StateBlock) Run(c *Char, ps []int32) (changeState bool) {
 	return false
 }
 
+type StateExpr BytecodeExp
+
+func (se StateExpr) Run(c *Char, _ []int32) (changeState bool) {
+	BytecodeExp(se).run(c)
+	return false
+}
+
 type StateControllerBase []byte
 
 func newStateControllerBase() *StateControllerBase {
@@ -3964,6 +3984,56 @@ func (sc envColor) Run(c *Char, _ []int32) bool {
 	return false
 }
 
+type displayToClipboard StateControllerBase
+
+const (
+	displayToClipboard_params byte = iota
+	displayToClipboard_text
+)
+
+func (sc displayToClipboard) Run(c *Char, _ []int32) bool {
+	params := []interface{}{}
+	StateControllerBase(sc).run(c, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case displayToClipboard_params:
+			for _, e := range exp {
+				if bv := e.run(c); bv.t == VT_Float {
+					params = append(params, bv.ToF())
+				} else {
+					params = append(params, bv.ToI())
+				}
+			}
+		case displayToClipboard_text:
+			sys.clipboardText[c.ss.sb.playerNo] = nil
+			sys.appendToClipboard(c.ss.sb.playerNo, int(exp[0].evalI(c)), params...)
+		}
+		return true
+	})
+	return false
+}
+
+type appendToClipboard displayToClipboard
+
+func (sc appendToClipboard) Run(c *Char, _ []int32) bool {
+	params := []interface{}{}
+	StateControllerBase(sc).run(c, func(id byte, exp []BytecodeExp) bool {
+		switch id {
+		case displayToClipboard_params:
+			for _, e := range exp {
+				if bv := e.run(c); bv.t == VT_Float {
+					params = append(params, bv.ToF())
+				} else {
+					params = append(params, bv.ToI())
+				}
+			}
+		case displayToClipboard_text:
+			sys.appendToClipboard(c.ss.sb.playerNo, int(exp[0].evalI(c)), params...)
+		}
+		return true
+	})
+	return false
+}
+
 type StateBytecode struct {
 	stateType StateType
 	moveType  MoveType

--- a/src/char.go
+++ b/src/char.go
@@ -478,6 +478,10 @@ func (hd *HitDef) invalidate(stateType StateType) {
 	hd.reversal_attr |= -1 << 31
 	hd.lhit = false
 }
+func (hd *HitDef) testAttr(attr int32) bool {
+	attr &= hd.attr
+	return attr&int32(ST_MASK) != 0 && attr&^int32(ST_MASK)&^(-1<<31) != 0
+}
 
 type GetHitVar struct {
 	hitBy          [][2]int32
@@ -1881,3 +1885,6 @@ func (c *Char) canCtrl() bool {
 func (c *Char) win() bool {
 	return sys.winTeam == c.playerNo&1
 }
+func (c *Char) hitDefAttr(attr int32) bool {
+	return c.ss.sb.moveType == MT_A && c.hitdef.testAttr(attr)
+}

--- a/src/compiler.go
+++ b/src/compiler.go
@@ -30,67 +30,69 @@ type Compiler struct {
 func newCompiler() *Compiler {
 	c := &Compiler{}
 	c.scmap = map[string]scFunc{
-		"hitby":          c.hitBy,
-		"nothitby":       c.notHitBy,
-		"assertspecial":  c.assertSpecial,
-		"playsnd":        c.playSnd,
-		"changestate":    c.changeState,
-		"selfstate":      c.selfState,
-		"tagin":          c.tagIn,
-		"tagout":         c.tagOut,
-		"destroyself":    c.destroySelf,
-		"changeanim":     c.changeAnim,
-		"changeanim2":    c.changeAnim2,
-		"helper":         c.helper,
-		"ctrlset":        c.ctrlSet,
-		"explod":         c.explod,
-		"modifyexplod":   c.modifyExplod,
-		"gamemakeanim":   c.gameMakeAnim,
-		"posset":         c.posSet,
-		"posadd":         c.posAdd,
-		"velset":         c.velSet,
-		"veladd":         c.velAdd,
-		"velmul":         c.velMul,
-		"palfx":          c.palFX,
-		"allpalfx":       c.allPalFX,
-		"bgpalfx":        c.bgPalFX,
-		"afterimage":     c.afterImage,
-		"afterimagetime": c.afterImageTime,
-		"hitdef":         c.hitDef,
-		"reversaldef":    c.reversalDef,
-		"projectile":     c.projectile,
-		"width":          c.width,
-		"sprpriority":    c.sprPriority,
-		"varset":         c.varSet,
-		"varadd":         c.varAdd,
-		"parentvarset":   c.parentVarSet,
-		"parentvaradd":   c.parentVarAdd,
-		"turn":           c.turn,
-		"targetfacing":   c.targetFacing,
-		"targetbind":     c.targetBind,
-		"bindtotarget":   c.bindToTarget,
-		"targetlifeadd":  c.targetLifeAdd,
-		"targetstate":    c.targetState,
-		"targetvelset":   c.targetVelSet,
-		"targetveladd":   c.targetVelAdd,
-		"targetpoweradd": c.targetPowerAdd,
-		"targetdrop":     c.targetDrop,
-		"lifeadd":        c.lifeAdd,
-		"lifeset":        c.lifeSet,
-		"poweradd":       c.powerAdd,
-		"powerset":       c.powerSet,
-		"hitvelset":      c.hitVelSet,
-		"screenbound":    c.screenBound,
-		"posfreeze":      c.posFreeze,
-		"envshake":       c.envShake,
-		"hitoverride":    c.hitOverride,
-		"pause":          c.pause,
-		"superpause":     c.superPause,
-		"trans":          c.trans,
-		"playerpush":     c.playerPush,
-		"statetypeset":   c.stateTypeSet,
-		"angledraw":      c.angleDraw,
-		"envcolor":       c.envColor,
+		"hitby":              c.hitBy,
+		"nothitby":           c.notHitBy,
+		"assertspecial":      c.assertSpecial,
+		"playsnd":            c.playSnd,
+		"changestate":        c.changeState,
+		"selfstate":          c.selfState,
+		"tagin":              c.tagIn,
+		"tagout":             c.tagOut,
+		"destroyself":        c.destroySelf,
+		"changeanim":         c.changeAnim,
+		"changeanim2":        c.changeAnim2,
+		"helper":             c.helper,
+		"ctrlset":            c.ctrlSet,
+		"explod":             c.explod,
+		"modifyexplod":       c.modifyExplod,
+		"gamemakeanim":       c.gameMakeAnim,
+		"posset":             c.posSet,
+		"posadd":             c.posAdd,
+		"velset":             c.velSet,
+		"veladd":             c.velAdd,
+		"velmul":             c.velMul,
+		"palfx":              c.palFX,
+		"allpalfx":           c.allPalFX,
+		"bgpalfx":            c.bgPalFX,
+		"afterimage":         c.afterImage,
+		"afterimagetime":     c.afterImageTime,
+		"hitdef":             c.hitDef,
+		"reversaldef":        c.reversalDef,
+		"projectile":         c.projectile,
+		"width":              c.width,
+		"sprpriority":        c.sprPriority,
+		"varset":             c.varSet,
+		"varadd":             c.varAdd,
+		"parentvarset":       c.parentVarSet,
+		"parentvaradd":       c.parentVarAdd,
+		"turn":               c.turn,
+		"targetfacing":       c.targetFacing,
+		"targetbind":         c.targetBind,
+		"bindtotarget":       c.bindToTarget,
+		"targetlifeadd":      c.targetLifeAdd,
+		"targetstate":        c.targetState,
+		"targetvelset":       c.targetVelSet,
+		"targetveladd":       c.targetVelAdd,
+		"targetpoweradd":     c.targetPowerAdd,
+		"targetdrop":         c.targetDrop,
+		"lifeadd":            c.lifeAdd,
+		"lifeset":            c.lifeSet,
+		"poweradd":           c.powerAdd,
+		"powerset":           c.powerSet,
+		"hitvelset":          c.hitVelSet,
+		"screenbound":        c.screenBound,
+		"posfreeze":          c.posFreeze,
+		"envshake":           c.envShake,
+		"hitoverride":        c.hitOverride,
+		"pause":              c.pause,
+		"superpause":         c.superPause,
+		"trans":              c.trans,
+		"playerpush":         c.playerPush,
+		"statetypeset":       c.stateTypeSet,
+		"angledraw":          c.angleDraw,
+		"envcolor":           c.envColor,
+		"displaytoclipboard": c.displayToClipboard,
+		"appendtoclipboard":  c.appendToClipboard,
 	}
 	return c
 }
@@ -406,6 +408,80 @@ func (c *Compiler) attr(text string, hitdef bool) (int32, error) {
 	}
 	return flg, nil
 }
+func (c *Compiler) trgAttr(in *string) (int32, error) {
+	flg := int32(0)
+	*in = strings.TrimSpace(*in)
+	i := strings.IndexAny(*in, kuuhaktokigou)
+	var att string
+	if i >= 0 {
+		att = (*in)[:i]
+		*in = strings.TrimSpace((*in)[i:])
+	} else {
+		att = *in
+		*in = ""
+	}
+	for _, a := range att {
+		switch a {
+		case 'S', 's':
+			flg |= int32(ST_S)
+		case 'C', 'c':
+			flg |= int32(ST_C)
+		case 'A', 'a':
+			flg |= int32(ST_A)
+		default:
+			return 0, Error(att + "が不正な属性値です")
+		}
+	}
+	for len(*in) > 0 && (*in)[0] == ',' {
+		oldin := *in
+		*in = strings.TrimSpace((*in)[1:])
+		i := strings.IndexAny(*in, kuuhaktokigou)
+		var att string
+		if i >= 0 {
+			att = (*in)[:i]
+			*in = strings.TrimSpace((*in)[i:])
+		} else {
+			att = *in
+			*in = ""
+		}
+		switch strings.ToLower(att) {
+		case "na":
+			flg |= int32(AT_NA)
+		case "nt":
+			flg |= int32(AT_NT)
+		case "np":
+			flg |= int32(AT_NP)
+		case "sa":
+			flg |= int32(AT_SA)
+		case "st":
+			flg |= int32(AT_ST)
+		case "sp":
+			flg |= int32(AT_SP)
+		case "ha":
+			flg |= int32(AT_HA)
+		case "ht":
+			flg |= int32(AT_HT)
+		case "hp":
+			flg |= int32(AT_HP)
+		case "aa":
+			flg |= int32(AT_AA)
+		case "at":
+			flg |= int32(AT_AT)
+		case "ap":
+			flg |= int32(AT_AP)
+		case "n":
+			flg |= int32(AT_NA | AT_NT | AT_NP)
+		case "s":
+			flg |= int32(AT_SA | AT_ST | AT_SP)
+		case "h", "a":
+			flg |= int32(AT_HA | AT_HT | AT_HP)
+		default:
+			*in = oldin
+			return flg, nil
+		}
+	}
+	return flg, nil
+}
 func (c *Compiler) kakkohiraku(in *string) error {
 	if c.tokenizer(in) != "(" {
 		return Error(c.token + "の次に'('がありません")
@@ -657,15 +733,13 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string,
 		c.token = c.tokenizer(in)
 		return bv, nil
 	}
-	if !sys.ignoreMostErrors {
-		defer func() { c.usiroOp = false }()
-	}
 	_var := func(sys, f bool) error {
 		bv1, err := c.oneArg(out, in, rd, false)
 		if err != nil {
 			return err
 		}
 		var oc OpCode
+		c.token = c.tokenizer(in)
 		set, _else := c.token == ":=", false
 		if !bv1.IsNone() && bv1.ToI() >= 0 {
 			switch [2]bool{sys, f} {
@@ -751,6 +825,16 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string,
 		}
 		return nil
 	}
+	eqne2 := func(f func(not bool) error) error {
+		not, err := c.kyuushiki(in)
+		if err != nil {
+			return err
+		}
+		if err := f(not); err != nil {
+			return err
+		}
+		return nil
+	}
 	var be1, be2, be3 BytecodeExp
 	var bv1, bv2, bv3 BytecodeValue
 	var n int32
@@ -889,21 +973,13 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string,
 			return bvNone(), err
 		}
 	case "var":
-		if err := _var(false, false); err != nil {
-			return bvNone(), err
-		}
+		return bvNone(), _var(false, false)
 	case "fvar":
-		if err := _var(false, true); err != nil {
-			return bvNone(), err
-		}
+		return bvNone(), _var(false, true)
 	case "sysvar":
-		if err := _var(true, false); err != nil {
-			return bvNone(), err
-		}
+		return bvNone(), _var(true, false)
 	case "sysfvar":
-		if err := _var(true, true); err != nil {
-			return bvNone(), err
-		}
+		return bvNone(), _var(true, true)
 	case "ifelse", "cond":
 		cond := c.token == "cond"
 		if err := c.kakkohiraku(in); err != nil {
@@ -971,10 +1047,12 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string,
 				bv = bv3
 			}
 		}
-	case "time":
+	case "time", "statetime":
 		out.append(OC_time)
 	case "alive":
 		out.append(OC_alive)
+	case "ctrl":
+		out.append(OC_ctrl)
 	case "random":
 		out.append(OC_random)
 	case "roundstate":
@@ -1005,8 +1083,10 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string,
 	case "animtime":
 		out.append(OC_animtime)
 	case "animelem":
-		if _, err = c.kyuushiki(in); err != nil {
+		if not, err := c.kyuushiki(in); err != nil {
 			return bvNone(), err
+		} else if not && !sys.ignoreMostErrors {
+			return bvNone(), Error("animelemに != は使えません")
 		}
 		if c.token == "-" {
 			return bvNone(), Error("マイナスが付くとエラーです")
@@ -1161,6 +1241,14 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string,
 		out.append(OC_bottomedge)
 	case "power":
 		out.append(OC_power)
+	case "roundsexisted":
+		out.append(OC_roundsexisted)
+	case "gametime":
+		out.append(OC_gametime)
+	case "hitfall":
+		out.append(OC_hitfall)
+	case "win":
+		out.append(OC_ex_, OC_ex_win)
 	case "ishelper":
 		if _, err := c.oneArg(out, in, rd, true, BytecodeInt(-1)); err != nil {
 			return bvNone(), err
@@ -1171,10 +1259,11 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string,
 			return bvNone(), err
 		}
 		out.append(OC_numhelper)
-	case "roundsexisted":
-		out.append(OC_roundsexisted)
 	case "teammode":
 		if err := eqne(func() error {
+			if len(c.token) == 0 {
+				return Error("teammodeの値が指定されていません")
+			}
 			var tm TeamMode
 			switch c.token {
 			case "single":
@@ -1191,10 +1280,90 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string,
 		}); err != nil {
 			return bvNone(), err
 		}
-	case "win":
-		out.append(OC_ex_, OC_ex_win)
-	case "ctrl":
-		out.append(OC_ctrl)
+	case "statetype", "p2statetype":
+		trname := c.token
+		if err := eqne2(func(not bool) error {
+			if len(c.token) == 0 {
+				return Error(trname + "の値が指定されていません")
+			}
+			var st StateType
+			switch c.token[0] {
+			case 's':
+				st = ST_S
+			case 'c':
+				st = ST_C
+			case 'a':
+				st = ST_A
+			case 'l':
+				st = ST_L
+			default:
+				return Error(c.token + "が無効な値です")
+			}
+			if trname == "p2statetype" {
+				out.appendI32Op(OC_p2, 2+Btoi(not))
+			}
+			out.append(OC_statetype, OpCode(st))
+			if not {
+				out.append(OC_blnot)
+			}
+			return nil
+		}); err != nil {
+			return bvNone(), err
+		}
+	case "movetype", "p2movetype":
+		trname := c.token
+		if err := eqne2(func(not bool) error {
+			if len(c.token) == 0 {
+				return Error(trname + "の値が指定されていません")
+			}
+			var mt MoveType
+			switch c.token[0] {
+			case 'i':
+				mt = MT_I
+			case 'a':
+				mt = MT_A
+			case 'h':
+				mt = MT_H
+			default:
+				return Error(c.token + "が無効な値です")
+			}
+			if trname == "p2movetype" {
+				out.appendI32Op(OC_p2, 2+Btoi(not))
+			}
+			out.append(OC_movetype, OpCode(mt))
+			if not {
+				out.append(OC_blnot)
+			}
+			return nil
+		}); err != nil {
+			return bvNone(), err
+		}
+	case "hitdefattr":
+		hda := func() error {
+			if attr, err := c.trgAttr(in); err != nil {
+				return err
+			} else {
+				out.appendI32Op(OC_hitdefattr, attr)
+			}
+			return nil
+		}
+		if sys.cgi[c.playerNo].ver[0] == 1 {
+			if err := eqne(hda); err != nil {
+				return bvNone(), err
+			}
+		} else {
+			if not, err := c.kyuushiki(in); err != nil {
+				if sys.ignoreMostErrors {
+					out.appendValue(BytecodeBool(false))
+				} else {
+					return bvNone(), err
+				}
+			} else if err := hda(); err != nil {
+				return bvNone(), err
+			} else if not && !sys.ignoreMostErrors {
+				return bvNone(), Error("旧バージョンのためhitdefattrに != は使えません")
+			}
+		}
 	case "abs":
 		if bv, err = c.mathFunc(out, in, rd, OC_abs, out.abs); err != nil {
 			return bvNone(), err
@@ -1356,6 +1525,48 @@ func (c *Compiler) expValue(out *BytecodeExp, in *string,
 		if err := c.kakkotojiru(in); err != nil {
 			return bvNone(), err
 		}
+	case "const240p":
+		if bv, err = c.oneArg(&be1, in, false, false); err != nil {
+			return bvNone(), err
+		}
+		if bv.IsNone() {
+			if rd {
+				out.append(OC_rdreset)
+			}
+			out.append(be1...)
+			out.appendValue(BytecodeFloat(1))
+			out.append(OC_mul)
+		} else {
+			out.mul(&bv, BytecodeFloat(1))
+		}
+	case "const480p":
+		if bv, err = c.oneArg(&be1, in, false, false); err != nil {
+			return bvNone(), err
+		}
+		if bv.IsNone() {
+			if rd {
+				out.append(OC_rdreset)
+			}
+			out.append(be1...)
+			out.appendValue(BytecodeFloat(0.5))
+			out.append(OC_mul)
+		} else {
+			out.mul(&bv, BytecodeFloat(0.5))
+		}
+	case "const720p":
+		if bv, err = c.oneArg(&be1, in, false, false); err != nil {
+			return bvNone(), err
+		}
+		if bv.IsNone() {
+			if rd {
+				out.append(OC_rdreset)
+			}
+			out.append(be1...)
+			out.appendValue(BytecodeFloat(0.25))
+			out.append(OC_mul)
+		} else {
+			out.mul(&bv, BytecodeFloat(0.25))
+		}
 	case "const":
 		if err := c.kakkohiraku(in); err != nil {
 			return bvNone(), err
@@ -1580,19 +1791,21 @@ func (c *Compiler) expPostNot(out *BytecodeExp, in *string) (BytecodeValue,
 	if err != nil {
 		return bvNone(), err
 	}
-	for c.token == "!" {
-		c.usiroOp = true
-		if bv.IsNone() {
-			out.append(OC_blnot)
-		} else {
-			out.blnot(&bv)
+	if sys.ignoreMostErrors {
+		for c.token == "!" {
+			c.usiroOp = true
+			if bv.IsNone() {
+				out.append(OC_blnot)
+			} else {
+				out.blnot(&bv)
+			}
+			c.token = c.tokenizer(in)
 		}
-		c.token = c.tokenizer(in)
 	}
 	if len(c.maeOp) == 0 {
 		opp := c.isOperator(c.token)
 		if opp == 0 {
-			if !c.usiroOp && c.token == "(" {
+			if !sys.ignoreMostErrors || !c.usiroOp && c.token == "(" {
 				return bvNone(), Error("演算子がありません")
 			}
 			oldtoken, oldin := c.token, *in
@@ -4842,6 +5055,60 @@ func (c *Compiler) envColor(is IniSection, sc *StateControllerBase,
 	})
 	return *ret, err
 }
+func (c *Compiler) displayToClipboardSub(is IniSection,
+	sc *StateControllerBase) error {
+	if err := c.stateParam(is, "params", func(data string) error {
+		bes, err := c.exprs(data, VT_SFalse, 100000)
+		if err != nil {
+			return err
+		}
+		sc.add(displayToClipboard_params, bes)
+		return nil
+	}); err != nil {
+		return err
+	}
+	b := false
+	if err := c.stateParam(is, "text", func(data string) error {
+		b = true
+		_else := false
+		if len(data) >= 2 && data[0] == '"' {
+			data = data[1:]
+			if i := strings.Index(data, "\""); i >= 0 {
+				data = data[:i]
+			} else {
+				_else = true
+			}
+		} else {
+			_else = true
+		}
+		if _else {
+			return Error("\"で囲まれていません")
+		}
+		sc.add(displayToClipboard_text,
+			sc.iToExp(int32(sys.stringPool[c.playerNo].Add(data))))
+		return nil
+	}); err != nil {
+		return err
+	}
+	if !b {
+		return Error("textが指定されていません")
+	}
+	return nil
+}
+func (c *Compiler) displayToClipboard(is IniSection, sc *StateControllerBase,
+	_ int8) (StateController, error) {
+	ret, err := (*displayToClipboard)(sc), c.stateSec(is, func() error {
+		return c.displayToClipboardSub(is, sc)
+	})
+	return *ret, err
+}
+func (c *Compiler) appendToClipboard(is IniSection, sc *StateControllerBase,
+	_ int8) (StateController, error) {
+	ret, err := (*appendToClipboard)(sc), c.stateSec(is, func() error {
+		return c.displayToClipboardSub(is, sc)
+	})
+	return *ret, err
+}
 func (c *Compiler) stateCompile(bc *Bytecode, filename, def string) error {
 	var str string
 	fnz := filename
@@ -5133,16 +5400,19 @@ func (c *Compiler) readString(line *string) (string, error) {
 	*line = (*line)[i+1:]
 	return s, nil
 }
-func (c *Compiler) readSentenceLine(line *string) (s string, err error) {
+func (c *Compiler) readSentenceLine(line *string) (s string, assign bool,
+	err error) {
 	c.token = ""
 	offset := 0
 	for {
 		i := strings.IndexAny((*line)[offset:], ";#\"{}")
 		if i < 0 {
+			assign = assign || strings.Index((*line)[offset:], ":=") >= 0
 			s, *line = *line, ""
 			return
 		}
 		i += offset
+		assign = assign || strings.Index((*line)[offset:i], ":=") >= 0
 		switch (*line)[i] {
 		case ';', '{', '}':
 			c.token = (*line)[i : i+1]
@@ -5152,7 +5422,7 @@ func (c *Compiler) readSentenceLine(line *string) (s string, err error) {
 		case '"':
 			tmp := (*line)[i+1:]
 			if _, err := c.readString(&tmp); err != nil {
-				return "", err
+				return "", false, err
 			}
 			offset = len(*line) - len(tmp)
 			continue
@@ -5161,10 +5431,10 @@ func (c *Compiler) readSentenceLine(line *string) (s string, err error) {
 	}
 	return
 }
-func (c *Compiler) readSentence(line *string) (s string, err error) {
-	sen, err := c.readSentenceLine(line)
-	if err != nil {
-		return "", err
+func (c *Compiler) readSentence(line *string) (s string, a bool, err error) {
+
+	if s, a, err = c.readSentenceLine(line); err != nil {
+		return
 	}
 	for c.token == "" {
 		var ok bool
@@ -5172,13 +5442,14 @@ func (c *Compiler) readSentence(line *string) (s string, err error) {
 		if !ok {
 			break
 		}
-		s, err := c.readSentenceLine(line)
-		if err != nil {
-			return "", err
+		if sen, ass, err := c.readSentenceLine(line); err != nil {
+			return "", false, err
+		} else {
+			s += "\n" + sen
+			a = a || ass
 		}
-		sen += "\n" + s
 	}
-	return strings.TrimSpace(sen), nil
+	return strings.TrimSpace(s), a, nil
 }
 func (c *Compiler) statementEnd(line *string) error {
 	c.token = c.tokenizer(line)
@@ -5201,7 +5472,7 @@ func (c *Compiler) readKeyValue(is IniSection, end string,
 	if err := c.needToken(":"); err != nil {
 		return err
 	}
-	data, err := c.readSentence(line)
+	data, _, err := c.readSentence(line)
 	if err != nil {
 		return err
 	}
@@ -5214,7 +5485,7 @@ func (c *Compiler) subBlock(line *string,
 	switch c.token {
 	case "{":
 	case "if":
-		expr, err := c.readSentence(line)
+		expr, _, err := c.readSentence(line)
 		if err != nil {
 			return nil, err
 		}
@@ -5326,7 +5597,35 @@ func (c *Compiler) stateBlock(line *string, bl *StateBlock, root bool) error {
 				}
 				c.scan(line)
 				continue
+			} else {
+				otk := c.token
+				expr, assign, err := c.readSentence(line)
+				if err != nil {
+					return err
+				}
+				expr = otk + " " + expr
+				otk = c.token
+				if stex, err := c.fullExpression(&expr, VT_SFalse); err != nil {
+					return err
+				} else {
+					bl.ctrls = append(bl.ctrls, StateExpr(stex))
+				}
+				c.token = otk
+				if err := c.needToken(";"); err != nil {
+					return err
+				}
+				if !assign {
+					return Error("値が利用されない式")
+				}
+				if root {
+					if err := c.statementEnd(line); err != nil {
+						return err
+					}
+				}
+				c.scan(line)
+				continue
 			}
+		case "varset", "varadd":
 		}
 		break
 	}

--- a/src/script.go
+++ b/src/script.go
@@ -139,7 +139,7 @@ func scriptCommonInit(l *lua.LState) {
 		return 0
 	})
 	luaRegister(l, "setHomeTeam", func(l *lua.LState) int {
-		tn := int32(numArg(l, 1))
+		tn := int(numArg(l, 1))
 		if tn < 1 || tn > 2 {
 			l.RaiseError("チーム番号(%v)が不正です。", tn)
 		}

--- a/src/system.go
+++ b/src/system.go
@@ -1,6 +1,7 @@
 package main
 
 import (
+	"fmt"
 	"github.com/go-gl/gl/v2.1/gl"
 	"github.com/go-gl/glfw/v3.2/glfw"
 	"github.com/timshannon/go-openal/openal"
@@ -82,7 +83,8 @@ type System struct {
 	keyConfig                   []*KeyConfig
 	com                         [MaxSimul * 2]int32
 	autolevel                   bool
-	home                        int32
+	home                        int
+	gameTime                    int32
 	match                       int32
 	inputRemap                  [MaxSimul * 2]int
 	listenPort                  string
@@ -133,6 +135,7 @@ type System struct {
 	envcol                      [3]int32
 	envcol_time                 int32
 	envcol_under                bool
+	clipboardText               [MaxSimul * 2][]string
 }
 
 func (s *System) init(w, h int32) *lua.LState {
@@ -240,6 +243,13 @@ func (s *System) setSF(gsf GlobalSpecialFlag) {
 func (s *System) unsetSF(gsf GlobalSpecialFlag) {
 	s.specialFlag &^= gsf
 }
+func (s *System) appendToClipboard(pn, sn int, a ...interface{}) {
+	spl := s.stringPool[pn].List
+	if sn >= 0 && sn < len(spl) {
+		s.clipboardText[pn] = append(s.clipboardText[pn],
+			strings.Split(fmt.Sprintf(spl[sn], a...), "\n")...)
+	}
+}
 
 type SelectChar struct {
 	def, name            string
@@ -488,7 +498,8 @@ func (l *Loader) loadChar(pn int) int {
 		sys.cgi[pn].palno = pal
 	}
 	if sys.cgi[pn].sff == nil {
-		if l.code[pn], l.err = newCompiler().Compile(p.playerNo, cdef); l.err != nil {
+		if l.code[pn], l.err =
+			newCompiler().Compile(p.playerNo, cdef); l.err != nil {
 			sys.chars[pn] = nil
 			return -1
 		}