• Commodore Free Magazine, Issue 79 - Part 11

    From Stephen Walsh@39:901/280 to All on Tue Apr 15 19:49:02 2014
    t.

    The graphics are good for this type of game and the sounds are more than acceptable, I think it would be asking too much for a sound track to play
    along with the game play, as I would think the machine is already maxed out displaying all the graphics! the question is does it really need a
    soundtrack, Slap on a cd turn out the lights and then the TV sound up to
    loud and your all set!

    A brief information screen appears once at the start, then after you press
    fire your launched straight into the game, once all live are lost you just start again , no menu screen is shown on subsequent starts of the game.
    The gameplay is just as good as the game itself! You just have the right amount of hardness curve (if that's the right term) truly the standards bar
    has been lifted some way with this release!

    Program file:
    github.com/SvenMichaelKlose/pulse/blob/master/pulse.prg?raw=true

    Source code:
    github.com/SvenMichaelKlose/pulse

    SCORES

    Graphics: 7/10
    colourful and incredibly speedy
    Sounds: 6/10
    just in game shots and explosions
    but fitting for the game
    Gameplay: 9/10
    wow
    Overall: 8.5/10
    unbelievably quick game for the VIC

    SUMMARY

    Wow this is an unbelievably quick game for the unexpanded VIC, one or two
    small glitches, but the speed and playability of the game are just unbelievable, a must have download for any VIC user



    *************************************
    REVIEW: PANICMAN
    For the VIC 20
    By Commodore Free
    *************************************

    Name: Panicman
    Authors: Dane Bills,
    Jeff Messner
    Released: March 2, 2014
    Requirements: VIC20 with +3k or +8k,
    joystick (developed on
    NTSC)

    Description: A maze game clone of a well known 80s game written in
    assembly

    INFORMATION

    Both versions should load and you can type 'run' from the basic prompt
    after loading. e.g.: load "panicman3k.prg",8

    There is no difference between the 3k and 8k version other than a splash
    screen to show the authors on the 8k. I just thought it might be nice to
    have the 8k executable for someone to run on the real iron if they didn't
    have a 3k cartridge. The 3K has received the most testing on real
    hardware.

    +3k version:

    drive.google.com/file/d/0B0VOPYWAvrJHZjJBQW1uVWVYcDg/edit?usp=sharing

    +8k version:

    drive.google.com/file/d/0B0VOPYWAvrJHSHhBd0hJbHg5RE0/edit?usp=sharing

    discussion thread:

    sleepingelephant.com/ipw-web/bulletin/bb/viewtopic.php?f=10&t=6870

    So then pack man, just for the one person who doesn't know, you are a
    yellow man and must collect dots, you must avoid the ghosts if you touch
    them they will kill you, the larger dots turn the ghost blue so you can eat them.

    Right, well not much to add really a very competent version for the VIC,
    with just a 3k expansion, it's all here; the secret break in the maze to
    shoot off one side and return on the other, and the fruits that appear in
    the lower of the screen to boost your score. The ghosts are a little on
    the dim side in logic, but that means more playtime if your not very
    dextrous or nimble on the joystick. The graphics are very faithful to the original and the sounds take you back to the 80` all over again, (not sure
    if that's a good or bad thing really, flashbacks of mullets are affecting
    my judgement)

    Well executed, you sort of start thinking "what's happening on the VIC with
    the community" the amount of software appearing it's amazing, both in the quality, playability and the dedicated programmers showing the machine is
    far from dead.

    This version is fast and almost glitch free, I am just amazed at the
    quality and can't wait to see what releases will be churned out for the VIC next, I think if you sat someone down and said you're playing the Commodore
    64 version, I don't think anyone would notice!

    SCORING

    Graphics: 9/10
    faithful to the original
    Sounds: 9/10
    again faithful to the original
    Gameplay: 8/10
    maybe just a touch to easy
    Overall: 9/10
    very faithful conversion

    SUMMARY

    Wow what can I say a faithful version of Pacman on the VIC, with the fruits
    and secret tunnels to either side of the screen. Brilliant, an almost a perfect conversion.



    *************************************
    THE ASSEMBLY LINE
    $02: Binary Numbers
    By Bert Novilla (satpro)
    *************************************

    Last time out we looked at the hardware registers in the 65x family of processors. Today we will discuss the format your computer expects all
    code and data to be encoded with - binary. Knowing the fundamental
    structure of a byte is absolutely invaluable, and you will want to know how
    to fluently read, write, and convert to (and from) binary format in order
    to be successful writing programs in assembly language. If binary numbers
    are new or seem confusing, then today's topic is for you.

    THE POWER OF 2

    When we talk of numbering systems it is crucial to remember that the CPU
    uses numbers in binary format exclusively; that is, the CPU understands
    only binary digits 0 and 1. No fractions, no number 2. And that's it.
    The CPU understands the binary format and moves data around between memory
    and devices using this format. There. See? That's all there is to the
    world of Binary.

    In this binary world everything is always exactly one of two ways - on or
    off, enabled or disabled, high or low, true or false, set or reset - it is
    this one simple fact which will factor into every programming choice you
    make - ever. Other programming languages deal with this fact, too, and
    have developed concepts such as if-then, for-next, case, and so on, but
    these concepts represent many instructions encoded in binary format and
    placed in a coherent order for the CPU to execute with expected results.
    The concepts are meant to make a programmer's life easier. In assembly language you are working with the computer at a much more fundamental level
    - the bit, nybble, byte, and flag level - and the CPU expects all data to
    be in binary format. For you the assembly language programmer, if-then statements become a series of loads, stores, loops, comparisons, branches,
    and flags.

    THE BIT

    A basic unit of measurement in the computer world is the byte. While this
    is true, a byte is actually made up of something smaller still - a set of 8 individual components called bits. Bits are simple on/off switches. The
    state of any bit is always either set (= 1) or reset (= 0). You write a
    binary number just as you write a decimal number; that is, least
    significant digit on the right, all larger digits to the left. The
    difference is, in binary you only have two digits -> 0 and 1.

    THE BYTE

    An 8-bit CPU such as the 6502 is called an 8-bit processor because it is
    able to process eight data lines at a time, or in programming terms,
    process one byte of data (eight individual bits, each connected in parallel
    to the computer's data bus, together representing a byte). The byte is the standard frame of reference in programming. Although individual bits are sub-parts of a byte, they are not directly addressable, and are instead manipulated in the A Register using specialized instructions such as OR,
    AND, EOR, and others. An entire byte is moved to or from memory at a time,
    so all eight bits go at once.

    THE WORD

    The 6502 needs to make two separate memory accesses in order to modify a
    16-bit value (aka word). It only knows 8-bit quantities, so a double byte
    must be attended to as two individual bytes working together as a single
    16-bit entity. Addition and subtraction instructions rely heavily on the
    state of the Carry flag in a multi-byte operation.

    The 65816 can access 16 bits, or two bytes, per memory access. The first
    byte, commonly called the low byte, contains the lower 8 bits, while the
    byte directly after, aka the high byte, contains the upper 8 bits. So,
    it's two adjacent bytes, 8-bits each, with least significant byte first in memory (even though we write numbers high-byte first in source code). Each more significa

    --- MBSE BBS v1.0.01 (GNU/Linux-i386)
    * Origin: Dragon's Lair ---:- bbs.vk3heg.net -:--- (39:901/280)