Forum

CS2D

Scripts

Brainfuck CS2D Scripting Interface

Forums overview CS2D overview Scripts overview Log in to reply

Brainfuck CS2D Scripting Interface

11 replies

Brainfuck CS2D Scripting Interface

Qb OP
User Off

Offline

14.08.17 03:05:20 pm

Didn't you too always want to write CS2D scripts in Brainfuck? No? Whatever you can do it anyway!

What is Brainfuck

I spend weeks(a few hours today) to write an interface that allows loading Brainfuck programs that communicate with lua to give them full control over the scripting environment. Why? For the good of all of humanity of course... and because I was bored.

How does it work? It's a lua script that can be loaded that interprets the Brainfuck programs using an interpreter I wrote yesterday. But that's not all! It keeps track of the output and buffers it. As soon as you write a null character to the output it takes that buffer and executes it using loadstring and thus executes the previous output as lua code. If your output starts with an exclamation point(!) it will read whatever was returned by loadstring into Brainfuck's input.

The input will be modified according to the following rules:

Numbers will stay as they are and will cause errors if they aren't integer numbers within the range 0-255.

Booleans will be turned into 1(true) and 0(false).

Strings will be turned into char codes (as per usual).

All other types will be turned into strings and then handled like a string.

The Brainfuck programs do one operation every tick (using an always hook).

How do you use it? It comes with a few simple commands.

_BF.add_program(program,input,callback)

     Adds a program to be executed to the system.
     program: the Brainfuck code as a string
     input: the starting setup for the input as a string
     callback: function that will be triggered whenever the program puts out a character (can be nil)

_BF.dofile(file)

Adds a program to be executed to the system with empty input and no callback.
file: the location of the Brainfuck code file

Script and Examples

MoonScript source code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153

class Brainfuck
	maximum_runtime: 16384
	
	new: (code,input,output_callback) =>
		@code=code
		@input=input
		@output_callback=output_callback
		@matrix={0}
		@memory_pointer=1
		@code_pointer=1
	
	shift_right: =>
		@memory_pointer += 1
		if @matrix[@memory_pointer]==nil
			@matrix[@memory_pointer]=0
	
	shift_left: =>
		@memory_pointer -= 1
		if @matrix[@memory_pointer]==nil
			@matrix[@memory_pointer]=0
	
	increment: =>
		@matrix[@memory_pointer]=(@matrix[@memory_pointer]+1)%256
	
	decrement: =>
		@matrix[@memory_pointer]=(@matrix[@memory_pointer]-1)%256
	
	jez_forward: =>
		if @get_value! == 0
			depth = 0
			while true
				@move_forward!
				switch @get_current_char!
					when "["
						depth += 1
					when "]"
						if depth == 0
							return nil
						else
							depth -= 1
					when nil
						return nil
	
	jnz_backward: =>
		if @get_value! != 0
			depth = 0
			while true
				@move_backward!
				switch @get_current_char!
					when "["
						if depth == 0
							return nil
						else
							depth -= 1
					when "]"
						depth += 1
					when ""
						return nil
	
	read_input: =>
		char = string.sub @input, 1, 1
		if char!=""
			@set_value string.byte char
		else
			@set_value 0
		@input = string.sub @input, 2
	
	move_forward: => @code_pointer+=1
	move_backward: => @code_pointer-=1
	get_char: (n) => string.sub @code, n, n
	get_current_char: => @get_char(@code_pointer)
	get_value: => @matrix[@memory_pointer]
	set_value: (value) => @matrix[@memory_pointer]=value
	
	append_input: (input) => @input ..= input
	
	step: =>
		ret = nil
		switch @get_current_char!
			when "["
				@jez_forward!
			when "]"
				@jnz_backward!
			when "+"
				@increment!
			when "-"
				@decrement!
			when "."
				ret=string.char @get_value!
				if @output_callback != nil
					output_callback ret
			when ","
				@read_input!
			when ">"
				@shift_right!
			when "<"
				@shift_left!
			when ""
				return false
		@move_forward!
		ret
	
	run: =>
		output=""
		for i=1,@maximum_runtime
			step=@step!
			if step==false
				break
			elseif step!=nil
				output ..= step
		output

export _BF
_BF={}
_BF.programs={}

addhook "always","_BF.step_programs"
_BF.step_programs = ->
	for key,program in pairs _BF.programs
		_BF.current_program=program
		step=program.instance\step!
		if step==false
			table.remove _BF.programs, key
		elseif step=="\0"
			write_input = (string.sub program.output_buffer, 1, 1) == "!"
			program.output_buffer = write_input and (string.sub program.output_buffer, 2) or program.output_buffer
			ret = (loadstring program.output_buffer)!
			if write_input
				switch type(ret)
					when "string"
						program.instance\append_input ret
					when "number"
						program.instance\append_input string.char ret
					when "boolean"
						program.instance\append_input (ret and "\1" or "\0")
					else
						program.instance\append_input tostring ret
			program.output_buffer=""
		elseif step!=nil
			program.output_buffer ..= step
			
_BF.add_program = (program,input,callback)->
	input = input==nil and "" or input
	program_table =
		output_buffer: "",
		instance: Brainfuck(program,input,callback)
	table.insert _BF.programs, program_table

_BF.dofile = (file) ->
    f = io.open(file, "rb")
    content = f:read("*all")
    f:close()
    _BF.add_program content, "", nil

Compiled lua Script

local Brainfuck
do
  local _class_0
  local _base_0 = {
    maximum_runtime = 16384,
    shift_right = function(self)
      self.memory_pointer = self.memory_pointer + 1
      if self.matrix[self.memory_pointer] == nil then
        self.matrix[self.memory_pointer] = 0
      end
    end,
    shift_left = function(self)
      self.memory_pointer = self.memory_pointer - 1
      if self.matrix[self.memory_pointer] == nil then
        self.matrix[self.memory_pointer] = 0
      end
    end,
    increment = function(self)
      self.matrix[self.memory_pointer] = (self.matrix[self.memory_pointer] + 1) % 256
    end,
    decrement = function(self)
      self.matrix[self.memory_pointer] = (self.matrix[self.memory_pointer] - 1) % 256
    end,
    jez_forward = function(self)
      if self:get_value() == 0 then
        local depth = 0
        while true do
          self:move_forward()
          local _exp_0 = self:get_current_char()
          if "[" == _exp_0 then
            depth = depth + 1
          elseif "]" == _exp_0 then
            if depth == 0 then
              return nil
            else
              depth = depth - 1
            end
          elseif nil == _exp_0 then
            return nil
          end
        end
      end
    end,
    jnz_backward = function(self)
      if self:get_value() ~= 0 then
        local depth = 0
        while true do
          self:move_backward()
          local _exp_0 = self:get_current_char()
          if "[" == _exp_0 then
            if depth == 0 then
              return nil
            else
              depth = depth - 1
            end
          elseif "]" == _exp_0 then
            depth = depth + 1
          elseif "" == _exp_0 then
            return nil
          end
        end
      end
    end,
    read_input = function(self)
      local char = string.sub(self.input, 1, 1)
      if char ~= "" then
        self:set_value(string.byte(char))
      else
        self:set_value(0)
      end
      self.input = string.sub(self.input, 2)
    end,
    move_forward = function(self)
      self.code_pointer = self.code_pointer + 1
    end,
    move_backward = function(self)
      self.code_pointer = self.code_pointer - 1
    end,
    get_char = function(self, n)
      return string.sub(self.code, n, n)
    end,
    get_current_char = function(self)
      return self:get_char(self.code_pointer)
    end,
    get_value = function(self)
      return self.matrix[self.memory_pointer]
    end,
    set_value = function(self, value)
      self.matrix[self.memory_pointer] = value
    end,
    append_input = function(self, input)
      self.input = self.input .. input
    end,
    step = function(self)
      local ret = nil
      local _exp_0 = self:get_current_char()
      if "[" == _exp_0 then
        self:jez_forward()
      elseif "]" == _exp_0 then
        self:jnz_backward()
      elseif "+" == _exp_0 then
        self:increment()
      elseif "-" == _exp_0 then
        self:decrement()
      elseif "." == _exp_0 then
        ret = string.char(self:get_value())
        if self.output_callback ~= nil then
          output_callback(ret)
        end
      elseif "," == _exp_0 then
        self:read_input()
      elseif ">" == _exp_0 then
        self:shift_right()
      elseif "<" == _exp_0 then
        self:shift_left()
      elseif "" == _exp_0 then
        return false
      end
      self:move_forward()
      return ret
    end,
    run = function(self)
      local output = ""
      for i = 1, self.maximum_runtime do
        local step = self:step()
        if step == false then
          break
        elseif step ~= nil then
          output = output .. step
        end
      end
      return output
    end
  }
  _base_0.__index = _base_0
  _class_0 = setmetatable({
    __init = function(self, code, input, output_callback)
      self.code = code
      self.input = input
      self.output_callback = output_callback
      self.matrix = {
        0
      }
      self.memory_pointer = 1
      self.code_pointer = 1
    end,
    __base = _base_0,
    __name = "Brainfuck"
  }, {
    __index = _base_0,
    __call = function(cls, ...)
      local _self_0 = setmetatable({}, _base_0)
      cls.__init(_self_0, ...)
      return _self_0
    end
  })
  _base_0.__class = _class_0
  Brainfuck = _class_0
end
_BF = { }
_BF.programs = { }
addhook("always", "_BF.step_programs")
_BF.step_programs = function()
  for key, program in pairs(_BF.programs) do
    _BF.current_program = program
    local step = program.instance:step()
    if step == false then
      table.remove(_BF.programs, key)
    elseif step == "\0" then
      local write_input = (string.sub(program.output_buffer, 1, 1)) == "!"
      program.output_buffer = write_input and (string.sub(program.output_buffer, 2)) or program.output_buffer
      local ret = (loadstring(program.output_buffer))()
      if write_input then
        local _exp_0 = type(ret)
        if "string" == _exp_0 then
          program.instance:append_input(ret)
        elseif "number" == _exp_0 then
          if ret < 255.5 and ret >= -0.5 then
            program.instance:append_input(string.char(math.floor(a + 0.5)))
          else
            program.instance:append_input(tostring(ret))
          end
        else
          program.instance:append_input(tostring(ret))
        end
      end
      program.output_buffer = ""
    elseif step ~= nil then
      program.output_buffer = program.output_buffer .. step
    end
  end
end
_BF.add_program = function(program, input, callback)
  input = input == nil and "" or input
  local program_table = {
    output_buffer = "",
    instance = Brainfuck(program, input, callback)
  }
  return table.insert(_BF.programs, program_table)
end

Example: print to console

This program executes

print("Hello World!")

_BF.add_program("+[------->++<]>++.++.---------.+++++.++++++.+[--->+<]>+.------.++[->++<]>.-[->+++++<]>++.+++++++..+++.[--->+<]>-----.---[->+++<]>.-[--->+<]>---.+++.------.--------.-[--->+<]>.+.+++++++.>>>.","")

Example: evaluate to input

This program executes

!return "abc"

and thus writes "abc" into it's own input. After that it engages an infinite loop.

_BF.add_program("++++[->++++++++<]>+.+++++[->+++<]>.-------------.[--->+<]>---.+.---.----.-[->+++++<]>-.++.+[--->+<]>.+.+.[--->+<]>+.>>>.+[]","")

The files can be downloaded here: file

Brainfuck+TISfuck CS2D Scripting Interfaces (6)

In case it wasn't clear enough: This is a joke and should not be taken seriously. The execution of Brainfuck scripts is very slow this way and Brainfuck is not a language that should be used seriously anyway.

I hope you like what I did and maybe even learned a thing or two. Have a nice day!
Necro

edited 3×, last 22.08.17 12:44:48 pm

Re: Brainfuck CS2D Scripting Interface

Yates
Reviewer Off

Offline

14.08.17 03:07:46 pm

Now do Lisp.

Re: Brainfuck CS2D Scripting Interface

_Yank
User Off

Offline

14.08.17 03:18:40 pm

jesus

Re: Brainfuck CS2D Scripting Interface

ohaz
User Off

Offline

14.08.17 03:26:51 pm

-[------->+<]>.-[->++++<]>.++[--->++<]>.---.++.------.--[--->+<]>-.--[->++++<]>-.+[->+++<]>.---.+++++++++++++.-------------.--[--->+<]>-.---[->++++<]>.------------.+.++++++++++.+[---->+<]>+++.-[--->++<]>-.++++++++++.+[---->+<]>+++.++[->+++<]>+.++++++++.------.+++++.-------.

Spoiler

Re: Brainfuck CS2D Scripting Interface

SQ
Moderator Off

Offline

14.08.17 03:32:21 pm

I'll write a new mod in this. Good luck editing it.

Re: Brainfuck CS2D Scripting Interface

mrc
User

Offline

14.08.17 05:20:38 pm

Why dont u use ur knowledge to make good stuffs for the game instead of these useless things.

TISfuck

Qb OP
User Off

Offline

16.08.17 01:45:49 pm

I'm glad you seem to like it.

I've been working on own more advanced language based on Brainfuck.

TISfuck specification

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

TISfuck

It's Brainfuck with a few extras. It was inspired by TIS-100 by Zachtronics.
There is a tranferable memory cell that is unaffected by pointer shifts.
There are multiple lines. The program wraps around to the beginning of the next line after the end of the end of a line. After the last line it wraps around to the top line again. The program only halts when told to do so.
There are a few new commands and existing commands can optionally take numbers as parameters to slightly alter their behaviour.

+		Adds 1 to current cell
-		Subtracts 1 from current cell
<		Shifts pointer 1 to the left
>		Shifts pointer 1 to the right
.		Puts out the current cell's value
[		Jump forward to the matching ] or the next line if the current cell's value is 0
]		Jump backward to the matching [ or the previous line if the current cell's value is not 0
*		Sets the current cell's value to 0
!		Sets the transferable memory's value to the current cell's value
;		Halt program unconditionally
^		Jump upward 1 line
v		Jump downward 1 line

,		Read an input to the current cell
:		Swaps the current cell's value with the transferable memory's value

+FF		Adds 255 to current cell
-FF		Subtracts 255 from current cell
<FF		Shifts pointer 255 to the left
>FF		Shifts pointer 255 to the right
.FF		Puts out 255
[FF		Jump forward to the matching ] or the next line if the current cell's value is 255
]FF		Jump backward to the matching [ or the previous line if the current cell's value is not 255
*FF		Sets the current cell's value to zero or value
!FF		Sets the transferable memory's value to 255
;FF		Halt program if the current cell's value is FF
^FF		Jump upward 255 lines
vFF		Jump downward 255 lines
~		Can be used instead of numbers to target the current cell's value instead
?		Can be used instead of numbers to target the transferable memory's value instead

And I have modified my Brainfuck interpreter to work on TISfuck instead. PASTEBIN

I might also make a CS2D interface for it and I'll fix the minor bugs my Brainfuck interpreter has.

@ user

Yates: I get it was meant as a joke but I still looked into LISP but I won't make an interface for that. The reason being that I don't want to write an interpreter for it. There are lua LISP interpreters and even pure lua implementations out there but I think it would be boring just to use one of those.

@ user

mrc: I make this useless stuff because I think it's a fun way to challenge myself. But because you asked for it I think I can do a custom game mode script. I already have an idea of what it should be like. I won't start creating it right away though.

.48*61..76.65.20..20.6E.69.63.65.20.64..79.21;

Spoiler

edited 4×, last 17.08.17 09:19:59 pm

Re: Brainfuck CS2D Scripting Interface

xsiN
User Off

Offline

16.08.17 01:56:56 pm

I've heard about that scripting language, my senpai made it look really difficult to use and I agree with him.

those symbols are truly made to brainfuck people

Re: Brainfuck CS2D Scripting Interface

Yates
Reviewer Off

Offline

16.08.17 02:41:26 pm

Qb:

1
2
3
4
5
6
7
8

(DEFUN RIP ()
    "RIP LISP")

(DEFUN LISPTOLUA ()
    nil)

(if (NOT (LISPTOLUA))
    (PRINT (RIP)))

(Lisp (is (a great) programming (language)) and (should be (more (widespread)))
(please (consider) Lisp's (feelings)))

Re: Brainfuck CS2D Scripting Interface

Qb OP
User Off

Offline

18.08.17 05:59:42 pm

I just released the TISfuck Scripting Interface: file

Brainfuck+TISfuck CS2D Scripting Interfaces (6)

@ user

Yates: It's not that I don't like LISP. It's just that it's far more complex than Brainfuck and TISfuck will ever be. It would be far too much work for what is essentially a joke.

Re: Brainfuck CS2D Scripting Interface

Yates
Reviewer Off

Offline

18.08.17 06:47:32 pm

Qb: I know I'm just making fun of Lisp leave me be :p

Re: Brainfuck CS2D Scripting Interface

omg
User

Offline

21.08.17 04:22:46 am

this has nothing on subleq (the 1 instruction by itself can compute anything)
actually, someone made a (limited) C to subleq program which blows my mind (higher subleq)