burn 0.1.3 → 0.2.0

data/lib/burn/config/loader.rb

@@ -0,0 +1,23 @@
+module Burn
+  module Configuration
+    class Loader
+      attr_reader :server, :app
+      
+      def initialize(code)
+        @server = Server.new
+        @app = App.new
+        self.instance_eval code
+      end
+      
+      def method_missing(method_symbol, *args, &block)
+        if method_symbol == :config then
+          if args[0] == :server then
+            @server.instance_eval &block
+          elsif args[0] == :app then
+            @app.instance_eval &block
+          end
+        end
+      end
+    end
+  end
+end

data/lib/burn/config/server.rb

@@ -0,0 +1,11 @@
+module Burn
+  module Configuration
+    class Server < ConfigBase
+      def initialize
+        @ip_addr = '127.0.0.1'
+        @port = 60000
+        @max_clients = 1
+      end
+    end
+  end
+end

data/lib/burn/fuel.rb

@@ -0,0 +1,11 @@
+require 'burn/fuel/dsl_base'
+require 'burn/fuel/rom/sound_effect'
+require 'burn/fuel/rom/note'
+require 'burn/fuel/rom/channel_stream'
+require 'burn/fuel/rom/declare'
+require 'burn/fuel/rom/sound'
+require 'burn/fuel/rom/music'
+require 'burn/fuel/rom/scene'
+
+require 'burn/fuel/telnet/declare'
+require 'burn/fuel/telnet/scene'

data/lib/burn/{dsl → fuel}/dsl_base.rb

@@ -1,5 +1,5 @@
 module Burn
-  module Dsl
+  module Fuel
     class DslBase
       # blankslate
       instance_methods.each do |m|

data/lib/burn/fuel/rom/channel_stream.rb

@@ -0,0 +1,106 @@
+module Burn
+  module Fuel
+    module Rom
+      class ChannelStream
+        # tempo 193 ~ 211 (18 levels, 202 is median)
+        # see: http://ja.wikipedia.org/wiki/%E6%BC%94%E5%A5%8F%E8%A8%98%E5%8F%B7
+        TEMPO_BASE = 192
+        PRESTO = 1 + TEMPO_BASE
+        ALLEGRO = 2 + TEMPO_BASE
+        MODERATO = 3 + TEMPO_BASE
+        ANDANTE = 4 + TEMPO_BASE
+        ADAGIO = 5 + TEMPO_BASE
+        LARGO = 6 + TEMPO_BASE
+        
+        # instrument number 64~126 (62steps) *note* no sound for 64, 65~72 seems working right now
+        BASS = 65
+        PIANO = 66
+        STRING = 67
+        ARPEGGIO = 68
+        STEP = 69
+        BELL = 70
+        ACOUSTIC = 71
+        GUITAR = 72
+        THEREMIN = 73
+        
+        def initialize(index, instrument, tempo)
+          @index = index
+          
+          @duration_list = [:half, :quarter, :eighth, :sixteenth]
+          @duration_numeric_list = {2=>:half, 4=>:quarter, 8=>:eighth, 16=>:sixteenth}
+          @duration_symbol_list = [:dotted, :triplet]
+          @articulation_list = [:tenuto, :staccato, :accent]
+          @instrument_list = [:piano, :bass]
+          
+          @notes = Array.new
+          @notes << ChannelStream.const_get(tempo.upcase)
+          @notes << ChannelStream.const_get(instrument.upcase)  
+          
+          @default_duration = :quarter
+          @default_articulation = nil
+          @default_pitch = :c0
+          
+          @output_buffer = Array.new
+        end
+        
+        def default(*args)
+          args.each{ |option|
+            if @duration_numeric_list.include?(option) then
+              @default_duration = @duration_numeric_list[option]
+            elsif @duration_list.include?(option) then
+              @default_duration = option
+            elsif @articulation_list.include?(option) then 
+              @default_articulation = option
+            end
+          }
+        end
+        
+        def method_missing(method_symbol, *args, &block)
+          case method_symbol
+          when :segno then
+            @output_buffer << __translate
+            @output_buffer << "@chn#{@index.to_s}_segno:"
+            @notes = Array.new
+          when :dal_segno then
+            @output_buffer << __translate
+            @output_buffer << "	.byte $fe" # end of stream
+            @output_buffer << "	.word @chn#{@index.to_s}_segno"
+            @notes = Array.new
+          else
+            note = Note.new(@default_duration, method_symbol, @default_articulation)
+            args.each{ |option|
+              if @duration_numeric_list.include?(option) then
+                note.duration = @duration_numeric_list[option]
+              elsif @duration_list.include?(option) then
+                note.duration = option
+              elsif @articulation_list.include?(option) then 
+                note.articulation = option
+              elsif @duration_symbol_list.include?(option) then
+                note.duration_symbol = option
+              end
+            }
+            @notes.concat note.generate
+          end
+        end
+        
+        def load(&block)
+          self.instance_eval &block
+        end
+        
+        def generate
+          if @notes.count>0 then
+            @output_buffer << __translate
+          end
+          @output_buffer.join("\n")
+          # "	.byte " + @notes.map{|p| "$%02x" % p}.join(",")
+          # "	.byte $c1,$43,$1d,$80,$1f,$80,$21,$82,$1d,$80,$1d,$80,$1f,$92"
+        end
+        
+        private
+        def __translate
+          "	.byte " + @notes.map{|p| "$%02x" % p}.join(",")
+        end
+      end
+    end
+  end
+end

data/lib/burn/fuel/rom/declare.rb

@@ -0,0 +1,43 @@
+module Burn
+  module Fuel
+    module Rom
+      class Declare < Fuel::DslBase
+          
+        def initialize(resource_name, context)
+          super(resource_name, context)
+        end
+        
+        def method_missing(method_symbol, *args, &block)
+          log :method_symbol=>method_symbol, :args=>args, block=>block
+          
+          proc = Proc.new{|args|
+            key=args.shift
+            value=args.shift
+            if value.is_a?(String) then
+              patternizer = Util::Patternizer.new(value)
+              
+              struct_var = "static sprite_schema #{key}={0, 0, {"
+              @pattern_table_index[key.to_sym] = @pattern_table_pointer
+              patternizer.patterns.each_with_index do |p, i|
+                log p, i, patternizer.height, "aaaaaaaaaaaaaaaaaaa"
+                struct_var += sprintf("%d, %d, %#x, 0,", (i % patternizer.width)*8 , (i / (patternizer.patterns.size / patternizer.height) )*8 , @pattern_table_pointer)
+                @pattern_tables << p
+                @pattern_table_pointer+=1
+              end
+              struct_var += "128}};"
+              
+              @global.push sprintf(struct_var, "")
+              
+            else
+              @global.push "static unsigned char #{key};"
+              @code_blocks.push "#{key}="+sprintf("%#x", value)+";"
+              log :key=>key, :value=>value.to_s(16), :value_class=>value.class
+            end
+          }
+
+          @context.instance_exec [method_symbol.to_s, args[0]], &proc
+        end
+      end
+    end
+  end
+end

data/lib/burn/fuel/rom/music.rb

@@ -0,0 +1,37 @@
+module Burn
+  module Fuel
+    module Rom
+      class Music < DslBase
+        def initialize(resource_name, context)
+          super(resource_name, context)
+          
+          @default_tempo = :allegro
+          
+          if resource_name.nil? then
+            raise Exception.new "Resource name for Music class must be provided."
+          else
+            @resource_name = resource_name
+          end
+          
+          @context.instance_exec resource_name, &lambda{|resource_name|
+            @resources["#{resource_name}"] = Array.new
+          }
+          
+        end
+        
+        def channel(instrument, &block)
+          @context.instance_exec(@resource_name,@default_tempo) do |resource_name, default_tempo|
+            stream = ChannelStream.new(@resources["#{resource_name}"].count, instrument, default_tempo)
+            stream.load(&block)
+            @resources["#{resource_name}"] << stream.generate
+            #@resources["#{resource_name}"] << "	.byte $43,$1d,$80,$1f,$80,$21,$82,$1d,$80,$1d,$80,$1f,$92"
+          end
+        end
+        
+        def tempo(speed)
+          @default_tempo = speed
+        end
+      end
+    end
+  end
+end

data/lib/burn/fuel/rom/note.rb

@@ -0,0 +1,126 @@
+module Burn
+  module Fuel
+    module Rom
+      class Note
+        # For music
+        # (0..59 are octaves 1-5, 63 note stop)
+        C = 0
+        D = 2
+        E = 4
+        F = 5
+        G = 7
+        A = 9
+        B = 11
+        
+        CS = 11
+        DS = 1
+        ES = 3
+        FS = 4
+        GS = 6
+        AS = 8
+        BS = 10
+        
+        REST = -1
+        
+        
+        # Empty Rows 128~191 (63steps)
+        DURATION_BASE = 127
+        SIXTEENTH = 4 + DURATION_BASE
+        EIGHTH = 10 + DURATION_BASE
+        QUARTER = 22 + DURATION_BASE
+        HALF = 46 + DURATION_BASE
+        DOTTED_SIXTEENTH = 7 + DURATION_BASE
+        DOTTED_EIGHTH = 16 + DURATION_BASE
+        DOTTED_QUARTER = 34 + DURATION_BASE
+        DOTTED_HALF = 70 + DURATION_BASE
+        TRIPLET_SIXTEENTH = 1 + DURATION_BASE
+        TRIPLET_EIGHTH = 4 + DURATION_BASE
+        TRIPLET_QUARTER = 10 + DURATION_BASE
+        TRIPLET_HALF = 22 + DURATION_BASE
+        
+        TENUTO = 1.0
+        ACCENT = 0.7
+        STACCATO = 0.2
+        
+        attr_accessor :duration, :articulation, :duration_symbol
+        
+        def initialize(duration=:quarter, pitch=:c0, articulation=nil, duration_symbol=nil)
+          @pitch_list = {c:C, bsharp:C,
+                         ds:DS, dflat:DS, csharp:DS,
+                         d:D, 
+                         es:ES, eflat:ES, dsharp:DS,
+                         e:E, fs:FS, fflat:FS,
+                         f:F, esharp:F,
+                         gs:GS, gflat:GS, fsharp:GS,
+                         g:G, 
+                         as:AS, aflat:AS, gsharp:AS,
+                         a:A, 
+                         bs:BS, bflat:BS, asharp:BS,
+                         b:B, cs:CS, cflat:CS,
+                         rest:REST,
+                         }
+
+          # Fix pitch first at this early timing
+          if !pitch.to_s.match(/(.+)(\d)/).nil? then
+            raise Exception.new "pitch #{pitch.to_s} is not defined." if !@pitch_list.keys.include?(Regexp.last_match(1).to_sym)
+            @pitch = @pitch_list[Regexp.last_match(1).to_sym]
+            if Regexp.last_match(2).to_i <= 4 then
+              @octave = Regexp.last_match(2).to_i
+            else
+              raise Exception.new "Sorry only 0-4 octave range is supported."
+            end
+          else
+            raise Exception.new "pitch #{pitch.to_s} is not defined." if !@pitch_list.keys.include?(pitch)
+            @pitch = @pitch_list[pitch]
+            @octave = 0
+          end
+          
+          @duration = duration
+          @articulation = articulation
+          @duration_symbol = duration_symbol
+        end
+        
+        def generate
+          duration = get_actual_duration
+          
+          result = Array.new
+          if @pitch==REST then
+            @articuulation = 0
+          else
+            result << @pitch + 12 * @octave
+          end
+          
+          articulation = Note.const_get(@articulation.upcase) if !@articulation.nil?
+          if articulation.nil? then
+            result << duration
+            result << 63 # note stop
+          elsif articulation == TENUTO then
+            result << duration + 1
+          else
+            if (len(duration)*articulation).ceil > 0 then
+              result << DURATION_BASE + (len(duration)*articulation).ceil
+              result << 63 # note stop
+            end
+            if (len(duration)*(1.0 - articulation)).floor > 0 then
+              result << DURATION_BASE + (len(duration)*(1.0-articulation)).floor
+            end
+          end
+          result
+        end
+        
+        private
+        def len(duration)
+          duration - DURATION_BASE
+        end
+        
+        def get_actual_duration
+          if !@duration_symbol.nil? then
+            Note.const_get(@duration_symbol.upcase.to_s + "_" + @duration.upcase.to_s)
+          else
+            Note.const_get(@duration.upcase.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/burn/fuel/rom/scene.rb

@@ -0,0 +1,279 @@
+module Burn
+  module Fuel
+    module Rom
+      class Scene < DslBase
+        # Where to draw
+        BG = 0          # background palette (0x00-0x0f)
+        TEXT = 1        # background palette (0x00-0x0f)
+        PALETTE_X1 = 5  # palette A for #screen and #paint method (whcih is a part background palette)
+        PALETTE_X2 = 6
+        PALETTE_X3 = 7
+        PALETTE_Y1 = 9
+        PALETTE_Y2 = 10
+        PALETTE_Y3 = 11
+        PALETTE_Z1 = 13
+        PALETTE_Z2 = 14
+        PALETTE_Z3 = 15
+        SPRITE = 17     # sprite palette (0x10-0x1f)
+        
+        PALETTE_DEFAULT = 0
+        PALETTE_X = 85  # palette expression for PPU Attribute table
+        PALETTE_Y = 170 # palette expression for PPU Attribute table
+        PALETTE_Z = 255 # palette expression for PPU Attribute table
+        
+        # Color Control
+        WHITE = 0
+        LIGHTBLUE = 1
+        BLUE = 2
+        PURPLE = 3
+        PINK = 4
+        RED = 5
+        DEEPRED = 6
+        ORANGE = 7
+        LIGHTORANGE = 8
+        DARKGREEN = 9
+        GREEN = 10
+        LIGHTGREEN = 11
+        BLUEGREEN = 12
+        GRAY = 13
+        BLACK = 14
+        
+        # Light Control
+        DARKEST = 0
+        DARKER = 16
+        LIGHTER = 32
+        LIGHTEST = 48
+        
+        def initialize(resource_name, context)
+          super(resource_name, context)
+        end
+        
+        def label(string, x=0, y=1)
+          @context.instance_exec {@code_blocks.push sprintf("put_str(NTADR(%d,%d),\"%s\");", x, y, string.upcase)}
+        end
+        
+        def fade_in
+          @context.instance_exec do
+            [
+              "ppu_on_all();",
+              "screen_fade_in();"
+            ].each {|p| @code_blocks.push p}
+          end
+        end
+        
+        def fade_out(sec=3)
+          @context.instance_exec {@code_blocks.push "screen_fade_out(#{sec.to_s});"}
+        end
+        
+        def color(palette, color, lightness=:lighter)
+          palette=Scene.const_get(palette.upcase)
+          color=Scene.const_get(color.upcase)
+          lightness=Scene.const_get(lightness.upcase)
+          
+          @context.instance_exec {@code_blocks.push "pal_col(#{palette},0x#{(lightness+color).to_s(16)});"}
+        end
+        
+        def play(song_title)
+          @context.instance_exec do
+            @global << "extern const unsigned char music_#{song_title}[];"
+            @code_blocks << "music_play(music_#{song_title});"
+          end
+        end
+        
+        def stop
+          @context.instance_exec {@code_blocks.push "music_stop();"}
+        end
+        
+        def show(string, x=0, y=0, *args)
+          @context.instance_exec(@resource_name) do |resource|
+            nmi_plots = Array.new
+            iChrCount=0
+            isRequireArgs=false
+            vname = resource+"_nmi_list"
+            init_name = resource+"_nmi_init"
+            
+            string.split(//).each do |c|
+              if c=='%' then
+                isRequireArgs=true
+                next
+              end
+              nmi_plots.push [x+iChrCount,y] if nmi_plots.index([x+iChrCount, y]).nil?
+              if !isRequireArgs then
+                @code_blocks.push sprintf("#{vname}[%d]=%s;", nmi_plots.index([x+iChrCount,y])*3+2, sprintf("%#x", c.bytes.to_a[0]-32))
+                iChrCount+=1
+              else
+                if c=='d' then
+                  @code_blocks.push sprintf("#{vname}[%d]=0x10+%s;", nmi_plots.index([x+iChrCount,y])*3+2, args.shift)
+                  iChrCount+=1
+                elsif c=='s' then
+                  args.shift.split(//).each do |d|
+                    nmi_plots.push [x+iChrCount,y] if nmi_plots.index([x+iChrCount, y]).nil?
+                    @code_blocks.push sprintf("#{vname}[%d]=%s;", nmi_plots.index([x+iChrCount,y])*3+2, sprintf("%#x", d.bytes.to_a[0]-32))
+                    iChrCount+=1
+                  end
+                else
+                  raise "method #show can't take any data except for %d or %s. Please make sure you are passing correct 4th parameter."
+                end
+              end
+              isRequireArgs=false
+            end
+            
+            if nmi_plots.count>0 then
+              # declaration for show method
+              @global.push sprintf("static unsigned char #{vname}[%d*3];", nmi_plots.count)
+              @global.push sprintf("const unsigned char #{init_name}[%d*3]={", nmi_plots.count)
+              nmi_plots.each_with_index do |plot,i|
+                @global.push sprintf("MSB(NTADR(%d,%d)),LSB(NTADR(%d,%d)),0%s", plot[0],plot[1],plot[0],plot[1],i<(nmi_plots.count-1)?",":"")
+              end
+              @global.push "};"
+              @code_blocks.unshift "memcpy(#{vname},#{init_name},sizeof(#{init_name}));", sprintf("set_vram_update(%d,#{vname});", nmi_plots.count)
+            end
+            
+          end
+        end
+        
+        def wait(interval)
+          #@context.instance_exec do
+          #  [
+          #    "while(1){",
+          #      "ppu_on_all();",
+          #      "delay(#{interval});",
+          #      "ppu_off();",
+          #      "break;",
+          #    "}"
+          #  ].each {|p| @code_blocks.push p}
+          #end
+          @context.instance_exec {@code_blocks.push "delay(#{interval});"}
+        end
+        
+        def goto(scene_name)
+          @context.instance_exec do
+            [
+              "ppu_off();",
+              "set_vram_update(0,0);", #clear vram condition for #show
+              "vram_adr(0x2000);",     #clear nametable
+              "vram_fill(0,1024);",    #clear nametable
+              "goto #{scene_name};"
+            ].each {|p| @code_blocks.push p}
+          end
+        end
+        
+        def main_loop(rrb_source=nil)
+          rrb_source = File.open("#{@resource_name}.rrb").read if rrb_source.nil? || File.extname(rrb_source) == "#{@resource_name}.rrb"
+          
+          # preprocess - for show method, all parameters after the 3rd parameter must be converted to String.
+          rrb_source = rrb_source.lines.map{|line|
+            if /^[\s\t]*show/ =~ line then
+              line.chomp.split(",").each_with_index.map{|data, i|
+                if i>2 then
+                  '"' + data + '"'
+                else
+                  data
+                end
+              }.join(",")
+            else
+              line.chomp
+            end
+          }.join("\n")
+          
+          @context.instance_exec(@context,@resource_name) do |c, resource|
+            # preprocess
+            [
+              "ppu_on_all();",
+              "while(1){",
+                "ppu_waitnmi(); //wait for next TV frame",
+            ].each {|p| @code_blocks.push p}
+            
+            # parse ruby source code and process them partially
+            p = Pxes::Cc65Transpiler.new(Ripper.sexp(rrb_source),c,resource)
+            #require 'pp'
+            #pp p
+            @code_blocks.push p.to_c
+            
+            # postprocess
+            @code_blocks.push "}"
+          end
+          
+        end
+        
+        def inline(code)
+          @context.instance_exec {@code_blocks.push code}
+        end
+        
+        #def sprite_set(x,y,tile_number,palette=0)
+        #  @context.instance_exec {@code_blocks.push "oam_spr(#{x},#{y},0x"+tile_number.to_s(16)+",#{palette},0);//0x40 is tile number, i&3 is palette"}
+        #end
+        
+        def sprite(resource)
+          @context.instance_exec {@code_blocks.push "sprite(&#{resource});"}
+        end
+        
+        def screen(map, vars)
+          @context.instance_exec(@resource_name) do |resource|
+            current_char = nil
+            consective_count = 0
+            output = Array.new
+            # the last character "\b" is just a dummy to finialize loop process
+            (map.gsub(/(\r\n|\r|\n)/,"")+"\b").chars do |c|
+              if current_char != c then
+                if !current_char.nil? then
+                  if vars.keys.include?(current_char.to_sym) then
+                    output.push @pattern_table_index[vars[current_char.to_sym].to_sym] # user defined specific pattern
+                  else
+                    output.push 0 # blank pattern
+                  end
+                  # repeat to draw same pattern
+                  output.push 1, consective_count if consective_count>0
+                end
+                current_char = c
+                consective_count = 0
+              else
+                consective_count += 1
+              end
+            end
+            @global.push "const unsigned char screen_#{resource}["+(output.count+3).to_s+"]={0x01,"+output.map{|p| sprintf "0x%.2x", p}.join(",")+",0x01,0x00};"
+            # "unrle_vram" means "decode Run Length Encoding and set them to vram".
+            @code_blocks.push "unrle_vram(screen_#{resource},0x2020);" # previously used 0x2000 but it doesn't display very first line of screen.
+          end
+        end
+        
+        def paint(dest, palette)
+          @context.instance_exec(@resource_name) do |resource|
+            var_name="screen_#{resource}_color_#{@global.count}"
+            @global.push "const unsigned char #{var_name}[6]={0x01,0x"+Scene.const_get(palette.upcase).to_s(16)+",0x01,"+sprintf("0x%.2x",dest.end-dest.begin)+",0x01,0x00};"
+            @code_blocks.push "unrle_vram(#{var_name},0x"+(9152+dest.begin).to_s(16)+");" # 9152 is equivalent to 23C0
+          end
+        end
+        
+        def sound(effect_name)
+          @context.instance_exec {@code_blocks.push "sfx_play(SFX_#{effect_name.upcase},0);"}
+        end
+        
+        
+        # vcall-ish methods
+        def rand
+          @context.instance_exec {@code_blocks.push "rand8()"}
+        end
+        
+        alias_method :play_sound, :sound
+        alias_method :play_music, :play
+        
+        # utility methods
+        def range(x_from, y_from, x_to, y_to)
+          x_to = x_from if x_to.nil?
+          y_to = y_from if y_to.nil?
+          
+          plots = [x_from,y_from,x_to,y_to].map do |v|
+            if v.is_a?(String) && v.end_with?("px") then # x:0-255, y:0:239
+              v.to_i / 32
+            else
+              v.to_i / 4
+            end
+          end
+          
+          plots[1]*8+plots[0]..plots[3]*8+plots[2]
+        end
+      end
+    end
+  end
+end