gen3_pokeedit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 76cb20ee1ee5ea208ecacae5246c35b69403fb3c
+  data.tar.gz: 5f5915df7e49134065dcfcfbbec015594fe90dbf
+SHA512:
+  metadata.gz: b3194a78ff66da10e7bd34e86a881190eae6bd386250e505d1984ed99b2cff80caa937bebc71857d7b89e4729278af6973fc451a2e4f23cbeaeb0e19ae3594d2
+  data.tar.gz: 4343f0d4ad5ad0b79f376b913b904fea0fecd9603f23da832aab86365dc2e9375f3c78fc48c3a7b8d27fd965c86a295419cf7a80ec2d32ff2c14c1a6c5883670

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.1
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gen3_pokeedit.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 RainbowReich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# Gen3Pokeedit
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/gen3_pokeedit`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'gen3_pokeedit'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install gen3_pokeedit
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake false` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/gen3_pokeedit.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "gen3_pokeedit"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/gen3_pokeedit.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'gen3_pokeedit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "gen3_pokeedit"
+  spec.version       = Gen3PokeEdit::VERSION
+  spec.authors       = ["RainbowReich"]
+  spec.email         = ["rainbowryke@gmail.com"]
+
+  spec.summary       = %q{Gen3PokeEdit is a gem for viewing and editing save files from Pokemon Ruby, Sapphire, Emerald, Firered, and Leafgreen versions.}
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/gen3_pokeedit.rb

@@ -0,0 +1,4 @@
+require "gen3_pokeedit/version"
+
+require "gen3_pokeedit/Gen3PokemonStruct"
+require "gen3_pokeedit/Gen3PokemonSaveLoader"

data/lib/gen3_pokeedit/ByteCompiler.rb

@@ -0,0 +1,27 @@
+module ByteCompiler
+  def compile_bytes(*dat)
+    total_value = 0
+    dat = dat[0]
+    dat.each_index do |i|
+      total_value += dat[i] << (8*i)
+    end
+    return total_value
+  end
+  
+  def decompile_bytes(value, num_bytes)
+    total_array = Array.new
+    num_bytes.times do |i|
+      total_array << ((value & (0xFF << 8*i)) >> 8*i)
+    end
+    return total_array
+  end
+  
+  def set_bit(value, bit)
+    value = value | (1 << bit)
+  end
+  
+  def unset_bit(value, bit)
+    value = value & !(1 << bit)
+  end
+  
+end

data/lib/gen3_pokeedit/Gen3PokemonSaveLoader.rb

@@ -0,0 +1,150 @@
+require_relative "Gen3PokemonStruct"
+require_relative "ByteCompiler"
+
+class Gen3PokemonSaveLoader
+
+  include ByteCompiler
+
+  def initialize(file = nil)
+    @game = nil 
+	return if file.nil?	
+    load_save(file) 
+    detect_game_version
+  end
+  
+  def load_save(file)
+    @save = File.new(file,"r+b")
+  end
+  
+  def close
+    @save.close
+  end
+  
+  def get_section_loc(id)
+	raise "Save file not loaded" if game.nil?
+    case id
+    when 0
+      if @game == :rs
+        return 0
+      elsif @game == :frlg
+        return 0
+      elsif @game == :e
+        return 0
+      end
+    when 1
+      if @game == :rs
+        return 0x234
+      elsif @game == :frlg
+        return 0x234
+      elsif @game == :e
+        return 0x34
+      end
+    end
+  end
+  
+  def calculate_section_checksum(id)
+    num_data = 0
+    case id
+      when 0
+        num_data = 3884
+      when 1
+        num_data = 3968
+    end
+    @save.pos = find_section(id)
+    calc_checksum = 0
+    num_data.times do |i|
+      if i%4==0
+        calc_checksum += compile_bytes([@save.readbyte,@save.readbyte,@save.readbyte,@save.readbyte])
+      end
+    end
+    calc_checksum = (((calc_checksum&0xFFFF0000)>>16) + (calc_checksum&0xFFFF)) & 0xFFFF
+    @save.pos = find_section(id) + 0xFF6
+		@save.pos = find_section(id) + 0xFF6
+    @save.putc (calc_checksum&0xFF)
+    @save.putc ((calc_checksum&0xFF00)>>8)
+  end
+  
+  def get_team_size
+    @save.pos = find_section(1)
+    return @save.readbyte
+  end
+  
+  def set_team_size(val)
+    @save.pos = find_section(1)
+    @save.putc (val&7)
+  end
+  
+  def get_team_pokemon(id)
+    @save.pos = find_section(1) + get_section_loc(1) + 4 + ((id-1)*100)
+    temp_pks = Gen3PokemonStruct.new
+    100.times do |i|
+      temp_pks.pdata[i] = @save.readbyte
+    end
+    return temp_pks
+  end
+  
+  def put_team_pokemon(id, pks)
+    @save.pos = find_section(1) + get_section_loc(1) + 4 + ((id-1)*100)
+    100.times do |i|
+      if pks.pdata[i] != nil
+        @save.putc pks.pdata[i]
+      else 
+        @save.pos = @save.pos + 1
+      end
+    end
+    calculate_section_checksum(1)
+  end
+  
+  def find_section(id)
+    cur_id = 255
+    @save.pos = find_recent_save + 0xFF4
+    while cur_id != id
+      cur_id = @save.readbyte
+      @save.pos += 0x1000 - 1
+    end
+    return @save.pos - 0x1000 - 0xFF4
+  end
+  
+  def find_recent_save
+    @save.pos = 0xFFC
+    game_a = 0
+    game_b = 0
+    4.times do |i|
+      game_a += (@save.readbyte << 8*i)
+    end
+    @save.pos = 0xEFFC
+    4.times do |i|
+      game_b += (@save.readbyte << 8*i)
+    end
+    game_a == 0xFFFFFFFF ? game_a = 0 : game_b == 0xFFFFFFFF ? game_b = 0 : 0
+    if game_a > game_b
+      return 0
+    else
+      return 0xE000
+    end
+  end
+  
+  def detect_game_version
+    @save.pos = find_section(0) + 0xAC
+    tempdata = 0
+    4.times do
+      tempdata << 8
+      tempdata | @save.readbyte
+    end
+    
+    puts tempdata
+    case tempdata
+    when 0
+     @game = :rs
+    when 1
+     @game = :frlg
+    else
+     @game = :e
+    end
+    puts @game.to_s
+    return tempdata
+  end
+  
+end
+
+

data/lib/gen3_pokeedit/Gen3PokemonStruct.rb

@@ -0,0 +1,504 @@
+require_relative 'ByteCompiler'
+require_relative 'TextConverter'
+
+class Gen3PokemonStruct
+  
+  include ByteCompiler
+  
+  def initialize
+    @pdata = Array.new(100,0)
+    @block_g = 32; @block_a = 44; @block_e = 56; @block_m = 68
+  end
+  
+  def pdata
+    return @pdata
+  end
+  
+  def generate_block_order #Call this after changing the PID of a Gen3PokemonStruct
+    g = @pdata[@block_g,12]
+    a = @pdata[@block_a,12]
+    m = @pdata[@block_m,12]
+    e = @pdata[@block_e,12]
+    calculate_block_order
+    @pdata[@block_g,12] = g
+    @pdata[@block_a,12] = a
+    @pdata[@block_m,12] = m
+    @pdata[@block_e,12] = e
+    return self
+  end
+  
+  def calculate_block_order #Call this before editing any properties of a Gen3PokemonStruct
+    case (pid % 24)
+    when 0
+      @block_g = 32; @block_a = 44; @block_e = 56; @block_m = 68
+    when 1
+      @block_g = 32; @block_a = 44; @block_e = 68; @block_m = 56
+    when 2
+      @block_g = 32; @block_a = 56; @block_e = 44; @block_m = 68
+    when 3
+      @block_g = 32; @block_a = 68; @block_e = 44; @block_m = 56
+    when 4
+      @block_g = 32; @block_a = 56; @block_e = 68; @block_m = 44
+    when 5
+      @block_g = 32; @block_a = 68; @block_e = 56; @block_m = 44
+    when 6
+      @block_g = 44; @block_a = 32; @block_e = 56; @block_m = 68
+    when 7
+      @block_g = 44; @block_a = 32; @block_e = 68; @block_m = 56
+    when 8
+      @block_g = 56; @block_a = 32; @block_e = 44; @block_m = 68
+    when 9
+      @block_g = 68; @block_a = 32; @block_e = 44; @block_m = 56
+    when 10
+      @block_g = 44; @block_a = 32; @block_e = 68; @block_m = 44
+    when 11
+      @block_g = 68; @block_a = 32; @block_e = 56; @block_m = 44
+    when 12
+      @block_g = 44; @block_a = 56; @block_e = 32; @block_m = 68
+    when 13
+      @block_g = 44; @block_a = 68; @block_e = 32; @block_m = 56
+    when 14
+      @block_g = 56; @block_a = 44; @block_e = 32; @block_m = 68
+    when 15
+      @block_g = 68; @block_a = 44; @block_e = 32; @block_m = 56
+    when 16
+      @block_g = 56; @block_a = 68; @block_e = 32; @block_m = 44
+    when 17
+      @block_g = 68; @block_a = 56; @block_e = 32; @block_m = 44
+    when 18
+      @block_g = 44; @block_a = 56; @block_e = 68; @block_m = 32
+    when 19
+      @block_g = 44; @block_a = 68; @block_e = 56; @block_m = 32
+    when 20
+      @block_g = 56; @block_a = 44; @block_e = 68; @block_m = 32
+    when 21
+      @block_g = 68; @block_a = 44; @block_e = 56; @block_m = 32
+    when 22
+      @block_g = 56; @block_a = 68; @block_e = 44; @block_m = 32
+    when 23
+      @block_g = 68; @block_a = 56; @block_e = 44; @block_m = 32
+    end
+    return self
+  end
+  
+  def pid
+    return compile_bytes(@pdata[0,4])
+  end
+  
+  def pid=(value)
+    @pdata[0,4] = decompile_bytes(value, 4)
+  end
+  
+  def otid
+    return compile_bytes(@pdata[4,2])
+  end
+  
+  def secretid
+    return compile_bytes(@pdata[6,2])
+  end
+  
+  def secretid=(value)
+    @pdata[6,2] = decompile_bytes(value,2)
+  end
+  
+  def shiny?
+    return (((((otid) ^ secretid) ^ (pid & 0xFFFF0000)>>16) ^ pid & 0xFFFF) < 8)
+  end
+  
+  def wurmple_evolution? #true for Silcoon and false for Cascoon
+    ((pid & 0xFFFF) ^ 10) < 5 ? true : false
+  end
+  
+  def otid=(value)
+    @pdata[4,2] = decompile_bytes(value, 2)
+  end
+  
+  def egg
+		if @pdata[@block_m+3]&64==64
+			return true
+		else
+			return false
+		end
+	end
+	
+	def egg=(value)
+	  if value
+	    set_bit(@pdata[@block_m+3],7)
+	  else
+	    unset_bit(@pdata[@block_m+3],7)
+	  end
+	end
+	
+	def happiness
+	  return @pdata[@block_g+9]
+	end
+	
+	def happiness=(value)
+	  @pdata[@block_g+9] = value
+	end
+
+  def ability
+		if @pdata[@block_m+3]&128==128
+			return true
+		else
+			return false
+		end
+	end
+
+  def species
+    return (compile_bytes(@pdata[@block_g,2]))
+  end
+  
+  def nature
+    return pid % 25
+  end
+  
+  def nature_name
+    case nature
+    when 0
+      return "Hardy"
+    when 1
+      return "Lonely"
+    when 2
+      return "Brave"
+    when 3
+      return "Adamant"
+    when 4
+      return "Naughty"
+    when 5
+      return "Bold"
+    when 6
+      return "Docile"
+    when 7
+      return "Relaxed"
+    when 8
+      return "Impish"
+    when 9
+      return "Lax"
+    when 10
+      return "Timid"
+    when 11
+      return "Hasty"
+    when 12
+      return "Serious"
+    when 13
+      return "Jolly"
+    when 14
+      return "Naive"
+    when 15
+      return "Modest"
+    when 16
+      return "Mild"
+    when 17
+      return "Quiet"
+    when 18
+      return "Bashful"
+    when 19
+      return "Rash"
+    when 20
+      return "Calm"
+    when 21
+      return "Gentle"
+    when 22
+      return "Sassy"
+    when 23
+      return "Careful"
+    when 24
+      return "Quirky"
+    end
+  end
+  
+  def pokedex_species
+    return species if species <= 251
+    return species - 25 if species > 251
+  end
+  
+  def species=(val)
+    @pdata[@block_g,2] = decompile_bytes(val,2)
+  end
+  
+  def exp
+    return compile_bytes(@pdata[@block_g+4,4])
+  end
+  
+  def exp=(val)
+    @pdata[@block_g+4,4] = decompile_bytes(val,4)
+  end
+  
+  def nickname
+    tmpar = @pdata[8,10]
+    return "" if tmpar.uniq.count == 1 && tmpar.uniq[0] == 0
+    tmpar.slice!(tmpar.find_index(0xFF)..tmpar.length-1) if tmpar.find_index(0xFF) != nil
+    tmpar.each_index do |i|
+      tmpar[i] = tmpar[i].chr
+    end
+    return TextConverter.convert_text_to_ascii(tmpar.join, {gen: 3}).encode('UTF-8')
+  end
+  
+  def nickname=(value)
+    if value != ""
+      newname = TextConverter.convert_text_to_game(value, {gen: 3})
+      newray = Array.new(10)
+      newname.each_char.with_index do |char, i|
+        newray[i] = char.ord
+      end
+      newray.each_index do |i| 
+        if i>=newname.length
+          newray[i] = 0xFF unless newname.length >= 10
+        end
+      end
+      puts newray
+      @pdata[8,10] = newray[0,10]
+    end
+  end
+  
+  def change_to_shiny
+    
+  end
+  
+  def language
+    return compile_bytes(@pdata[18,2])
+  end
+  
+  def language_name
+    case language
+    when 0x201
+      return "Japanese"
+    when 0x202
+      return "English"
+    when 0x203
+      return "French"
+    when 0x204
+      return "Italian"
+    when 0x205
+      return "German"
+    when 0x206
+      return "Korean"
+    when 0x207
+      return "Spanish"
+    end
+  end
+  
+  def language=(value)
+    @pdata[18,2] = decompile_bytes(value,2)
+  end
+  
+  def marking
+    tmpmark = @pdata[27]
+    mark = {}
+    mark[:circle] = true if tmpmark & 1 == 1
+    mark[:square] = true if tmpmark & 2 == 2
+    mark[:triangle] = true if tmpmark & 4 == 4
+    mark[:heart] = true if tmpmark & 8 == 8
+    return mark
+  end
+  
+  def marking=(mark)
+    @pdata[27] = value & 0xFF
+    mark[:circle] ? set_bit(@pdata[27],0) : unset_bit(@pdata[27],0)
+    mark[:square] ? set_bit(@pdata[27],1) : unset_bit(@pdata[27],1)
+    mark[:triangle] ? set_bit(@pdata[27],2) : unset_bit(@pdata[27],2)
+    mark[:heart] ? set_bit(@pdata[27],3) : unset_bit(@pdata[27],3)
+  end
+  
+  def checksum
+    return compile_bytes(@pdata[28,2])
+  end
+  
+  def checksum=(value)
+    @pdata[28,2] = decompile_bytes(value,2)
+  end
+  
+  def status
+    return compile_bytes(@pdata[80,4])
+  end
+  
+  def status=(value)
+    @pdata[80,4] = decompile_bytes(value, 4)
+  end
+  
+  def level
+    return @pdata[84]
+  end
+  
+  def level=(value)
+    @pdata[84] = value & 0xFF
+  end
+  
+  def pokerus
+    return @pdata[85]
+  end
+  
+  def pokerus=(value)
+    @pdata[85] = value & 0xFF
+  end
+  
+  def curhp
+    return compile_bytes(@pdata[86,2])
+  end
+  
+  def curhp=(value)
+    @pdata[86,2] = decompile_bytes(value,2)
+  end
+  
+  def maxhp
+    return compile_bytes(@pdata[88,2])
+  end
+  
+  def maxhp=(value)
+    @pdata[88,2] = decompile_bytes(value,2)
+  end
+  
+  def attack
+    return compile_bytes(@pdata[90,2])
+  end
+  
+  def attack=(value)
+    @pdata[90,2] = decompile_bytes(value,2)
+  end
+  
+  def defense
+    return compile_bytes(@pdata[92,2])
+  end
+  
+  def defense=(value)
+    @pdata[92,2] = decompile_bytes(value,2)
+  end
+  
+  def speed
+    return compile_bytes(@pdata[94,2])
+  end
+  
+  def speed=(value)
+    @pdata[94,2] = decompile_bytes(value,2)
+  end
+  
+  def special_attack
+    return compile_bytes(@pdata[96,2])
+  end
+  
+  def special_attack=(value)
+    @pdata[96,2] = decompile_bytes(value,2)
+  end
+  
+  def special_defense
+    return compile_bytes(@pdata[98,2])
+  end
+  
+  def special_defense=(value)
+    @pdata[98,2] = decompile_bytes(value,2)
+  end
+  
+  def iv(options = {hp: true})
+    iv_total = compile_bytes(@pdata[@block_m+4,4])
+    if options[:hp]
+      return (iv_total & 0x1F)
+    elsif options[:attack]
+      return ((iv_total & 0x3E0)>>5)
+    elsif options[:defense]
+      return ((iv_total & 0x7C00)>>10)
+    elsif options[:speed]
+      return ((iv_total & 0xF8000)>>15)
+    elsif options[:special_attack]
+      return ((iv_total & 0x1F00000)>>20)
+    elsif options[:special_defense]
+      return ((iv_total & 0x3E000000)>>25)
+    end
+  end
+  
+  def ivs
+    iv_total = compile_bytes(@pdata[@block_m+4,4])
+    return {hp: iv_total & 0x1F, attack: ((iv_total & 0x3E0)>>5), defense: ((iv_total & 0x7C00)>>10), speed: ((iv_total & 0xF8000)>>15), special_attack: ((iv_total & 0x1F00000)>>20), special_defense: ((iv_total & 0x3E000000)>>25)}
+  end
+  
+  def ivs=(val)
+    iv_total = (val[:hp].to_i&0x1F) | ((val[:attack].to_i&0x1F)<<5) | ((val[:defense].to_i&0x1F)<<10) | ((val[:speed].to_i&0x1F)<<15) | ((val[:special_attack].to_i&0x1F)<<20) | ((val[:special_defense].to_i&0x1F)<<25)
+    @pdata[@block_m+4,4] = decompile_bytes(iv_total,4)
+  end
+  
+  def evs
+    return {hp: @pdata[@block_e].to_i, attack: @pdata[@block_e+1].to_i, defense: @pdata[@block_e+2].to_i, speed: @pdata[@block_e+3].to_i, special_attack: @pdata[@block_e+4].to_i, special_defense: @pdata[@block_e+5].to_i}
+  end
+  
+  def evs=(val)
+    @pdata[@block_e] = val[:hp]
+    @pdata[@block_e+1] = val[:attack]
+    @pdata[@block_e+2] = val[:defense]
+    @pdata[@block_e+3] = val[:speed]
+    @pdata[@block_e+4] = val[:special_attack]
+    @pdata[@block_e+5] = val[:special_defense]
+  end
+  
+  def ev(options = {hp: true})
+    if options[:hp]
+      return @pdata[@block_e]
+    elsif options[:attack]
+      return @pdata[@block_e+1]
+    elsif options[:defense]
+      return @pdata[@block_e+2]
+    elsif options[:speed]
+      return @pdata[@block_e+3]
+    elsif options[:special_attack]
+      return @pdata[@block_e+4]
+    elsif options[:special_defense]
+      return @pdata[@block_e+5]
+    end
+  end
+  
+  def ball_caught_with
+    return ((compile_bytes(@pdata[@block_m+2,2]) & 0x7800)>>11)
+  end
+  
+  def moves
+    return {1=>compile_bytes(@pdata[@block_a,2]), 2=>compile_bytes(@pdata[@block_a+2,2]), 3=>compile_bytes(@pdata[@block_a+4,2]), 4=>compile_bytes(@pdata[@block_a+6,2]) }
+  end
+  
+  def moves=(val)
+    @pdata[@block_a,2] = decompile_bytes(val[1],2)
+    @pdata[@block_a+2,2] = decompile_bytes(val[2],2)
+    @pdata[@block_a+4,2] = decompile_bytes(val[3],2)
+    @pdata[@block_a+6,2] = decompile_bytes(val[4],2)
+  end
+  
+  def decrypt
+    temp_pks = self.dup
+    decrypt_key = pid ^ (((secretid&0xFFFF)<<16) | (otid&0xFFFF))
+    calc_checksum = 0
+    pdata[32,48].each_index do |i|
+      i+=32
+      if i%4==0
+        temp_pks.pdata[i,4] = decompile_bytes(decrypt_key ^ compile_bytes(@pdata[i,4]),4)
+      end
+    end
+    pdata[32,48].each_index do |i|
+      i+=32
+      if i%2==0
+        calc_checksum += compile_bytes(temp_pks.pdata[i,2])
+      end
+    end
+    puts "0x" + checksum.to_s(16) + ": Invalid Checksum!!! (Should be 0x" + (calc_checksum&0xFFFF).to_s(16).upcase + ")" if (calc_checksum&0xFFFF) != checksum
+    return temp_pks
+  end
+  
+  def encrypt
+    temp_pks = self.dup
+    decrypt_key = pid ^ (((secretid&0xFFFF)<<16) | (otid&0xFFFF))
+    calc_checksum = 0
+    
+    pdata[32,48].each_index do |i|
+      i+=32
+      if i%2==0
+        calc_checksum += compile_bytes(temp_pks.pdata[i,2])
+      end
+    end
+    
+    pdata[32,48].each_index do |i|
+      i+=32
+      temp_pks.pdata[i] = pdata[i] ^ ((decrypt_key & (0xFF << (i%4)*8)) >> ((i%4)*8))
+    end
+    
+    temp_pks.checksum = calc_checksum
+    return temp_pks
+  end
+  
+end