burn 0.1.0

data/lib/burn/dsl/scene.rb

@@ -0,0 +1,278 @@
+module Burn
+  module Dsl
+    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 = Burn::Util::Pxes.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

data/lib/burn/dsl/sound.rb

@@ -0,0 +1,30 @@
+module Burn
+  module Dsl
+    class Sound < DslBase
+      def initialize(resource_name, context)
+        super(resource_name, context)
+        
+        if resource_name.nil? then
+          raise Exception.new "Resource name for Sound class must be provided."
+        else
+          @resource_name = resource_name
+        end
+        
+        @context.instance_exec resource_name, &lambda{|resource_name|
+          @resources["#{resource_name}"] = Array.new
+        }
+        
+        @se = SoundEffect.new
+        
+      end
+      
+      def effect(&block)
+        @context.instance_exec(@resource_name,@se) do |resource_name,se|
+          se.load(&block)
+          @resources["#{resource_name}"] << se.generate
+        end
+      end
+      
+    end
+  end
+end

data/lib/burn/dsl/sound_effect.rb

@@ -0,0 +1,91 @@
+module Burn
+  module Dsl
+    class SoundEffect
+      # duty cycle: 00�F12.5%�@01�F25%�@10�F50%�@11�F75%
+      LOWEST = 0
+      LOWER = 1
+      HIGHER = 2
+      HIGHEST = 3
+      
+      def initialize
+        @output_buffer = Array.new
+      end
+      
+      def load(&block)
+        self.instance_eval &block
+      end
+      
+      # $4000 related
+      def duty_cycle(ratio)
+        @duty_cycle = SoundEffect.const_get(ratio.upcase)
+      end
+      
+      def velocity(level)
+        @velocity = level
+      end
+      
+      def envelope_decay(flag)
+        @envelope_decay = flag==:enable ? 0 : 1
+      end
+      
+      def envelope_decay_loop(flag)
+        @envelope_decay_loop = flag==:enable ? 1 : 0
+      end
+      
+      def length_counter_clock(flag)
+        @envelope_decay_loop = flag==:enable ? 0 : 1
+      end
+      
+      # $4001 related
+      def pitch(i)
+        @pitch = i
+      end
+      
+      def length(i)
+        @length = i + 15
+      end
+      
+      alias_method :envelope_decay_rate, :velocity
+      alias_method :volume, :velocity
+      alias_method :envelope, :envelope_decay
+      alias_method :envelope_loop, :envelope_decay_loop
+      alias_method :key_off_counter, :length_counter_clock
+      
+      def generate
+        if !@duty_cycle.nil? || !@velocity.nil? || @envelope_decay.nil? || @envelope_decay_loop.nil? then
+          @duty_cycle = HIGHER if !@duty_cycle.nil?
+          @velocity = 7 if @velocity.nil?
+          @envelope_decay = 0 if @envelope_decay.nil?
+          @envelope_decay_loop = 0 if @envelope_decay_loop.nil?
+          
+          reg = @duty_cycle*64 + @envelope_decay*32 + @envelope_decay_loop*16 + @velocity
+          if @reg4000 != reg then
+            @output_buffer << "	.byte $00,$%02x" % reg
+            @reg4000 = reg
+          end
+        end
+        
+        if !@pitch.nil? then
+          if @reg4001 != @pitch then
+            @output_buffer << "	.byte $01,$%02x" % @pitch
+            @reg4001 = @pitch
+          end
+        end
+        
+        @length = 16 if @length.nil?
+        @output_buffer << "	.byte $%02x" % @length
+        
+        # return result
+        @output_buffer.join("\n") + "\n"
+        
+        #"	.byte $00,$7f\n	.byte $01,$ab\n	.byte $02,$01\n	.byte $13\n	.byte $01,$3f\n	.byte $39\n	.byte $01,$1c\n	.byte $13\n	.byte $ff\n"
+      end
+      
+      private
+      def __translate
+        "	.byte " + @notes.map{|p| "$%02x" % p}.join(",")
+      end
+      
+    end
+  end
+end

data/lib/burn/dsl.rb

@@ -0,0 +1,8 @@
+require 'burn/dsl/sound_effect'
+require 'burn/dsl/note'
+require 'burn/dsl/channel_stream'
+require 'burn/dsl/dsl_base'
+require 'burn/dsl/declare'
+require 'burn/dsl/sound'
+require 'burn/dsl/music'
+require 'burn/dsl/scene'

data/lib/burn/generator/assembly_music.rb

@@ -0,0 +1,47 @@
+module Burn
+  module Generator
+    class AssemblyMusic
+      include Debug
+      
+      def initialize(workspace_root)
+        # Generic
+        @workspace_root = workspace_root
+        
+        # Music related
+        @resources = {}
+        
+        #@channels = Array.new
+        
+      end
+      
+      def get_context
+        self
+      end
+      
+      def generate
+        # prepare music.s - music assembler file
+        File.write(
+          "#{@workspace_root}/tmp/burn/asset/music.s", 
+          File.read(File.dirname(__FILE__)+"/../workspace_default/asset/music.s")
+            .gsub(/__@__EXPORT__@__/, @resources.keys.map{|p| "	.export _music_#{p}"}.join("\n"))
+            .gsub(/__@__INCLUDE__@__/, @resources.keys.map{|p| "_music_#{p}: 		.include \"mus_#{p}.s\""}.join("\n"))
+        )
+        
+        # preparing each song file
+        @resources.each {|resource_name, channels|
+          # prepare other music resources
+          File.write( "#{@workspace_root}/tmp/burn/asset/mus_#{resource_name}.s",
+            File.read(File.dirname(__FILE__)+"/template/mus_template.s")
+              .gsub(/__@__NAME__@__/, resource_name)
+              .gsub(/__@__CHANNEL1__@__/, channels.shift || "")
+              .gsub(/__@__CHANNEL2__@__/, channels.shift || "")
+              .gsub(/__@__CHANNEL3__@__/, channels.shift || "")
+              .gsub(/__@__CHANNEL4__@__/, channels.shift || "")
+              .gsub(/__@__CHANNEL5__@__/, channels.shift || "")
+          )
+        }
+      
+      end
+    end
+  end
+end

data/lib/burn/generator/assembly_sound_effect.rb

@@ -0,0 +1,33 @@
+module Burn
+  module Generator
+    class AssemblySoundEffect
+      include Debug
+      attr_reader :resources
+      
+      def initialize(workspace_root)
+        # Generic
+        @workspace_root = workspace_root
+        
+        # Music related
+        @resources = {}
+        
+      end
+      
+      def get_context
+        self
+      end
+      
+      def generate
+        # prepare sound.s - sound effect assembler file
+        File.write(
+          "#{@workspace_root}/tmp/burn/asset/sounds.s", 
+          "sounds:\n" \
+            + @resources.keys.map{|p| "	.word @#{p}"}.join("\n") \
+            + "\n" \
+            + @resources.map{|key,value| "@#{key}:\n#{value.join}	.byte $ff\n" }.join
+        )
+        
+      end
+    end
+  end
+end

data/lib/burn/generator/c_source.rb

@@ -0,0 +1,54 @@
+module Burn
+  module Generator
+    class CSource
+      include Debug
+      attr_reader :global, :code_blocks
+      
+      def initialize(workspace_root)
+        # Generic
+        @workspace_root = workspace_root
+        @global = Array.new
+        @code_blocks = Array.new
+        
+        # Scene related
+        @pattern_tables = Array.new
+        @pattern_table_pointer = 80 #0x50 equivalent
+        @pattern_table_index = Hash.new
+      end
+      
+      def get_context
+        self
+      end
+      
+      def generate
+        # Initialization for codeblocks
+        @code_blocks.unshift "init();"
+        
+        # generate source code
+        File.write(
+          "#{@workspace_root}/tmp/burn/main.c", 
+          File.read(File.dirname(__FILE__) + "/template/template.c")
+            .gsub(/__@__MAIN__@__/, @code_blocks.join("\n"))
+            .gsub(/__@__GLOBAL__@__/, @global.join("\n"))
+        )
+        
+        # save pattern tables associated with source code
+        pattern_header = []
+        File.open("#{@workspace_root}/tmp/burn/asset/tileset.chr", "rb") do |f|
+          pattern_header << f.read(16*80)
+        end
+        File.open("#{@workspace_root}/tmp/burn/asset/tileset.chr", "wb") do |f|
+          f << pattern_header[0]
+          @pattern_tables.each do |p|
+            f << p
+          end
+          (8192-16*80-@pattern_tables.count*16).times do |i|
+            f << ["0x00"].pack("B*")
+          end
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/burn/generator/template/mus_template.s

@@ -0,0 +1,49 @@
+__@__NAME__@__:
+	.word @chn0,@chn1,@chn2,@chn3,@chn4,music_instruments
+	.byte $03
+
+@chn0:
+@chn0_0:
+__@__CHANNEL1__@__
+@chn0_loop:
+@chn0_1:
+	.byte $9f
+	.byte $fe
+	.word @chn0_loop
+
+@chn1:
+@chn1_0:
+__@__CHANNEL2__@__
+@chn1_loop:
+@chn1_1:
+	.byte $9f
+	.byte $fe
+	.word @chn1_loop
+
+@chn2:
+@chn2_0:
+__@__CHANNEL3__@__
+	.byte $89
+@chn2_loop:
+@chn2_1:
+	.byte $9f
+	.byte $fe
+	.word @chn2_loop
+
+@chn3:
+@chn3_0:
+__@__CHANNEL4__@__
+@chn3_loop:
+@chn3_1:
+	.byte $9f
+	.byte $fe
+	.word @chn3_loop
+
+@chn4:
+@chn4_0:
+__@__CHANNEL5__@__
+@chn4_loop:
+@chn4_1:
+	.byte $9f
+	.byte $fe
+	.word @chn4_loop

data/lib/burn/generator/template/template.c

@@ -0,0 +1,88 @@
+#include "neslib.h"
+#include "test.h"
+
+#define NTADR(x,y) ((0x2000|((y)<<5)|x))
+#define MSB(x) (((x)>>8))
+#define LSB(x) (((x)&0xff))
+
+const unsigned char palSprites[16]={
+	0x0f,0x17,0x27,0x37,
+	0x0f,0x11,0x21,0x31,
+	0x0f,0x15,0x25,0x35,
+	0x0f,0x19,0x29,0x39
+};
+
+static unsigned char vram_buffer[896]; // 896:32*28
+static unsigned char spr;
+
+void put_str(unsigned int adr,const char *str)
+{
+	vram_adr(adr);
+
+	while(1)
+	{
+		if(!*str) break;
+		vram_put((*str++)-0x20); //-0x20 because ASCII code 0x20 is placed in tile 0 of the CHR
+	}
+}
+
+void screen_fade_out(interval){
+	unsigned char i=0x05;
+	while(1){
+		//ppu_waitnmi();//wait for next TV frame
+		i--;
+		pal_bright(i);
+		delay(interval);
+		if (i==0){
+			break;
+		}
+	}
+}
+
+void screen_fade_in(){
+	unsigned char i=0x00;
+	while(1){
+		//ppu_waitnmi();//wait for next TV frame
+		i++;
+		pal_bright(i);
+		delay(5);
+		if (i==4){
+			break;
+			//goto mystart;
+		}
+	}
+}
+
+void init_screen(){
+	memfill(vram_buffer, 0, 896); // 896:32*28
+	vram_write((unsigned char *)vram_buffer, NTADR(0, 1), 32 * 28);
+}
+
+void init(){
+	pal_spr(palSprites);//set palette for sprites
+	pal_col(1,0x30);//set while color
+}
+
+int is_pressed(unsigned char pad){
+	unsigned char i;
+	i=pad_poll(0);
+	return i&pad;
+}
+
+typedef struct {
+	int x;
+	int y;
+	unsigned char pattern[];
+} sprite_schema;
+
+__@__GLOBAL__@__
+
+void sprite(sprite_schema *data){
+	spr=oam_meta_spr(data->x,data->y,spr,data->pattern);
+}
+
+void main(void)
+{
+
+}
+

data/lib/burn/generator.rb

@@ -0,0 +1,3 @@
+require 'burn/generator/assembly_sound_effect'
+require 'burn/generator/assembly_music'
+require 'burn/generator/c_source'