Thinking about doing another space oriented theme within vectorblade. I happen to have the idea of a giant sized spacecraft in the shape of a globe – as a boss fight. Don’t think anyone ever had an idea as such.
Anyway – the picture above might be a little bit detailed. While the image alone displays alright – Hertz-wise I might get into trouble if it starts shooting :-).
I just wanted to give a little status. For some weeks Vectorblade had been on the backburner. But a week ago (or so) I started to slowly get into it again. There were some things that I postponed since I really didin’t feel like doing them.
You might have read, that I was on the quest to have more space to have enough ressources to reach my 100 level goal.
For that to do I have:
- restructured the code (bank 0/bank1)
- edited all bonus “icons” (they look the same, but internally they are handled much more efficiently)
- did new explosions (player and enemies), the enemy explosions might at first look strange – but once you get used to them – they are cool, at least I think so (and damn – efficient and memory non expensive!)
- restructuring and bug hunting took several days, right now I am fairly confident to be at the same stage as a month ago – I have no known bug.
- I can actually start to do something new!!!
- I have (bank 0 and bank 1) alltogether about 15kb left, that should be sufficient for said 100 levels (and perhaps some other bonus stuff I might think about)
In one week I’ll go on a holiday for two weeks, and this weekend is fully booked… so probably for another couple of weeks there will be no further update.
But.
Vectorblade is in a state where I actually WANT to do new stuff, and that is a great incentive! Actually I played it a lot to find bugs and such – and I very much still like it. IMHO it plays like a charm. And although if provoked it might go under 50Hz – most of the time it is very fast and stable.
Bug fixes apart from the stuff mentioned above:
- shop is exited with button 3 (instead of 4)
- the “shift” dot in the center is gone
Added because I had some extra time:
- super shot
- lazer shot (which is funny – the display I wanted to do does not work on all vectrex – so I had to switch to a rather boring “line” display 🙁 )
I also did some documentation – since I am afraid that when I leave it alone for too long, that I can’t remember what I did.
Following I post the documentation of the level structure. This will most probably be boring and you probably should not read it – hehehe.
But it is my blog – and I also sometimes use it as “open” documentation – so here you go!
Enemies
Enemies are defined with an EnemyDefinition.
struct EnemyDefinition
ds ANGLE8_TABLE,2 ; if zero -> BigBug
ds BUG_ENEMY_HP, 0
ds ENEMY_STRENGTH,1 ; HP
ds WAIT_ANIM_TABLE,2
ds ENEMY_BULLET_SPEED, 1 ; bug only (for now), lower nibble speed, uppernibble
; #mt3n, m= 1 can fire missiles, t = 1 can fire target shots, 3 = 1 can fire tripples
; if m = 1 than always missile
; if 3 = 1 than always tripple (if not missile)
; t else
ds ADDITIONAL_TYPE_INFO,1
ds CLONE_INFO, 1 ;ccnnnnnn , cc = number of clones+1 1-4, nnnnn wait bewteen clones 0-63
end struct
end struct
As of now two different enemies exist
a) “normal” enemies
b) Big bugs
Normal enemies
– enter the game in patterns
– behavior of pattern and intro can be modified with “ADDITIONAL_TYPE_INFO”
– normal behavior:
– intro via a pattern
– after pattern a “delay” is done (enemy invisible)
– enemy enters screen at a random position at the top of the screen
– enemy goes to its waiting position
– waiting position:
– 20 different positions, where enemies wait and “wobble”
– waiting positions can be defined per level (pointer to waiting position table)
– from waiting positions attack patterns are randomly initiated
(count of attack pattern using enemies at the same time can be set via level information)
– enemies can shoot (count of maximum shots per level can be set per level)
– probability of shooting (and of bonus drop) can be set per level
The normal behaviour of an enemy can be modified by “ADDITIONAL TYPE” definitions, as of now:
TYPE_NONE = 0
TYPE_DIRECT_WAIT = %00000001
– does not enter a “delay”, will not be invisible, from last “intro pattern” position, the enemy moves to waiting position
TYPE_DONT_SHOOT = %00000010
– this enemy can not shoot – never!
TYPE_DONT_ATTACK = %00000100
– this enemy will not initiate an attack pattern
(all three combined can be used to define “blockers”)
TYPE_DONT_WAIT = %00001000
– this enemy behaves in a “normal” level like a “kamikaze” attacker
(it does not enter a waiting position after intro pattern – it “vanishes” instead)
this can be used to have larger intro waves – but still restrict the overall enemy count to 20 on screen!
Blocker example:
The above shown blockers “protect” the attacking enemies. Each blocker in the example has about 20 hitpoints.
Attack Pattern
Addition to attack patterns
– attack pattern are really something one would nowadays call “scripted enemy behaviour”.
Anyway attack sub-pattern definition can now also include “loops” – so the order of sub-patterns
(in one attack pattern) is not necessarily linear anymore.
Level Definition
—————-
1. List of levels
…………….
Is a list of all levels (word list of pointers).
List is 0000 terminated – if 0000 is reached the game starts from level 0.
2. Level Definition
……………….
struct LevelDefinition
ds LEVEL_INTRO_PATTERN,2
ds LEVEL_WAITING_PATTERN,2
ds LEVEL_ATTACK_PATTERN,2 ; pointer to attack pattern list – pointer to 4 pointers to attack patterns
ds LEVEL_ENEMY_DEFINITION,2
ds LEVEL_MAX_SHOTS_IN_AIR, 1
ds LEVEL_MAX_ATTACK_PATTERNS, 1
ds LEVEL_TYPE, 1
ds LEVEL_BULLET_BORDER, 1 ; how probable is it that enemies shoots
ds LEVEL_BONUS_BORDER, 1 ; how probable is it that bonus drops
ds LEVEL_BUG_DEFINITION, 2
ds LEVEL_BUG_COUNT, 1
ds LEVEL_SHOT_DELAY_BUG, 1
end struct
LEVEL_INTRO_PATTERN one word pointer to level intro patterns, definition see there.
LEVEL_WAITING_PATTERN one word pointer to level waiting patterns, definition see there.
LEVEL_ATTACK_PATTERN one word pointer to level attack patterns, definition see there.
LEVEL_ENEMY_DEFINITION one word pointer to level enemy definition, definition see there.
LEVEL_MAX_SHOTS_IN_AIR
Number of enemy bullets that are allowed to be “in the air” at one time.
Capped to maximum number of enemy bullets (10).
LEVEL_MAX_ATTACK_PATTERNS
Number of enemies that are allowed to enter an attack pattern at the same time (no limit).
LEVEL_TYPE
A combination of following values and bit fields
Value (only one of these at a given time)
LEVEL_TYPE_NORMAL = 1
LEVEL_TYPE_KAMIKAZE = 2
LEVEL_TYPE_BIGGY = 3
LEVEL_TYPE_BONUS = 4
LEVEL_TYPE_BOSS1 = 5
LEVEL_TYPE_BOSS2 = 6
LEVEL_TYPE_BOSS3 = 7
LEVEL_TYPE_BOSS4 = 8
And bits in combination of the above entry:
LEVEL_TYPE_SHOP_AFTER = %10000000
LEVEL_TYPE_WARP_AFTER = %01000000
LEVEL_TYPE_DONT_SHOOT_WHILE_WAITING = %00100000
LEVEL_BULLET_BORDER
A probablility value that an enemy will shoot.
Only one enemy can shoot in each game round.
A random value is determined (0-255) if the random value is equal or less the value given here –
the shot will be initiated.
LEVEL_BONUS_BORDER
A probablility value that a dead enemy will drop a bonus
A random value is determined (0-255) if the random value is equal or less the value given here –
a bonus will spawn.
LEVEL_BUG_DEFINITION
If there this is a bug, a pointer (word) to the bug definition is given. A level can only have ONE
kind of bug.
LEVEL_BUG_COUNT
Count of bugs this level has (only if bug level).
LEVEL_SHOT_DELAY_BUG
Delay value (in game rounds) a bug will delay between shots (not random!).
3. LEVEL_INTRO_PATTERN
………………….
Intro pattern is 0000 terminated list of 3 values of an intro line.
struct IntroLine
ds LINE_PATTERN_DEF, 2
ds LINE_PATTERN_INVERS ,1
ds LINE_PATTERN_ENEMY_COUNT ,1
end struct
LINE_PATTERN_DEF
Is a word pointer to an intro pattern definition (see there).
LINE_PATTERN_INVERS
If 0 pattern is taken with original values, if !=0, then
all x positions in the pattern are mirrored.
LINE_PATTERN_ENEMY_COUNT
A count of enemies this intro pattern is applied to.
The actual enemy information is taken from the LEVEL_ENEMY_DEFINITION of the level definition.
4. LEVEL_WAITING_PATTERN
……………………
Is a list of positions (y,x) where the enemies will “wait”.
Each spawned enemy receives a unique id.
Only 20 enemies are allowed at any one time MAX.
The unique id of the enemy (0-19) is an index to the y,x position within this list of waiting coordinates.
5. LEVEL_ATTACK_PATTERN
…………………..
Is a list of exactly 4 attack pattern definition.
If an enemy of a level is randomly chosen to attack the player, than randomly one of the four attack
patterns that are valid for the level is chosen and used.
Each one of the four entries is a pointer to an ATTACK_DEFINITION (see there).
6. LEVEL_ENEMY_DEFINITION
…………………….
Is simple “counted” list of enemy definitions.
It consists of two parts
a) a count (byte) of enemy definitions to follow
b) a list of (count) enemy definitions to use in the level
While the level is initialized (and the enemies enter with the intro pattern) above counter of
enemies is kept and the counter modulo the “count”(of enemies defined) is matched to the enemy list.
e.g.
An enemy definition list for a level looks like:
db 2
dw enemy1 , enemy2
Than e.g. the first ten enemies would be enemy1, enemy2, enemy1, enemy2, enemy1, enemy2, enemy1, enemy2, enemy1, enemy2.
The modulo ensures that always an enemy definition is available however many enemies spawn and also allows for
small lists.
7. INTRO_PATTERN_DEF
………………..
An intro pattern definition consists of several parts.
struct IntroPattern
byte delayBetweenSpawn
byte initialDelay
PatternLineList (zero terminated list of)
end struct
delayBetweenSpawn
Is a delay value between enemies spawning (in game rounds).
This delay should be chosen in regard to the movement speed of the enemies.
initialDelay
Delay befor this pattern starts (in game rounds). This might be necessary to be defined
when more than one pattern definitions are used.
PatternLineList
A 0000 terminated list of PatternLine definitions.
This is no pointer! The following bytes represent the structure PatternLine until a line
end is reached (adders are both 0000 AND the angle must be 0)
The definition is as:
struct PatternLine
ds P_YPOS, 1
ds P_XPOS, 1
ds P_YADD, 2
ds P_XADD, 2
ds P_ANGLE,1 also loop destintion
ds P_PAD ,1
end struct
In short:
P_YPOS, P_XPOS (bytes) starting coordinates.
P_YADD, P_YADD (words) hi/lo values to add to a 16bit coordinate.
if both are zero this is taken as “end of definition”
The values are “adds” to go from the above given P_YPOS, P_XPOS to the next lines P_YPOS, P_XPOS values.
The size of these values are determined by the excel sheet and there using the provided “speed”.
P_ANGLE (byte) The angle to be used for the enemy display (0-7)
P_PAD (byte) Pad byte to have a size of eight.
Note:
It is possible to loop within one pattern definition list.
In order to initate a loop, following conditions must be met
– P_YADD, P_XADD must both be 0 (words)
– the P_ANGLE than denotes the (1 based) pattern definition count within this PatternLineList.
– if you loop the P_YPOS, P_XPOS of the loop initiating pattern should be the same as the
P_YPOS, P_XPOS of the loop destination pattern
– if you build loops within intro patterns, there is no way to “break” the loops, the
enemies must be destroyed by the player, otherwise the enemies do not leave of their own!
Definitions can be build using the excel sheet provided.
More explanation can be seen at: http://vectrexproject.malban.de/10th-of-march-2018-vectorblade-ii
8.ATTACK_DEFINITION
……………….
An attack definition is a terminated (by 0000 as first two bytes) list of different types of patterns.
The different single pattern definitions one complete attack pattern can have are applied
one after another untill the list is terminated (or the attacker is dead).
Depending on the kind of pattern the meaning of the data in one pattern line differs.
One pattern line is 4 bytes long.
All have in common, that the second byte of the definition describes the type of attack pattern.
Following three types are possible:
SINGLE_ATTACK_TARGET_ENEMY_PATTERN
SINGLE_ATTACK_ABSOLUT_PATTERN
SINGLE_ATTACK_RELATIVE_PATTERN
In addition to above three pattern a fourth type is available: SINGLE_ATTACK_JUMP
with that definition the next pattern line can be accessed via a “jump” to a different pattern.
Thus reuse of sub parts of complete patternlist definitions is possible.
The structure used for such a jump is:
struct SingleAttackPatternLine
ds (byte) not used
ds (byte) SINGLE_ATTACK_PATTERN_TYPE
ds (word) address of patternline in attack pattern
end struct
a) SINGLE_ATTACK_TARGET_ENEMY_PATTERN (4 bytes)
This is the most simple attack type.
That pattern moves the enemy from the current position to the position the player resides at the moment
the pattern is initiated.
The structure used:
struct SingleAttackPatternLine
ds (byte) SINGLE_ATTACK_SPEED
ds (byte) SINGLE_ATTACK_PATTERN_TYPE
ds (byte) fill up to 4 bytes with 0
end struct
SINGLE_ATTACK_SPEED
Speed with which to attack. All coordinates and movement are calculated in game in relation to
start position and player position.
b) SINGLE_ATTACK_ABSOLUT_PATTERN (4 bytes)
This pattern moves the enemy from the current position to the absolut position denoted by the pattern.
The structure used:
struct SingleAttackPatternLine
ds (byte) SINGLE_ATTACK_SPEED
ds (byte) SINGLE_ATTACK_PATTERN_TYPE
ds (byte) YPOS
ds (byte) XPOS
end struct
c) SINGLE_ATTACK_RELATIVE_PATTERN (4 bytes)
This pattern moves the enemy from the current position to coordinates relative to its current position.
The structure used:
struct SingleAttackPatternLine
ds (byte) not used
ds (byte) SINGLE_ATTACK_PATTERN_TYPE
ds (word) RELATIVE_MOVEMENT_PATTERNLIST
end struct
Since relative movements are in general more complex than the other attack patterns, this one
uses an additional structure to define relative movement.
The additional structure pointed to by RELATIVE_MOVEMENT_PATTERNLIST (see there) consists of a number of
relative movement definitions. With this “outsourcing” reuse of sub-parts is possibly (e.g. looping).
9. RELATIVE_MOVEMENT_PATTERNLIST
…………………………..
Is a list of terminated (0000) 8 byte wide relative pattern definitions.
The definition is as:
struct PatternLine
ds P_YPOS, 1 ; relative
ds P_XPOS, 1 ; relative
ds P_YADD, 2 ; movement 16 bit
ds P_XADD, 2 ; movement 16 bit
ds P_ANGLE,1 ; 0-7
ds P_PAD ,1
end struct
The definition is very similar to the definition of PatternLine for the intro patterns.
In short:
P_YPOS, P_XPOS (bytes) destination relative coordinates.
P_YADD, P_YADD (words) hi/lo values to add to a 16bit coordinate.
The values are “adds” to go from the above given P_YPOS, P_XPOS to the next lines P_YPOS, P_XPOS values.
The size of these values are determined by the excel sheet and there using the provided “speed”
P_ANGLE (byte) The angle to be used for the enemy display (0-7)
P_PAD (byte) Pad byte to have a size of eight.
Definitions can be build using the excel sheet provided.
More explanation can be seen at: http://vectrexproject.malban.de/10th-of-march-2018-vectorblade-ii
—
Malban
Interesting reading ( no I’m not being sarcastic)
Awesome work and write up, love it!
This is looking great and keep up the excellent work!