burn 0.1.3 → 0.2.0

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

@@ -0,0 +1,31 @@
+module Burn
+  module Fuel
+    module Rom
+      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
+end

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

@@ -0,0 +1,92 @@
+module Burn
+  module Fuel
+    module Rom
+      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
+end

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

@@ -0,0 +1,26 @@
+module Burn
+  module Fuel
+    module Telnet
+      class Declare < DslBase
+          
+        def initialize(resource_name, context)
+          super(resource_name, context)
+        end
+        
+        def method_missing(method_symbol, *args, &block)
+          proc = Proc.new{|args|
+            key=args.shift
+            value=args.shift
+            if value.is_a?(String) then
+              @opcodes << "@___#{key} = Sprite.new(\"#{value}\",0,0)"
+            else
+              @opcodes << "@___#{key} = #{value}"
+            end
+          }
+
+          @context.instance_exec [method_symbol.to_s, args[0]], &proc
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,112 @@
+module Burn
+  module Fuel
+    module Telnet
+      class Scene < DslBase
+        # Where to draw
+        BG = 40          # background palette (0x00-0x0f)
+        TEXT = 30        # background palette (0x00-0x0f)
+        # SPRITE = 17     # sprite palette (0x10-0x1f)
+        
+        # Color Control
+        WHITE = 7
+        LIGHTBLUE = 4
+        BLUE = 4
+        PURPLE = 5
+        PINK = 5
+        RED = 1
+        DEEPRED = 1
+        ORANGE = 3
+        LIGHTORANGE = 3
+        DARKGREEN = 2
+        GREEN = 2
+        LIGHTGREEN = 6
+        BLUEGREEN = 6
+        GRAY = 7
+        BLACK = 0
+        
+        # Light Control
+        DARKEST = 60
+        DARKER = 60
+        LIGHTER = 0
+        LIGHTEST = 0
+
+        def initialize(resource_name, context)
+          super(resource_name, context)
+        end
+        
+        def label(string, x=0, y=1)
+          @context.instance_exec { @opcodes << "@screen.display[#{y}][#{x},#{string.length}] = \"#{string.upcase}\"" }
+        end
+
+        def wait(interval)
+          @context.instance_exec { @opcodes << "@wait = #{interval}" }
+        end
+        
+        def method_missing(method_symbol, *args, &block)
+          #TBD if needed
+        end
+        
+        def goto(scene_name)
+          @context.instance_exec { @opcodes << "@screen.flush_screen && @pc = @opcodes.index(\"##{scene_name}\")" }
+        end
+        
+        def color(palette, color, lightness=:lighter)
+          target = palette==:bg ? "bg" : "fg"
+          palette=Scene.const_get(palette.upcase)
+          color=Scene.const_get(color.upcase)
+          lightness=Scene.const_get(lightness.upcase)
+          @context.instance_exec { @opcodes << "@screen.#{target}_color = #{palette+color+lightness}" }
+        end
+        
+        def main_loop(rrb_source=nil)
+          @context.instance_exec(@context,@resource_name) do |c, resource|
+            p=Pxes::CrubyTranspiler.new(Ripper.sexp(rrb_source),c,resource)
+            start_label = "##{resource}-main_loop:" + @opcodes.count.to_s
+            @opcodes << start_label
+            @opcodes << "@user_input.init_for_next_loop"
+            @opcodes.concat p.to_rb.split("\n")
+            @opcodes << "@pc = @opcodes.index(\"#{start_label}\")" #JUMP
+          end
+        end
+        
+        def sprite(resource)
+          @context.instance_exec { @opcodes << "@screen.activated_sprite_objects << @___#{resource} if @screen.activated_sprite_objects.index(@___#{resource}).nil?" }
+        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 show(string, x=0, y=0, *args)
+#            end
+#            
+#            def inline(code)
+#            end
+#            
+#            def screen(map, vars)
+#            end
+#            
+#            def paint(dest, palette)
+#            end
+#            
+#            def rand
+#              @context.instance_exec {@code_blocks.push "rand8()"}
+#            end
+#            
+#            # utility methods
+#            def range(x_from, y_from, x_to, y_to)
+#            end
+        
+      end
+    end
+  end
+end

data/lib/burn/generator.rb

@@ -1,3 +1,10 @@
-require 'burn/generator/assembly_sound_effect'
-require 'burn/generator/assembly_music'
-require 'burn/generator/c_source'
+require 'burn/generator/rom/assembly_sound_effect'
+require 'burn/generator/rom/assembly_music'
+require 'burn/generator/rom/c_source'
+require 'burn/generator/rom_builder'
+
+require 'burn/generator/telnet/sprite'
+require 'burn/generator/telnet/screen'
+require 'burn/generator/telnet/user_input'
+require 'burn/generator/telnet/jit_compiler'
+require 'burn/generator/telnet_vm'

data/lib/burn/generator/rom/assembly_music.rb

@@ -0,0 +1,49 @@
+module Burn
+  module Generator
+    module Rom
+      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("#{@workspace_root}/tmp/burn/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
+end

data/lib/burn/generator/rom/assembly_sound_effect.rb

@@ -0,0 +1,35 @@
+module Burn
+  module Generator
+    module Rom
+      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
+end

data/lib/burn/generator/rom/c_source.rb

@@ -0,0 +1,55 @@
+module Burn
+  module Generator
+    module Rom
+      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
+end

data/lib/burn/generator/rom_builder.rb

@@ -0,0 +1,67 @@
+module Burn
+  module Generator
+    class RomBuilder
+      include Fuel::Rom
+      include Generator::Rom
+      include Debug
+      
+      def initialize(workspace_root)
+        @workspace_root = workspace_root
+        
+        @game_generator = CSource.new(@workspace_root)
+        @music_generator = AssemblyMusic.new(@workspace_root)
+        @sound_effect_generator = AssemblySoundEffect.new(@workspace_root)
+      end
+      
+      def verbose(flag)
+        Debug::Logger.new.enabled flag
+      end
+      
+      def load(dsl_raw_text)
+        self.instance_eval dsl_raw_text
+      end
+      
+      def generate
+        @game_generator.generate
+        @music_generator.generate
+        @sound_effect_generator.generate
+      end
+      
+      def method_missing(method_symbol, *args, &block)
+        log :method_symbol=>method_symbol, :args=>args, :block=>block
+        if method_symbol == :music then
+          Music.new(args[0], @music_generator.get_context).instance_eval(&block) 
+          
+        elsif method_symbol == :scene then
+          # preprocess
+          args[0] = "main" if args[0].nil?
+          @game_generator.get_context.instance_exec args[0], &lambda{|resource_name|
+            [
+              "",
+              "//#{resource_name} label starts",
+              "#{resource_name}:"
+            ].each {|p| @code_blocks.push p}
+          }
+          
+          # execute dsls
+          Scene.new(args[0], @game_generator.get_context).instance_eval(&block)
+          
+          # postprocess - To deal with the case of on_enter_frame not found, adding while loop at the end of program
+          @game_generator.get_context.instance_exec {@code_blocks.push "ppu_on_all();", "while(1);"}
+          
+        elsif method_symbol == :declare then
+          Declare.new(args[0], @game_generator.get_context).instance_eval(&block) 
+        
+        elsif method_symbol == :sound then
+          Sound.new(args[0], @sound_effect_generator.get_context).instance_eval(&block)
+          
+          # postprocess
+          @game_generator.get_context.instance_exec(@sound_effect_generator.resources.count-1) do |count|
+            @global.push "#define SFX_#{args[0].upcase} #{count.to_s}"
+          end
+          
+        end
+      end
+    end
+  end
+end