Lab46 Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
======MTB4======
Only task headings have been provided. You are not expected to know how to do the task given by just that description (although in some cases it can be adequately figured out). Instead, if no further information is yet present, ASK FOR DETAILS on the discord, then contribute that clarity here.

If something is present but needs polish: spruce it up.

If something is present but is incorrect: please fix it.

This is intended to be an informative, useful document that all can benefit from.

Those with prior experience, please be mindful not to gobble up all the low-hanging fruit from the newcomers.

=====URLs=====
  * Vircon32 homepage: https://www.vircon32.com/
  * Vircon32 API reference: https://www.vircon32.com/api.html

=====power ups=====
It might be a good idea to implement structs to represent powerups. Within this struct, it would have an x and y value (this could be a struct in and of itself called point, which has two ints: x and y). The struct could also have a variable called type that represents what type of powerup it is, e.g., type = 1 for damage, and type = 2 for duplicating that ball. One easy way to represent all the possible powerups as integer values is through the use of enums (enumerations).

struct Powerup
{
 Point position;
 int type;
}

struct Point
{
 int x,
 int y
};

What is an enumerator?
Microsoft definition: An enumeration type (or enum type) is a value type defined by a set of named constants of the underlying integral numeric type.
this means that you can define named constants that have an underlying numeric value.

Example:
enum Teachers
{
 MATT = 1,
 JOE = 2
};

instead of literally typing 1, you could just write MATT, and it would represent the value 1, but the type is enum, not int.

Back to the context of powerups, you could make an enum as such:

enum POWERUPS
{
 DUPLICATE = 1,
 MOARDAMAGE = 2,
 FASTER = 3
};

then make a struct:

struct Powerup
{
 Point position;
 POWERUPS type;
}

then create a struct with the desired powerup and position:
<code>
void main()
{
 Powerup *ptrPowerup;                          //create a pointer to a powerup
 ptrPowerup->position.x = screen_width / 2;    //set x and y values of the point struct within the powerup
 ptrPowerup->position.y = screen_height / 2;
 ptrPowerup->type = DUPLICATE;                   //set the type variable within the powerup struct to DUPLICATE, which represent the underlying value of 1
}
</code>
now everytime that you call ptrPowerup->type it will return DUPLICATE, which under the hood, represents 1.

Some Power-Ups you could make could range from trivial to more difficult. One could be a Power-Up that increases the size of your paddle.
You can accomplish this by checking if the Power-Up is active, then selecting a different region before drawing the paddle and the given coordinates.
You will of course need to change the boundaries in which the ball collides with the bigger paddle as well.
If you are using an array to track your Power-Ups, it would look something like:
<code>
if ( PowerUpCollected[1] == true )
{
    select_region( RegionLargePaddle );
} else {
    select_region( RegionPaddle );
}
draw_region_at( PaddleX, PaddleY );
</code>
Lab46 Wiki

User Tools

Site Tools

Page Tools
