예제 #1
0
파일: slice.go 프로젝트: EncoreJiang/luar
func main() {
	lua := `
    fn = function(obj)
      slice = obj.GetSlice()
      print(type(slice), #slice)
      obj = slice[1]  -- slice[2] will raise a 'index out of range' error
      -- obj.Naam = 'howzit'  -- will raise a 'no field' error
      name = obj.GetName() 
      return name
    end
  `
	L := luar.Init()
	defer L.Close()

	L.DoString(lua)

	luafn := luar.NewLuaObjectFromName(L, "fn")
	gobj := NewStructWithSlice("string")
	res, err := luafn.Call(gobj)
	if err != nil {
		fmt.Println("error!", err)
	} else {
		fmt.Println("result", res)
	}
}
예제 #2
0
파일: luar3.go 프로젝트: EncoreJiang/luar
func main() {
	L := luar.Init()
	defer L.Close()

	L.GetGlobal("print")
	print := luar.NewLuaObject(L, -1)
	print.Call("one two", 12)

	L.GetGlobal("package")
	pack := luar.NewLuaObject(L, -1)
	fmt.Println(pack.Get("path"))

	lcopy := luar.NewLuaObjectFromValue

	gsub := luar.NewLuaObjectFromName(L, "string.gsub")

	rmap := lcopy(L, luar.Map{
		"NAME": "Dolly",
		"HOME": "where you belong",
	})

	res, err := gsub.Call("hello $NAME go $HOME", "%$(%u+)", rmap)
	if res == nil {
		fmt.Println("error", err)
	} else {
		fmt.Println("result", res)
	}

}
예제 #3
0
func main() {
	L := luar.Init()
	defer L.Close()

	L.GetGlobal("print")
	print := luar.NewLuaObject(L, -1)
	print.Call("one two", 12)

	L.GetGlobal("package")
	pack := luar.NewLuaObject(L, -1)
	fmt.Println(pack.Get("path"))

	/*
	   L.GetGlobal("string")
	   strtab := luar.NewLuaObject(L,-1)
	   iter := strtab.Iter()
	   for iter.Next() {
	       fmt.Println(iter.Key,iter.Value)
	   }
	*/

	gsub := luar.NewLuaObjectFromName(L, "string.gsub")
	res, err := gsub.Call("hello $NAME go $HOME", "%$(%u+)", luar.Map{
		"NAME": "Dolly",
		"HOME": "where you belong",
	})
	if res == nil {
		fmt.Println("error", err)
	} else {
		fmt.Println("result", res)
	}

}
예제 #4
0
func (r Runtime) CallPlugin(name, function string, args []interface{}) (interface{}, error) {
	luafn := luar.NewLuaObjectFromName(r.plugins[name], function)
	value, err := luafn.Call(args...)
	if err != nil {
		return nil, err
	}
	return value, nil
}
예제 #5
0
파일: main.go 프로젝트: jeromer/haiconf
func (c *Conf) RunMain() {
	fun := luar.NewLuaObjectFromName(c.l, "Main")
	_, err := fun.Call()

	if err != nil {
		panic(err)
	}
}
예제 #6
0
파일: luatest.go 프로젝트: yc7369/gostudy
func main() {
	whj := "wang::hai::jun"
	fmt.Println(strings.Split(whj, "::"))
	TestCall("111")
	L := luar.Init()
	defer L.Close()
	M := luar.Map{
		"one":   "ein",
		"two":   "zwei",
		"three": "drei",
	}

	S := []string{"alfred", "alice", "bob", "frodo"}

	ST := &MyStruct{"Dolly", 46}

	luar.Register(L, "", luar.Map{
		"Print":    fmt.Println,
		"testcall": TestCall,
		"print":    fmt.Println,
		"MSG":      "hello", // can also register constants
		"M":        M,
		"S":        S,
		"ST":       ST,
	})

	//L.DoString(test)
	L.DoString(code)
	L.GetGlobal("print")
	print := luar.NewLuaObject(L, -1)
	print.Call("one two", 12)

	L.GetGlobal("package")
	pack := luar.NewLuaObject(L, -1)
	fmt.Println(pack.Get("path"))

	lcopy := luar.NewLuaObjectFromValue

	gsub := luar.NewLuaObjectFromName(L, "string.gsub")

	rmap := lcopy(L, luar.Map{
		"NAME": "Dolly",
		"HOME": "where you belong",
	})

	res, err := gsub.Call("hello $NAME go $HOME", "%$(%u+)", rmap)
	if res == nil {
		fmt.Println("error", err)
	} else {
		fmt.Println("\033[0;31mresult\033[0m", res)
	}

}
예제 #7
0
파일: script.go 프로젝트: imvu/Tetra
// AddLuaHook adds a named hook from lua.
func (script *Script) AddLuaHook(verb string, name string) error {
	function := luar.NewLuaObjectFromName(script.L, name)

	hook := NewHook(verb, func(args ...interface{}) {
		script.Trigger <- []interface{}{
			INV_NAMHOOK, function, args,
		}
	})

	script.Hooks = append(script.Hooks, hook)

	return nil
}
예제 #8
0
파일: script.go 프로젝트: imvu/Tetra
// AddLuaProtohook adds a lua function as a protocol hook.
func (script *Script) AddLuaProtohook(verb string, name string) error {
	function := luar.NewLuaObjectFromName(script.L, name)

	handler, err := AddHandler(verb, func(line *r1459.RawLine) {
		debugf("sending %s", verb)
		script.Trigger <- []interface{}{INV_PROHOOK, function, line}
	})
	if err != nil {
		return err
	}

	handler.Script = script
	script.Handlers[handler.Uuid] = handler

	return nil
}
예제 #9
0
func ExampleNewLuaObjectFromValue() {
	L := luar.Init()
	defer L.Close()

	gsub := luar.NewLuaObjectFromName(L, "string.gsub")

	// We do have to explicitly copy the map to a Lua table, because `gsub`
	// will not handle userdata types.
	gmap := luar.NewLuaObjectFromValue(L, luar.Map{
		"NAME": "Dolly",
		"HOME": "where you belong",
	})
	res, err := gsub.Call("hello $NAME go $HOME", "%$(%u+)", gmap)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(res)
	// Output:
	// hello Dolly go where you belong
}
예제 #10
0
파일: script.go 프로젝트: imvu/Tetra
// AddLuaCommand adds a new command to a script from a lua context.
func (script *Script) AddLuaCommand(verb string, name string) error {
	function := luar.NewLuaObjectFromName(script.L, name)

	command, err := script.Client.NewCommand(verb, func(client *Client, target Targeter, args []string) string {
		reschan := make(chan string)
		defer close(reschan)

		script.Trigger <- []interface{}{
			INV_COMMAND, function, client, target, args, reschan,
		}

		return <-reschan
	})

	if err != nil {
		return err
	}

	command.Script = script

	script.Commands[command.Uuid] = command

	return nil
}
예제 #11
0
func ExampleLuaObject_Callf() {
	L := luar.Init()
	defer L.Close()

	returns := luar.Types([]string{}) // []reflect.Type

	const code = `
function return_strings()
    return {'one', luar.null, 'three'}
end`

	err := L.DoString(code)
	if err != nil {
		log.Fatal(err)
	}

	fun := luar.NewLuaObjectFromName(L, "return_strings")
	// Using `Call` we would get a generic `[]interface{}`, which is awkward to
	// work with. But the return type can be specified:
	results, err := fun.Callf(returns)
	if err != nil {
		log.Fatal(err)
	}

	strs := results[0].([]string)

	fmt.Println(strs[0])
	// We get an empty string corresponding to a luar.null in a table,
	// since that's the empty 'zero' value for a string.
	fmt.Println(strs[1])
	fmt.Println(strs[2])
	// Output:
	// one
	//
	// three
}
예제 #12
0
파일: luar.go 프로젝트: EncoreJiang/luar
func main() {
	history := os.Getenv("HOME") + "/.luar_history"
	linenoise.LoadHistory(history)

	defer func() {
		L.Close()
		linenoise.SaveHistory(history)
		if x := recover(); x != nil {
			fmt.Println("runtime " + x.(error).Error())
		}
	}()

	luar.Register(L, "", luar.Map{
		"__DUMMY__": &Dummy{"me"},
	})

	// most of this program's code is Lua....
	err := L.DoString(lua_code)
	if err != nil {
		fmt.Println("initial " + err.Error())
		return
	}
	// particularly the completion logic
	complete := luar.NewLuaObjectFromName(L, "lua_candidates")
	// this function returns a string slice of candidates
	str_slice := luar.Types([]string{})

	linenoise.SetCompletionHandler(func(in string) []string {
		val, err := complete.Callf(str_slice, in)
		if err != nil || len(val) == 1 && val[0] == nil {
			return []string{}
		} else {
			return val[0].([]string)
		}
	})

	register()

	fmt.Println("luar 1.2 Copyright (C) 2013-2014 Steve Donovan")
	fmt.Println("Lua 5.1.4  Copyright (C) 1994-2008 Lua.org, PUC-Rio")

	prompt := LUA_PROMPT1
	code := ""

	for {
		// ctrl-C/ctrl-D handling with latest update of go.linenoise
		str, err := linenoise.Line(prompt)
		if err != nil {
			return
		}
		if len(str) > 0 {
			if str == "exit" {
				return
			}
			linenoise.AddHistory(str)
			if str[0] == '=' || str[0] == '.' {
				exprs := str[1:]
				if str[0] == '=' {
					str = "pprint(" + exprs + ")"
				} else {
					str = "println(" + exprs + ")"
				}
			}
			continuing := false
			code = code + str
			//fmt.Println("'"+code+"'")
			err := L.DoString(code)
			if err != nil {
				errs := err.Error()
				// fmt.Println("err",errs)
				// strip line nonsense if error occurred on prompt
				idx := strings.Index(errs, ": ")
				if idx > -1 && strings.HasPrefix(errs, "[string ") {
					errs = errs[idx+2:]
				}
				// need to keep collecting line?
				if strings.HasSuffix(errs, "near '<eof>'") {
					continuing = true
				} else {
					fmt.Println(errs)
				}
			}
			if continuing { // prompt must reflect continuing state
				prompt = LUA_PROMPT2
				code = code + "\n"
			} else {
				prompt = LUA_PROMPT1
				code = ""
			}
		} else {
			fmt.Println("empty line. Use exit to get out")
		}
	}
}
예제 #13
0
// Handle Directionals
func (gs *GameServer) HandleMovementPacket(cp *ClientPacket) {
	action := cp.Data.(game.Action)
	p := cp.Client.Player
	offset := game.DirTable[action]
	oldposx, oldposy := p.GetPos()
	newpos := image.Pt(oldposx+offset.X, oldposy+offset.Y)
	valid := true

	// check terrain collision
	if !gs.Map.CheckCollision(nil, newpos) {
		valid = false
		cp.Reply(gnet.NewPacket("Rchat", "Ouch! You bump into a wall."))
	}

	// check gameobject collision
	for o := range gs.Objects.Chan() {

		// check if collision with Item and item name is flag
		px, py := o.GetPos()
		if px == newpos.X && py == newpos.Y {
			collfn := luar.NewLuaObjectFromName(gs.Lua, "collide")
			res, err := collfn.Call(p, o)
			if err != nil {
				log.Printf("GameServer: HandleMovementPacket: Lua error: %s", err)
				return
			}

			// only update position if collide returns true
			if thebool, ok := res.(bool); !ok || !thebool {
				log.Printf("GameServer: HandleMovementPacket: Lua collision failed")
				valid = false
			} else {
				// tell everyone that the colliders changed
				gs.SendPacketAll(gnet.NewPacket("Raction", o))
			}

			if o.GetTag("player") {
				cp.Reply(gnet.NewPacket("Rchat", fmt.Sprintf("Ouch! You bump into %s.", o.GetName())))

				// check if other player's got the goods
				for sub := range o.GetSubObjects().Chan() {
					if sub.GetTag("item") == true {
						// swap pop'n'lock

						// remove item from player
						swap := o.RemoveSubObject(sub)
						p.AddSubObject(swap)
						cp.Reply(gnet.NewPacket("Rchat", fmt.Sprintf("You steal a %s!", swap.GetName())))
					}
				}
			}

			if o.GetTag("item") && o.GetTag("gettable") && valid {
				cp.Reply(gnet.NewPacket("Rchat", fmt.Sprintf("You see a %s here.", o.GetName())))
			}
		}
	}

	if valid {
		cp.Client.Player.SetPos(newpos.X, newpos.Y)
		//gs.SendPacketAll(gnet.NewPacket("Raction", p))
	}

}